stream: propagate destruction in duplexPair

Ensure destroying one side of a duplexPair triggers destruction of the
other side via process.nextTick().

To avoid a breaking change and unhandled 'error' events (e.g., in HTTP
tests), the error object is not propagated; only the destruction signal
is sent.

Author: aelhor

lib/internal/streams/duplexpair.js

@@ -53,14 +53,25 @@ class DuplexSide extends Duplex {
 
 
   _destroy(err, callback) {
-    if (err) {
-      // Error case: tell the other side to also destroy with that error.
-      this.#otherSide.destroy(err);
-    } else if (this.#otherSide && !this.#otherSide.destroyed) {
-      // Graceful close case (destroy() without error):
-      // send an EOF to the other side's readable end if it hasn't already closed.
-      this.#otherSide.push(null);
+    const otherSide = this.#otherSide;
+
+    if (otherSide !== null && !otherSide.destroyed) {
+      // Use nextTick to avoid crashing the current execution stack (like HTTP parser)
+      process.nextTick(() => {
+        if (otherSide.destroyed) return;
+
+        if (err) {
+          // Destroy the other side, without passing the 'err' object.
+          // This closes the other side gracefully so it doesn't hang,
+          // but prevents the "Unhandled error" crash.
+          otherSide.destroy();
+        } else {
+          // Standard graceful close
+          otherSide.push(null);
+        }
+      });
     }
+
     callback(err);
   }
 }

test/parallel/test-duplex-error.js

@@ -6,15 +6,27 @@ const { duplexPair } = require('stream');
 
 const [sideA, sideB] = duplexPair();
 
+// Side A should receive the error because we called .destroy(err) on it.
 sideA.on('error', common.mustCall((err) => {
   assert.strictEqual(err.message, 'Simulated error');
 }));
 
-sideB.on('error', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'Simulated error');
+// Side B should NOT necessarily emit an error (to avoid crashing
+// existing code), but it MUST be destroyed.
+sideB.on('error', common.mustNotCall('Side B should not emit an error event'));
+
+sideB.on('close', common.mustCall(() => {
+  assert.strictEqual(sideB.destroyed, true);
 }));
 
 sideA.resume();
 sideB.resume();
 
-sideB.destroy(new Error('Simulated error'));
+// Trigger the destruction
+sideA.destroy(new Error('Simulated error'));
+
+// Check the state in the next tick to allow nextTick/microtasks to run
+setImmediate(common.mustCall(() => {
+  assert.strictEqual(sideA.destroyed, true);
+  assert.strictEqual(sideB.destroyed, true);
+}));