A node:net client that retains incoming chunks (protocol reassembly: tedious TDS messages, length-prefixed framing, etc.) pins up to 14x more memory than the data it holds, because every read hands JS an ArrayBuffer that owns the full 64 KB read slab regardless of nread. This PR right-sizes small reads, dropping retention to Node parity:

20,000 retained chunks per run, ack-paced so each write lands as its own read (as on a real network, where reads don't coalesce to full slabs); medians of 5, macOS aarch64, both binaries built from the same tree with the same profile — the baseline is this branch's base commit, so the only difference is this diff. Every run content-verified (all retained bytes checked, totals exact). The baseline's flat ~380 MiB independent of chunk size is the signature of the bug: 20,000 × ~19 KB resident (the 64 KB slab, page-rounded by the OS) no matter how few bytes each read carried. With this PR, growth tracks the actual retained data at every size, within a few MiB of Node.

Wall time on the same runs improves as a side effect of the reduced allocator/GC pressure: 912→743 ms (512 B), 919→769 ms (1400 B), 955→841 ms (4 KiB); 16 KiB unchanged within noise.

Cause

on_uv_read (ext/node/ops/stream_wrap.rs) always transferred ownership of the 65536-byte slab from on_uv_alloc into the ArrayBuffer passed to onread, with a deleter that frees it at GC. Buffer.from(ab, 0, nread) in onStreamRead then views only nread bytes, but the view keeps the whole slab alive for as long as the consumer holds the chunk. Node instead shrinks the store to nread before handing it to JS (BackingStore::Reallocate in EmitToJSStreamListener::OnStreamRead, src/stream_base.cc).

Beyond RSS, the handoff also defeats the slab pool this file maintains (READ_BUF_POOL, 128 slots): slabs come back only at GC, so in steady state the pool runs dry and reads fall back to the system allocator — the exact mach_vm_reclaim overhead (~6% CPU in the profile that motivated the pool) it was added to avoid.

Fix

Reads with nread <= READ_COPY_THRESHOLD (half a slab, 32 KB) are copied into an exact-size backing store (new_backing_store_from_vec) and the slab is returned to the pool immediately. Larger reads — bulk transfers actually filling most of the slab — keep the existing zero-copy slab handoff, so the well-behaved path is untouched. The copy is bounded at 32 KB (~1 µs) against a read dispatch that costs ~10 µs+.

No regressions on the paths that were already fine

• Bulk 1 GiB transfer (reads coalesce to ~64 KB → slab-handoff path): 2470 → 2463 MiB/s, medians of 7. Unchanged, as intended.
• 512 B ping-pong, 32 connections × 5000 round trips (per-read fixed cost): 23.2 → 22.9 µs/rt, medians of 5.

Verification

• unit_node::net_test, unit_node::http_test, unit_node::tls_test — pass on this branch (TLS matters here: ciphertext ingest rides this same read path via the TLSWrap onread forwarder).
• specs::node (257 tests): failure set byte-identical to an upstream/main baseline build run on the same machine — the same 2 pre-existing child_process_ipc_handle::destroy_before_ack_* flakes on both (they reproduce at ~3/30 on unpatched debug builds).
• Integrity checked on every benchmark run: every retained byte verified against the sent pattern, byte counts exact.
• tools/format.js and tools/lint.js pass.

// Ack-paced small reads; client retains all chunks (protocol-assembly
// pattern). Usage: deno run -A bench.ts [chunks] [chunkBytes]
import net from "node:net";
import process from "node:process";

const args = typeof Deno !== "undefined" ? Deno.args : process.argv.slice(2);
const rssNow = () =>
  typeof Deno !== "undefined" ? Deno.memoryUsage().rss : process.memoryUsage().rss;

const CHUNKS = Number(args[0]) || 20000;
const CHUNK = Number(args[1]) || 1400;

const server = net.createServer((sock) => {
  sock.setNoDelay(true);
  const chunk = Buffer.alloc(CHUNK, 0x61);
  let sent = 0;
  // One chunk per 1-byte ack from the client, so reads never coalesce.
  sock.on("data", () => {
    if (sent >= CHUNKS) return sock.end();
    sent++;
    sock.write(chunk);
  });
  sock.on("error", () => {});
});
await new Promise<void>((r) => server.listen(0, "127.0.0.1", () => r()));
const port = (server.address() as net.AddressInfo).port;

const rssStart = rssNow();
const t0 = performance.now();
const retained: Buffer[] = [];
let received = 0, reads = 0;

await new Promise<void>((resolve, reject) => {
  const ack = Buffer.from([1]);
  const sock = net.connect({ port, host: "127.0.0.1" }, () => {
    sock.setNoDelay(true);
    sock.write(ack);
  });
  sock.on("data", (buf: Buffer) => {
    retained.push(buf);
    received += buf.length;
    reads++;
    sock.write(ack);
  });
  sock.on("end", resolve);
  sock.on("error", reject);
});

const wall = performance.now() - t0;
server.close();
const rssEnd = rssNow();

let badBytes = 0;
for (const b of retained) for (let i = 0; i < b.length; i++) if (b[i] !== 0x61) badBytes++;
console.log(`chunks=${CHUNKS} x ${CHUNK}B  wall ${wall.toFixed(0)} ms  reads=${reads}`);
console.log(
  `retainedData ${(received / 1048576).toFixed(1)} MiB  growth ${
    ((rssEnd - rssStart) / 1048576).toFixed(0)
  } MiB  amplification ${((rssEnd - rssStart) / received).toFixed(1)}x`,
);
console.log(`integrity: ${badBytes === 0 && received === CHUNKS * CHUNK ? "OK" : "FAIL"}`);
if (retained.length === -1) console.log(retained.length); // keep alive

I used Cursor (Claude) to help investigate and write this change.