deps: bump moq-noq for the lost handshake ACK fix

Cargo.toml

@@ -159,7 +159,7 @@ moq-mux = { version = "0.10.11", path = "rs/moq-mux" }
 moq-net = { version = "0.3.10", path = "rs/moq-net" }
 # The MoQ fork of noq (moq-dev/noq). iroh keeps upstream noq, so a build with the
 # iroh feature carries both stacks.
-moq-noq-proto = { version = "2.0.4", default-features = false }
+moq-noq-proto = { version = "2.0.5", default-features = false }
 # NVENC bindings, forked from ViliamVadocz/nvidia-video-codec-sdk to dlopen the
 # driver at runtime. Compiles on any platform (macOS included) but only actually
 # used by moq-video on Linux.
@@ -243,7 +243,7 @@ web-transport-iroh = "0.8.1"
 # default-features off so the QUIC crypto provider is chosen by moq-tokio's
 # aws-lc-rs / ring features.
 # The WebTransport adapter released with moq-noq, from the same repository.
-web-transport-moq = { version = "2.0.4", default-features = false }
+web-transport-moq = { version = "2.0.5", default-features = false }
 web-transport-proto = "0.6"
 web-transport-trait = "0.5"
 web-transport-wasm = "0.8"

quest/m1/test-flakes-2/README.md

@@ -36,7 +36,6 @@ Public API: none. Wire: none.
 - [TS resume late frames](/quest/m1/test-flakes-2/ts-resume-late-frames.md) - the same-instance TS resume test keeps its late frames, fixed in production or the fixture as the evidence says
 - [WebTransport close release](/quest/m1/test-flakes-2/interop-close-release.md) - a compatible published adapter contains the acknowledged-close fix
 - [Interop close code](/quest/m1/test-flakes-2/interop-close-code.md) - adopt that release so the browser reliably sees `unauthorized` for a refused session
-- [Handshake ACK](/quest/m1/test-flakes-2/handshake-ack.md) - the impaired cluster drill's connect survives a lost handshake ACK
 - [Auth refresh mocks time](/quest/m1/test-flakes-2/auth-refresh-mock-time.md) - moq-relay's auth refresh and fixed-lease tests measure a grant's life on one mocked clock
 - [uring teardown close](/quest/m1/test-flakes-2/uring-teardown-close.md) - moq-uring's published-close teardown test holds under load, fixed at its cause
 - [Auth serve signals](/quest/m1/test-flakes-2/auth-serve-signals.md) - moq-cli's auth serve signal tests hold under load

rs/moq-quic/src/tests/mod.rs

@@ -3295,6 +3295,56 @@ fn lost_finished_after_initial_backoff() {
     assert!(elapsed < Duration::from_secs(1), "{elapsed:?}");
 }
 
+/// A lost ACK of a multi-datagram flight's head is repeated in the next packet the receiver
+/// sends in that space, so the sender learns the head arrived without waiting on another ACK.
+#[test]
+fn lost_handshake_ack_repeats_in_next_packet() {
+    let _guard = subscribe();
+    let (cert, key) = big_cert_and_key();
+    let mut pair = Pair::new(
+        Default::default(),
+        server_config_with_cert(cert.clone(), key),
+    );
+    pair.latency = Duration::from_millis(50);
+
+    pair.begin_connect(client_config_with_certs(vec![cert]));
+    pair.drive_client();
+    pair.time = pair.server.next_wakeup().unwrap();
+    pair.server.drive(pair.time, pair.client.addr);
+    // Only the head of the server's flight arrives. The rest, whether sent with it or paced
+    // out behind it, is lost.
+    let mut lost = pair.server.outbound.len() - 1;
+    pair.server.outbound.truncate(1);
+    pair.drive_server();
+    while pair.server.next_wakeup() < pair.client.next_wakeup() {
+        pair.time = pair.server.next_wakeup().unwrap();
+        pair.server.drive(pair.time, pair.client.addr);
+        lost += pair.server.outbound.len();
+        pair.server.outbound.clear();
+    }
+    assert!(lost > 0);
+    let server_ch = pair.server.assert_accept();
+
+    // The client ACKs the head, and that ACK is lost.
+    pair.time = pair.client.next_wakeup().unwrap();
+    pair.drive_client();
+    assert!(!pair.server.inbound.is_empty());
+    pair.server.inbound.clear();
+    let acks = pair.server_conn_mut(server_ch).stats().frame_rx.acks;
+
+    // The client's next packet is its PTO probe, which carries the ACK again.
+    while pair.server.inbound.is_empty() {
+        pair.time = pair.client.next_wakeup().unwrap();
+        pair.drive_client();
+    }
+    pair.time = pair.server.inbound.front().unwrap().0;
+    pair.drive_server();
+    assert_eq!(
+        pair.server_conn_mut(server_ch).stats().frame_rx.acks,
+        acks + 1
+    );
+}
+
 /// A short idle timeout does not cut the handshake to two Initial flights.
 ///
 /// Before an RTT sample the PTO is 999ms, so a 2s idle timeout is armed at 2997ms, while