@@ -2223,10 +2223,41 @@ class QuicStream {
     const handle = this.#handle;
     const stream = this;
     let closed = false;
+    let ending = false;
     let errored = false;
     let error = null;
     let totalBytesWritten = 0;
     let drainWakeup = null;
+    let pendingWrite = null;
+    let pendingEnd = null;
+
+    function raceWithSignal(promise, signal) {
+      if (signal === undefined) return promise;
+      signal.throwIfAborted();
+
+      const deferred = PromiseWithResolvers();
+      const onAbort = () => deferred.reject(signal.reason);
+      signal.addEventListener('abort', onAbort, {
+        __proto__: null,
+        once: true,
+      });
+      PromisePrototypeThen(
+        promise,
+        (value) => {
+          signal.removeEventListener('abort', onAbort);
+          deferred.resolve(value);
+        },
+        (reason) => {
+          signal.removeEventListener('abort', onAbort);
+          deferred.reject(reason);
+        });
+      return deferred.promise;
+    }
+
+    function waitForDrain(signal) {
+      drainWakeup ??= PromiseWithResolvers();
+      return raceWithSignal(drainWakeup.promise, signal);
+    }
 
     // Drain callback - C++ fires this when send buffer has space
     stream[kDrain] = () => {
@@ -2251,16 +2282,16 @@ class QuicStream {
     };
 
     // A note on backpressure handling: per the stream/iter spec, the default
-    // backpressure policy for writers is strict, meaning that if the stream
-    // signals backpressure additional writes are rejected until the buffer has
-    // capacity again.
+    // backpressure policy for writers is strict. One async write may wait for
+    // capacity; additional writes are rejected until it settles.
 
-    function writeConvertedSync(chunk) {
+    function writeConvertedSync(chunk, token) {
+      const isPending = pendingWrite === token && token !== undefined;
       // If the stream is closed, errored, or write-ended, we cannot accept
       // more data. Refuse the sync write.
-      // If a drain is already pending, another operation is waiting
-      // for capacity. Refuse the sync write.
-      if (closed || errored || stream.#inner.state.writeEnded || drainWakeup != null) {
+      if (closed || errored || stream.#inner.state.writeEnded ||
+          (ending && !isPending) ||
+          (pendingWrite !== null && !isPending)) {
         return false;
       }
       const len = TypedArrayPrototypeGetByteLength(chunk);
@@ -2292,25 +2323,52 @@ class QuicStream {
 
     async function writeAsync(chunk, signal) {
       if (errored) throw error;
-      if (closed || stream.#inner.state.writeEnded) {
+      if (closed || ending || stream.#inner.state.writeEnded) {
         throw new ERR_INVALID_STATE('Writer is closed');
       }
       signal?.throwIfAborted();
-      // If a drain is already pending, another operation is waiting
-      // for capacity. Under strict policy, reject immediately.
-      // Later, if we add support for other backpressure policies,
-      // we could instead await the existing drain before proceeding.
-      if (drainWakeup != null) {
+
+      if (writeConvertedSync(chunk)) return;
+      await writeWhenDrained(chunk, writeConvertedSync, signal);
+    }
+
+    async function writeWhenDrained(chunks, writeConverted, signal) {
+      if (pendingWrite !== null) {
+        throw new ERR_INVALID_STATE.RangeError(
+          'Backpressure violation: too many pending writes. ' +
+          'Await each write() call to respect backpressure.');
+      }
+      if (stream.#inner.state.writeDesiredSize !== 0) {
         throw new ERR_INVALID_STATE('Stream write buffer is full');
       }
 
-      if (!writeConvertedSync(chunk)) {
-        throw new ERR_INVALID_STATE('Stream write buffer is full');
+      const done = PromiseWithResolvers();
+      const token = { __proto__: null, done };
+      pendingWrite = token;
+      try {
+        while (true) {
+          await waitForDrain(signal);
+          if (errored) throw error;
+          if (closed || stream.#inner.state.writeEnded) {
+            throw new ERR_INVALID_STATE('Writer is closed');
+          }
+          signal?.throwIfAborted();
+          if (writeConverted(chunks, token)) return;
+          if (stream.#inner.state.writeDesiredSize !== 0) {
+            throw new ERR_INVALID_STATE('Stream write buffer is full');
+          }
+        }
+      } finally {
+        if (pendingWrite === token) pendingWrite = null;
+        done.resolve();
       }
     }
 
-    function writevConvertedSync(chunks) {
-      if (closed || errored || stream.#inner.state.writeEnded || drainWakeup != null) {
+    function writevConvertedSync(chunks, token) {
+      const isPending = pendingWrite === token && token !== undefined;
+      if (closed || errored || stream.#inner.state.writeEnded ||
+          (ending && !isPending) ||
+          (pendingWrite !== null && !isPending)) {
         return false;
       }
       let len = 0;
@@ -2335,22 +2393,13 @@ class QuicStream {
 
     async function writevAsync(chunks, signal) {
       if (errored) throw error;
-      if (closed || stream.#inner.state.writeEnded) {
+      if (closed || ending || stream.#inner.state.writeEnded) {
         throw new ERR_INVALID_STATE('Writer is closed');
       }
       signal?.throwIfAborted();
 
-      // If a drain is already pending, another operation is waiting
-      // for capacity. Under strict policy, reject immediately.
-      // Later, if we add support for other backpressure policies,
-      // we could instead await the existing drain before proceeding.
-      if (drainWakeup != null) {
-        throw new ERR_INVALID_STATE('Stream write buffer is full');
-      }
-
-      if (!writevConvertedSync(chunks)) {
-        throw new ERR_INVALID_STATE('Stream write buffer is full');
-      }
+      if (writevConvertedSync(chunks)) return;
+      await writeWhenDrained(chunks, writevConvertedSync, signal);
     }
 
     function endSync() {
@@ -2364,8 +2413,8 @@ class QuicStream {
       // If we're already closed, just return the total bytes written.
       if (closed) return totalBytesWritten;
 
-      // If we are waiting for drain to complete, we cannot end synchronously.
-      if (drainWakeup != null) return -1;
+      // Accepted writes and existing drain waiters must settle before ending.
+      if (ending || pendingWrite !== null || drainWakeup !== null) return -1;
 
       // Fantastic, we can end synchronously!
       handle.endWrite();
@@ -2381,13 +2430,7 @@ class QuicStream {
     async function endAsync(signal) {
       if (errored) throw error;
       if (closed) return totalBytesWritten;
-      if (signal !== undefined) {
-        signal.throwIfAborted();
-        // TODO(@jasnell): The stream/iter spec allows individual sync end
-        // calls to be canceled via an AbortSignal. We currently do not support
-        // this, but we can add before the impl is graduated from experimental.
-        // At most we do here is check for signal abort at the start of the call.
-      }
+      signal?.throwIfAborted();
 
       // Per the streams/iter spec, endSync and end follow a try-fallback
       // pattern. That is, callers should try endSync first and if it returns
@@ -2406,16 +2449,28 @@ class QuicStream {
       if (n >= 0) return n;
       if (errored) throw error;
 
-      drainWakeup ??= PromiseWithResolvers();
-      try {
-        await drainWakeup.promise;
-      } finally {
-        drainWakeup = null;
+      if (pendingEnd === null) {
+        ending = true;
+        pendingEnd = finishEnd();
+      }
+      return raceWithSignal(pendingEnd, signal);
+    }
+
+    async function finishEnd() {
+      if (pendingWrite !== null) {
+        await pendingWrite.done.promise;
       }
       if (errored) throw error;
-      const result = endSync();
+
+      if (drainWakeup !== null) {
+        await drainWakeup.promise;
+      }
       if (errored) throw error;
-      return result;
+
+      if (!stream.#inner.state.writeEnded) handle.endWrite();
+      closed = true;
+      ending = false;
+      return totalBytesWritten;
     }
 
     function fail(reason) {
@@ -2448,7 +2503,9 @@ class QuicStream {
     const writer = {
       __proto__: null,
       get canWrite() {
-        if (closed || errored || stream.#inner.state.writeEnded) return null;
+        if (closed || ending || errored || stream.#inner.state.writeEnded) {
+          return null;
+        }
         return stream.#inner.state.writeDesiredSize > 0;
       },
       writeSync,
@@ -2459,14 +2516,15 @@ class QuicStream {
       end,
       fail,
       [drainableProtocol]() {
-        if (closed || errored) return null;
+        if (closed || ending || errored) return null;
         // If a drain is already pending, return the existing promise.
         if (drainWakeup != null) return drainWakeup.promise;
         if (stream.#inner.state.writeDesiredSize > 0) return null;
         drainWakeup = PromiseWithResolvers();
         return drainWakeup.promise;
       },
       [SymbolAsyncDispose]() {
+        if (ending) return pendingEnd;
         if (!closed && !errored) fail();
         return PromiseResolve();
       },