node:http: drain the pinned res.write() tail before socket.end() sends FIN

[robobun]

Problem

const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Length": String(BIG.length) });
  res.write(BIG);        // 8 MiB
  req.socket.end();      // no res.end()
});
// raw net client reads: ~2.5 MiB of body, then FIN.
// node:              8 MiB of body, then FIN.

Since #34511, res.write() payloads larger than the 16 KB cork buffer take a zero-copy path: tryWriteBody writes what the kernel accepts and the unsent tail is held by reference in NodeHTTPResponse::pending_pinned_write, not copied into AsyncSocketData::buffer. req.socket.end() (jsFunctionNodeHTTPServerSocketEnd -> shutdownAfterResponseDrains) only consults AsyncSocket::getBufferedAmount(), sees 0, and shuts the socket down immediately. In Node.js res.write() and socket.end() go through one net.Socket Writable, so the FIN is already ordered behind every queued byte.

Fix

• shutdownAfterResponseDrains() first spills the current response's pending_pinned_write into AsyncSocketData::buffer (new Bun__NodeHTTPResponse_spillPendingPinnedWrite, the same spill path res.end() already uses), so getBufferedAmount() counts it and deferShutdownUntilResponseDrains hands the close to HttpContext::onWritable.
• deferShutdownUntilResponseDrains uncorks before probing getBufferedAmount(): socket.end() can run inside HttpContext::onData's corked region (e.g. from a req 'data' listener), and a sub-cork-buffer spill or prior res.write(small) would otherwise be invisible to the probe.
• New HttpResponseData::HTTP_NODE_SOCKET_ENDED bit is set alongside HTTP_CONNECTION_CLOSE, and HttpContext::onWritable's shutdown gate also checks it: socket.end() means no more response bytes will ever be written, so the gate fires once the buffer has drained even when res.end() was never called. HTTP_RESPONSE_PENDING is left alone so onEnd's httpAllowHalfOpen gate and onData's pipelined-dispatch branch keep their existing semantics. The bit is per-response (cleared by resetResponseState()) so it cannot leak into a subsequent keep-alive response and trip the gate while that response still has a pinned tail outstanding.

Verification

New describe.each in test/js/node/http/node-http-pinned-write.test.ts covers Content-Length, chunked, and two pipelined keep-alive requests in one write; each receives ~2.5 MiB on main and the full 8 MiB with the fix, matching Node.js byte-for-byte (the test asserts the exact body length per framing). node-http-pinned-write.test.ts (12/12), node-http-backpressure.test.ts, node-http-server-socket-end-drain.test.ts, node-http-nested-cork.test.ts, node-http-transfer-encoding.test.ts and node-http.test.ts pass (the one request via http proxy failure there is pre-existing on released bun in this environment).

---

no test proof · iteration 0 · Platform-specific test(s) that do not run on this machine. Deferring to CI, which covers all platforms: test/js/node/http/node-http-pinned-write.test.ts

[robobun]

^{Updated 11:10 PM PT - Jul 21st, 2026}

❌ @robobun, your commit fea03f2 has 1 failures in Build #77396 (All Failures):

• test/js/bun/http/bun-server.test.ts - code 1 on 🍎 14 aarch64

---

🧪   To try this PR locally:

bunx bun-pr 35027

That installs a local version of the PR into your bun-35027 executable, so you can run:

bun-35027 --bun

[coderabbitai]

Walkthrough

Changes

Node HTTP shutdown now preserves socket-end state, spills pending pinned writes before FIN checks, and validates response delivery across content-length, chunked, and pipelined scenarios when req.socket.end() occurs without res.end().

Node HTTP shutdown

Layer / File(s)	Summary
Track socket-end shutdown state packages/bun-uws/src/HttpResponseData.h, packages/bun-uws/src/HttpContext.h, src/jsc/bindings/node/JSNodeHTTPServerSocket.cpp	Adds HTTP_NODE_SOCKET_ENDED and permits shutdown when the socket-end state is set.
Spill pinned writes before close src/runtime/server/NodeHTTPResponse.rs, src/jsc/bindings/node/JSNodeHTTPServerSocket.cpp	Exports and invokes a callback that moves pending pinned write data into buffered output before shutdown checks.
Validate socket-end response delivery test/js/node/http/node-http-pinned-write.test.ts	Tests content-length, chunked, and pipelined keep-alive responses delivered after req.socket.end() without res.end().

Possibly related PRs

• oven-sh/bun#34432: Updates related node:http socket read pause/resume and HttpContext handling.
• oven-sh/bun#34511: Adds pending pinned-write machinery used by this shutdown path.
• oven-sh/bun#34610: Extends pending pinned write tail handling in Node HTTP response streaming.

Suggested reviewers: cirospaciari

🚥 Pre-merge checks | ✅ 4

✅ Passed checks (4 passed)

Check name	Status	Explanation
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Title check	✅ Passed	The title clearly and accurately summarizes the main change: draining pinned res.write() data before socket.end() sends FIN.
Description check	✅ Passed	The description covers the PR purpose and verification, though it uses custom headings instead of the template's exact section names.

---

_{Comment @coderabbitai help to get the list of available commands.}

[coderabbitai]

Actionable comments posted: 1

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/jsc/bindings/node/JSNodeHTTPServerSocket.cpp`:
- Around line 251-253: Condense each non-obvious comment to three lines or fewer
while preserving its rationale: update the shutdown-state comment at
src/jsc/bindings/node/JSNodeHTTPServerSocket.cpp lines 251-253, the
pinned-tail/FIN comment at test/js/node/http/node-http-pinned-write.test.ts
lines 343-347, and the framing comment at
test/js/node/http/node-http-pinned-write.test.ts lines 391-394; make no code
changes.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 3ce53087-91fe-4fbe-8219-1682dadf3441

📥 Commits

Reviewing files that changed from the base of the PR and between 85ddc95 and 1e51745.

📒 Files selected for processing (5)

• packages/bun-uws/src/HttpContext.h
• packages/bun-uws/src/HttpResponseData.h
• src/jsc/bindings/node/JSNodeHTTPServerSocket.cpp
• src/runtime/server/NodeHTTPResponse.rs
• test/js/node/http/node-http-pinned-write.test.ts

[claude]

fea03f2 addresses my last concern — HTTP_NODE_SOCKET_ENDED is out of HTTP_CONNECTION_SCOPED, so resetResponseState() clears it and it can't leak into a subsequent response. I re-checked the current diff and found nothing further; deferring to a maintainer for the uWS socket-lifecycle change.

What was reviewed:

• onWritable shutdown gate: the new OR branch fires only with HTTP_CONNECTION_CLOSE (set alongside the bit) and only for the response that called socket.end().
• spill_pending_pinned_write_for_end reuses the existing spill path (spillBodyTail) already exercised by res.end() and second-write-before-drain.
• The new uncork() before the buffered-amount probe: onData's trailing uncork() becomes a no-op (no cork slot), and the early flush is what makes sub-cork-buffer writes visible to the probe.

Extended reasoning...

Overview

Fixes a node:http compat truncation: res.write(large); req.socket.end() (no res.end()) sent FIN before the zero-copy pinned tail drained. Touches packages/bun-uws/src/HttpContext.h (onWritable shutdown gate), HttpResponseData.h (new HTTP_NODE_SOCKET_ENDED bit), JSNodeHTTPServerSocket.cpp (spill + uncork before the buffered-amount probe), a thin Rust export in NodeHTTPResponse.rs, and three new describe.each cases in node-http-pinned-write.test.ts.

Prior review status

I flagged two issues on earlier revisions, both fixed: (1) clearing HTTP_RESPONSE_PENDING broke onEnd's half-open gate and onData's pipelined-dispatch check → replaced with a dedicated bit in 1e51745; (2) that bit was in HTTP_CONNECTION_SCOPED and could leak into a later response → dropped in fea03f2. On the current head I traced the remaining reader (onWritable) and the two resetResponseState() callers and found no further hazard: the bit is set only alongside HTTP_CONNECTION_CLOSE, and while HTTP_RESPONSE_PENDING is set neither reset caller is reachable.

Security risks

None identified. Server-side write ordering; no parsing of untrusted input, no auth/crypto.

Level of scrutiny

High — this is bun-uws HTTP server socket lifecycle (cork state, buffered-amount accounting, shutdown sequencing) on a hot node:http compat path. Two earlier revisions had real ordering bugs, which is a signal the interaction surface is subtle.

Other factors

Tests cover Content-Length, chunked, and pipelined keep-alive; the PR body lists the surrounding test files as passing. The Rust export is a one-line wrapper over an existing helper. Given the subsystem, a maintainer familiar with the uWS/node:http integration (coderabbit suggested cirospaciari) should give final sign-off.

[robobun]

CI on build 77396: the diff is green (the new node-http-pinned-write.test.ts cases pass on every lane). The sole red lane is test/js/bun/http/bun-server.test.ts on darwin-14-aarch64 ("should not use 100% CPU when websocket is idle", 5.2% vs threshold), which is pre-existing on main and unrelated to this change. The remaining annotations are flaky install / napi / repl / GC-timing tests that passed on retry. Ready for review.

[robobun]

Note on the state of main for this case, from the check that closed #35054.

Main at 36cd151 (with #43557) no longer truncates: res.write(8 MiB) then req.socket.end() delivers all the bytes. What remains is the FIN. If the handler never calls res.end(), main sends no FIN after the bytes. Node.js v26.3.0 sends it at once.

8 MiB, response never ended	Node.js v26.3.0	canary 367d939 (before #43557)	main 36cd151 (debug)
one res.write(), socket.end()	closed, 8,388,749 bytes	closed, 2,621,579 bytes	no close after 40 s, 8,388,749 bytes
8 KiB writes, socket.end()	closed, 8,396,931 bytes	no close after 15 s	no close after 15 s, 8,396,931 bytes
one res.write(), destroySoon()	closed, 8,388,749 bytes	closed, 2,621,579 bytes	closed, 8,388,749 bytes
8 KiB writes, destroySoon()	closed, 8,396,931 bytes	closed, 2,594,001 bytes	closed, 8,396,931 bytes

With 1 MiB (it fits the socket buffers) socket.end() closes correctly on main.

Repro

// WRITE=one|many  CLOSE=end|destroySoon
import { once } from "node:events";
import http from "node:http";
import net from "node:net";
const SIZE = 8 << 20;
const { WRITE = "one", CLOSE = "end" } = process.env;
const server = http.createServer((req, res) => {
  res.writeHead(200);
  if (WRITE === "one") res.write(Buffer.alloc(SIZE, 0x61));
  else {
    const chunk = Buffer.alloc(8 * 1024, 0x61);
    for (let i = 0; i < SIZE / chunk.length; i++) res.write(chunk);
  }
  if (CLOSE === "end") req.socket.end();
  else req.socket.destroySoon();
});
await once(server.listen(0, "127.0.0.1"), "listening");
const c = net.connect(server.address().port, "127.0.0.1");
await once(c, "connect");
let bytes = 0;
c.on("data", d => (bytes += d.length));
c.on("error", () => {});
c.write("GET / HTTP/1.1\r\nHost: x\r\n\r\n");
const watchdog = setTimeout(() => {
  console.log("no close after 15 s, bytes=" + bytes);
  process.exit(1);
}, 15000);
await new Promise(resolve => c.once("close", resolve));
clearTimeout(watchdog);
console.log("closed, bytes=" + bytes);
process.exit(0);

This branch conflicts with main.

[robobun]

Closing: #44244 replaces this PR. It is stacked on #44243.

• The spill of the pinned write and the uncork that this PR added are on main through node:http: the server follows Node (request body, framing, response finish, lifecycle) #43557.
• What was left is the FIN behind bytes that uWS still holds, when the response never ends. node:http: half-close from the drain gate when socket.end() waited for buffered bytes #44244 sends that FIN from the drain gate as a half-close, so the socket stays until the peer ends.
• The gate arm of this PR calls shutdown() and close(). That is the lifetime of destroySoon(), not of end().