James M Snell

Consolidated IdentityTransformStream/FixedLengthStream Test Suite A structured, consolidated suite for ITS/FLS. Runs both the legacy C++ and TypeScript implementations across a common set of tests, with additional tests for unflagged legacy behaviors. Accomodation for intentional divergences between the implementations is called out with two open TODOs for bugs to fix in the TS impl.

Expand the node:stream web-interop suite Cover the adapter contracts beyond the happy path: argument and option validation (before any lock is taken), lock acquisition and the locked error each implementation raises, derived queuing strategies and the backpressure they produce in both directions, chunk conversion (Buffer copies out of Readable.toWeb, node-style Buffer conversion into the web sinks, objectMode identity), close/end/error/destroy propagation in both directions, the unreadable/unwritable inputs that yield pre-cancelled or pre-closed streams, and the Duplex pair whose two halves settle together because both adapters observe the whole Duplex. Add bodies (Request/Response bodies through the adapters in both directions, IdentityTransformStream, FixedLengthStream with the per-implementation enforcement shapes, pipeThrough chains), node:stream/consumers over web streams, and Readable.from() over a web ReadableStream. The C++ cell pins transformstream_enable_standard_constructor for the transform chains.

Add digest streams suite; migrate existing DigestStream tests

Implement TS DigestStream DigestStream is one of only two WritableStream subclasses in the runtime. When the typescript_implemented_streams flag swaps globalThis.WritableStream for the TypeScript class, a C++ subclass of the C++ WritableStream stops passing the brand checks pipeTo relies on, and instanceof WritableStream becomes false for it. Reimplementing the subclass in TypeScript is what restores the hierarchy. Only the stream semantics move. Hashing stays in C++ behind a new DigestContextHandle, reached through a deliberately crypto-free declaration in digest-bootstrap.h so the per-isolate bootstrap need not depend on the crypto headers. String chunks are forwarded to it rather than encoded here, because the encoding is not expressible in JavaScript: TextEncoder always substitutes U+FFFD, so it cannot produce the WTF-8 bytes DigestStream has always hashed. That is also why update() returns a byte count, a string's UTF-8 length not being observable from JavaScript. Both implementations run crypto-streams-test.js unmodified so the two cannot drift. ts-digest-stream-test.js covers TypeScript-only behavior and holds the canary that the install in main.ts actually took effect, without which the rest of the suite would pass against the C++ class too. One divergence is intentional: the digest promise is marked handled, so abandoning it produces no unhandled-rejection report where the C++ implementation does. Consuming digest is optional, an abort still surfaces through the writer's ready/closed promises, and marking does not propagate to derived promises. The other subclass, FileSystemWritableFileStream, has the same problem but is constructed from C++ rather than by user code, so it needs a native source/sink bridge instead of a straight port.

Implement proper js rpc stream cancel propagation Two defects in jsrpc streams handling here are addressed. 1. ReadableStream: when the receiver canceled (or released) its copy, the origin only found out when its next write into the ByteStream failed. A source that was idle -- waiting for data it would never produce -- never wrote again, so its cancel algorithm never ran and the pump stayed parked until the request ended. No origin pump watched the sink for disconnection, and the byte stream is one-directional, so there was no channel for the receiver to report it. 2. Native WritableStream (e.g. IdentityTransformStream.writable): when the receiver aborted or dropped its copy, the origin's WritableStreamRpcAdapter was destroyed and dropped its WritableStreamSink without calling abort(). The identity stream's shared state kept its pending read request, so a read on the paired readable hung forever. Only the legacy implementation's native sinks were affected; JS-backed and TypeScript-implemented origins already aborted on drop. For the first, this implemens a readableStream.canceler capability that is called when the remote side drops or cancels the stream, allowing that signal to propagate. For the second, WritableStreamRpcAdapter tracks ended. On destruction or revoke is cancels in-flight operations then inner->abort() unless cleanly ended. Both are gated by separate autogates for tested rollout.

Settle identity-stream writes once read; span reads; tee at the slowest An IdentityTransformStream write enqueued its whole chunk once a read had been issued and settled then. A BYOB read that took part of it left the rest in the readable queue with the write already resolved and its bytes gone from the writer's desiredSize, and on a tee a write settled as soon as it entered the shared queue. A BYOB read never spanned writes, directly or on a tee branch: the writable hands the sink one write at a time. The identity suite's partialFillAcrossReads passed only because of microtask ordering. The TypeScript contract is now: - A write settles once reads have taken all its bytes, and stays counted in the writer's desiredSize until then. - A read takes everything already written. Each accepted write's bytes are snapshotted in its size() callback, so a pull hands over the rest of the in-flight write and the writes queued behind it, before the writable reaches them. A direct BYOB read fills its view across them through its byobRequest; a read with a minimum waits for it, then takes everything available, up to its view. Default reads and tee branches get one chunk per write through the batched enqueue, so a branch's BYOB read spans them while a default read still takes one write. - On a tee, backpressure follows the slowest branch: a write settles once every branch has read its last byte, tracked through the queue's consumption hook. As a pending read on any cursor overrides backpressure in the queue's pull rule, a starved branch (a pull that finds nothing more) releases a fully delivered write, so an idle branch buffers rather than stalling the writer. A write read before the writable reaches it settles when its sink step runs, a few microtasks after the read, so tests that asserted writer accounting immediately after reads now wait for the writes. A draining read sweeps every write made before it, and bytes that partly fill a read waiting for its minimum count as read, so a writer that awaits each write can supply the rest. This intentionally differs from the C++ IdentityTransformStream, which is unchanged: it answers a BYOB read with at most one write's bytes, stops a read with a minimum once it is met, settles a write once one tee branch has read it, and caps a branch's reads at the sizes the first-reading branch requested. The differences are pinned in the identity suite (ledger #22, #23, including the new tee-byob.js and the per-implementation tee-backpressure tests) and in the r2-patterns readAtLeast cases (its ledger #5). Behind the experimental typescript_implemented_streams flag.

Add readable streams suite: scaffold and core modules (phase A)

Add compression streams suite; migrate existing CS/DS tests

Add cache, htmlrewriter, and formdata streams suites

Add piping suite: migrate pipe matrix (phase A)