quic: address qard review feedback

Author: jasnell

doc/api/quic.md

@@ -1497,7 +1497,7 @@ The following body source types are supported:
 * `AsyncIterable`, `Iterable` — Each yielded chunk (string or
   `Uint8Array`) is written incrementally in streaming mode.
 * `Promise` — Awaited; the resolved value is used as the body (subject
-  to the same type rules, with a nesting depth limit).
+  to the same type rules).
 
 Throws `ERR_INVALID_STATE` if the outbound is already configured or if
 the writer has been accessed.

lib/internal/quic/quic.js

@@ -910,28 +910,23 @@ function applyCallbacks(session, cbs) {
  * @param {QuicStream} stream The JS stream object
  * @param {*} body The body source
  */
-const kMaxConfigureOutboundDepth = 3;
 const kDefaultHighWaterMark = 65536;
 const kDefaultMaxPendingDatagrams = 128;
 
-function configureOutbound(handle, stream, body, depth = 0) {
-  if (depth > kMaxConfigureOutboundDepth) {
-    throw new ERR_INVALID_STATE(
-      'Body source resolved to too many nested promises');
-  }
-
+function configureOutbound(handle, stream, body) {
   // body: null - close writable side immediately (FIN)
   if (body === null) {
     handle.initStreamingSource();
     handle.endWrite();
     return;
   }
 
-  // Handle Promise - await and recurse with depth limit
+  // Handle Promise - await and recurse. Native promises auto-flatten,
+  // so the resolved value will never itself be a promise.
   if (isPromise(body)) {
     PromisePrototypeThen(
       body,
-      (resolved) => configureOutbound(handle, stream, resolved, depth + 1),
+      (resolved) => configureOutbound(handle, stream, resolved),
       (err) => {
         if (!stream.destroyed) {
           stream.destroy(err);

test/parallel/test-quic-stream-body-promise-reject.mjs

@@ -1,8 +1,8 @@
 // Flags: --experimental-quic --experimental-stream-iter --no-warnings
 
-// Test: body: Promise rejection and nested promise depth.
-// Promise rejection during body configuration errors the stream.
-// Nested promises are resolved up to the depth limit.
+// Test: body: nested promise resolution.
+// Native promises auto-flatten, so Promise<Promise<string>> resolves
+// to the inner string value.
 
 import { hasQuic, skip, mustCall } from '../common/index.mjs';
 import assert from 'node:assert';
@@ -16,8 +16,8 @@ if (!hasQuic) {
 const { listen, connect } = await import('../common/quic.mjs');
 const { bytes } = await import('stream/iter');
 
-// Nested promises — the body is resolved recursively up to
-// depth 3. A Promise<Promise<string>> should work.
+// Nested promises — native promises auto-flatten, so the
+// resolved value is never itself a promise.
 {
   const serverDone = Promise.withResolvers();