streams: forward errors correctly for duplexPair endpoints

fix the duplexPair implementation so that when one side is
destroyed with an error, the other side also receives the error
or a close event as appropriate.

previous behavior caused sideA to never emit an 'error' or
'close' when sideB errored, which prevented users from
observing or handling the paired stream failure.

Fixes: #61015

Author: aelhor

lib/internal/streams/duplexpair.js

@@ -50,13 +50,29 @@ class DuplexSide extends Duplex {
     this.#otherSide.on('end', callback);
     this.#otherSide.push(null);
   }
+
+
+  _destroy(err, callback) {
+
+    if (err) {
+      // Error case: tell the other side to also destroy with that error.
+      this.#otherSide.destroy(err);
+    } else {
+      // Graceful close case (destroy() without error):
+      // send an EOF to the other side's readable end if it hasn't already closed.
+      if (this.#otherSide && !this.#otherSide.destroyed) {
+        this.#otherSide.push(null);
+      }
+    }
+    callback(err);
+  }
 }
 
 function duplexPair(options) {
   const side0 = new DuplexSide(options);
   const side1 = new DuplexSide(options);
   side0[kInitOtherSide](side1);
   side1[kInitOtherSide](side0);
-  return [ side0, side1 ];
+  return [side0, side1];
 }
 module.exports = duplexPair;

test/parallel/test-duplex-error.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const assert = require('assert');
+const { duplexPair } = require('stream');
+
+const [sideA, sideB] = duplexPair();
+
+let sideAErrorReceived = false;
+let sideBErrorReceived = false;
+
+// Add error handlers
+sideA.on('error', (err) => {
+  sideAErrorReceived = true;
+});
+sideB.on('error', (err) => {
+  sideBErrorReceived = true;
+});
+
+// Ensure the streams are flowing
+sideA.resume();
+sideB.resume();
+
+// Destroy sideB with an error
+sideB.destroy(new Error('Simulated error'));
+
+// Wait for event loop to process error events
+setImmediate(() => {
+  assert.strictEqual(
+    sideAErrorReceived,
+    true,
+    'sideA should receive the error when sideB is destroyed with an error'
+  );
+  assert.strictEqual(
+    sideBErrorReceived,
+    true,
+    'sideB should emit its own error when destroyed'
+  );
+});
+