[19.2.x][FlightReply] Don't drop FormData entries in decodeReplyFromBusboy (#36566)

Co-authored-by: Hendrik Liebau <mail@hendrik-liebau.de>

Author: eps1lon

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(