stream: reject writes during WritableStream close

lib/internal/webstreams/writablestream.js

@@ -1241,9 +1241,11 @@ function writableStreamDefaultControllerGetChunkSize(controller, chunk) {
     sizeAlgorithm,
   } = controller[kState];
   if (sizeAlgorithm === undefined) {
-    assert(stream[kState].state === 'closed' ||
-           stream[kState].state === 'errored' ||
-           stream[kState].state === 'erroring');
+    // The algorithms are also cleared while the close request is in
+    // flight, before the stream leaves the 'writable' state; the caller
+    // then rejects the write as closing.
+    assert(stream[kState].state !== 'writable' ||
+           stream[kState].closeQueuedOrInFlight);
     return 1;
   }
 

test/parallel/test-whatwg-writablestream-close.js

@@ -27,3 +27,40 @@ test('should throw error when writing after close', async (t) => {
     }
   );
 });
+
+test('should reject writes while the close is in flight', async () => {
+  const { promise, resolve } = Promise.withResolvers();
+  const writable = new WritableStream({
+    close() {
+      return promise;
+    },
+  });
+
+  const writer = writable.getWriter();
+  const closed = writer.close();
+  // Let the close request reach the sink.
+  await new Promise(setImmediate);
+
+  await assert.rejects(writer.write('World'), { name: 'TypeError' });
+
+  resolve();
+  await closed;
+});
+
+test('should reject writes to a TransformStream while flush() is pending', async () => {
+  const { promise, resolve } = Promise.withResolvers();
+  const transform = new TransformStream({
+    flush() {
+      return promise;
+    },
+  });
+
+  const writer = transform.writable.getWriter();
+  const closed = writer.close();
+  await new Promise(setImmediate);
+
+  await assert.rejects(writer.write('World'), { name: 'TypeError' });
+
+  resolve();
+  await closed;
+});