stream: improve Web Compression spec compliance

panva · panva · commit 17679f8a776d · 2026-03-04T22:57:40.000+01:00
Pass rejectGarbageAfterEnd: true to createInflateRaw() and
createBrotliDecompress(), matching the behavior already in place
for deflate and gzip. The Compression Streams spec treats any
data following a valid compressed payload as an error.

When the underlying Node.js stream throws synchronously from
write() (e.g. zlib rejects an invalid chunk type), destroy the
stream so that the readable side is also errored. Without this,
the readable side hangs forever waiting for data that will never
arrive.

Unskip WPT compression bad-chunks tests which now run instead of hang.

Mark the remaining expected failures due to Node.js accepting
SharedArrayBuffer-backed TypedArrays.
diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
@@ -220,12 +220,22 @@ function newWritableStreamFromStreamWritable(streamWritable) {
       if (!streamWritable.writableObjectMode && isArrayBuffer(chunk)) {
         chunk = new Uint8Array(chunk);
       }
-      if (streamWritable.writableNeedDrain || !streamWritable.write(chunk)) {
-        backpressurePromise = PromiseWithResolvers();
-        return SafePromisePrototypeFinally(
-          backpressurePromise.promise, () => {
-            backpressurePromise = undefined;
-          });
+      // If the underlying Node.js stream throws synchronously from
+      // write() (e.g. zlib rejects an invalid chunk type), we must
+      // destroy the stream so that the readable side is also errored.
+      // Without this, the readable side would hang forever waiting
+      // for data that will never arrive.
+      try {
+        if (streamWritable.writableNeedDrain || !streamWritable.write(chunk)) {
+          backpressurePromise = PromiseWithResolvers();
+          return SafePromisePrototypeFinally(
+            backpressurePromise.promise, () => {
+              backpressurePromise = undefined;
+            });
+        }
+      } catch (error) {
+        destroy(streamWritable, error);
+        throw error;
       }
     },
 
diff --git a/lib/internal/webstreams/compression.js b/lib/internal/webstreams/compression.js
@@ -108,15 +108,19 @@ class DecompressionStream {
         });
         break;
       case 'deflate-raw':
-        this.#handle = lazyZlib().createInflateRaw();
+        this.#handle = lazyZlib().createInflateRaw({
+          rejectGarbageAfterEnd: true,
+        });
         break;
       case 'gzip':
         this.#handle = lazyZlib().createGunzip({
           rejectGarbageAfterEnd: true,
         });
         break;
       case 'brotli':
-        this.#handle = lazyZlib().createBrotliDecompress();
+        this.#handle = lazyZlib().createBrotliDecompress({
+          rejectGarbageAfterEnd: true,
+        });
         break;
     }
     this.#transform = newReadableWritablePairFromDuplex(this.#handle);
diff --git a/test/parallel/test-webstreams-adapters-sync-write-error.js b/test/parallel/test-webstreams-adapters-sync-write-error.js
@@ -0,0 +1,52 @@
+'use strict';
+// Flags: --no-warnings --expose-internals
+require('../common');
+const assert = require('assert');
+const test = require('node:test');
+const { Writable } = require('stream');
+const {
+  newWritableStreamFromStreamWritable,
+} = require('internal/webstreams/adapters');
+
+// Verify that when the underlying Node.js stream throws synchronously from
+// write(), the writable web stream properly rejects and the underlying
+// stream is destroyed.
+
+test('WritableStream from Node.js stream handles sync write throw', async () => {
+  const error = new TypeError('invalid chunk');
+  const writable = new Writable({
+    write() {
+      throw error;
+    },
+  });
+
+  const ws = newWritableStreamFromStreamWritable(writable);
+  const writer = ws.getWriter();
+
+  await assert.rejects(writer.write('bad'), (err) => {
+    assert.strictEqual(err, error);
+    return true;
+  });
+
+  // The underlying stream must be destroyed
+  assert.strictEqual(writable.destroyed, true);
+});
+
+test('WritableStream from Node.js stream - valid writes still work', async () => {
+  const chunks = [];
+  const writable = new Writable({
+    write(chunk, _encoding, cb) {
+      chunks.push(chunk);
+      cb();
+    },
+  });
+
+  const ws = newWritableStreamFromStreamWritable(writable);
+  const writer = ws.getWriter();
+
+  await writer.write(Buffer.from('hello'));
+  await writer.write(Buffer.from(' world'));
+  await writer.close();
+
+  assert.strictEqual(Buffer.concat(chunks).toString(), 'hello world');
+});
diff --git a/test/parallel/test-webstreams-compression-bad-chunks.js b/test/parallel/test-webstreams-compression-bad-chunks.js
@@ -0,0 +1,45 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const test = require('node:test');
+const { CompressionStream, DecompressionStream } = require('stream/web');
+
+// Verify that writing invalid (non-BufferSource) chunks to
+// CompressionStream and DecompressionStream properly rejects
+// on both the write and the read side, instead of hanging.
+
+const badChunks = [
+  { name: 'undefined', value: undefined },
+  { name: 'null', value: null },
+  { name: 'number', value: 3.14 },
+  { name: 'object', value: {} },
+  { name: 'array', value: [65] },
+];
+
+for (const format of ['deflate', 'deflate-raw', 'gzip', 'brotli']) {
+  for (const { name, value } of badChunks) {
+    test(`CompressionStream rejects bad chunk (${name}) for ${format}`, async () => {
+      const cs = new CompressionStream(format);
+      const writer = cs.writable.getWriter();
+      const reader = cs.readable.getReader();
+
+      const writePromise = writer.write(value);
+      const readPromise = reader.read();
+
+      await assert.rejects(writePromise, { name: 'TypeError' });
+      await assert.rejects(readPromise, { name: 'TypeError' });
+    });
+
+    test(`DecompressionStream rejects bad chunk (${name}) for ${format}`, async () => {
+      const ds = new DecompressionStream(format);
+      const writer = ds.writable.getWriter();
+      const reader = ds.readable.getReader();
+
+      const writePromise = writer.write(value);
+      const readPromise = reader.read();
+
+      await assert.rejects(writePromise, { name: 'TypeError' });
+      await assert.rejects(readPromise, { name: 'TypeError' });
+    });
+  }
+}
diff --git a/test/parallel/test-webstreams-decompression-reject-trailing.js b/test/parallel/test-webstreams-decompression-reject-trailing.js
@@ -0,0 +1,86 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const test = require('node:test');
+const { CompressionStream, DecompressionStream } = require('stream/web');
+
+// Verify that DecompressionStream rejects trailing data after a valid
+// compressed payload for all four supported formats (deflate, deflate-raw, gzip, brotli).
+
+const input = Buffer.from('hello');
+const trailingJunk = Buffer.from([0xDE, 0xAD]);
+
+async function compress(format, data) {
+  const cs = new CompressionStream(format);
+  const writer = cs.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const chunks = await Array.fromAsync(cs.readable);
+  return Buffer.concat(chunks.map((c) => Buffer.from(c)));
+}
+
+for (const format of ['deflate', 'deflate-raw', 'gzip', 'brotli']) {
+  test(`DecompressionStream rejects trailing junk for ${format}`, async () => {
+    const compressed = await compress(format, input);
+    const withJunk = Buffer.concat([compressed, trailingJunk]);
+
+    const ds = new DecompressionStream(format);
+    const writer = ds.writable.getWriter();
+    const reader = ds.readable.getReader();
+
+    writer.write(withJunk).catch(() => {});
+    writer.close().catch(() => {});
+
+    await assert.rejects(async () => {
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+    }, (err) => {
+      assert(err instanceof Error, `Expected Error, got ${err?.constructor?.name}`);
+      return true;
+    });
+  });
+
+  test(`DecompressionStream accepts valid ${format} data without trailing junk`, async () => {
+    const compressed = await compress(format, input);
+
+    const ds = new DecompressionStream(format);
+    const writer = ds.writable.getWriter();
+
+    writer.write(compressed);
+    writer.close();
+
+    const chunks = await Array.fromAsync(ds.readable);
+    const result = Buffer.concat(chunks.map((c) => Buffer.from(c)));
+    assert.strictEqual(result.toString(), 'hello');
+  });
+}
+
+// Extra: Verify that trailing data is also rejected when passed as a separate
+// chunk after the valid compressed data has been fully written.
+for (const format of ['deflate', 'deflate-raw', 'gzip', 'brotli']) {
+  test(`DecompressionStream rejects trailing junk as separate chunk for ${format}`, async () => {
+    const compressed = await compress(format, input);
+
+    const ds = new DecompressionStream(format);
+    const writer = ds.writable.getWriter();
+    const reader = ds.readable.getReader();
+
+    writer.write(compressed).catch(() => {});
+    writer.write(trailingJunk).catch(() => {});
+    writer.close().catch(() => {});
+
+    await assert.rejects(async () => {
+      while (true) {
+        const { done } = await reader.read();
+        if (done) break;
+      }
+    }, (err) => {
+      assert(err instanceof Error, `Expected Error, got ${err?.constructor?.name}`);
+      return true;
+    });
+  });
+}
diff --git a/test/wpt/status/compression.json b/test/wpt/status/compression.json
@@ -1,9 +1,24 @@
 {
   "compression-bad-chunks.any.js": {
-    "skip": "Execution \"hangs\", ArrayBuffer and TypedArray is not accepted and throws, instead of rejects during writer.write"
+    "fail": {
+      "note": "Node.js accepts SharedArrayBuffer-backed TypedArrays",
+      "expected": [
+        "chunk of type shared Uint8Array should error the stream for deflate",
+        "chunk of type shared Uint8Array should error the stream for deflate-raw",
+        "chunk of type shared Uint8Array should error the stream for gzip",
+        "chunk of type shared Uint8Array should error the stream for brotli"
+      ]
+    }
   },
   "decompression-bad-chunks.any.js": {
-    "skip": "Execution \"hangs\", ArrayBuffer and TypedArray is not accepted and throws, instead of rejects during writer.write"
+    "fail": {
+      "note": "Node.js accepts SharedArrayBuffer-backed TypedArrays and rejects Error instead of TypeError",
+      "expected": [
+        "chunk of type shared Uint8Array should error the stream for brotli",
+        "chunk of type invalid deflate bytes should error the stream for brotli",
+        "chunk of type invalid gzip bytes should error the stream for brotli"
+      ]
+    }
   },
   "compression-with-detach.window.js": {
     "requires": ["crypto"]
