diff --git a/doc/api/http.md b/doc/api/http.md
index 71a7bb1db942cc..bb6a3afaf9fdf7 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -745,7 +745,7 @@ added: v0.1.94
 -->
 
 * `response` {http.IncomingMessage}
-* `socket` {stream.Duplex}
+* `stream` {stream.Duplex}
 * `head` {Buffer}
 
 Emitted each time a server responds to a request with an upgrade. If this
@@ -768,13 +768,13 @@ const server = http.createServer((req, res) => {
   res.writeHead(200, { 'Content-Type': 'text/plain' });
   res.end('okay');
 });
-server.on('upgrade', (req, socket, head) => {
-  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
+server.on('upgrade', (req, stream, head) => {
+  stream.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
                'Upgrade: WebSocket\r\n' +
                'Connection: Upgrade\r\n' +
                '\r\n');
 
-  socket.pipe(socket); // echo back
+  stream.pipe(stream); // echo back
 });
 
 // Now that server is running
@@ -793,9 +793,9 @@ server.listen(1337, '127.0.0.1', () => {
   const req = http.request(options);
   req.end();
 
-  req.on('upgrade', (res, socket, upgradeHead) => {
+  req.on('upgrade', (res, stream, upgradeHead) => {
     console.log('got upgraded!');
-    socket.end();
+    stream.end();
     process.exit(0);
   });
 });
@@ -809,13 +809,13 @@ const server = http.createServer((req, res) => {
   res.writeHead(200, { 'Content-Type': 'text/plain' });
   res.end('okay');
 });
-server.on('upgrade', (req, socket, head) => {
-  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
+server.on('upgrade', (req, stream, head) => {
+  stream.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
                'Upgrade: WebSocket\r\n' +
                'Connection: Upgrade\r\n' +
                '\r\n');
 
-  socket.pipe(socket); // echo back
+  stream.pipe(stream); // echo back
 });
 
 // Now that server is running
@@ -834,9 +834,9 @@ server.listen(1337, '127.0.0.1', () => {
   const req = http.request(options);
   req.end();
 
-  req.on('upgrade', (res, socket, upgradeHead) => {
+  req.on('upgrade', (res, stream, upgradeHead) => {
     console.log('got upgraded!');
-    socket.end();
+    stream.end();
     process.exit(0);
   });
 });
@@ -1674,6 +1674,14 @@ per connection (in the case of HTTP Keep-Alive connections).
 <!-- YAML
 added: v0.1.94
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/60016
+    description: Request bodies are no longer exposed raw (unparsed) on the
+                 socket argument. Instead, if a body is received, the stream
+                 argument will be a duplex that emits socket content only
+                 after the request body, while the parsed request body data
+                 will be emitted from the request, just as in normal server
+                 `'request'` events.
   - version:
      - v24.9.0
      - v22.21.0
@@ -1689,7 +1697,7 @@ changes:
 
 * `request` {http.IncomingMessage} Arguments for the HTTP request, as it is in
   the [`'request'`][] event
-* `socket` {stream.Duplex} Network socket between the server and client
+* `stream` {stream.Duplex} The upgraded stream between the server and client
 * `head` {Buffer} The first packet of the upgraded stream (may be empty)
 
 Emitted each time a client's HTTP upgrade request is accepted. By default
@@ -1697,23 +1705,29 @@ all HTTP upgrade requests are ignored (i.e. only regular `'request'` events
 are emitted, sticking with the normal HTTP request/response flow) unless you
 listen to this event, in which case they are all accepted (i.e. the `'upgrade'`
 event is emitted instead, and future communication must handled directly
-through the raw socket). You can control this more precisely by using the
+through the raw stream). You can control this more precisely by using the
 server `shouldUpgradeCallback` option.
 
 Listening to this event is optional and clients cannot insist on a protocol
 change.
 
-After this event is emitted, the request's socket will not have a `'data'`
-event listener, meaning it will need to be bound in order to handle data
-sent to the server on that socket.
-
 If an upgrade is accepted by `shouldUpgradeCallback` but no event handler
-is registered then the socket is destroyed, resulting in an immediate
+is registered then the socket will be destroyed, resulting in an immediate
 connection closure for the client.
 
-This event is guaranteed to be passed an instance of the {net.Socket} class,
-a subclass of {stream.Duplex}, unless the user specifies a socket
-type other than {net.Socket}.
+In the uncommon case that the incoming request has a body, this body will be
+parsed as normal, separate to the upgrade stream, and the raw stream data will
+only begin after it has completed. To ensure that reading from the stream isn't
+blocked by waiting for the request body to be read, any reads on the stream
+will start the request body flowing automatically. If you want to read the
+request body, ensure that you do so (i.e. you attach `'data'` listeners)
+before starting to read from the upgraded stream.
+
+The stream argument will typically be the {net.Socket} instance used by the
+request, but in some cases (such as with a request body) it may be a duplex
+stream. If required, you can access the raw connection underlying the request
+via [`request.socket`][], which is guaranteed to be an instance of {net.Socket}
+unless the user specified another socket type.
 
 ### `server.close([callback])`
 
diff --git a/lib/_http_server.js b/lib/_http_server.js
index 7a0f6447e20751..3fd14faedf46d8 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -34,6 +34,7 @@ const {
   SymbolFor,
 } = primordials;
 
+const { Duplex } = require('stream');
 const net = require('net');
 const EE = require('events');
 const assert = require('internal/assert');
@@ -43,6 +44,7 @@ const {
   continueExpression,
   chunkExpression,
   kIncomingMessage,
+  kSocket,
   HTTPParser,
   isLenient,
   _checkInvalidHeaderChar: checkInvalidHeaderChar,
@@ -106,6 +108,7 @@ const onResponseFinishChannel = dc.channel('http.server.response.finish');
 
 const kServerResponse = Symbol('ServerResponse');
 const kServerResponseStatistics = Symbol('ServerResponseStatistics');
+const kUpgradeStream = Symbol('UpgradeStream');
 
 const kOptimizeEmptyRequests = Symbol('OptimizeEmptyRequestsOption');
 
@@ -953,6 +956,77 @@ function socketOnError(e) {
   }
 }
 
+class UpgradeStream extends Duplex {
+  constructor(socket, req) {
+    super({
+      allowHalfOpen: socket.allowHalfOpen,
+    });
+
+    this[kSocket] = socket;
+    this[kIncomingMessage] = req;
+
+    // Proxy error, end & closure events immediately.
+    socket.on('error', (err) => this.destroy(err));
+
+    socket.on('close', () => this.destroy());
+    this.on('close', () => socket.destroy());
+
+    socket.on('end', () => {
+      this.push(null);
+
+      // Match the socket behaviour, where 'end' will fire despite no 'data'
+      // listeners if a socket with no pending data ends:
+      if (this.readableLength === 0) {
+        this.resume();
+      }
+    });
+
+    // Other events (most notably, reading) all only
+    // activate after requestBodyCompleted is called.
+  }
+
+  requestBodyCompleted(upgradeHead) {
+    this[kIncomingMessage] = null;
+
+    // When the request body is completed, we begin streaming all the
+    // post-body data for the upgraded protocol:
+    if (upgradeHead?.length > 0) {
+      if (!this.push(upgradeHead)) {
+        this[kSocket].pause();
+      }
+    }
+
+    this[kSocket].on('data', (data) => {
+      if (!this.push(data)) {
+        this[kSocket].pause();
+      }
+    });
+  }
+
+  _read(size) {
+    // Reading the upgrade stream starts the request stream flowing. It's
+    // important that this happens, even if there are no listeners, or it
+    // would be impossible to read this without explicitly reading all the
+    // request body first, which is backward incompatible & awkward.
+    this[kIncomingMessage]?.resume();
+
+    this[kSocket].resume();
+  }
+
+  _final(callback) {
+    this[kSocket].end(callback);
+  }
+
+  _write(chunk, encoding, callback) {
+    this[kSocket].write(chunk, encoding, callback);
+  }
+
+  _destroy(err, callback) {
+    this[kSocket].destroy(err);
+    callback(err);
+  }
+}
+
 function onParserExecuteCommon(server, socket, parser, state, ret, d) {
   if (ret instanceof Error) {
     prepareError(ret, parser, d);
@@ -962,28 +1036,56 @@ function onParserExecuteCommon(server, socket, parser, state, ret, d) {
     // Upgrade or CONNECT
     const req = parser.incoming;
     debug('SERVER upgrade or connect', req.method);
+    const eventName = req.method === 'CONNECT' ? 'connect' : 'upgrade';
+
+    let upgradeStream;
+    if (req.complete) {
+      d ||= parser.getCurrentBuffer();
+
+      socket.removeListener('data', state.onData);
+      socket.removeListener('end', state.onEnd);
+      socket.removeListener('close', state.onClose);
+      socket.removeListener('drain', state.onDrain);
+      socket.removeListener('error', socketOnError);
+      socket.removeListener('timeout', socketOnTimeout);
+
+      unconsume(parser, socket);
+      parser.finish();
+      freeParser(parser, req, socket);
+      parser = null;
+
+      // If the request is complete (no body, or all body read upfront) then
+      // we just emit the socket directly as the upgrade stream.
+      upgradeStream = socket;
+    } else {
+      // If the body hasn't been fully parsed yet, we emit immediately but
+      // we add a wrapper around the socket to not expose incoming data
+      // until the request body has finished.
+
+      if (socket[kUpgradeStream]) {
+        // We've already emitted the incomplete upgrade - nothing do to
+        // until actual body parsing completion.
+        return;
+      }
 
-    d ||= parser.getCurrentBuffer();
+      d ||= Buffer.alloc(0);
 
-    socket.removeListener('data', state.onData);
-    socket.removeListener('end', state.onEnd);
-    socket.removeListener('close', state.onClose);
-    socket.removeListener('drain', state.onDrain);
-    socket.removeListener('error', socketOnError);
-    socket.removeListener('timeout', socketOnTimeout);
-    unconsume(parser, socket);
-    parser.finish();
-    freeParser(parser, req, socket);
-    parser = null;
+      upgradeStream = new UpgradeStream(socket, req);
+      socket[kUpgradeStream] = upgradeStream;
+    }
 
-    const eventName = req.method === 'CONNECT' ? 'connect' : 'upgrade';
     if (server.listenerCount(eventName) > 0) {
       debug('SERVER have listener for %s', eventName);
-      const bodyHead = d.slice(ret, d.length);
 
-      socket.readableFlowing = null;
+      const bodyHead = d.slice(ret, d.length);
 
-      server.emit(eventName, req, socket, bodyHead);
+      if (req.complete && socket[kUpgradeStream]) {
+        // Previously emitted, now completed - just activate the stream
+        socket[kUpgradeStream].requestBodyCompleted(bodyHead);
+      } else {
+        socket.readableFlowing = null;
+        server.emit(eventName, req, upgradeStream, bodyHead);
+      }
     } else {
       // Got upgrade or CONNECT method, but have no handler.
       socket.destroy();
@@ -1089,8 +1191,9 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
   if (req.upgrade) {
     req.upgrade = req.method === 'CONNECT' ||
                   !!server.shouldUpgradeCallback(req);
-    if (req.upgrade)
-      return 2;
+    if (req.upgrade) {
+      return 0;
+    }
   }
 
   state.incoming.push(req);
diff --git a/test/parallel/test-http-upgrade-server-with-body-and-extras.mjs b/test/parallel/test-http-upgrade-server-with-body-and-extras.mjs
new file mode 100644
index 00000000000000..bfe0472d8341ba
--- /dev/null
+++ b/test/parallel/test-http-upgrade-server-with-body-and-extras.mjs
@@ -0,0 +1,89 @@
+import * as common from '../common/index.mjs';
+import * as assert from 'assert';
+import * as http from 'http';
+import * as net from 'net';
+
+const EXPECTED_BODY_LENGTH = 12;
+
+const upgradeReceivedResolvers = Promise.withResolvers();
+
+const server = http.createServer();
+server.on('request', common.mustNotCall());
+server.on('upgrade', function(req, socket, upgradeHead) {
+  upgradeReceivedResolvers.resolve();
+
+  // Confirm the upgrade:
+  socket.write('HTTP/1.1 101 Switching Protocols\r\n' +
+              'Upgrade: custom-protocol\r\n' +
+              'Connection: Upgrade\r\n' +
+              '\r\n');
+
+  // Read and validate the request body:
+  let reqBodyLength = 0;
+  req.on('data', (chunk) => { reqBodyLength += chunk.length; });
+  req.on('end', common.mustCall(() => {
+    assert.strictEqual(reqBodyLength, EXPECTED_BODY_LENGTH);
+
+    assert.deepStrictEqual(req.trailers, { 'extra-data': 'abc' });
+
+    // Defer upgrade stream read slightly to make sure it doesn't start
+    // streaming along with the request body, until we actually read it:
+    setTimeout(common.mustCall(() => {
+      let socketData = upgradeHead;
+
+      socket.on('data', (d) => {
+        socketData = Buffer.concat([socketData, d]);
+      });
+
+      socket.on('end', common.mustCall(() => {
+        assert.strictEqual(socketData.toString(), 'upgrade head\npost-upgrade message');
+        socket.end();
+      }));
+    }), 10);
+  }));
+});
+
+await new Promise((resolve) => server.listen(0, () => resolve()));
+
+const conn = net.createConnection(server.address().port);
+conn.setEncoding('utf8');
+
+await new Promise((resolve) => conn.on('connect', resolve));
+
+// Write request headers, body & upgrade head all together
+conn.write(
+  'POST / HTTP/1.1\r\n' +
+  'host: localhost\r\n' +
+  'Upgrade: custom-protocol\r\n' +
+  'Connection: Upgrade\r\n' +
+  'transfer-encoding: chunked\r\n' +
+  'trailer: extra-data\r\n' +
+  '\r\n'
+);
+
+// Make sure the server has processed the above & fired 'upgrade', before the body
+// data starts streaming:
+await upgradeReceivedResolvers.promise;
+
+// Write the body, and include a chunk extension and a trailer header to check
+// that upgrade handling doesn't skip or confuse anything with request parsing:
+conn.write(
+  // 12 byte body sent immediately, with (ignored) chunk extension.
+  'C;chunk-hash=abc\r\nrequest body\r\n' +
+  '0\r\n' +
+  // Request trailer:
+  'extra-data: abc\r\n' +
+  '\r\n' +
+  'upgrade head'
+);
+
+const response = await new Promise((resolve) => conn.once('data', resolve));
+assert.ok(response.startsWith('HTTP/1.1 101 Switching Protocols\r\n'));
+
+// Send more data after connection is confirmed:
+conn.write('\npost-upgrade message');
+conn.end();
+
+await new Promise((resolve) => conn.on('end', resolve));
+
+server.close();
diff --git a/test/parallel/test-http-upgrade-server-with-body-error.mjs b/test/parallel/test-http-upgrade-server-with-body-error.mjs
new file mode 100644
index 00000000000000..68e0b6c98fac3a
--- /dev/null
+++ b/test/parallel/test-http-upgrade-server-with-body-error.mjs
@@ -0,0 +1,46 @@
+import * as common from '../common/index.mjs';
+import * as assert from 'assert';
+import * as http from 'http';
+import * as net from 'net';
+
+const upgradeReceivedResolvers = Promise.withResolvers();
+
+const server = http.createServer();
+server.on('request', common.mustNotCall());
+server.on('upgrade', function(req, socket, upgradeHead) {
+  upgradeReceivedResolvers.resolve();
+
+  // As soon as the body starts arriving, simulate an error
+  req.on('data', () => {
+    req.socket.destroy(new Error('simulated body error'));
+  });
+});
+
+await new Promise((resolve) => server.listen(0, () => resolve()));
+
+const conn = net.createConnection(server.address().port);
+conn.setEncoding('utf8');
+
+await new Promise((resolve) => conn.on('connect', resolve));
+
+// Write request headers, leave the body pending:
+conn.write(
+  'POST / HTTP/1.1\r\n' +
+  'host: localhost\r\n' +
+  'Upgrade: custom-protocol\r\n' +
+  'Connection: Upgrade\r\n' +
+  'transfer-encoding: chunked\r\n' +
+  '\r\n'
+);
+
+// Make sure the server has processed the above & fired 'upgrade' before the body
+// data starts streaming:
+await upgradeReceivedResolvers.promise;
+
+conn.write('5\r\nhello\r\n');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'simulated body error');
+  conn.destroy();
+  server.close();
+}));
diff --git a/test/parallel/test-http-upgrade-server-with-body.mjs b/test/parallel/test-http-upgrade-server-with-body.mjs
new file mode 100644
index 00000000000000..cd0b890cd5e7e8
--- /dev/null
+++ b/test/parallel/test-http-upgrade-server-with-body.mjs
@@ -0,0 +1,69 @@
+import * as common from '../common/index.mjs';
+import * as assert from 'assert';
+import * as http from 'http';
+import * as net from 'net';
+
+const EXPECTED_BODY_LENGTH = 12;
+
+const server = http.createServer();
+server.on('request', common.mustNotCall());
+server.on('upgrade', function(req, socket, upgradeHead) {
+  // Confirm the upgrade:
+  socket.write('HTTP/1.1 101 Switching Protocols\r\n' +
+              'Upgrade: custom-protocol\r\n' +
+              'Connection: Upgrade\r\n' +
+              '\r\n');
+
+  // Read and validate the request body:
+  let reqBodyLength = 0;
+  req.on('data', (chunk) => { reqBodyLength += chunk.length; });
+  req.on('end', common.mustCall(() => {
+    assert.strictEqual(reqBodyLength, EXPECTED_BODY_LENGTH);
+
+    // Defer upgrade stream read slightly to make sure it doesn't start
+    // streaming along with the request body, until we actually read it:
+    setTimeout(common.mustCall(() => {
+      let socketData = upgradeHead;
+
+      socket.on('data', (d) => {
+        socketData = Buffer.concat([socketData, d]);
+      });
+
+      socket.on('end', common.mustCall(() => {
+        assert.strictEqual(socketData.toString(), 'upgrade head\npost-upgrade message');
+        socket.end();
+      }));
+    }), 10);
+  }));
+});
+
+await new Promise((resolve) => server.listen(0, () => resolve()));
+
+const conn = net.createConnection(server.address().port);
+conn.setEncoding('utf8');
+
+await new Promise((resolve) => conn.on('connect', resolve));
+
+// Write request headers, body & upgrade head all together:
+conn.write(
+  'POST / HTTP/1.1\r\n' +
+  'host: localhost\r\n' +
+  'Upgrade: custom-protocol\r\n' +
+  'Connection: Upgrade\r\n' +
+  'transfer-encoding: chunked\r\n' +
+  '\r\n' +
+  'C\r\nrequest body\r\n' + // 12 byte body sent immediately
+  '0\r\n\r\n' +
+  'upgrade head'
+);
+
+const response = await new Promise((resolve) => conn.once('data', resolve));
+assert.ok(response.startsWith('HTTP/1.1 101 Switching Protocols\r\n'));
+
+// Send more data after connection is confirmed:
+conn.write('\npost-upgrade message');
+conn.end();
+
+await new Promise((resolve) => conn.on('end', resolve));
+
+server.close();
diff --git a/test/parallel/test-http-upgrade-server-with-large-body-unread.mjs b/test/parallel/test-http-upgrade-server-with-large-body-unread.mjs
new file mode 100644
index 00000000000000..67f791313d40a2
--- /dev/null
+++ b/test/parallel/test-http-upgrade-server-with-large-body-unread.mjs
@@ -0,0 +1,89 @@
+import * as common from '../common/index.mjs';
+import * as assert from 'assert';
+import * as http from 'http';
+import * as net from 'net';
+
+const upgradeReceivedResolvers = Promise.withResolvers();
+
+const server = http.createServer();
+server.on('request', common.mustNotCall());
+server.on('upgrade', function(req, socket, upgradeHead) {
+  upgradeReceivedResolvers.resolve();
+
+  // Confirm the upgrade:
+  socket.write('HTTP/1.1 101 Switching Protocols\r\n' +
+              'Upgrade: custom-protocol\r\n' +
+              'Connection: Upgrade\r\n' +
+              '\r\n');
+
+  // There's a large body stream in req, but we don't read it here, and we check
+  // that despite this we do still get the upgrade stream that follows it:
+
+  // Head should never be available, because body is still streaming:
+  assert.strictEqual(upgradeHead.length, 0);
+
+  // Defer upgrade stream read, to make sure socket is correctly paused
+  // until we read it
+  setTimeout(() => {
+    let socketData = Buffer.alloc(0);
+
+    // Collect the raw upgrade stream and check we do eventually get the
+    // complete stream:
+    socket.on('data', (d) => {
+      socketData = Buffer.concat([socketData, d]);
+    });
+
+    socket.on('end', common.mustCall(() => {
+      assert.strictEqual(socketData.toString(), 'upgrade head\npost-upgrade message');
+      socket.end();
+    }));
+  }, 10);
+});
+
+await new Promise((resolve) => server.listen(0, () => resolve()));
+
+const conn = net.createConnection(server.address().port);
+conn.setEncoding('utf8');
+
+await new Promise((resolve) => conn.on('connect', resolve));
+
+// Write request headers, leave the body pending:
+conn.write(
+  'POST / HTTP/1.1\r\n' +
+  'host: localhost\r\n' +
+  'Upgrade: custom-protocol\r\n' +
+  'Connection: Upgrade\r\n' +
+  'transfer-encoding: chunked\r\n' +
+  '\r\n'
+);
+
+// Make sure the server has processed the above & fired 'upgrade' before the body
+// data starts streaming:
+await upgradeReceivedResolvers.promise;
+
+// Write a 200KB body in small chunks:
+for (let i = 0; i < 20_000; i++) {
+  conn.write('5\r\nhello\r\n'); // 10 byte chunk = 5 byte body
+}
+
+// Wait briefly, to encourage (though we can't guarantee) the server to have to
+// correctly process the final chunk in one go
+await new Promise((resolve) => setTimeout(resolve, 10));
+
+// Final chunk + end-body + 'upgrade head' upgrade stream:
+conn.write(
+  '3\r\nbye\r\n' +
+  '0\r\n\r\n' +
+  'upgrade head'
+);
+
+const response = await new Promise((resolve) => conn.once('data', resolve));
+assert.ok(response.startsWith('HTTP/1.1 101 Switching Protocols\r\n'));
+
+// Send more data after connection is confirmed:
+conn.write('\npost-upgrade message');
+conn.end();
+
+await new Promise((resolve) => conn.on('end', resolve));
+
+server.close();
diff --git a/test/parallel/test-http-upgrade-server-with-large-body.mjs b/test/parallel/test-http-upgrade-server-with-large-body.mjs
new file mode 100644
index 00000000000000..e60bffc576b038
--- /dev/null
+++ b/test/parallel/test-http-upgrade-server-with-large-body.mjs
@@ -0,0 +1,95 @@
+import * as common from '../common/index.mjs';
+import * as assert from 'assert';
+import * as http from 'http';
+import * as net from 'net';
+
+const upgradeReceivedResolvers = Promise.withResolvers();
+const mainBodyReceivedResolvers = Promise.withResolvers();
+
+const EXPECTED_BODY_LENGTH = 100_003;
+
+const server = http.createServer();
+server.on('request', common.mustNotCall());
+server.on('upgrade', function(req, socket, upgradeHead) {
+  upgradeReceivedResolvers.resolve();
+
+  // Confirm the upgrade:
+  socket.write('HTTP/1.1 101 Switching Protocols\r\n' +
+              'Upgrade: custom-protocol\r\n' +
+              'Connection: Upgrade\r\n' +
+              '\r\n');
+
+  // Read and check the full body is eventually received:
+  let reqBodyLength = 0;
+  req.on('data', (chunk) => {
+    reqBodyLength += chunk.length;
+    if (reqBodyLength >= 100_000) mainBodyReceivedResolvers.resolve();
+  });
+  req.on('end', common.mustCall(() => {
+    assert.strictEqual(reqBodyLength, EXPECTED_BODY_LENGTH);
+  }));
+
+  // Head should never be available, because body is still streaming:
+  assert.strictEqual(upgradeHead.length, 0);
+
+  let socketData = Buffer.alloc(0);
+
+  // Start streaming the raw upgrade stream immediately as well, and check we do
+  // eventually get the complete stream:
+  socket.on('data', (d) => {
+    socketData = Buffer.concat([socketData, d]);
+  });
+
+  socket.on('end', common.mustCall(() => {
+    assert.strictEqual(socketData.toString(), 'upgrade head\npost-upgrade message');
+    socket.end();
+  }));
+});
+
+await new Promise((resolve) => server.listen(0, () => resolve()));
+
+const conn = net.createConnection(server.address().port);
+conn.setEncoding('utf8');
+
+await new Promise((resolve) => conn.on('connect', resolve));
+
+// Write request headers, leave the body pending:
+conn.write(
+  'POST / HTTP/1.1\r\n' +
+  'host: localhost\r\n' +
+  'Upgrade: custom-protocol\r\n' +
+  'Connection: Upgrade\r\n' +
+  'transfer-encoding: chunked\r\n' +
+  '\r\n'
+);
+
+// Make sure the server has processed the above & fired 'upgrade' before the body
+// data starts streaming:
+await upgradeReceivedResolvers.promise;
+
+// Write a 200KB body in small chunks:
+for (let i = 0; i < 20_000; i++) {
+  conn.write('5\r\nhello\r\n'); // 10 byte chunk = 5 byte body
+}
+
+// Wait until all that has been processed, to strongly encourage (though we can't guarantee)
+// the next chunk to arrive in one go, and have to be processed & correctly split
+await mainBodyReceivedResolvers.promise;
+
+// Final chunk + end-body + 'upgrade head' upgrade stream:
+conn.write(
+  '3\r\nbye\r\n' +
+  '0\r\n\r\n' +
+  'upgrade head'
+);
+
+const response = await new Promise((resolve) => conn.once('data', resolve));
+assert.ok(response.startsWith('HTTP/1.1 101 Switching Protocols\r\n'));
+
+// Send more data after connection is confirmed:
+conn.write('\npost-upgrade message');
+conn.end();
+
+await new Promise((resolve) => conn.on('end', resolve));
+
+server.close();