stream: trim webstreams sink wrappers and BYOB transfers

[mcollina]

Round 23 of the webstreams performance work. It is stacked on #66643 (the first commit here is that PR's commit); only the second commit, stream: trim webstreams sink wrappers and BYOB transfers, is new.

Sink and transformer one-shot methods without wrappers

The close and abort methods of an underlying sink and the flush and cancel methods of a transformer were each wrapped at construction in an async closure kept by the controller for the stream's lifetime (two per WritableStream, two per TransformStream, with their contexts). They are now stored as-is in the controller state next to the object they belong to and called as that object's methods, with the spec's argument list, through a promiseCall helper that reproduces the reference implementation's adoption ticks (a synchronous throw becomes a rejection, a returned promise settles the caller two microtasks later, a plain value settles it at once).

The per-chunk methods (write, transform) keep their closures: the captured method is a constant for TurboFan there, and replacing the closure with a FunctionPrototypeCall on a stored method lost the inlining of the user function on the pipe-to rows. The source's cancel wrapper is also kept, because every variant that touched the readable stream's construction path shifted its inlining budget enough to show up in the creation rows.

Bytes allocated per stream with user methods: WritableStream 1040 → 844, TransformStream 1816 → 1720.

Unobservable BYOB transfers

Each BYOB read performed up to four ArrayBuffer transfers, and allocating an ArrayBuffer costs about half a microsecond here. Two of them are dropped:

• ReadableByteStreamControllerConvertPullIntoDescriptor no longer transfers the descriptor's buffer before building the result view. By then nothing else can reach that buffer: it was transferred when the descriptor was created, and the BYOB request that exposes it is only ever invalidated together with a transfer.
• On enqueue(), the first pending descriptor's buffer is only transferred when a BYOB request exposes it; without one there is no view to detach.

Verification

• WPT streams, encoding and compression (286 files) and the parallel webstream, encoding, blob, fetch, stream and worker tests (426 files, including the new test-whatwg-webstreams-underlying-methods.js) pass.
• A probe of 46 scenarios covering every user method (start/pull/cancel/write/close/abort/transform/flush) returning a value, a native promise, a thenable, throwing, or returning a rejected promise logs the same microtask tick for every observable step on the base and patched builds, as do the ordering probes from the previous rounds.

Benchmarks

benchmark/compare.js, 20 runs, against the previous commit:

                                                                       confidence improvement accuracy (*)    (**)   (***)
webstreams/readable-read.js type='byob' n=100000                              ***     17.14 %       ±1.80%  ±2.41%  ±3.17%
webstreams/readable-async-iterator.js type='normal' n=100000                           3.79 %       ±4.49%  ±6.02%  ±7.92%
webstreams/from.js kind='sync' n=1000000                                        *     -2.18 %       ±2.02%  ±2.70%  ±3.57%
webstreams/js_transfer.js n=10000 payload='TransformStream'                     *     -1.85 %       ±1.58%  ±2.12%  ±2.81%

The other 42 rows are within their confidence intervals. The two rows at the 5% level are the expected number of false positives for 46 comparisons; the transfer row is the one that could be real (it was between -1.5% and -2.7% at the 5% level in three runs), and I could not find a mechanism for it, since the transfer path only loses two closures per WritableStream.

---

AI Generated, reviewed by me.