stream: detach sync share consumer before throwing

The `strict` backpressure branch of `SyncShareImpl` threw
`ERR_OUT_OF_RANGE` while leaving the consumer attached, so its cursor
stayed in the consumer set and kept pinning the buffer. Consumers that
were still reading correctly then hit the same error a few entries
later, because the buffer could no longer be trimmed past the stuck
cursor.

Build the error first, then detach and delete the consumer before
throwing, so the reported byte count still describes the condition that
triggered the failure. Every other terminal path of the same iterator
already detaches, and the async `ShareImpl` was fixed the same way.

Signed-off-by: Christian Aurich Zanettini Martins <christian.aurichzm@gmail.com>

Author: christianaurichzm

lib/internal/streams/iter/share.js

@@ -586,10 +586,14 @@ class SyncShareImpl {
             let dropped = false;
             if (self.#bufferedBytes >= self.#options.budget) {
               switch (self.#options.backpressure) {
-                case 'strict':
-                  throw new ERR_OUT_OF_RANGE(
+                case 'strict': {
+                  const error = new ERR_OUT_OF_RANGE(
                     'buffered bytes', `< ${self.#options.budget}`,
                     self.#bufferedBytes);
+                  state.detached = true;
+                  self.#deleteConsumer(state);
+                  throw error;
+                }
                 case 'drop-oldest':
                   while (self.#bufferedBytes >= self.#options.budget &&
                          self.#buffer.length > 0) {

test/parallel/test-stream-iter-share-sync.js

@@ -211,6 +211,44 @@ function testShareSyncDropNewestUnboundedSource() {
   shared.cancel();
 }
 
+// A strict budget failure detaches the consumer that threw so it cannot
+// later pin the buffer for consumers that continue reading.
+function testShareSyncStrictBackpressure() {
+  for (const transformed of [false, true]) {
+    function* source() {
+      for (let i = 0; i < 10; i++) {
+        yield [new Uint8Array(16384)];
+      }
+    }
+
+    const shared = shareSync(source(), {
+      budget: 32768,
+      backpressure: 'strict',
+    });
+
+    const consumer = transformed ?
+      shared.pull((chunks) => chunks) : shared.pull();
+    const failed = consumer[Symbol.iterator]();
+    const live = shared.pull()[Symbol.iterator]();
+
+    assert.strictEqual(failed.next().done, false);
+    assert.strictEqual(failed.next().done, false);
+    assert.throws(() => failed.next(), {
+      code: 'ERR_OUT_OF_RANGE',
+    });
+
+    assert.strictEqual(shared.consumerCount, 1);
+    assert.strictEqual(failed.next().done, true);
+
+    let count = 0;
+    while (!live.next().done) {
+      count++;
+    }
+    assert.strictEqual(count, 10);
+    assert.strictEqual(shared.consumerCount, 0);
+  }
+}
+
 // shareSync() accepts string source directly (normalized via fromSync())
 function testShareSyncStringSource() {
   const shared = shareSync('hello-sync-share');
@@ -229,5 +267,6 @@ Promise.all([
   testShareSyncRejectsUnbounded(),
   testShareSyncDropNewest(),
   testShareSyncDropNewestUnboundedSource(),
+  testShareSyncStrictBackpressure(),
   testShareSyncStringSource(),
 ]).then(common.mustCall());