Readable-byte suite: per-test map of the WPT general.any.js failures

Author: jasnell

src/tests/streams/readable-byte/AGENTS.md

@@ -59,6 +59,31 @@ bridge drives to consume TypeScript streams (conduit basics in the
 identity suite's draining-reader.js). No such global exists under the
 C++ implementation; `draining-reader.js` asserts both sides.
 
+## WPT map: readable-byte-streams/general.any.js expectedFailures
+
+The 34 C++ expectedFailures in that WPT file (see
+src/wpt/streams-test.ts), each mapped to the suite pin that owns the
+divergence root. "Family" means the WPT test fails for the same root a
+named suite test pins directly, differing only in incidental asserts.
+
+| WPT test (abbreviated) | Root | Suite pin |
+| --- | --- | --- |
+| start() throws an exception | ctor captures sync start throws (ledger #4) | `syncStartThrow` |
+| Automatic pull() after start() / after read() / after read(view) | proactive pull (ledger #3) | `pullCountShape` |
+| autoAllocateChunkSize | auto-allocated byobRequest on default reads (ledger #5) | `byobRequestOnDefaultRead` |
+| Respond to pull() by enqueue() asynchronously / multiple pull() by separate enqueue() / read() twice then enqueue() twice / Push source without pull signal / enqueue()+getReader()+read() | pull-count and coalescing family (ledger #3, #17) | `pullCountShape`, `byteDesiredSizeAccounting` |
+| constructor rejects size with type "bytes" | ledger #1 | `sizeStrategyForBytes` |
+| cancel() with partially filled pending pull() | done-shape family + partial discard | `cancelWithPartiallyFilledPull` (direct) |
+| getReader(), read(view), then cancel() | pull runs before cancel under C++ | `readViewThenCancelOrdering` (direct) |
+| enqueue() with Uint16Array then read() / 3 byte + 2-element Uint16Array | mismatched view/enqueue granularity | `readableStreamBytesMismatchedSizes`, `byobUint16Array` |
+| read(view) Uint32Array filled by multiple enqueue() | partial fills across enqueues | `byobUint32Array`, `byobPartialRespondMisalignsFillOffset` |
+| enqueue(), read(view) partially, then read() | remainder to a default read | `partialViewThenDefaultRead` (direct; PARITY) |
+| read(view) Uint16 on close()-d with 1 byte / errored if close()-d before fulfilling read(view) | close-with-partial (ledger #7) | `closeWithPartiallyFilledView` |
+| Throwing in pull ignored if errored / pull throw errors stream | pull-throw shapes | `pullThrowIgnoredIfErrored`, `pullThrowErrorsStream` |
+| enqueue() discards auto-allocated BYOB request | request invalidation | `enqueueDiscardsByobRequest` |
+| releaseLock()+second-reader ×9 (respond / respond(1) Uint16 / respond(3) / respondWithNewView / autoAllocate ×3 / Uint16 respond(1) chains ×2) | the release-relock cluster (ledger #9, #10) | `release-relock.js` (whole module) |
+| Multiple read(view): close() and respond() / big enqueue() / multiple enqueue() | multi-pending-read delivery | `readableStreamMultiplePendingReads` |
+
 ## Compatibility flags
 
 | Flag | Pinned in main cells | Other cells |

src/tests/streams/readable-byte/byob-reader.js

@@ -507,3 +507,34 @@ export const byobreaderRegression = {
     ok(done);
   },
 };
+
+// A BYOB read consumes part of an enqueued chunk; a later DEFAULT read
+// picks up the remainder (WPT 'enqueue(), read(view) partially, then
+// read()'). PARITY: [1,2] to the view, then Uint8Array [3] to the
+// default reader.
+export const partialViewThenDefaultRead = {
+  async test() {
+    const rs = new ReadableStream({
+      type: 'bytes',
+      start(c) {
+        c.enqueue(new Uint8Array([1, 2, 3]));
+      },
+    });
+    const byob = rs.getReader({ mode: 'byob' });
+    const first = await byob.read(new Uint8Array(2));
+    byob.releaseLock();
+    const dflt = rs.getReader();
+    const second = await Promise.race([
+      dflt
+        .read()
+        .then(
+          (r) =>
+            `second:done=${r.done},type=${r.value?.constructor?.name},bytes=[${r.value ? Array.from(r.value) : ''}]`
+        ),
+      scheduler.wait(200).then(() => 'second:pending'),
+    ]);
+    strictEqual(first.done, false);
+    strictEqual(Array.from(first.value).join(','), '1,2');
+    strictEqual(second, 'second:done=false,type=Uint8Array,bytes=[3]');
+  },
+};

src/tests/streams/readable-byte/controller.js

@@ -195,3 +195,83 @@ export const controllerType = {
     strictEqual(c instanceof ReadableByteStreamController, true);
   },
 };
+
+// cancel() while a partially filled pull-into is pending (WPT
+// 'cancel() with partially filled pending pull() request'): the read
+// resolves done with the partial bytes DISCARDED on both sides —
+// DIVERGENCE only in the done shape (C++ an empty view, TypeScript
+// undefined; the done-read family). The cancel hook gets the reason
+// and the cancel fulfills on both.
+export const cancelWithPartiallyFilledPull = {
+  async test() {
+    const events = [];
+    let controller;
+    const rs = new ReadableStream({
+      type: 'bytes',
+      start(c) {
+        controller = c;
+      },
+      cancel(reason) {
+        events.push(`cancel:${reason}`);
+      },
+    });
+    const reader = rs.getReader({ mode: 'byob' });
+    const readP = reader.read(new Uint16Array(1)); // wants 2 bytes
+    controller.enqueue(new Uint8Array([0x11])); // partial: 1 byte
+    await scheduler.wait(1);
+    const cancelP = reader.cancel('why');
+    const read = await Promise.race([
+      readP.then(
+        (r) =>
+          `read:done=${r.done},len=${r.value ? r.value.byteLength : 'undef'}`,
+        (e) => `read-rejected:${e.name}`
+      ),
+      scheduler.wait(200).then(() => 'read:pending'),
+    ]);
+    const cancel = await Promise.race([
+      cancelP.then(
+        () => 'cancel:fulfilled',
+        (e) => `cancel-rejected:${e.name}`
+      ),
+      scheduler.wait(200).then(() => 'cancel:pending'),
+    ]);
+    strictEqual(
+      read,
+      usingTsImpl ? 'read:done=true,len=undef' : 'read:done=true,len=0'
+    );
+    strictEqual(cancel, 'cancel:fulfilled');
+    strictEqual(events.join(','), 'cancel:why');
+  },
+};
+
+// read(view) then immediate cancel() (WPT 'getReader(), read(view),
+// then cancel()'): DIVERGENCE — C++ pulls proactively on the read, so
+// pull runs BEFORE the cancel hook; TypeScript never pulls (spec: the
+// cancel wins). The read resolves done on both.
+export const readViewThenCancelOrdering = {
+  async test() {
+    const events = [];
+    const rs = new ReadableStream({
+      type: 'bytes',
+      pull() {
+        events.push('pull');
+      },
+      cancel(reason) {
+        events.push(`cancel:${reason}`);
+      },
+    });
+    const reader = rs.getReader({ mode: 'byob' });
+    const readP = reader.read(new Uint8Array(4));
+    const cancelP = reader.cancel('stop');
+    await Promise.all([
+      readP.then((r) => events.push(`read:done=${r.done}`)),
+      cancelP,
+    ]);
+    strictEqual(
+      events.join(','),
+      usingTsImpl
+        ? 'cancel:stop,read:done=true'
+        : 'pull,cancel:stop,read:done=true'
+    );
+  },
+};

src/tests/streams/readable-byte/main.js

@@ -52,6 +52,8 @@ export {
   readDetachesCallerBuffer,
   closeWithPendingUnfilledByobRead,
   controllerType,
+  cancelWithPartiallyFilledPull,
+  readViewThenCancelOrdering,
 } from 'controller';
 
 export {
@@ -69,6 +71,7 @@ export {
   readableStreamBytesEnqueueSubarray,
   readableStreamMultiplePendingReads,
   byobreaderRegression,
+  partialViewThenDefaultRead,
 } from 'byob-reader';
 
 export {