[FlightReply] Don't drop FormData entries in decodeReplyFromBusboy (#36468)

Fixes a regression from #36425 where referenced `FormData` entries can
be dropped by `decodeReplyFromBusboy` when files are interleaved with
text fields in the payload.
`decodeReplyFromBusboy` queues text fields that arrive while a file is
being streamed and flushes them after the last file's `'end'`, working
around busboy emitting `'end'` deferred relative to subsequent `'field'`
events. With multiple files interleaved with text, this loses the
relative order of the affected text entries. The reorder was a
long-standing but invisible issue — entries came back in the wrong order
but were all present — until #36425 tightened how referenced FormData
entries are collected from the backing store to rely on them being
contiguous. With that assumption violated, referenced FormDatas can now
come back with some entries dropped. The pattern is most easily surfaced
through `useActionState` actions that return the submitted `FormData` as
part of their state.
This replaces the tail-flush with a linked list of pending files. Text
fields that arrive while a file is in flight are queued on the tail
file's `queuedFields`; fields that arrive when the list is empty resolve
immediately. `flush()` walks from the head, resolving each completed
file followed by its queued fields, and stops at the first file that
hasn't ended yet. The backing FormData now matches the payload's order,
restoring the contiguity assumption (and fixing the long-standing
reorder as a side effect). The same change is applied to all five copies
in `react-server-dom-{webpack,turbopack,parcel,esm,unbundled}`. Two new
tests cover the multi-file interleave.
fixesvercel/next.js#93822

Author: unstubbable

package.json

@@ -53,6 +53,7 @@
 "art": "0.10.1",
 "babel-plugin-syntax-hermes-parser": "^0.32.0",
 "babel-plugin-syntax-trailing-function-commas": "^6.5.0",
+"busboy": "^1.6.0",
 "chalk": "^3.0.0",
 "cli-table": "^0.3.1",
 "coffee-script": "^1.12.7",

packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js

@@ -62,6 +62,7 @@ import {
 }from'react-client/src/ReactFlightClientStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -329,6 +330,17 @@ function prerenderToNodeStream(
 });
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 functiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 moduleBasePath: ServerManifest,
@@ -344,14 +356,55 @@ function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -371,29 +424,46 @@ function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js

@@ -75,6 +75,7 @@ import {
 import{textEncoder}from'react-server/src/ReactServerStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -560,6 +561,17 @@ export function registerServerActions(manifest: ServerManifest) {
 serverManifest=manifest;
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 exportfunctiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 options?: {
@@ -574,14 +586,55 @@ export function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -601,29 +654,46 @@ export function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

package.json

@@ -53,6 +53,7 @@
 "art": "0.10.1",
 "babel-plugin-syntax-hermes-parser": "^0.32.0",
 "babel-plugin-syntax-trailing-function-commas": "^6.5.0",
+"busboy": "^1.6.0",
 "chalk": "^3.0.0",
 "cli-table": "^0.3.1",
 "coffee-script": "^1.12.7",

packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js

@@ -62,6 +62,7 @@ import {
 }from'react-client/src/ReactFlightClientStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -329,6 +330,17 @@ function prerenderToNodeStream(
 });
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 functiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 moduleBasePath: ServerManifest,
@@ -344,14 +356,55 @@ function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -371,29 +424,46 @@ function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js

@@ -75,6 +75,7 @@ import {
 import{textEncoder}from'react-server/src/ReactServerStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -560,6 +561,17 @@ export function registerServerActions(manifest: ServerManifest) {
 serverManifest=manifest;
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 exportfunctiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 options?: {
@@ -574,14 +586,55 @@ export function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -601,29 +654,46 @@ export function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

package.json

@@ -53,6 +53,7 @@
 "art": "0.10.1",
 "babel-plugin-syntax-hermes-parser": "^0.32.0",
 "babel-plugin-syntax-trailing-function-commas": "^6.5.0",
+"busboy": "^1.6.0",
 "chalk": "^3.0.0",
 "cli-table": "^0.3.1",
 "coffee-script": "^1.12.7",

packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js

@@ -62,6 +62,7 @@ import {
 }from'react-client/src/ReactFlightClientStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -329,6 +330,17 @@ function prerenderToNodeStream(
 });
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 functiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 moduleBasePath: ServerManifest,
@@ -344,14 +356,55 @@ function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -371,29 +424,46 @@ function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js

@@ -75,6 +75,7 @@ import {
 import{textEncoder}from'react-server/src/ReactServerStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -560,6 +561,17 @@ export function registerServerActions(manifest: ServerManifest) {
 serverManifest=manifest;
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 exportfunctiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 options?: {
@@ -574,14 +586,55 @@ export function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -601,29 +654,46 @@ export function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

package.json

@@ -53,6 +53,7 @@
 "art": "0.10.1",
 "babel-plugin-syntax-hermes-parser": "^0.32.0",
 "babel-plugin-syntax-trailing-function-commas": "^6.5.0",
+"busboy": "^1.6.0",
 "chalk": "^3.0.0",
 "cli-table": "^0.3.1",
 "coffee-script": "^1.12.7",

packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js

@@ -62,6 +62,7 @@ import {
 }from'react-client/src/ReactFlightClientStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -329,6 +330,17 @@ function prerenderToNodeStream(
 });
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 functiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 moduleBasePath: ServerManifest,
@@ -344,14 +356,55 @@ function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -371,29 +424,46 @@ function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js

@@ -75,6 +75,7 @@ import {
 import{textEncoder}from'react-server/src/ReactServerStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -560,6 +561,17 @@ export function registerServerActions(manifest: ServerManifest) {
 serverManifest=manifest;
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 exportfunctiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 options?: {
@@ -574,14 +586,55 @@ export function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -601,29 +654,46 @@ export function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

package.json

@@ -53,6 +53,7 @@
 "art": "0.10.1",
 "babel-plugin-syntax-hermes-parser": "^0.32.0",
 "babel-plugin-syntax-trailing-function-commas": "^6.5.0",
+"busboy": "^1.6.0",
 "chalk": "^3.0.0",
 "cli-table": "^0.3.1",
 "coffee-script": "^1.12.7",

packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js

@@ -62,6 +62,7 @@ import {
 }from'react-client/src/ReactFlightClientStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -329,6 +330,17 @@ function prerenderToNodeStream(
 });
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 functiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 moduleBasePath: ServerManifest,
@@ -344,14 +356,55 @@ function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -371,29 +424,46 @@ function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js

@@ -75,6 +75,7 @@ import {
 import{textEncoder}from'react-server/src/ReactServerStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -560,6 +561,17 @@ export function registerServerActions(manifest: ServerManifest) {
 serverManifest=manifest;
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 exportfunctiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 options?: {
@@ -574,14 +586,55 @@ export function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -601,29 +654,46 @@ export function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

package.json

@@ -53,6 +53,7 @@
 "art": "0.10.1",
 "babel-plugin-syntax-hermes-parser": "^0.32.0",
 "babel-plugin-syntax-trailing-function-commas": "^6.5.0",
+"busboy": "^1.6.0",
 "chalk": "^3.0.0",
 "cli-table": "^0.3.1",
 "coffee-script": "^1.12.7",

packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js

@@ -62,6 +62,7 @@ import {
 }from'react-client/src/ReactFlightClientStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -329,6 +330,17 @@ function prerenderToNodeStream(
 });
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 functiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 moduleBasePath: ServerManifest,
@@ -344,14 +356,55 @@ function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -371,29 +424,46 @@ function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js

@@ -75,6 +75,7 @@ import {
 import{textEncoder}from'react-server/src/ReactServerStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -560,6 +561,17 @@ export function registerServerActions(manifest: ServerManifest) {
 serverManifest=manifest;
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 exportfunctiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 options?: {
@@ -574,14 +586,55 @@ export function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -601,29 +654,46 @@ export function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

package.json

@@ -53,6 +53,7 @@
 "art": "0.10.1",
 "babel-plugin-syntax-hermes-parser": "^0.32.0",
 "babel-plugin-syntax-trailing-function-commas": "^6.5.0",
+"busboy": "^1.6.0",
 "chalk": "^3.0.0",
 "cli-table": "^0.3.1",
 "coffee-script": "^1.12.7",

packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js

@@ -62,6 +62,7 @@ import {
 }from'react-client/src/ReactFlightClientStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -329,6 +330,17 @@ function prerenderToNodeStream(
 });
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 functiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 moduleBasePath: ServerManifest,
@@ -344,14 +356,55 @@ function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -371,29 +424,46 @@ function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js

@@ -75,6 +75,7 @@ import {
 import{textEncoder}from'react-server/src/ReactServerStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -560,6 +561,17 @@ export function registerServerActions(manifest: ServerManifest) {
 serverManifest=manifest;
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 exportfunctiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 options?: {
@@ -574,14 +586,55 @@ export function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -601,29 +654,46 @@ export function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

package.json

@@ -53,6 +53,7 @@
 "art": "0.10.1",
 "babel-plugin-syntax-hermes-parser": "^0.32.0",
 "babel-plugin-syntax-trailing-function-commas": "^6.5.0",
+"busboy": "^1.6.0",
 "chalk": "^3.0.0",
 "cli-table": "^0.3.1",
 "coffee-script": "^1.12.7",

packages/react-server-dom-esm/src/server/ReactFlightDOMServerNode.js

@@ -62,6 +62,7 @@ import {
 }from'react-client/src/ReactFlightClientStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -329,6 +330,17 @@ function prerenderToNodeStream(
 });
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 functiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 moduleBasePath: ServerManifest,
@@ -344,14 +356,55 @@ function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -371,29 +424,46 @@ function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(

packages/react-server-dom-parcel/src/server/ReactFlightDOMServerNode.js

@@ -75,6 +75,7 @@ import {
 import{textEncoder}from'react-server/src/ReactServerStreamConfigNode';
 
 importtype{TemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
+importtype{FileHandle}from'react-server/src/ReactFlightReplyServer';
 
 export{createTemporaryReferenceSet}from'react-server/src/ReactFlightServerTemporaryReferences';
 
@@ -560,6 +561,17 @@ export function registerServerActions(manifest: ServerManifest) {
 serverManifest=manifest;
 }
 
+typePendingFile={
+name: string,
+file: FileHandle,
+complete: boolean,
+// Lazily allocated when a text field arrives after this file's 'file'
+// event but before its (deferred) 'end' event. Stored as flat
+// [name1, value1, name2, value2, ...] pairs.
+queuedFields: null|Array<string>,
+next: null|PendingFile,
+};
+
 exportfunctiondecodeReplyFromBusboy<T>(
 busboyStream: Busboy,
 options?: {
@@ -574,14 +586,55 @@ export function decodeReplyFromBusboy<T>(
 undefined,
 options ? options.arraySizeLimit : undefined,
 );
-letpendingFiles=0;
-constqueuedFields: Array<string>=[];
+
+// Linked list of pending files in arrival (payload) order. Text fields that
+// arrive while a file is in flight are queued on the tail file's
+// `queuedFields` so they can be resolved together when that file completes.
+// Fields that arrive while the list is empty bypass it and resolve
+// immediately. This makes the backing FormData's insertion order match the
+// payload's entry order.
+lethead: null|PendingFile=null;
+lettail: null|PendingFile=null;
+letbodyFinished=false;
+letclosed=false;
+
+functionflush(){
+while(head!==null){
+constcurrent=head;
+if(!current.complete){
+// This file is still streaming. Hold later files and fields until it
+// completes so the backing FormData reflects payload order.
+return;
+}
+try{
+resolveFileComplete(response,current.name,current.file);
+constqueuedFields=current.queuedFields;
+if(queuedFields!==null){
+for(leti=0;i<queuedFields.length;i+=2){
+resolveField(response,queuedFields[i],queuedFields[i+1]);
+}
+}
+}catch(error){
+busboyStream.destroy(error);
+return;
+}
+head=current.next;
+}
+tail=null;
+if(bodyFinished&&!closed){
+closed=true;
+close(response);
+}
+}
+
 busboyStream.on('field',(name,value)=>{
-if(pendingFiles>0){
-// Because the 'end' event fires two microtasks after the next 'field'
-// we would resolve files and fields out of order. To handle this properly
-// we queue any fields we receive until the previous file is done.
-queuedFields.push(name,value);
+if(tail!==null){
+// A file is in flight; queue the field on the tail (most recent) pending
+// file so it resolves after that file, preserving payload order.
+if(tail.queuedFields===null){
+tail.queuedFields=[];
+}
+tail.queuedFields.push(name,value);
 }else{
 try{
 resolveField(response,name,value);
@@ -601,29 +654,46 @@ export function decodeReplyFromBusboy<T>(
 );
 return;
 }
-pendingFiles++;
 constfile=resolveFileInfo(response,name,filename,mimeType);
+constpendingFile: PendingFile={
+ name,
+ file,
+complete: false,
+queuedFields: null,
+next: null,
+};
+if(tail===null){
+head=pendingFile;
+}else{
+tail.next=pendingFile;
+}
+tail=pendingFile;
 value.on('data',chunk=>{
-resolveFileChunk(response,file,chunk);
-});
-value.on('end',()=>{
 try{
-resolveFileComplete(response,name,file);
-pendingFiles--;
-if(pendingFiles===0){
-// Release any queued fields
-for(leti=0;i<queuedFields.length;i+=2){
-resolveField(response,queuedFields[i],queuedFields[i+1]);
-}
-queuedFields.length=0;
-}
+resolveFileChunk(response,file,chunk);
 }catch(error){
 busboyStream.destroy(error);
 }
 });
+value.on('error',error=>{
+busboyStream.destroy(error);
+});
+value.on('end',()=>{
+pendingFile.complete=true;
+flush();
+});
 });
 busboyStream.on('finish',()=>{
-close(response);
+bodyFinished=true;
+flush();
+if(!closed){
+// Invariant: busboy delays 'finish' until every file's 'end' event has
+// fired, so the flush above should always close the response.
+reportGlobalError(
+response,
+newError('Reply finished with incomplete file part.'),
+);
+}
 });
 busboyStream.on('error',err=>{
 reportGlobalError(