@@ -595,7 +595,7 @@ function onPing(payload) {
 // point, close them. If there is an open fd for file send, close that also.
 // At this point the underlying node::http2:Http2Stream handle is no
 // longer usable so destroy it also.
-function onStreamClose(code) {
+function onStreamClose(code, peerReset) {
   const stream = this[kOwner];
   if (!stream || stream.destroyed)
     return false;
@@ -614,8 +614,9 @@ function onStreamClose(code) {
     // If errored or ended, we can destroy immediately.
     stream.destroy();
   } else {
-    // Wait for end to destroy.
-    stream.on('end', stream[kMaybeDestroy]);
+    // Preserve buffered reads after a clean reset, but do not wait for
+    // pending writes: the peer reset may prevent them from finishing.
+    stream.on('end', peerReset ? stream.destroy : stream[kMaybeDestroy]);
     // Push a null so the stream can end whenever the client consumes
     // it completely.
     stream.push(null);
 
@@ -1129,6 +1129,13 @@ int Http2Session::OnFrameReceive(nghttp2_session* handle,
     case NGHTTP2_HEADERS:
       session->HandleHeadersFrame(frame);
       break;
+    case NGHTTP2_RST_STREAM:
+      // Distinguish a peer reset from a natural close with the same code.
+      if (BaseObjectPtr<Http2Stream> stream =
+              session->FindStream(frame->hd.stream_id)) {
+        stream->set_peer_reset();
+      }
+      break;
     case NGHTTP2_SETTINGS:
       session->HandleSettingsFrame(frame);
       break;
@@ -1338,9 +1345,12 @@ int Http2Session::OnStreamClose(nghttp2_session* handle,
   // ever passed on to the javascript side. If that happens, the callback
   // will return false.
   if (env->can_call_into_js()) {
-    Local<Value> arg = Integer::NewFromUnsigned(isolate, code);
+    Local<Value> argv[] = {
+        Integer::NewFromUnsigned(isolate, code),
+        Boolean::New(isolate, stream->peer_reset()),
+    };
     MaybeLocal<Value> answer = stream->MakeCallback(
-        env->http2session_on_stream_close_function(), 1, &arg);
+        env->http2session_on_stream_close_function(), arraysize(argv), argv);
     if (answer.IsEmpty() || answer.ToLocalChecked()->IsFalse()) {
       // Skip to destroy
       stream->Destroy();
 
@@ -65,6 +65,7 @@ constexpr int kStreamStateReadPaused = 0x4;
 constexpr int kStreamStateClosed = 0x8;
 constexpr int kStreamStateDestroyed = 0x10;
 constexpr int kStreamStateTrailers = 0x20;
+constexpr int kStreamStatePeerReset = 0x40;
 
 // Http2Session internal states
 constexpr int kSessionStateNone = 0x0;
@@ -352,6 +353,10 @@ class Http2Stream : public AsyncWrap,
     return flags_ & kStreamStateClosed;
   }
 
+  bool peer_reset() const { return flags_ & kStreamStatePeerReset; }
+
+  void set_peer_reset() { flags_ |= kStreamStatePeerReset; }
+
   bool has_trailers() const {
     return flags_ & kStreamStateTrailers;
   }
 
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+// A clean peer reset must retain 26.x's buffered reads and readable 'end',
+// rather than introducing the reset errors and immediate destroy from main.
+const body = 'buffered response';
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream) => {
+  stream.on('error', common.mustNotCall());
+  stream.resume();
+  stream.respond();
+  stream.write(body, common.mustCall(() => stream.close()));
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const request = client.request({ ':method': 'POST' });
+  request.write('request body');
+  request.pause();
+  request.read(0);
+  request.on('response', common.mustCall());
+  request.on('error', common.mustNotCall());
+  request.on('aborted', common.mustCall(() => {
+    setImmediate(common.mustCall(() => {
+      assert.strictEqual(request.destroyed, false);
+      assert.strictEqual(request.readableLength, Buffer.byteLength(body));
+      let received = '';
+      request.on('data', (chunk) => { received += chunk; });
+      request.on('end', common.mustCall(() => {
+        assert.strictEqual(received, body);
+      }));
+      request.resume();
+    }));
+  }));
+  request.on('close', common.mustCall(() => {
+    assert.strictEqual(request.readableEnded, true);
+    assert.strictEqual(request.rstCode, http2.constants.NGHTTP2_NO_ERROR);
+    client.close();
+    server.close();
+  }));
+}));
@@ -0,0 +1,67 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+
+// A peer reset may leave a write unfinished. Preserve the clean readable
+// end in 26.x, but do not wait for writable 'finish' to destroy the stream.
+for (const compat of [false, true]) {
+  const server = http2.createServer();
+  let client;
+  let request;
+
+  function onRequest(readable, writable, stream) {
+    readable.on('error', common.mustNotCall());
+    if (writable !== readable)
+      writable.on('error', common.mustNotCall());
+    stream.on('error', common.mustNotCall());
+    readable.resume();
+    readable.on('end', common.mustCall());
+    stream.on('aborted', common.mustCall());
+    stream.on('finish', common.mustNotCall());
+    if (compat) {
+      // The compat response retains its existing finish-on-close behavior.
+      writable.on('finish', common.mustCall());
+    }
+    stream.on('close', common.mustCall(() => {
+      assert.strictEqual(stream.rstCode, http2.constants.NGHTTP2_NO_ERROR);
+      assert.strictEqual(stream.readableEnded, true);
+      assert.strictEqual(stream.writableFinished, false);
+      assert.strictEqual(stream.destroyed, true);
+      client.close();
+      server.close();
+    }));
+
+    writable.write('first response', common.mustCall(() => {
+      // Model a write whose callback cannot finish after the peer resets.
+      // Start the reset only once the write is pending.
+      stream._write = common.mustCall(() => {
+        setImmediate(() => request.destroy());
+      });
+      writable.write('pending response');
+    }));
+  }
+
+  if (compat) {
+    server.on('request', common.mustCall((req, res) => {
+      onRequest(req, res, req.stream);
+    }));
+  } else {
+    server.on('stream', common.mustCall((stream) => {
+      stream.respond();
+      onRequest(stream, stream, stream);
+    }));
+  }
+
+  server.listen(0, common.mustCall(() => {
+    client = http2.connect(`http://localhost:${server.address().port}`);
+    request = client.request({ ':method': 'POST' });
+    request.on('close', common.mustCall());
+    request.on('error', common.mustNotCall());
+    request.resume();
+    request.write('request body');
+  }));
+}