@@ -3310,6 +3310,30 @@ value, PING frames will be sent automatically to keep the connection alive
 before the idle timeout fires. The value should be less than the effective
 idle timeout (`maxIdleTimeout` transport parameter) to be useful.
 
+#### `sessionOptions.truncatedReads`
+
+* Type: {string} One of `'error'` or `'ignore'`.
+* **Default:** `'error'`
+
+Controls how reading a stream reports a truncated read. A stream's read side
+can end without receiving a QUIC FIN, meaning the peer never signalled that
+the whole stream had been sent and the data received may be incomplete. This
+selects how the stream's async iterator reports this:
+
+* `'error'` - The default. Peers are expected to always send a FIN to end
+  their data explicitly, and so any truncation is an error. The iterator yields
+  the data that did arrive and then throws, so an incomplete stream can never
+  be mistaken for a complete one. Incomplete streams will either throw a
+  `ERR_QUIC_STREAM_RESET` carrying the peer's error code, a connection error,
+  or `ERR_QUIC_STREAM_ABORTED` for other cases.
+
+* `'ignore'` - The truncation itself is ignored: only a stream or connection
+  error is reported, and any clean abort/cancellation or similar simply ends
+  the stream. A non-zero peer reset, non-zero local stop-sending or connection
+  error still fails, but a truncation with no error at all (an idle timeout,
+  a graceful close, or a plain `stopSending()`) ends the read cleanly with the
+  data received. This matches `stream.closed`, which rejects only on an error.
+
 #### `sessionOptions.verifyPeer` (client only)
 
 * Type: {string} One of `'strict'`, `'auto'`, or `'manual'`.
 
@@ -625,7 +625,7 @@ const kMaxBatchChunks = 16;
 const kDefaultMaxBatchBytes = 65536;
 
 async function* createBlobReaderIterable(reader, options = kEmptyObject) {
-  const { getReadError, maxBatchBytes = kDefaultMaxBatchBytes } = options;
+  const { maxBatchBytes = kDefaultMaxBatchBytes } = options;
   let wakeup = PromiseWithResolvers();
   let immediate;
   reader.setWakeup(() => {
@@ -658,9 +658,7 @@ async function* createBlobReaderIterable(reader, options = kEmptyObject) {
           break;
         }
         if (pullResult.status < 0) {
-          error = typeof getReadError === 'function' ?
-            getReadError(pullResult.status) :
-            new ERR_INVALID_STATE('The reader is not readable');
+          error = new ERR_INVALID_STATE('The reader is not readable');
           break;
         }
         if (pullResult.status === 2) {
 
@@ -1715,8 +1715,6 @@ E('ERR_QUIC_CONNECTION_FAILED', 'QUIC connection failed', Error);
 E('ERR_QUIC_ENDPOINT_CLOSED', 'QUIC endpoint closed: %s (%d)', Error);
 E('ERR_QUIC_OPEN_STREAM_FAILED', 'Failed to open QUIC stream', Error);
 E('ERR_QUIC_STREAM_ABORTED', '%s', Error);
-E('ERR_QUIC_STREAM_RESET',
-  'The QUIC stream was reset by the peer with error code %d', Error);
 E('ERR_QUIC_VERSION_NEGOTIATION_ERROR', 'The QUIC session requires version negotiation', Error);
 E('ERR_REQUIRE_ASYNC_MODULE', function(filename, parent, locations) {
   let message = 'require() cannot be used on an ESM graph with top-level await. Use import() instead.';
 
@@ -13,7 +13,6 @@ const {
   ErrorCaptureStackTrace,
   FunctionPrototypeBind,
   FunctionPrototypeCall,
-  Number,
   ObjectDefineProperties,
   ObjectKeys,
   PromisePrototypeThen,
@@ -117,7 +116,6 @@ const {
     ERR_QUIC_ENDPOINT_CLOSED,
     ERR_QUIC_OPEN_STREAM_FAILED,
     ERR_QUIC_STREAM_ABORTED,
-    ERR_QUIC_STREAM_RESET,
     ERR_QUIC_VERSION_NEGOTIATION_ERROR,
   },
 } = require('internal/errors');
@@ -401,6 +399,7 @@ const endpointRegistry = new SafeSet();
  * @property {number} [minVersion] The minimum acceptable QUIC version
  * @property {'use'|'ignore'|'default'} [preferredAddressPolicy] The preferred address policy
  * @property {'strict'|'auto'|'manual'} [verifyPeer='auto'] Peer certificate verification policy (client only)
+ * @property {'error'|'ignore'} [truncatedReads] Truncated read policy
  * @property {ApplicationOptions} [application] The application options
  * @property {TransportParams} [transportParams] The transport parameters
  * @property {string} [servername] The server name identifier (client only)
@@ -1600,6 +1599,9 @@ class QuicStream {
     state: undefined,
     stats: undefined,
     pendingClose: undefined,
+    destroyError: undefined,
+    stopSendingCode: undefined,
+    truncatedReads: undefined,
     reader: undefined,
     destroying: false,
     iteratorLocked: false,
@@ -1648,9 +1650,10 @@ class QuicStream {
    * @param {object} handle
    * @param {QuicSession} session
    * @param {number} direction
-   * @param {boolean} [isLocal]
+   * @param {boolean} isLocal
+   * @param {'error'|'ignore'} truncatedReads
    */
-  constructor(privateSymbol, handle, session, direction, isLocal) {
+  constructor(privateSymbol, handle, session, direction, isLocal, truncatedReads) {
     assertPrivateSymbol(privateSymbol);
 
     this.#handle = handle;
@@ -1659,6 +1662,7 @@ class QuicStream {
     inner.session = session;
     inner.direction = direction;
     inner.isLocal = isLocal;
+    inner.truncatedReads = truncatedReads;
     inner.state = new QuicStreamState(
       kPrivateConstructor, handle.state, handle.stateByteOffset);
 
@@ -1690,34 +1694,49 @@ class QuicStream {
     inner.iteratorLocked = true;
 
     inner.reader ??= this.#handle?.getReader();
-    // Non-readable stream (outbound-only unidirectional, or closed)
-    if (!inner.reader) return;
-
-    yield* createBlobReaderIterable(inner.reader, {
-      getReadError: () => {
-        // The read side ends for one of three reasons:
-        //   * Clean FIN received from the peer (state.finReceived
-        //     === true). The iterator stops without calling this;
-        //     fall through to the generic state error if it does.
-        //   * Peer sent us a RESET_STREAM. The C++ side records the
-        //     code in state.resetCode regardless of whether the JS
-        //     onreset handler was attached. state.finReceived stays
-        //     false because no FIN was seen.
-        //   * We aborted locally via stream.resetStream() or
-        //     stream.stopSending(). Both paths run EndReadable in
-        //     C++, setting state.readEnded without setting
-        //     state.finReceived. There is no peer code to surface.
-        if (inner.state.readEnded && !inner.state.finReceived) {
-          const peerResetCode = inner.state.resetCode;
-          if (peerResetCode !== undefined && peerResetCode > 0n) {
-            return new ERR_QUIC_STREAM_RESET(Number(peerResetCode));
-          }
-          return new ERR_QUIC_STREAM_ABORTED(
-            'Stream aborted before FIN was received');
-        }
-        return new ERR_INVALID_STATE('The stream is not readable');
-      },
-    });
+    // No reader means either an outbound-only unidirectional stream, or a
+    // stream already destroyed (data gone, but truncation must still be
+    // checked below).
+    if (inner.reader) {
+      yield* createBlobReaderIterable(inner.reader);
+    }
+
+    if (inner.state.readEnded && !inner.state.finReceived) {
+      // The readable has been truncated - ended with no clean FIN. We expose
+      // this in different ways depending on the truncatedReads option.
+
+      // If we cancelled ourselves, check our own stop-sending code (not the
+      // result mirrored by the remote peer)
+      if (inner.stopSendingCode > 0n) {
+        throw new QuicError('Stream aborted before FIN was received',
+                            { __proto__: null,
+                              errorCode: inner.stopSendingCode });
+      }
+
+      // Non-zero reset is always an error:
+      const peerResetCode = inner.state.resetCode;
+      if (peerResetCode > 0n) {
+        throw new QuicError(
+          `The QUIC stream was reset by the peer with error code ${peerResetCode}`,
+          { __proto__: null,
+            code: 'ERR_QUIC_STREAM_RESET',
+            errorCode: peerResetCode });
+      }
+
+      // If stream teardown has started (stats.destroyedAt is set) then a
+      // close event confirming a final error/clean close will settle
+      // imminently (might be settled already). We await here to rethrow
+      // any errors if the connection has failed.
+      if (this.destroyed || this.stats.destroyedAt !== 0n) {
+        await this.closed;
+      }
+
+      // Clean abort is truncation, but not necessarily an error:
+      if (inner.truncatedReads === 'error') {
+        throw new QuicError('Stream aborted before FIN was received',
+                            { __proto__: null, errorCode: peerResetCode ?? 0n });
+      }
+    }
   }
 
   /**
@@ -2099,9 +2118,11 @@ class QuicStream {
     if (error !== undefined && typeof inner.onerror === 'function') {
       invokeOnerror(inner.onerror, error);
     }
-    const handle = this.#handle;
-    this[kFinishClose](error);
-    handle.destroy();
+    // handle.destroy() kicks off all the cleanup internals, eventually
+    // including [kFinishClose] which needs this original destroy error:
+    inner.destroyError = error;
+    this.#handle.destroy();
+    this[kFinishClose](error); // A no-op, unless destroy() failed
   }
 
   /**
@@ -2519,7 +2540,9 @@ class QuicStream {
   stopSending(code = 0n) {
     assertIsQuicStream(this);
     if (this.destroyed) return;
-    this.#handle.stopSending(BigInt(code));
+    const abortCode = BigInt(code);
+    this.#inner.stopSendingCode = abortCode;
+    this.#handle.stopSending(abortCode);
   }
 
   /**
@@ -2612,6 +2635,9 @@ class QuicStream {
     if (this.destroyed) {
       return inner.pendingClose.promise;
     }
+    // Prefer an error staged by destroy() (the original object the caller
+    // passed) over the error delivered by the native close callback.
+    error = inner.destroyError ?? error;
     if (error !== undefined) {
       inner.pendingClose.reject(error);
     } else {
@@ -2649,6 +2675,7 @@ class QuicStream {
     inner.session = undefined;
     inner.pendingClose.reject = undefined;
     inner.pendingClose.resolve = undefined;
+    inner.destroyError = undefined;
     inner.onblocked = undefined;
     inner.onreset = undefined;
     inner.onstopsending = undefined;
@@ -2859,6 +2886,7 @@ class QuicSession {
     // because server-side cert validation is handled by rejectUnauthorized
     // at the C++ level.
     verifyPeer: 'manual',
+    truncatedReads: 'error',
     handshakeInfo: undefined,
     /** @type {QuicSessionPath|undefined} */
     path: undefined,
@@ -2892,8 +2920,9 @@ class QuicSession {
    * @param {symbol} privateSymbol
    * @param {object} handle
    * @param {QuicEndpoint} endpoint
+   * @param {{ truncatedReads?: 'error'|'ignore' }} [options]
    */
-  constructor(privateSymbol, handle, endpoint) {
+  constructor(privateSymbol, handle, endpoint, options = kEmptyObject) {
     // Instances of QuicSession can only be created internally.
     assertPrivateSymbol(privateSymbol);
 
@@ -2902,6 +2931,8 @@ class QuicSession {
 
     const inner = this.#inner;
     inner.endpoint = endpoint;
+    const { truncatedReads } = options;
+    if (truncatedReads !== undefined) inner.truncatedReads = truncatedReads;
     // Move any qlog entries that arrived before the wrapper existed.
     if (handle._pendingQlog !== undefined) {
       inner.pendingQlog = handle._pendingQlog;
@@ -3447,7 +3478,8 @@ class QuicSession {
     }
 
     const stream = new QuicStream(
-      kPrivateConstructor, handle, this, direction, true /* isLocal */);
+      kPrivateConstructor, handle, this, direction, true /* isLocal */,
+      inner.truncatedReads);
     inner.streams.add(stream);
     if (typeof this.#inner.onerror === 'function') {
       markPromiseAsHandled(stream.closed);
@@ -4232,7 +4264,7 @@ class QuicSession {
   [kNewStream](handle, direction) {
     const inner = this.#inner;
     const stream = new QuicStream(kPrivateConstructor, handle, this, direction,
-                                  false /* isLocal */);
+                                  false /* isLocal */, inner.truncatedReads);
 
     // Set the default byte budget for received streams.
     stream.budget = kDefaultBudget;
@@ -4349,6 +4381,7 @@ class QuicEndpoint {
     sessions: new SafeSet(),
     stat: undefined,
     stats: undefined,
+    truncatedReads: undefined,
     onsession: undefined,
     sessionCallbacks: undefined,
   };
@@ -4481,8 +4514,8 @@ class QuicEndpoint {
     };
   }
 
-  #newSession(handle) {
-    const session = new QuicSession(kPrivateConstructor, handle, this);
+  #newSession(handle, options) {
+    const session = new QuicSession(kPrivateConstructor, handle, this, options);
     this.#inner.sessions.add(session);
     // Set default pending datagram queue size.
     session.maxPendingDatagrams = kDefaultMaxPendingDatagrams;
@@ -4656,9 +4689,13 @@ class QuicEndpoint {
       ontrailers,
       oninfo,
       onwanttrailers,
+      // Stored on the endpoint and applied to each incoming session.
+      truncatedReads,
       ...rest
     } = options;
 
+    inner.truncatedReads = truncatedReads;
+
     // Store session and stream callbacks to apply to each new incoming session.
     inner.sessionCallbacks = {
       __proto__: null,
@@ -4700,6 +4737,7 @@ class QuicEndpoint {
     validateObject(options, 'options');
     const {
       sessionTicket,
+      truncatedReads,
       ...rest
     } = options;
 
@@ -4708,7 +4746,7 @@ class QuicEndpoint {
     if (handle === undefined) {
       throw new ERR_QUIC_CONNECTION_FAILED();
     }
-    const session = this.#newSession(handle);
+    const session = this.#newSession(handle, { __proto__: null, truncatedReads });
     // Set callbacks before any async work to avoid missing events
     // that fire during or immediately after the handshake.
     applyCallbacks(session, options);
@@ -4942,7 +4980,8 @@ class QuicEndpoint {
     const inner = this.#inner;
     assert(typeof inner.onsession === 'function',
            'onsession callback not specified');
-    const session = this.#newSession(handle);
+    const session = this.#newSession(handle,
+                                     { __proto__: null, truncatedReads: inner.truncatedReads });
     // Apply session callbacks stored at listen time before notifying
     // the onsession callback, to avoid missing events that fire
     // during or immediately after the handshake.
@@ -5434,6 +5473,7 @@ function processSessionOptions(options, config = kEmptyObject) {
     maxDatagramSendAttempts = 5,
     streamIdleTimeout,
     verifyPeer = 'auto',
+    truncatedReads = 'error',
     // HTTP/3 application-specific options. Nested under `application`
     // to separate protocol-specific settings from transport-level ones.
     application = kEmptyObject,
@@ -5485,6 +5525,9 @@ function processSessionOptions(options, config = kEmptyObject) {
   validateOneOf(verifyPeer, 'options.verifyPeer',
                 ['strict', 'auto', 'manual']);
 
+  validateOneOf(truncatedReads, 'options.truncatedReads',
+                ['error', 'ignore']);
+
   validateInteger(drainingPeriodMultiplier, 'options.drainingPeriodMultiplier',
                   3, 255);
 
@@ -5547,6 +5590,7 @@ function processSessionOptions(options, config = kEmptyObject) {
       verifyHostname: verifyPeer !== 'manual',
     },
     verifyPeer,
+    truncatedReads,
     qlog,
     maxPayloadSize,
     unacknowledgedPacketThreshold,