@@ -51,6 +51,19 @@ use crate::{
     stream_type_reader::NewStreamHeadReader,
 };
 
+/// Number of unidirectional streams HTTP/3 opens for its own use (control, QPACK encoder, QPACK
+/// decoder).  Streams of reserved types (RFC 9114, Section 6.2.3), which a peer may also open,
+/// are deliberately not counted: how many a given peer opens is a guess.
+pub const HTTP3_UNI_CONTROL_STREAMS: u64 = 3;
+
+/// Upper bound on the connection-wide incoming stream limit derived from anticipated
+/// `WebTransport` streams.
+///
+/// Without a cap, an application-controlled value summed across an unbounded number of sessions
+/// could ratchet the advertised `MAX_STREAMS` arbitrarily high; the limit is monotonic, so it
+/// never comes back down as sessions close.
+pub const MAX_ANTICIPATED_INCOMING_STREAMS: u64 = 10_000;
+
 pub struct RequestDescription<'b, T: RequestTarget> {
     pub method: &'b str,
     pub connect_type: Option<ConnectType>,
@@ -1437,6 +1450,52 @@ impl Http3Connection {
         Ok(stats)
     }
 
+    /// Recompute the connection's incoming limit for `stream_type` as the sum over open
+    /// `WebTransport` sessions; see
+    /// [`crate::webtransport::ClientSession::webtransport_set_anticipated_incoming_uni_streams`].
+    /// Walks every receive stream: call per session, not per stream.
+    ///
+    /// # Errors
+    /// Returns `InvalidStreamId` if the session does not exist, is not a `WebTransport`
+    /// session, or is already closing.
+    pub(crate) fn webtransport_set_anticipated_incoming_streams(
+        &self,
+        conn: &mut Connection,
+        session_id: StreamId,
+        stream_type: StreamType,
+        value: u16,
+    ) -> Res<()> {
+        let session = self.webtransport_session(session_id)?;
+        if session.borrow().is_closing() {
+            return Err(Error::InvalidStreamId);
+        }
+        session
+            .borrow_mut()
+            .set_anticipated_incoming(stream_type, value);
+
+        let total: u64 = self
+            .recv_streams
+            .values()
+            .filter_map(|s| {
+                let session = s.extended_connect_session()?;
+                let session = session.borrow();
+                (!session.is_closing()
+                    && session.connect_type() == ExtendedConnectType::WebTransport)
+                    .then(|| u64::from(session.anticipated_incoming(stream_type)))
+            })
+            .sum::<u64>()
+            .min(MAX_ANTICIPATED_INCOMING_STREAMS);
+
+        let total_including_h3 = match stream_type {
+            // HTTP/3 opens its own unidirectional streams (control and the two QPACK
+            // streams) out of the same limit, so they have to be added on top.
+            StreamType::UniDi => total + HTTP3_UNI_CONTROL_STREAMS,
+            StreamType::BiDi => total,
+        };
+        conn.set_remote_max_streams(stream_type, total_including_h3);
+        Ok(())
+    }
+
     pub(crate) fn extended_connect_close_session(
         &mut self,
         conn: &mut Connection,
 
@@ -16,6 +16,7 @@ use std::{
 use neqo_common::{Bytes, Encoder, Header, MessageType, Role, qdebug, qtrace, to_u64};
 use neqo_transport::{
     AppError, Connection, DatagramQueueCapacity, DatagramQueueOutcome, DatagramTracking, StreamId,
+    StreamType,
     streams::{SendGroupId, SendOrder},
 };
 use rustc_hash::FxHashSet as HashSet;
@@ -68,6 +69,8 @@ pub(crate) struct Session {
     /// Set when a datagram capsule was refused with `FlowControlLimit`, so a
     /// resume event fires once the control stream is writable again.
     datagram_capsule_blocked: bool,
+    anticipated_incoming_uni: u16,
+    anticipated_incoming_bidi: u16,
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
@@ -128,6 +131,8 @@ impl Session {
             protocol,
             draining: false,
             datagram_capsule_blocked: false,
+            anticipated_incoming_uni: 0,
+            anticipated_incoming_bidi: 0,
         }
     }
 
@@ -159,6 +164,8 @@ impl Session {
             protocol,
             draining: false,
             datagram_capsule_blocked: false,
+            anticipated_incoming_uni: 0,
+            anticipated_incoming_bidi: 0,
         })
     }
 
@@ -172,6 +179,21 @@ impl Session {
         self.id
     }
 
+    pub(crate) const fn set_anticipated_incoming(&mut self, stream_type: StreamType, value: u16) {
+        match stream_type {
+            StreamType::UniDi => self.anticipated_incoming_uni = value,
+            StreamType::BiDi => self.anticipated_incoming_bidi = value,
+        }
+    }
+
+    #[must_use]
+    pub(crate) const fn anticipated_incoming(&self, stream_type: StreamType) -> u16 {
+        match stream_type {
+            StreamType::UniDi => self.anticipated_incoming_uni,
+            StreamType::BiDi => self.anticipated_incoming_bidi,
+        }
+    }
+
     /// Mark session as draining. Returns `true` if this was the first call
     /// (i.e. the session was not already draining).
     pub(crate) const fn set_draining(&mut self) -> bool {
@@ -361,6 +383,11 @@ impl Session {
         matches!(self.state, State::Active)
     }
 
+    #[must_use]
+    pub(crate) const fn is_closing(&self) -> bool {
+        self.state.closing_state()
+    }
+
     pub(crate) fn take_sub_streams(&mut self) -> (HashSet<StreamId>, HashSet<StreamId>) {
         self.protocol.take_sub_streams()
     }