diff --git a/quest/m1/vendor-sync/README.md b/quest/m1/vendor-sync/README.md index c4434ad5131..3d40c771706 100644 --- a/quest/m1/vendor-sync/README.md +++ b/quest/m1/vendor-sync/README.md @@ -58,7 +58,6 @@ behavior follows quinn's fixes. ## Required -- [moq-quic has every quinn fix it needs](/quest/m1/vendor-sync/quinn.md) - quinn's fixes since the last check are ported with their tests - [UniFFI generator forks are current](/quest/m1/vendor-sync/uniffi.md) - the generator forks carry upstream's fixes until rust2 replaces them - [moq-vaapi has every cros-codecs fix it needs](/quest/m1/vendor-sync/vaapi.md) - cros-libva and cros-codecs fixes reach moq-dev/vaapi diff --git a/quest/m1/vendor-sync/quinn.md b/quest/m1/vendor-sync/quinn.md deleted file mode 100644 index 1d8a7ef890d..00000000000 --- a/quest/m1/vendor-sync/quinn.md +++ /dev/null @@ -1,56 +0,0 @@ -# [S] moq-quic has every quinn fix it needs - -## Goal - -moq-quic, moq-sock's `udp`, moq-tokio's `quic::driver`, and moq-congestion's -BBR3 carry every -security and correctness fix quinn has landed since the last sync, each -ported with its regression test or recorded as not applying. The fork -ledger in `rs/moq-quic/README.md` says how far upstream was checked. - -## Plan - -Recurring child of the [vendor sync](/quest/m1/vendor-sync/README.md), which -says how each run works and recurs. Decided 2026-10-27 (maintainer), from a -second audit of main against release: the hard fork never merges upstream, so -checking upstream is recurring work. On 2026-10-30 the maintainer moved it into -the vendor sync with moq's other vendored code. - -Each run also checks [quinn#2481](https://github.com/quinn-rs/quinn/pull/2481), -the open BBR3 PR moq-congestion carries from -[`55f74c0d`](https://github.com/quinn-rs/quinn/pull/2481/commits/55f74c0dd0738b5ad7d7676c0b2869a547783f83), -for fixes to port, and records the PR commit checked in the README's BBR3 -entry. It was force-pushed to `01b8848d` on 2026-10-20. - -Last checked: quinn `main` through -[`2697de1e`](https://github.com/quinn-rs/quinn/commit/2697de1e1314cb9f98502b7323acd5bdd836b582) -(2026-10-28) and `0.11.x` through -[`4b84837d`](https://github.com/quinn-rs/quinn/commit/4b84837df1d25424bc37b0ed990e7b376d40a9c0), -recorded in `rs/moq-quic/README.md`'s `Upstream` section -([moq-dev/moq#7287](https://github.com/moq-dev/moq/pull/7287) checked -`f233510c`, `6c69f9f4`, and `623a0369`). Record the newest upstream commit -checked there. - -Remaining this run: -[`a2c55b36`](https://github.com/quinn-rs/quinn/commit/a2c55b36817ccaac1c39c6db92de8294f281819f) -(honor IPv4 source addresses on Apple: send `IP_PKTINFO` rather than -`IP_RECVDSTADDR`, in `moq_sock::udp`), the quinn#2481 check above, and judging -the new `read_datagrams` API -([`2697de1e`](https://github.com/quinn-rs/quinn/commit/2697de1e)), a feature: -plan it with `/quest-plan` if moq-tokio's driver would use it. - -Learned so far: a fix missing from the ledger is often already held, since the -fork reworked the same code (`stop` under `RESET_STREAM_AT`, the stale-accept -check under `handshake_timeout`, and socket setup in `moq_sock::bind`), so -check the fork's code before porting. A fix to quinn's `Endpoint::client` or -`server` lands in `moq_sock::bind`, which the driver's test helpers bind -through. Most of `0.11.x` is backports of `main`; compare its commits by -subject. - -Public API: none expected; a ported fix that changes one says so. Wire: -QUIC behavior follows upstream's fixes. - -## Related - -- [moq-quic's API improves on quinn's](/quest/m1/quic-api/README.md) - renames that make each port a hand translation -- [Dependency audit](/quest/m2/audit-deps.md) - covers crates cargo-deny can see diff --git a/rs/moq-congestion/src/bbr3/mod.rs b/rs/moq-congestion/src/bbr3/mod.rs index 6a1b718645b..337eb210698 100644 --- a/rs/moq-congestion/src/bbr3/mod.rs +++ b/rs/moq-congestion/src/bbr3/mod.rs @@ -468,6 +468,12 @@ pub struct Bbr3 { ack_phase: AckPhase, /// equivalent to BBR.is_bw_probe_sample bw_probe_samples: bool, + /// Whether the previous probe found excessive inflight, and whether this probe stopped at + /// that bound to wait for its feedback before probing higher. + prev_probe_too_high: bool, + undo_prev_probe_too_high: bool, + prev_probe_precautionary: bool, + undo_prev_probe_precautionary: bool, /// equivalent to BBR.loss_round_delivered: C.delivered during the first loss of the round loss_round_delivered: u64, /// equivalent to BBR.loss_in_round: flag set to true when loss occurs during the round @@ -647,6 +653,10 @@ impl Bbr3 { cycle_stamp: None, ack_phase: AckPhase::Init, bw_probe_samples: false, + prev_probe_too_high: false, + undo_prev_probe_too_high: false, + prev_probe_precautionary: false, + undo_prev_probe_precautionary: false, loss_events_in_round: 0, recovery_start_time: None, recovery_start_round: 0, @@ -831,8 +841,10 @@ impl Bbr3 { if self.full_bw_reached { self.extra_acked_filter.update_max(self.round_count, extra); self.extra_acked = self.extra_acked_filter.get_max(); + } else if self.round_start { + self.extra_acked = extra; } else { - self.extra_acked = extra; // In startup, just remember 1 round + self.extra_acked = Ord::max(self.extra_acked, extra); } } @@ -926,7 +938,8 @@ impl Bbr3 { /// Fast recovery ends when a packet sent after it began is acknowledged. /// fn check_recovery_done(&mut self, sent: Instant) { - if self.recovery_start_time.is_some_and(|start| sent > start) { + if self.in_recovery && self.recovery_start_time.is_some_and(|start| sent > start) { + self.restore_cwnd(); self.in_recovery = false; } } @@ -963,7 +976,9 @@ impl Bbr3 { if !self.full_bw_reached { return; } - self.adapt_long_term_model(newly_acked, now); + if self.adapt_long_term_model(newly_acked, now) { + return; + } let state = self.state; match state { BbrState::ProbeBw(ProbeBwSubstate::Down) => { @@ -980,7 +995,8 @@ impl Bbr3 { self.bw_probe_samples = true; self.start_probe_bw_up(); } - BbrState::ProbeBw(ProbeBwSubstate::Up) if self.maybe_go_down() => { + BbrState::ProbeBw(ProbeBwSubstate::Up) if self.maybe_go_down(newly_acked) => { + self.prev_probe_too_high = false; self.start_probe_bw_down(now); } BbrState::ProbeBw(ProbeBwSubstate::Up) => self.maybe_fill_probe_bw_up(now), @@ -1007,8 +1023,9 @@ impl Bbr3 { /// equivalent to BBRAdaptLongTermModel /// /// The probe's feedback ends once, on the first round after it stops, so later losses are not - /// taken as probe feedback and later rounds do not age the max-bw window again. - fn adapt_long_term_model(&mut self, newly_acked: u64, now: Instant) { + /// taken as probe feedback and later rounds do not age the max-bw window again. Returns + /// whether clean feedback from a precautionary probe started a new refill. + fn adapt_long_term_model(&mut self, newly_acked: u64, now: Instant) -> bool { if self.ack_phase == AckPhase::ProbeStarting && self.round_start { self.ack_phase = AckPhase::ProbeFeedback; } @@ -1021,10 +1038,19 @@ impl Bbr3 { { self.advance_max_bw_filter(now); } + // A precautionary stop waits for this one round of feedback, and no later. + let precautionary = std::mem::take(&mut self.prev_probe_precautionary); + if let BbrState::ProbeBw(_) = self.state + && precautionary + && !self.prev_probe_too_high + { + self.start_probe_bw_refill(); + return true; + } } if !self.is_inflight_too_high() { if self.inflight_longterm == u64::MAX { - return; + return false; } if let Some(rate_sample) = self.rs && rate_sample.tx_in_flight > self.inflight_longterm @@ -1035,6 +1061,7 @@ impl Bbr3 { self.probe_inflight_long_term_upward(newly_acked); } } + false } /// equivalent to BBRAdvanceMaxBwFilter @@ -1094,6 +1121,7 @@ impl Bbr3 { self.reset_short_term_model(); self.bw_probe_up_rounds = 0; self.bw_probe_up_acked = 0; + self.prev_probe_precautionary = false; self.ack_phase = AckPhase::Refilling; self.start_round(); self.cwnd_gain = self.default_cwnd_gain; @@ -1123,7 +1151,12 @@ impl Bbr3 { } /// equivalent to BBRIsTimeToGoDown - fn maybe_go_down(&mut self) -> bool { + fn maybe_go_down(&mut self, newly_acked: u64) -> bool { + let pre_ack_inflight = self.inflight.saturating_add(newly_acked); + if self.prev_probe_too_high && pre_ack_inflight >= self.inflight_longterm { + self.prev_probe_precautionary = true; + return true; + } if self.is_cwnd_limited && self.cwnd >= self.inflight_longterm { self.reset_full_bw(); if let Some(rate_sample) = self.rs { @@ -1145,12 +1178,14 @@ impl Bbr3 { if !self.is_cwnd_limited || self.cwnd < self.inflight_longterm { return; } - self.bw_probe_up_acked += newly_acked; + self.bw_probe_up_acked = self.bw_probe_up_acked.saturating_add(newly_acked); if self.bw_probe_up_acked >= self.probe_up_acked_per_inc && self.probe_up_acked_per_inc > 0 { let delta = self.bw_probe_up_acked / self.probe_up_acked_per_inc; self.bw_probe_up_acked -= delta * self.probe_up_acked_per_inc; - self.inflight_longterm += delta * self.smss; + self.inflight_longterm = self + .inflight_longterm + .saturating_add(delta.saturating_mul(self.smss)); } if self.round_start { self.raise_inflight_long_term_slope(); @@ -1278,13 +1313,14 @@ impl Bbr3 { /// equivalent to BBREnterProbeRTT fn enter_probe_rtt(&mut self) { self.state = BbrState::ProbeRtt; + self.prev_probe_precautionary = false; self.pacing_gain = self.default_pacing_gain; self.cwnd_gain = self.probe_rtt_cwnd_gain; } /// equivalent to BBRSaveCwnd fn save_cwnd(&mut self) { - if !self.loss_in_round && self.state != BbrState::ProbeRtt { + if !self.in_recovery && self.state != BbrState::ProbeRtt { self.prior_cwnd = self.cwnd; } else { self.prior_cwnd = Ord::max(self.prior_cwnd, self.cwnd); @@ -1644,6 +1680,8 @@ impl Bbr3 { _ => self.cwnd, }; self.undo_state = None; + self.undo_prev_probe_too_high = self.prev_probe_too_high; + self.undo_prev_probe_precautionary = self.prev_probe_precautionary; self.undo_bw_shortterm = self.bw_shortterm; self.undo_inflight_shortterm = self.inflight_shortterm; self.undo_inflight_longterm = self.inflight_longterm; @@ -1672,6 +1710,8 @@ impl Bbr3 { /// `rs` is the sample that showed it, if any. fn handle_inflight_too_high(&mut self, now: Instant, rs: Option) { self.bw_probe_samples = false; + self.prev_probe_too_high = true; + self.prev_probe_precautionary = false; if let Some(rate_sample) = rs && !rate_sample.is_app_limited { @@ -1881,6 +1921,12 @@ impl Controller for Bbr3 { self.bound_cwnd_for_probe_rtt(); self.loss_in_round = false; self.reset_full_bw(); + self.prev_probe_too_high = self.undo_prev_probe_too_high; + // A precautionary stop still waiting for its feedback round waits again; once that + // round has passed, the spurious loss cost the early refill for good. + self.prev_probe_precautionary = self.undo_prev_probe_precautionary + && self.state == BbrState::ProbeBw(ProbeBwSubstate::Down) + && self.ack_phase == AckPhase::ProbeStopping; self.bw_shortterm = [self.bw_shortterm, self.undo_bw_shortterm] .iter() .copied() @@ -4242,6 +4288,7 @@ mod test { // Peak max_bw seen in STARTUP; must stay ~BW, proving the burst didn't inflate the // delivery-rate estimate above the send rate. let mut peak_startup_max_bw: f64 = 0.0; + let mut last_startup_extra: Option<(u64, u64)> = None; // Captured on the STARTUP -> DRAIN edge, as in A.1. let mut transition: Option<(bool, f64)> = None; @@ -4296,6 +4343,15 @@ mod test { if bbr.state == BbrState::Startup { max_extra_acked = max_extra_acked.max(bbr.extra_acked); + if let Some((round, previous)) = last_startup_extra + && bbr.round_count == round + { + assert!( + bbr.extra_acked >= previous, + "startup lost its round's ACK aggregation budget" + ); + } + last_startup_extra = Some((bbr.round_count, bbr.extra_acked)); peak_startup_max_bw = peak_startup_max_bw.max(bbr.max_bw); // bbr.bdp is refreshed to max_bw*min_rtt on every set_cwnd; once the // aggregation estimate is positive it should lift cwnd past 2*BDP. @@ -7254,7 +7310,11 @@ mod test { } limited(&mut sim, MAX_FULL_BW_COUNT); assert!(sim.bbr.probe_inflight().is_some()); + // The idle ACK renewed the application-limited marker, so the round sent right after it + // still counts as application-limited; the sender's next round is its own. sim.round((MAX_FULL_BW_COUNT + 1) * 20 * MS, 100, 10 * MS); + assert!(sim.bbr.probe_inflight().is_some(), "sent under the marker"); + sim.round((MAX_FULL_BW_COUNT + 2) * 20 * MS, 100, 10 * MS); assert_eq!(sim.bbr.state, BbrState::Startup); assert_eq!( sim.bbr.probe_inflight(), @@ -8133,4 +8193,107 @@ mod test { assert!(marked.bbr.max_bw > 0.9 * control.bbr.max_bw); assert_eq!(marked.bbr.inflight_shortterm, u64::MAX); } + + /// Each idle ACK can pass the old application-limited marker while reporting that the + /// sender is still idle. The next keepalive must keep its application-limited label. + #[test] + fn idle_keepalives_remain_application_limited() { + let mut sim = scripted(); + sim.bbr.on_app_limited(0); + for i in 0..10 { + let now = i * 1000 * MS; + let pn = sim.pn; + sim.send(now, 1); + sim.ack(now + 10 * MS, [pn], true); + assert!( + sim.bbr.rs.unwrap().is_app_limited, + "keepalive {i} lost its label" + ); + } + } + + #[test] + fn recovery_exit_restores_the_saved_window() { + let mut sim = probing_up(); + sim.lose(15 * MS, 10); + assert_eq!(sim.bbr.prior_cwnd, 20_000); + let now = sim.at(16 * MS); + sim.bbr.on_loss(Loss { + now, + packets: &[], + in_flight: sim.inflight, + persistent: true, + }); + assert_eq!(sim.bbr.cwnd, sim.bbr.min_pipe_cwnd); + sim.bbr.inflight_longterm = 100_000; + sim.bbr.inflight_shortterm = 100_000; + sim.send(16 * MS, 1); + sim.ack(26 * MS, [sim.pn - 1], false); + assert!(!sim.bbr.in_recovery); + assert!( + sim.bbr.cwnd >= 20_000, + "recovery lost its saved window: {}", + sim.bbr.cwnd + ); + } + + #[test] + fn precautionary_probe_restarts_on_clean_feedback() { + let mut sim = probing_up(); + sim.lose(15 * MS, 10); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Down)); + let risky_inflight = sim.bbr.inflight_longterm; + sim.ack(20 * MS, 11..20, false); + let wait_ns = sim.bbr.bw_probe_wait.as_nanos() as u64 + 30 * MS; + sim.bbr.probe_rtt_min_stamp = Some(sim.at(wait_ns)); + sim.round(wait_ns, 5, 10 * MS); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Refill)); + sim.round(wait_ns + 10 * MS, 5, 10 * MS); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Up)); + let t_probe = wait_ns + 20 * MS; + let first = sim.pn; + sim.send(t_probe, risky_inflight.div_ceil(sim.mss)); + sim.ack(t_probe + 10 * MS, first..first + 1, false); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Down)); + assert_eq!(sim.bbr.inflight_longterm, risky_inflight); + sim.ack(t_probe + 12 * MS, first + 1..sim.pn, false); + sim.round(t_probe + 15 * MS, 5, 10 * MS); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Refill)); + sim.round(t_probe + 25 * MS, 5, 10 * MS); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Up)); + } + + /// A loss in a precautionary stop's feedback round, later declared spurious, still lets the + /// clean feedback start the next refill early. + #[test] + fn spurious_loss_keeps_the_precautionary_refill() { + let mut sim = probing_up(); + sim.lose(15 * MS, 10); + let risky_inflight = sim.bbr.inflight_longterm; + sim.ack(20 * MS, 11..20, false); + let wait_ns = sim.bbr.bw_probe_wait.as_nanos() as u64 + 30 * MS; + sim.bbr.probe_rtt_min_stamp = Some(sim.at(wait_ns)); + sim.round(wait_ns, 5, 10 * MS); + sim.round(wait_ns + 10 * MS, 5, 10 * MS); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Up)); + let t_probe = wait_ns + 20 * MS; + let first = sim.pn; + sim.send(t_probe, risky_inflight.div_ceil(sim.mss)); + sim.ack(t_probe + 10 * MS, first..first + 1, false); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Down)); + assert!(sim.bbr.prev_probe_precautionary); + + sim.lose(t_probe + 11 * MS, first + 1); + assert!( + !sim.bbr.prev_probe_precautionary, + "the loss reads as too high" + ); + sim.bbr.on_spurious_loss(); + assert!(sim.bbr.prev_probe_precautionary); + assert!(!sim.bbr.prev_probe_too_high); + + sim.ack(t_probe + 12 * MS, first + 2..sim.pn, false); + sim.round(t_probe + 15 * MS, 5, 10 * MS); + assert_eq!(sim.bbr.state, BbrState::ProbeBw(ProbeBwSubstate::Refill)); + } } diff --git a/rs/moq-congestion/src/rate.rs b/rs/moq-congestion/src/rate.rs index abb57f61bba..941f74aa138 100644 --- a/rs/moq-congestion/src/rate.rs +++ b/rs/moq-congestion/src/rate.rs @@ -135,7 +135,8 @@ impl Sampler { if self.app_limited != 0 && self.delivered > self.app_limited { self.app_limited = 0; - } else if ack.app_limited { + } + if ack.app_limited { self.mark_app_limited(ack.in_flight); } diff --git a/rs/moq-quic/README.md b/rs/moq-quic/README.md index 1f2df38cfda..44a96d36842 100644 --- a/rs/moq-quic/README.md +++ b/rs/moq-quic/README.md @@ -9,7 +9,7 @@ All credit for the code goes to the quinn developers; it stays under quinn's MIT ## Upstream Forked from quinn-proto in quinn-rs/quinn `main` at [`7616e6b2`](https://github.com/quinn-rs/quinn/commit/7616e6b2782722f3ce4a1b181ef08817d7f545e4) (2026-10-05). -That covers every quinn security advisory published through 2026-09-30. +All 13 published [security advisories](https://github.com/quinn-rs/quinn/security/advisories) were checked; the newest are still the 2026-09-30 fixes included at the fork point. Ported since the fork point: @@ -23,11 +23,21 @@ Ported since the fork point: - [`f233510c`](https://github.com/quinn-rs/quinn/commit/f233510cf37e1be9511070bf743151736d621a5e): a disabled idle timeout no longer abandons every accept as stale. Does not apply: the fork drops a stale Initial after `transport::Config::handshake_timeout`, which cannot be disabled, rather than the idle timeout. - [`6c69f9f4`](https://github.com/quinn-rs/quinn/commit/6c69f9f4ed2362002a0e2e5312a6dfa3ceb31c1d): stopping a reset stream no longer credits its unread data twice. Already held: `Recv::unread_credit` counts only what a reset still owes below its Reliable Size (see `RESET_STREAM_AT` below), and `stop_after_reset_credits_once` covers it. - [`623a0369`](https://github.com/quinn-rs/quinn/commit/623a0369536b9a1e731a8629c80c164eb8f2e637) (moq-tokio's `quic::driver`): an endpoint on a specific IPv6 address is not made dual-stack, so Windows does not refuse the driver's IPv4 socket options. `moq_sock::bind::udp` already did this; the driver's tests now bind through it, with upstream's `specific_v6_addr`. +- [`a2c55b36`](https://github.com/quinn-rs/quinn/commit/a2c55b36817ccaac1c39c6db92de8294f281819f) (`moq_sock::udp`, [moq-dev/moq#7418](https://github.com/moq-dev/moq/pull/7418)): send IPv4 source overrides with Apple's `IP_PKTINFO` in both `sendmsg` and `sendmsg_x`; `IP_RECVDSTADDR` only selects received destination metadata there. +- [`2c575013`](https://github.com/quinn-rs/quinn/commit/2c5750139fa09aab588bf0f939c83f521d658baf): already covered by the `MIN_PACKET_SPACE` check when choosing a GSO segment size, carried with bandwidth probing. +- [`c2a47f6d`](https://github.com/quinn-rs/quinn/commit/c2a47f6d06447a997451568b90d5495c7e7bc3a9) (`0.11.x`, `moq_tokio::quic::driver`): already covered by `poll_recv`, which propagates every error except `WouldBlock`. The fork has no async-io runtime. -Checked through quinn `main` at [`2697de1e`](https://github.com/quinn-rs/quinn/commit/2697de1e1314cb9f98502b7323acd5bdd836b582) (2026-10-28), and the `0.11.x` branch through [`4b84837d`](https://github.com/quinn-rs/quinn/commit/4b84837df1d25424bc37b0ed990e7b376d40a9c0); start the next sync there. +Dependency bumps are not ported. The `0.11.x` accept refactors are already covered by this fork's split acceptance and CID routing. +[`2697de1e`](https://github.com/quinn-rs/quinn/commit/2697de1e1314cb9f98502b7323acd5bdd836b582)'s batched datagram API is not carried: the current WebTransport reader consumes one at a time, and the [planned driver lock profile](../../quest/m2/perf/quic-lock-contention.md) measures contention before adding batching. + +Checked through quinn `main` at [`2c575013`](https://github.com/quinn-rs/quinn/commit/2c5750139fa09aab588bf0f939c83f521d658baf), and the `0.11.x` branch through [`4b84837d`](https://github.com/quinn-rs/quinn/commit/4b84837df1d25424bc37b0ed990e7b376d40a9c0) (2026-10-31); start the next sync there. The fork never merges upstream, and takes the workspace's formatting and names, so upstream patches no longer apply. Upstream fixes are ported by hand, together with their regression tests. +A fix missing from this list is often already held, because the fork reworked the same code (`stop` under `RESET_STREAM_AT`, the stale-accept check under `handshake_timeout`, socket setup in `moq_sock::bind`), so check the fork's code before porting. +A fix to quinn's `Endpoint::client` or `server` lands in `moq_sock::bind`, which the driver's test helpers bind through. +Most of `0.11.x` backports `main`, so compare its commits by subject. +Each sync also checks [quinn#2481](https://github.com/quinn-rs/quinn/pull/2481), the BBR3 PR moq-congestion carries, for fixes to port, and records the PR commit checked in the BBR3 entries below. quinn-udp, from the same commit, is the `udp` module of [moq-sock](../moq-sock/README.md), with its tests in `tests/udp`. Its benchmark is not carried (moq-uring's `udp_tokio` covers it), and the module logs through `tracing` only, so quinn-udp's `log` feature and no-op logger are dropped. @@ -45,6 +55,7 @@ Changes on top of the upstream commit, besides the renames: - **Close events**: a local close reports `connection::Error::LocallyClosed` with its code and reason as the connection's `ConnectionLost`, a handshake that idles out reports `HandshakeTimeout`, and close reasons are strings, lossily decoded. - **No early data**: TLS never offers or accepts 0-RTT, and early packets are discarded without decryption. The early keys, remembered transport parameters, stream rollback, and early-session driver APIs are removed. Session tickets still resume 1-RTT handshakes. MoQ's CONNECT and authorization already wait for the handshake. - **BBR3**, from [quinn#2481](https://github.com/quinn-rs/quinn/pull/2481) at [`55f74c0d`](https://github.com/quinn-rs/quinn/pull/2481/commits/55f74c0dd0738b5ad7d7676c0b2869a547783f83) (open upstream), rebased onto the fork point with authorship kept. It replaces quinn's BBR and is the default controller. It carries the BBR correctness fixes moq-dev/noq shipped in `moq-noq` 1.3.1, and with them the `Controller` changes BBR needs: per-packet send and loss callbacks, `on_cwnd_limited`, `on_app_limited`, `on_ack_frequency_update`, and controller-owned pacing and burst size. `Metrics` rates are bytes per second. +- **BBR3 upstream refresh**: Checked against the force-pushed [`01b8848d`](https://github.com/quinn-rs/quinn/pull/2481/commits/01b8848dcb321eb17ad4d88dd6f84f28f45a0d6a) on 2026-10-31: carry startup's per-round ACK aggregation maximum, restore the saved window once when recovery ends, preserve it through recovery into ProbeRTT, saturate probe-bound growth, and stop a probe at the previous loss bound before accelerating again on clean feedback. Spurious-loss undo also restores that probe history, and an idle ACK renews application-limited marking even when it crosses the old marker. The two-cycle bandwidth filter and transport-owned packet snapshots already cover its other fixes. Upstream's bandwidth metric conversion to bits/s does not apply: this fork's controller metrics use bytes/s. - **BBR3 loss samples**: a lost packet supplies its own inflight, loss, and application-limited state without borrowing or overwriting the ACK sample, including before the first ACK observation. This follows draft-06 and Google Linux BBRv3; upstream submission waits on quinn#2481 for the same callback adaptation as packet retirement. - **BBR3 packet retirement**: per-space packet lookup and round-indexed expiry retire completed snapshots incrementally, preserving the extra ACK batch of metadata for late loss callbacks. The bounded indexes handle sparse packet numbers without walking the live flight. Upstream submission is deferred while quinn#2481 remains open: this fork also carries the packet-space and loss callback adaptations, so a port needs to target that implementation after its shape settles. - **Classic ECN for BBR3**, ported from [moq-dev/noq#12](https://github.com/moq-dev/noq/pull/12): CE exits Startup, stops a bandwidth probe, or lowers the short-term model, once per recovery episode, instead of counting as a loss.