From 226668f33ca4e5103864f45309f8adba32f6d6e3 Mon Sep 17 00:00:00 2001
From: Ji Hoon Kang <ivory.ma9ic@gmail.com>
Date: Sat, 1 Aug 2026 09:09:08 +0900
Subject: [PATCH 1/2] doc: document quic stopSending() and resetStream()

`QuicStream` exposes `stopSending()` and `resetStream()`, but neither
appeared in the QuicStream API reference. Both matter when half-closing
a stream, which protocols such as WebTransport rely on.

Document the two methods and list them in the "Aborting a stream"
summary, which previously covered only `writer.fail()` and
`stream.destroy()`. Unlike those, both send the given code as-is rather
than deriving a wire code from an error.

Fixes: https://github.com/nodejs/node/issues/63680
Signed-off-by: Ji Hoon Kang <ivory.ma9ic@gmail.com>
---
 doc/api/quic.md | 44 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 1a592d85945d..a174527872aa 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -1923,9 +1923,14 @@ True if `stream.destroy()` has been called.
 
 ### Aborting a stream
 
-A QuicStream can be aborted in three ways, each producing different
+A QuicStream can be aborted in several ways, each producing different
 wire-frame side effects:
 
+* [`stream.stopSending()`][] — Aborts only the readable side. Sends
+  `STOP_SENDING` to the peer. The writable side is unaffected.
+* [`stream.resetStream()`][] — Aborts only the writable side. Sends
+  `RESET_STREAM` to the peer. Unlike [`writer.fail(reason)`][], the wire
+  code is given directly rather than derived from an error.
 * [`writer.fail(reason)`][] — Aborts only the writable side. Sends
   `RESET_STREAM` to the peer. The readable side is unaffected; any data
   already buffered for read remains available.
@@ -1943,6 +1948,41 @@ the wire code for both `writer.fail()` and `stream.destroy()`. Otherwise
 the implementation falls back to the negotiated application protocol's
 "internal error" code (see [`QuicError`][]).
 
+[`stream.stopSending()`][] and [`stream.resetStream()`][] do
+not perform this derivation: they send `code` as given.
+
+### `stream.resetStream([code])`
+
+<!-- YAML
+added: v23.8.0
+-->
+
+* `code` {number|bigint} The application error code to send to the peer.
+  **Default:** `0n`.
+
+Tells the peer that this end will not send any more data on this stream,
+sending a `RESET_STREAM` frame carrying `code`. The readable side is left
+open, so data already sent by the peer remains available to read.
+
+No acknowledgement of this action is provided. Has no effect if the stream
+has been destroyed.
+
+### `stream.stopSending([code])`
+
+<!-- YAML
+added: v23.8.0
+-->
+
+* `code` {number|bigint} The application error code to send to the peer.
+  **Default:** `0n`.
+
+Asks the peer to stop sending data on this stream, sending a `STOP_SENDING`
+frame carrying `code`. The writable side is left open, so this end can
+still send data.
+
+No acknowledgement of this action is provided. Has no effect if the stream
+has been destroyed.
+
 ### `stream.early`
 
 <!-- YAML
@@ -4576,11 +4616,13 @@ throughput issues caused by flow control.
 [`stream.onwanttrailers`]: #streamonwanttrailers
 [`stream.pendingTrailers`]: #streampendingtrailers
 [`stream.priority`]: #streampriority
+[`stream.resetStream()`]: #streamresetstreamcode
 [`stream.sendHeaders()`]: #streamsendheadersheaders-options
 [`stream.sendInformationalHeaders()`]: #streamsendinformationalheadersheaders
 [`stream.sendTrailers()`]: #streamsendtrailersheaders
 [`stream.setBody()`]: #streamsetbodybody
 [`stream.setPriority()`]: #streamsetpriorityoptions
+[`stream.stopSending()`]: #streamstopsendingcode
 [`stream.writer`]: #streamwriter
 [`writer.fail()`]: #streamwriter
 [`writer.fail(reason)`]: #streamwriter

From 8784c5a601b52408d157293839135bc72e95f5ca Mon Sep 17 00:00:00 2001
From: Ji Hoon Kang <ivory.ma9ic@gmail.com>
Date: Sun, 2 Aug 2026 22:43:42 +0900
Subject: [PATCH 2/2] doc: note quic reset and unidirectional edge cases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The reference added earlier in this pull request described only the
bidirectional happy path. Three behaviours were missing:

* `resetStream()` discards any data still queued for sending. A reset
  stream is never acknowledged, so that queue can no longer drain.
* `resetStream()` is a no-op once the stream has already been reset.
* Neither method sends a frame on the unidirectional stream that lacks
  the side it aborts — `stopSending()` on a locally-initiated one,
  `resetStream()` on a remote-initiated one. Both fail silently there.

The wording for stream directionality follows `stream.destroy()`, which
already states that the readable side exists on bidirectional and
remote-initiated unidirectional streams.

Refs: https://github.com/nodejs/node/issues/63680
Signed-off-by: Ji Hoon Kang <ivory.ma9ic@gmail.com>
---
 doc/api/quic.md | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index a174527872aa..3fe8f9f2c53d 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -1964,8 +1964,12 @@ Tells the peer that this end will not send any more data on this stream,
 sending a `RESET_STREAM` frame carrying `code`. The readable side is left
 open, so data already sent by the peer remains available to read.
 
-No acknowledgement of this action is provided. Has no effect if the stream
-has been destroyed.
+Any data still queued for sending is discarded. A reset stream is never
+acknowledged by the peer, so the outbound queue can no longer drain.
+
+No acknowledgement of this action is provided. The call does nothing if the
+stream has been destroyed, if it has already been reset, or if it is a
+remote-initiated unidirectional stream, which has no writable side to abort.
 
 ### `stream.stopSending([code])`
 
@@ -1980,8 +1984,9 @@ Asks the peer to stop sending data on this stream, sending a `STOP_SENDING`
 frame carrying `code`. The writable side is left open, so this end can
 still send data.
 
-No acknowledgement of this action is provided. Has no effect if the stream
-has been destroyed.
+No acknowledgement of this action is provided. The call does nothing if the
+stream has been destroyed, or if it is a locally-initiated unidirectional
+stream, which has no readable side to abort.
 
 ### `stream.early`