René's URL Explorer Experiment

{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"http: 'drain' is never emitted for chunked responses with multi-byte strings (v24.22.0 regression)","articleBody":"### Version\n\nv24.22.0 (also main / v27.0.0-pre; v24.21.0 is not affected)\n\n### Platform\n\n```text\nDarwin arm64 (macOS); also linux x64 in Docker (node:24-alpine)\n```\n\n### Subsystem\n\nhttp\n\n### What steps will reproduce the bug?\n\nRun the following single-file script with `node repro.js`. It starts an HTTP server that writes 30k multi-byte string chunks to a chunked `http.ServerResponse`, awaiting `'drain'` whenever `write()` returns `false`. A forked child process reads the response slowly.\n\n```js\n'use strict';\nconst http = require('node:http');\nconst { once } = require('node:events');\nconst { fork } = require('node:child_process');\n\nif (process.argv[2] === 'client') {\n  // Slow consumer in a separate process.\n  http.get(`http://127.0.0.1:${process.argv[3]}/`, (res) => {\n    let bytes = 0;\n    res.on('data', (chunk) => {\n      bytes += chunk.length;\n      const t = performance.now();\n      while (performance.now() - t \u003c 2); // simulate per-chunk work\n    });\n    res.on('end', () => process.send({ done: true, bytes }));\n  });\n  return;\n}\n\nconst ROWS = 30000;\n// Rows of mixed ASCII + 2-byte UTF-8 characters, ~200-600 bytes each.\nconst rows = Array.from({ length: ROWS }, (_, i) =>\n  'a'.repeat(50 + (i * 37) % 200) + 'ع'.repeat(50 + (i * 53) % 150) + '\\n');\n\nconst server = http.createServer(async (req, res) => {\n  for (let i = 0; i \u003c ROWS; i++) {\n    if (!res.write(rows[i])) {\n      const timer = setTimeout(() => {\n        console.log(`${process.version}: STALLED at row ${i}`, {\n          writableNeedDrain: res.writableNeedDrain,\n          writableLength: res.writableLength,\n          socketWritableLength: res.socket.writableLength,\n          socketWritableNeedDrain: res.socket.writableNeedDrain,\n        });\n        process.exit(1);\n      }, 3000);\n      await once(res, 'drain');\n      clearTimeout(timer);\n    }\n  }\n  res.end();\n});\n\nserver.listen(0, () => {\n  const child = fork(__filename, ['client', server.address().port]);\n  child.on('message', ({ bytes }) => {\n    console.log(`${process.version}: OK, client received ${bytes} bytes`);\n    child.kill();\n    process.exit(0);\n  });\n});\n```\n\n### How often does it reproduce? Is there a required condition?\n\nEvery time in our environment (it stalls at the same row on every run).\n\nRequired conditions:\n- a chunked response (no `Content-Length`)\n- **multi-byte string chunks**: the same script with ASCII-only rows of identical *byte* length does not stall\n- a reader slow enough to apply backpressure (a fast reader such as `curl` does not trigger it)\n\n### What is the expected behavior? Why is that the expected behavior?\n\nAfter `res.write()` returns `false`, `'drain'` is emitted once the buffered data has been flushed, as documented for writable streams. v24.21.0 completes:\n\n```\nv24.21.0: OK, client received 11985000 bytes\n```\n\n### What do you see instead?\n\n`'drain'` is never emitted, even though nothing is buffered anymore:\n\n```\nv24.22.0: STALLED at row 2140 {\n  writableNeedDrain: true,\n  writableLength: 0,\n  socketWritableLength: 0,\n  socketWritableNeedDrain: false\n}\n```\n\nThe writer waits forever. In production the client (undici) eventually aborts with `UND_ERR_BODY_TIMEOUT` after 300 s.\n\n### Additional information\n\n- This started with v24.22.0, which includes #64987 (`http: coalesce chunked writes during auto-corking`). With that change, `write()` decides its return value from the message-level buffer (`msg.writableLength`), where `kChunkedLength` is measured in **bytes** (`Buffer.byteLength`). Once that reaches the high-water mark it returns `false` and sets `kNeedDrain`.\n- The coalesced chunks are then flushed in the next-tick `uncork()` via `socket.write()` with string data, and `net.Socket` accounts string chunks in **UTF-16 code units**, not bytes:\n\n  ```js\n  socket.cork(); socket.write('ع'.repeat(1000)); // 2000 bytes on the wire\n  socket.writableLength; // 1000 (same on v24.21.0 and v24.22.0)\n  ```\n\n  So with multi-byte text the socket believes it is below its high-water mark, `socket.write()` returns `true`, the socket never sets `needDrain` and never emits `'drain'`. The other emit path (`uncork()` checking `writableLength === 0` right after the flush) is missed because bytes are still pending at that instant. `kNeedDrain` stays `true` with nothing buffered.\n- Before #64987 the return value came from the socket itself, so the two accountings could not disagree. With ASCII-only data bytes equal code units, which is why only multi-byte bodies are affected.\n- #66039 (`http: count buffered outgoing data in bytes`) looks related but does not cover this: it changes the buffered branch of `_writeRaw()` (`outputData` / `outputSize`), and instrumenting this repro shows that branch is never taken (every write goes straight to the socket).\n- I have a fix with a test that re-checks the drain condition once the flushed data has been written, and will open a PR referencing this issue.","author":{"url":"https://github.com/junyup0503","@type":"Person","name":"junyup0503"},"datePublished":"2026-10-16T06:11:16Z","url":"https://github.com/nodejs/node/issues/66781"}