http: emit ServerResponse 'close' on client disconnect

When the canUseInternalAssignSocket fast path is taken,
assignSocketInternal stores onServerResponseClose on the socket via
setCloseCallback (self[kCloseCallback] = ...) instead of registering a
real EventEmitter listener. The 'close' event the Duplex fires when the
underlying handle goes away never triggered that stored callback, so
ServerResponse.on('close', ...) never fired on client abort.

Hook NodeHTTPServerSocket.emit so the stored callback runs when the
socket emits 'close', mirroring what ServerResponse.prototype.emit
already does for the response side.

Fixes #29219

Author: robobun

src/js/node/_http_server.ts

@@ -1106,6 +1106,18 @@ const NodeHTTPServerSocket = class Socket extends Duplex {
     return super.resume();
   }
 
+  emit(event, ...args) {
+    if (event === "close") {
+      // Trigger the stored close callback (onServerResponseClose from
+      // assignSocketInternal) so the attached ServerResponse receives its
+      // own 'close' event. The canUseInternalAssignSocket path stores the
+      // callback as self[kCloseCallback] instead of adding a real event
+      // listener, so we need this hook to reach it. See issue #29219.
+      callCloseCallback(this);
+    }
+    return super.emit(event, ...args);
+  }
+
   get [kInternalSocketData]() {
     return this[kHandle]?.response;
   }

test/regression/issue/29219.test.ts

@@ -0,0 +1,51 @@
+// https://github.com/oven-sh/bun/issues/29219
+//
+// http.ServerResponse must emit 'close' when the client disconnects in the
+// middle of an in-flight response. Pre-fix, `res.on('close')` never fired
+// because the stored `onServerResponseClose` callback on the socket was
+// never invoked when the socket emitted its own 'close' event.
+import { expect, test } from "bun:test";
+import http from "node:http";
+import net from "node:net";
+
+test("ServerResponse emits 'close' when the client aborts mid-response", async () => {
+  const { promise, resolve } = Promise.withResolvers<{
+    resClosed: boolean;
+    reqErrored: boolean;
+  }>();
+
+  let resClosed = false;
+  let reqErrored = false;
+
+  const server = http.createServer((req, res) => {
+    res.on("close", () => {
+      resClosed = true;
+    });
+
+    // Write some data so the response is mid-stream when the client aborts.
+    res.write("hello\n");
+
+    req.on("error", () => {
+      reqErrored = true;
+      server.close(() => {
+        resolve({ resClosed, reqErrored });
+      });
+    });
+  });
+
+  await new Promise<void>(done => {
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address() as net.AddressInfo;
+      const client = net.createConnection({ port, host: "127.0.0.1" }, () => {
+        client.write("GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n");
+        client.on("data", () => {
+          client.end(); // force abort mid-response
+        });
+      });
+      done();
+    });
+  });
+
+  const result = await promise;
+  expect(result).toEqual({ resClosed: true, reqErrored: true });
+});