From 8fb0f5d99a83f81df1d5bfc796375a30c6f94abb Mon Sep 17 00:00:00 2001
From: mp0rta <3p0rta26@gmail.com>
Date: Wed, 7 Oct 2026 00:03:01 +0900
Subject: [PATCH 1/7] feat(mqproxy): serve HTTP/3 through h3wire

---
 Cargo.lock                |  1 +
 crates/mqproxy/Cargo.toml |  1 +
 crates/mqproxy/src/run.rs | 16 +++++++++++-----
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index fd8a556c..70a5406f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -662,6 +662,7 @@ version = "0.0.4"
 dependencies = [
  "clap",
  "log",
+ "mq-h3",
  "mq-linux",
  "mq-proxy",
  "mq-runtime",
diff --git a/crates/mqproxy/Cargo.toml b/crates/mqproxy/Cargo.toml
index c8863728..05848782 100644
--- a/crates/mqproxy/Cargo.toml
+++ b/crates/mqproxy/Cargo.toml
@@ -10,6 +10,7 @@ mq-proxy = { path = "../mq-proxy" }
 mq-runtime = { path = "../mq-runtime" }
 mq-transport = { path = "../mq-transport" }
 mq-transport-api = { path = "../mq-transport-api" }
+mq-h3 = { path = "../mq-h3" }
 mq-linux = { path = "../mq-linux" }
 clap = { workspace = true }
 log = { workspace = true }
diff --git a/crates/mqproxy/src/run.rs b/crates/mqproxy/src/run.rs
index efc29334..46c3d8bf 100644
--- a/crates/mqproxy/src/run.rs
+++ b/crates/mqproxy/src/run.rs
@@ -4,6 +4,7 @@
 
 use crate::cli::{self, Client as ClientArgs, Mode, Resolved, Server as ServerArgs};
 use crate::setup_redirect;
+use mq_h3::H3Wire;
 use mq_proxy::server::origin::{build_client_config, native_roots};
 use mq_proxy::{client, client::Client, server::Server};
 use mq_runtime::driver::{Driver, DriverConfig, StdResolver};
@@ -67,7 +68,12 @@ fn seed() -> u64 {
 }
 
 /// The transport (cert/key loaded here, H3 per `cli::wants_h3`), then `--qlog`.
-fn transport(r: &Resolved, role: Role, max_conns: u32, err: String) -> Result<Transport, String> {
+fn transport(
+    r: &Resolved,
+    role: Role,
+    max_conns: u32,
+    err: String,
+) -> Result<H3Wire<Transport>, String> {
     let name = if matches!(role, Role::Client) {
         "client"
     } else {
@@ -81,7 +87,7 @@ fn transport(r: &Resolved, role: Role, max_conns: u32, err: String) -> Result<Tr
         cc: r.cc,
         realtime_offset_us: realtime_offset_us(),
         h3: cli::wants_h3(r),
-        h3_backend: mq_transport_api::H3Backend::XqcH3,
+        h3_backend: mq_transport_api::H3Backend::Raw,
         qlog: r.qlog.clone(),
     })
     .map_err(|e| match (&e, &r.qlog) {
@@ -96,7 +102,7 @@ fn transport(r: &Resolved, role: Role, max_conns: u32, err: String) -> Result<Tr
             dir.join(format!("{name}.qlog")).display()
         );
     }
-    Ok(t)
+    Ok(H3Wire::new(t))
 }
 
 fn driver() -> Result<Driver, String> {
@@ -118,9 +124,9 @@ fn ready(r: &Resolved, line: String) {
 }
 
 /// spec §5.3: `run` → `into_transport` → `Transport::close` with the last `now`.
-fn finish<A: App>(d: Driver, shard: Shard<Transport, A>) -> i32 {
+fn finish<A: App>(d: Driver, shard: Shard<H3Wire<Transport>, A>) -> i32 {
     let (code, shard) = d.run(shard);
-    shard.into_transport().close(now());
+    shard.into_transport().into_inner().close(now());
     code
 }
 

From 50a07c95968c4c42a2bc57da2b4cfbc132f9865c Mon Sep 17 00:00:00 2001
From: mp0rta <3p0rta26@gmail.com>
Date: Wed, 7 Oct 2026 00:24:40 +0900
Subject: [PATCH 2/7] fix(h3): coalesce FIN with final request headers

---
 crates/mq-h3/src/req.rs    |  4 +++
 crates/mq-h3/src/send.rs   | 19 ++++++++---
 crates/mq-h3/tests/send.rs | 66 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 84 insertions(+), 5 deletions(-)

diff --git a/crates/mq-h3/src/req.rs b/crates/mq-h3/src/req.rs
index 8e03cd61..180a8237 100644
--- a/crates/mq-h3/src/req.rs
+++ b/crates/mq-h3/src/req.rs
@@ -91,6 +91,9 @@ pub(crate) struct Req {
     pub(crate) stream_closed: bool,
     /// The DATA frame `h3_send_body` started and has not written whole (adoption spec §4.5).
     pub(crate) frame: Option<InFlight>,
+    /// HEADERS were sent with `fin=true`; the raw FIN rides their final bytes, so
+    /// suppress h3wire's corresponding empty `FinishStream` action.
+    pub(crate) coalesced_header_fin: bool,
     /// `h3_finish` (or a bare `fin`) is waiting for `send_data(0, true)` to stop being
     /// `Blocked` behind queued HEADERS bytes.
     pub(crate) finish_latched: bool,
@@ -135,6 +138,7 @@ impl Req {
             fin_read: false,
             stream_closed: false,
             frame: None,
+            coalesced_header_fin: false,
             finish_latched: false,
             writable_wanted: false,
             send_stopped: false,
diff --git a/crates/mq-h3/src/send.rs b/crates/mq-h3/src/send.rs
index 378150d1..b2c0d952 100644
--- a/crates/mq-h3/src/send.rs
+++ b/crates/mq-h3/src/send.rs
@@ -137,6 +137,7 @@ impl<T: TransportOps> H3Wire<T> {
         let r = conn.h3.send_headers(Q(req.quic_id), &fields, fin);
         req.core |= r.is_ok();
         if r.is_ok() {
+            req.coalesced_header_fin = fin;
             conn.core.insert(req.quic_id);
         }
         self.drive_inner(now);
@@ -402,10 +403,17 @@ impl<T: TransportOps> H3Wire<T> {
                 // A `Blocked` FIN is kept and retried; it survives a peer RESET_STREAM
                 // (adoption spec §3, §4.5).
                 Action::FinishStream(q) => {
-                    if let Some(s) = mq(q)
-                        && self.inner.stream_send(now, s, &[], true) == Err(StreamError::Blocked)
-                    {
-                        conn.fins.insert(s);
+                    if let Some(s) = mq(q) {
+                        let headers_fin = self
+                            .reqs
+                            .get_mut(&req_id(s))
+                            .is_some_and(|req| std::mem::take(&mut req.coalesced_header_fin));
+                        if !headers_fin
+                            && self.inner.stream_send(now, s, &[], true)
+                                == Err(StreamError::Blocked)
+                        {
+                            conn.fins.insert(s);
+                        }
                     }
                 }
                 // Direction guard (adoption spec §4.5): the transport ops do not check.
@@ -456,8 +464,9 @@ impl<T: TransportOps> H3Wire<T> {
             let mut req = reqs.get_mut(&req_id(s)).filter(|_| q.is_request());
             while let Some(bytes) = conn.h3.poll_send(q).filter(|b| !b.is_empty()) {
                 let len = bytes.len();
+                let fin = req.as_ref().is_some_and(|req| req.coalesced_header_fin);
                 // Another error is final for the stream: no retry owed.
-                let n = match inner.stream_send(now, s, bytes, false) {
+                let n = match inner.stream_send(now, s, bytes, fin) {
                     Ok(n) => n,
                     Err(e) => {
                         short |= e == StreamError::Blocked;
diff --git a/crates/mq-h3/tests/send.rs b/crates/mq-h3/tests/send.rs
index 1c2f5ed6..8da1c97b 100644
--- a/crates/mq-h3/tests/send.rs
+++ b/crates/mq-h3/tests/send.rs
@@ -175,6 +175,72 @@ fn client_request_round_trip() {
     assert_eq!(body, b"hello");
 }
 
+#[test]
+fn headers_fin_rides_final_header_bytes() {
+    let mut r = client();
+    let (id, s) = open(&mut r);
+    assert_eq!(
+        r.w.h3_send_headers(r.now, id, &request("GET"), true),
+        Ok(())
+    );
+    let fin_calls: Vec<_> =
+        r.h.log()
+            .into_iter()
+            .filter_map(|c| match c {
+                Call::StreamSend {
+                    s: sent,
+                    bytes,
+                    fin: true,
+                } if sent == s => Some(bytes),
+                _ => None,
+            })
+            .collect();
+    assert_eq!(fin_calls.len(), 1);
+    assert!(!fin_calls[0].is_empty(), "FIN should ride HEADERS bytes");
+    assert_eq!(r.fins(s), 1);
+    r.pump();
+    assert_peer_finished(&r, Q(0));
+}
+
+#[test]
+fn headers_fin_survives_partial_write_once() {
+    let mut r = client();
+    let (id, s) = open(&mut r);
+    r.limit(s, Some(1));
+    assert_eq!(
+        r.w.h3_send_headers(r.now, id, &request("GET"), true),
+        Ok(())
+    );
+    assert_eq!(r.h.sent_bytes(s).len(), 1);
+    assert_eq!(r.fins(s), 0, "partial headers must not commit FIN");
+
+    r.limit(s, None);
+    r.h.push_event(Event::StreamWritable(s));
+    r.w.drive(r.now);
+    assert_eq!(r.fins(s), 1);
+    let fin_calls: Vec<_> =
+        r.h.log()
+            .into_iter()
+            .filter_map(|c| match c {
+                Call::StreamSend {
+                    s: sent,
+                    bytes,
+                    fin: true,
+                } if sent == s => Some(bytes),
+                _ => None,
+            })
+            .collect();
+    assert_eq!(
+        fin_calls.len(),
+        2,
+        "the unfinished header tail retries with FIN"
+    );
+    assert!(fin_calls.iter().all(|bytes| !bytes.is_empty()));
+    r.pump();
+    assert_peer_finished(&r, Q(0));
+    assert_eq!(r.fins(s), 1, "the retry commits exactly one FIN");
+}
+
 #[test]
 fn send_body_partial_payload() {
     let (mut r, id, s, head) = posting();

From f5e09825c474edbf0b96525f439c23f202830718 Mon Sep 17 00:00:00 2001
From: mp0rta <3p0rta26@gmail.com>
Date: Wed, 7 Oct 2026 00:29:09 +0900
Subject: [PATCH 3/7] test(h3): cover blocked header FIN retry

---
 crates/mq-h3/tests/send.rs | 49 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/crates/mq-h3/tests/send.rs b/crates/mq-h3/tests/send.rs
index 8da1c97b..fa9c6c1c 100644
--- a/crates/mq-h3/tests/send.rs
+++ b/crates/mq-h3/tests/send.rs
@@ -241,6 +241,55 @@ fn headers_fin_survives_partial_write_once() {
     assert_eq!(r.fins(s), 1, "the retry commits exactly one FIN");
 }
 
+#[test]
+fn headers_fin_retries_after_blocked_write_once() {
+    let mut r = client();
+    let (id, s) = open(&mut r);
+    r.limit(s, Some(0));
+    assert_eq!(
+        r.w.h3_send_headers(r.now, id, &request("GET"), true),
+        Ok(())
+    );
+    assert!(r.h.sent_bytes(s).is_empty());
+    assert_eq!(r.fins(s), 0, "a blocked write cannot commit FIN");
+    let blocked: Vec<_> =
+        r.h.log()
+            .into_iter()
+            .filter_map(|c| match c {
+                Call::StreamSend {
+                    s: sent,
+                    bytes,
+                    fin: true,
+                } if sent == s => Some(bytes),
+                _ => None,
+            })
+            .collect();
+    assert_eq!(blocked.len(), 1);
+    assert!(!blocked[0].is_empty(), "the blocked call carries HEADERS");
+
+    r.limit(s, None);
+    r.h.push_event(Event::StreamWritable(s));
+    r.w.drive(r.now);
+    assert_eq!(r.fins(s), 1);
+    let fin_calls: Vec<_> =
+        r.h.log()
+            .into_iter()
+            .filter_map(|c| match c {
+                Call::StreamSend {
+                    s: sent,
+                    bytes,
+                    fin: true,
+                } if sent == s => Some(bytes),
+                _ => None,
+            })
+            .collect();
+    assert_eq!(fin_calls.len(), 2, "one blocked attempt, one retry");
+    assert!(fin_calls.iter().all(|bytes| !bytes.is_empty()));
+    r.pump();
+    assert_peer_finished(&r, Q(0));
+    assert_eq!(r.fins(s), 1, "the retry commits exactly one FIN");
+}
+
 #[test]
 fn send_body_partial_payload() {
     let (mut r, id, s, head) = posting();

From d89407c961c541448a8f9d0a088b27375d113812 Mon Sep 17 00:00:00 2001
From: mp0rta <3p0rta26@gmail.com>
Date: Wed, 7 Oct 2026 00:37:40 +0900
Subject: [PATCH 4/7] refactor(transport-api): default bodies for the H3 ops

---
 crates/mq-runtime/tests/app.rs     |  49 +--------
 crates/mq-transport-api/src/ops.rs | 171 +++++++++++++++++++++++++----
 2 files changed, 151 insertions(+), 69 deletions(-)

diff --git a/crates/mq-runtime/tests/app.rs b/crates/mq-runtime/tests/app.rs
index fc251083..4a142314 100644
--- a/crates/mq-runtime/tests/app.rs
+++ b/crates/mq-runtime/tests/app.rs
@@ -5,9 +5,8 @@ use mq_runtime::{
     StreamPreread, Target, TcpEnd, TcpId, TimerId, UdpSocketId,
 };
 use mq_transport_api::{
-    ConnConfig, ConnId, ConnStats, ConnectError, DatagramError, Error, Event, H3Header, H3ReqId,
-    H3ReqInfo, PathError, PathId, SlotId, StreamError, StreamId, StreamInfo, Time, Transmit,
-    TransportOps, TxKey,
+    ConnConfig, ConnId, ConnStats, ConnectError, DatagramError, Error, Event, PathError, PathId,
+    SlotId, StreamError, StreamId, StreamInfo, Time, Transmit, TransportOps, TxKey,
 };
 use std::io;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
@@ -85,50 +84,6 @@ impl TransportOps for Null {
     fn open_uni(&mut self, _: Time, _: ConnId) -> Result<StreamId, Error> {
         Err(Error::Role)
     }
-    fn open_h3_request(&mut self, _: Time, _: ConnId) -> Result<H3ReqId, Error> {
-        Err(Error::Role)
-    }
-    fn h3_send_headers(
-        &mut self,
-        _: Time,
-        _: H3ReqId,
-        _: &[H3Header<'_>],
-        _: bool,
-    ) -> Result<(), StreamError> {
-        Err(StreamError::Stale)
-    }
-    fn h3_send_body(
-        &mut self,
-        _: Time,
-        _: H3ReqId,
-        _: &[u8],
-        _: bool,
-    ) -> Result<usize, StreamError> {
-        Err(StreamError::Stale)
-    }
-    fn h3_finish(&mut self, _: Time, _: H3ReqId) -> Result<(), StreamError> {
-        Err(StreamError::Stale)
-    }
-    fn h3_recv_headers(
-        &mut self,
-        _: Time,
-        _: H3ReqId,
-        _: &mut dyn FnMut(&[u8], &[u8]),
-    ) -> Result<bool, StreamError> {
-        Err(StreamError::Stale)
-    }
-    fn h3_recv_body(
-        &mut self,
-        _: Time,
-        _: H3ReqId,
-        _: &mut [u8],
-    ) -> Result<(usize, bool), StreamError> {
-        Err(StreamError::Stale)
-    }
-    fn h3_reset(&mut self, _: Time, _: H3ReqId) {}
-    fn h3_req_info(&self, _: H3ReqId) -> Result<H3ReqInfo, Error> {
-        Err(Error::Stale)
-    }
 }
 
 /// Toy app implementing every §5.4 callback.
diff --git a/crates/mq-transport-api/src/ops.rs b/crates/mq-transport-api/src/ops.rs
index 905fc111..88cb1271 100644
--- a/crates/mq-transport-api/src/ops.rs
+++ b/crates/mq-transport-api/src/ops.rs
@@ -82,40 +82,167 @@ pub trait TransportOps {
 
     // H3 requests (spec §3.1)
     /// Client only: a server-role transport returns `Error::Role`.
-    fn open_h3_request(&mut self, now: Time, conn: ConnId) -> Result<H3ReqId, Error>;
+    fn open_h3_request(&mut self, _: Time, _: ConnId) -> Result<H3ReqId, Error> {
+        Err(Error::Role)
+    }
     /// All-or-error; `Blocked` cannot occur with the vendored xquic (spec §3.1).
     fn h3_send_headers(
         &mut self,
-        now: Time,
-        r: H3ReqId,
-        hs: &[H3Header<'_>],
-        fin: bool,
-    ) -> Result<(), StreamError>;
+        _: Time,
+        _: H3ReqId,
+        _: &[H3Header<'_>],
+        _: bool,
+    ) -> Result<(), StreamError> {
+        Err(StreamError::Conn)
+    }
     /// The `stream_send` contract: `Ok(n)` accepted, FIN only when `n == data.len()`.
     fn h3_send_body(
         &mut self,
-        now: Time,
-        r: H3ReqId,
-        data: &[u8],
-        fin: bool,
-    ) -> Result<usize, StreamError>;
+        _: Time,
+        _: H3ReqId,
+        _: &[u8],
+        _: bool,
+    ) -> Result<usize, StreamError> {
+        Err(StreamError::Conn)
+    }
     /// A bare FIN (spec §3.1).
-    fn h3_finish(&mut self, now: Time, r: H3ReqId) -> Result<(), StreamError>;
+    fn h3_finish(&mut self, _: Time, _: H3ReqId) -> Result<(), StreamError> {
+        Err(StreamError::Conn)
+    }
     /// Drains one header section; `Ok(fin)`. `Blocked` when none is pending.
     fn h3_recv_headers(
         &mut self,
-        now: Time,
-        r: H3ReqId,
-        each: &mut dyn FnMut(&[u8], &[u8]),
-    ) -> Result<bool, StreamError>;
+        _: Time,
+        _: H3ReqId,
+        _: &mut dyn FnMut(&[u8], &[u8]),
+    ) -> Result<bool, StreamError> {
+        Err(StreamError::Conn)
+    }
     /// `(bytes, fin)`; `(0, false)` is `Blocked`.
     fn h3_recv_body(
         &mut self,
-        now: Time,
-        r: H3ReqId,
-        buf: &mut [u8],
-    ) -> Result<(usize, bool), StreamError>;
+        _: Time,
+        _: H3ReqId,
+        _: &mut [u8],
+    ) -> Result<(usize, bool), StreamError> {
+        Err(StreamError::Conn)
+    }
     /// A no-op on a stale id.
-    fn h3_reset(&mut self, now: Time, r: H3ReqId);
-    fn h3_req_info(&self, r: H3ReqId) -> Result<H3ReqInfo, Error>;
+    fn h3_reset(&mut self, _: Time, _: H3ReqId) {}
+    fn h3_req_info(&self, _: H3ReqId) -> Result<H3ReqInfo, Error> {
+        Err(Error::Role)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::net::SocketAddr;
+
+    struct RawOnly;
+
+    impl TransportOps for RawOnly {
+        fn recv_datagram(&mut self, _: Time, _: SocketAddr, _: SocketAddr, _: &[u8]) {}
+        fn drive(&mut self, _: Time) {}
+        fn pending_transmit(&self, _: &mut Vec<TxKey>) {}
+        fn peek_transmit(&mut self, _: TxKey) -> Option<Transmit<'_>> {
+            None
+        }
+        fn transmit_done(&mut self, _: TxKey, _: usize) {}
+        fn resume_pending(&self) -> bool {
+            false
+        }
+        fn poll_event(&mut self) -> Option<Event> {
+            None
+        }
+        fn next_timeout(&self) -> Option<Time> {
+            None
+        }
+        fn connect(&mut self, _: Time, _: &ConnConfig) -> Result<ConnId, ConnectError> {
+            unimplemented!()
+        }
+        fn open_stream(&mut self, _: Time, _: ConnId) -> Result<StreamId, Error> {
+            unimplemented!()
+        }
+        fn stream_send(
+            &mut self,
+            _: Time,
+            _: StreamId,
+            _: &[u8],
+            _: bool,
+        ) -> Result<usize, StreamError> {
+            unimplemented!()
+        }
+        fn stream_recv(
+            &mut self,
+            _: Time,
+            _: StreamId,
+            _: &mut [u8],
+        ) -> Result<(usize, bool), StreamError> {
+            unimplemented!()
+        }
+        fn stream_reset(&mut self, _: Time, _: StreamId) {}
+        fn open_uni(&mut self, _: Time, _: ConnId) -> Result<StreamId, Error> {
+            unimplemented!()
+        }
+        fn stream_reset_send(&mut self, _: Time, _: StreamId, _: u64) {}
+        fn stream_stop_sending(&mut self, _: Time, _: StreamId, _: u64) {}
+        fn add_path(&mut self, _: Time, _: ConnId, _: bool) -> Result<PathId, PathError> {
+            unimplemented!()
+        }
+        fn close_conn(&mut self, _: Time, _: ConnId) {}
+        fn close_conn_with(&mut self, _: Time, _: ConnId, _: u64) {}
+        fn mark_conn_authed(&mut self, _: ConnId) {}
+        fn conn_stats(&self, _: ConnId) -> Result<ConnStats, Error> {
+            unimplemented!()
+        }
+        fn conn_live(&self, _: ConnId) -> bool {
+            false
+        }
+        fn stream_info(&self, _: StreamId) -> Result<StreamInfo, Error> {
+            unimplemented!()
+        }
+        fn datagram_send(&mut self, _: Time, _: ConnId, _: &[u8]) -> Result<(), DatagramError> {
+            unimplemented!()
+        }
+        fn datagram_mss(&self, _: ConnId) -> usize {
+            0
+        }
+        fn datagram_recv(&mut self, _: ConnId, _: &mut [u8]) -> Option<usize> {
+            None
+        }
+    }
+
+    #[test]
+    fn raw_transport_h3_defaults() {
+        let mut transport = RawOnly;
+        let request = H3ReqId::from_slot(crate::ids::SlotId::new(0, 1)).unwrap();
+        let conn = ConnId::from_slot(crate::ids::SlotId::new(0, 1)).unwrap();
+        assert_eq!(
+            transport.open_h3_request(Time::ZERO, conn),
+            Err(Error::Role)
+        );
+        assert_eq!(
+            transport.h3_send_headers(Time::ZERO, request, &[], false),
+            Err(StreamError::Conn)
+        );
+        assert_eq!(
+            transport.h3_send_body(Time::ZERO, request, &[], false),
+            Err(StreamError::Conn)
+        );
+        assert_eq!(
+            transport.h3_finish(Time::ZERO, request),
+            Err(StreamError::Conn)
+        );
+        assert_eq!(
+            transport.h3_recv_headers(Time::ZERO, request, &mut |_, _| {}),
+            Err(StreamError::Conn)
+        );
+        assert_eq!(
+            transport.h3_recv_body(Time::ZERO, request, &mut []),
+            Err(StreamError::Conn)
+        );
+        transport.h3_reset(Time::ZERO, request);
+        assert_eq!(transport.h3_req_info(request), Err(Error::Role));
+    }
 }

From de47e8e4bf3070f5062dc435da677fff67ad943e Mon Sep 17 00:00:00 2001
From: mp0rta <3p0rta26@gmail.com>
Date: Wed, 7 Oct 2026 00:49:38 +0900
Subject: [PATCH 5/7] test: port surviving xqc_h3-era regressions to the raw-H3
 backend

---
 crates/mq-integration/tests/pair_h3.rs    | 198 +++++++++++++++++++++-
 crates/mq-transport/tests/fabric_h3raw.rs | 182 +++++++++++++++++++-
 2 files changed, 377 insertions(+), 3 deletions(-)

diff --git a/crates/mq-integration/tests/pair_h3.rs b/crates/mq-integration/tests/pair_h3.rs
index 5cd63d17..f103b464 100644
--- a/crates/mq-integration/tests/pair_h3.rs
+++ b/crates/mq-integration/tests/pair_h3.rs
@@ -9,7 +9,8 @@ use mq_integration::loopback::{
 use mq_integration::matrix;
 use mq_integration::raw_h3::{RawH3Handle, RawH3Peer, RawH3Script, field, headers_frame};
 use mq_runtime::Shard;
-use mq_transport_api::Role;
+use mq_runtime::testing::{RecordHandle, Recorded, RecordingApp};
+use mq_transport_api::{ConnConfig, ConnProto, Event, H3Header, Role};
 use std::net::Ipv4Addr;
 use std::thread;
 use std::time::{Duration, Instant};
@@ -275,3 +276,198 @@ fn raw_peer_smoke() {
         p.join_both();
     }
 }
+
+/// Two live H3Wire requests: an unread partial response and an unfinished request.
+fn live_wire_pair(
+    idle: Option<Duration>,
+    close_on_response: bool,
+) -> LoopbackPair<RecordHandle, RecordHandle> {
+    let lo = Ipv4Addr::LOCALHOST.into();
+    LoopbackPair::spawn(
+        (lo, lo),
+        Vec::new(),
+        move |local| {
+            let (app, rec) = RecordingApp::new();
+            rec.on(|r, cx| match r {
+                Recorded::TransportEvent(Event::H3Readable(req)) => {
+                    let fin = cx.h3_recv_headers(*req, &mut |_, _| {});
+                    if fin == Ok(true) {
+                        let headers = [H3Header {
+                            name: b":status",
+                            value: b"200",
+                        }];
+                        assert_eq!(cx.h3_send_headers(*req, &headers, false), Ok(()));
+                        assert_eq!(cx.h3_send_body(*req, b"partial", false), Ok(7));
+                    }
+                }
+                Recorded::Shutdown => cx.request_exit(0),
+                _ => {}
+            });
+            (
+                Shard::new(h3_transport(server_role(), Backend::Wire), app, local, 1),
+                rec,
+            )
+        },
+        move |local, server| {
+            let (app, rec) = RecordingApp::new();
+            let mut close_on_response = close_on_response;
+            rec.on(move |r, cx| match r {
+                Recorded::Start => {
+                    cx.connect(&ConnConfig {
+                        peer: server,
+                        sni: "mqproxy",
+                        idle_timeout: idle,
+                        proto: ConnProto::H3,
+                    })
+                    .expect("connect");
+                }
+                Recorded::TransportEvent(Event::ConnEstablished(conn)) => {
+                    let headers = [
+                        H3Header {
+                            name: b":method",
+                            value: b"POST",
+                        },
+                        H3Header {
+                            name: b":scheme",
+                            value: b"https",
+                        },
+                        H3Header {
+                            name: b":authority",
+                            value: b"x",
+                        },
+                        H3Header {
+                            name: b":path",
+                            value: b"/",
+                        },
+                    ];
+                    for fin in [true, false] {
+                        let req = cx.open_h3_request(*conn).expect("open request");
+                        assert_eq!(cx.h3_send_headers(req, &headers, fin), Ok(()));
+                    }
+                }
+                Recorded::TransportEvent(Event::H3Readable(req)) if close_on_response => {
+                    close_on_response = false;
+                    let conn = cx.h3_req_info(*req).expect("live request").conn;
+                    cx.close_conn(conn);
+                }
+                Recorded::Shutdown => cx.request_exit(0),
+                _ => {}
+            });
+            (
+                Shard::new(h3_transport(Role::Client, Backend::Wire), app, local, 2),
+                rec,
+            )
+        },
+    )
+}
+
+fn wait_records(rec: &RecordHandle, pred: impl Fn(&[Recorded]) -> bool) {
+    let end = Instant::now() + Duration::from_secs(10);
+    while !pred(&rec.records()) {
+        assert!(Instant::now() < end, "timed out: {:?}", rec.records());
+        thread::sleep(Duration::from_millis(2));
+    }
+}
+
+/// The peer disappears mid-response: the real engine's idle timeout closes live requests.
+#[test]
+fn wire_idle_timeout_mid_response_aborts() {
+    let idle = Duration::from_secs(1);
+    let mut p = live_wire_pair(Some(idle), false);
+    wait_records(&p.client.handle, |records| {
+        records
+            .iter()
+            .any(|r| matches!(r, Recorded::TransportEvent(Event::H3Readable(_))))
+    });
+    let start = Instant::now();
+    // The server exits without sending CONNECTION_CLOSE, so only idle expiry can close it.
+    p.server.shutdown.trigger();
+    assert_eq!(p.server.join_timeout(Duration::from_secs(10)), Some(0));
+    wait_records(&p.client.handle, |records| {
+        records
+            .iter()
+            .any(|r| matches!(r, Recorded::TransportEvent(Event::ConnClosed(..))))
+    });
+    assert!(start.elapsed() <= 2 * idle, "after {:?}", start.elapsed());
+    let records = p.client.handle.records();
+    let closed: Vec<_> = records
+        .iter()
+        .filter_map(|r| match r {
+            Recorded::TransportEvent(Event::H3Closed(_, close)) => Some(close),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(closed.len(), 2, "{records:?}");
+    for close in closed {
+        assert_eq!(close.unread, None, "{close:?}");
+    }
+    p.client.shutdown.trigger();
+    assert_eq!(p.client.join(), 0);
+}
+
+/// Local close reports every live request before ConnClosed and rescues no partial body.
+#[test]
+fn wire_local_close_with_live_requests_is_clean() {
+    let p = live_wire_pair(None, true);
+    wait_records(&p.client.handle, |records| {
+        records
+            .iter()
+            .any(|r| matches!(r, Recorded::TransportEvent(Event::ConnClosed(..))))
+    });
+    let records = p.client.handle.records();
+    let conn = records
+        .iter()
+        .position(|r| matches!(r, Recorded::TransportEvent(Event::ConnClosed(..))))
+        .expect("ConnClosed");
+    let closed: Vec<_> = records
+        .iter()
+        .enumerate()
+        .filter_map(|(i, r)| match r {
+            Recorded::TransportEvent(Event::H3Closed(_, close)) => Some((i, close)),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(closed.len(), 2, "{records:?}");
+    for (i, close) in closed {
+        assert!(i < conn, "{records:?}");
+        assert_eq!(close.unread, None, "{close:?}");
+    }
+    assert_eq!(p.join_both(), (0, 0));
+}
+
+/// Engine teardown with open requests on both sides, including an unread partial response.
+#[test]
+fn wire_drop_transport_with_live_requests_is_clean() {
+    let p = live_wire_pair(None, false);
+    wait_records(&p.client.handle, |records| {
+        records
+            .iter()
+            .any(|r| matches!(r, Recorded::TransportEvent(Event::H3Readable(_))))
+    });
+    wait_records(&p.server.handle, |records| {
+        records
+            .iter()
+            .filter(|r| matches!(r, Recorded::TransportEvent(Event::H3Request(..))))
+            .count()
+            == 2
+    });
+    let server = p.server.handle.records();
+    assert_eq!(
+        server
+            .iter()
+            .filter(|r| matches!(r, Recorded::TransportEvent(Event::H3Request(..))))
+            .count(),
+        2,
+        "{server:?}"
+    );
+    for rec in [&p.client.handle, &p.server.handle] {
+        assert!(
+            !rec.records().iter().any(|r| matches!(
+                r,
+                Recorded::TransportEvent(Event::H3Closed(..) | Event::ConnClosed(..))
+            )),
+            "requests still live"
+        );
+    }
+    assert_eq!(p.join_both(), (0, 0));
+}
diff --git a/crates/mq-transport/tests/fabric_h3raw.rs b/crates/mq-transport/tests/fabric_h3raw.rs
index 639d2a6b..02340171 100644
--- a/crates/mq-transport/tests/fabric_h3raw.rs
+++ b/crates/mq-transport/tests/fabric_h3raw.rs
@@ -1,13 +1,20 @@
 //! adoption spec §3 "Raw-H3 backend": ALPN `h3` over raw xquic streams.
 mod common;
 
-use common::lockstep::{self, Peer, cfg, server_role};
-use common::pair::{MS, Opts, Pair, new_streams, read_all, recv, send, stream_count};
+use common::initial::{client_hello_fragment, initial};
+use common::lockstep::{self, Peer, cfg, exchange_many, server_role};
+use common::pair::{
+    MS, Opts, Pair, T0, cli_addr, conn_cfg, new_streams, read_all, recv, send, srv_addr,
+    stream_count,
+};
 use mq_transport_api::{
     ConnId, ConnProto, ErrType, Error, Event, H3Backend, Role, StreamCloseStats, StreamError,
     StreamId, StreamKind, Time, TransportConfig, TransportOps,
 };
 
+use std::net::SocketAddr;
+use std::time::Duration;
+
 fn raw_h3_cfg(role: Role) -> TransportConfig {
     TransportConfig {
         h3: true,
@@ -623,3 +630,174 @@ fn no_close_stats_on_raw_conns() {
     };
     assert_eq!((n(&p.cev), n(&p.sev)), (0, 0));
 }
+
+fn new_conns(ev: &[Event]) -> Vec<(ConnId, ConnProto)> {
+    ev.iter()
+        .filter_map(|e| match e {
+            Event::NewConn(c, p) => Some((*c, *p)),
+            _ => None,
+        })
+        .collect()
+}
+
+#[test]
+fn raw_h3_conn_counts_toward_max_conns() {
+    let mut scfg = raw_h3_cfg(server_role());
+    scfg.max_conns = 1;
+    let server = Peer::spawn(scfg, vec![srv_addr()]);
+    let mut now = T0;
+    let client = |k: usize, now: Time| {
+        let c = Peer::spawn(raw_h3_cfg(Role::Client), vec![cli_addr(k)]);
+        let mut cc = conn_cfg(None);
+        cc.proto = ConnProto::H3;
+        let id = c.call(now, move |t, now| t.connect(now, &cc)).unwrap();
+        (c, id)
+    };
+    let run = |peers: &[&Peer], now: &mut Time, steps: usize| {
+        for _ in 0..steps {
+            *now = *now + MS;
+            for p in peers {
+                p.drive(*now);
+            }
+            exchange_many(*now, peers);
+        }
+    };
+    let count = |s: &Peer| s.call(T0, |t, _| (t.conn_count(), t.n_provisional()));
+
+    let (c0, id0) = client(3, now);
+    run(&[&c0, &server], &mut now, 5);
+    assert!(c0.drain_events().contains(&Event::ConnEstablished(id0)));
+    let news = new_conns(&server.drain_events());
+    assert!(matches!(news[..], [(_, ConnProto::H3)]), "{news:?}");
+    assert_eq!(count(&server), (1, 0));
+
+    // spec §4.7: an unauthenticated H3 conn (no request yet) is evicted by a newcomer.
+    let (c1, id1) = client(0, now);
+    let (mut sev, mut c0ev) = (Vec::new(), Vec::new());
+    for _ in 0..1000 {
+        run(&[&c0, &c1, &server], &mut now, 10);
+        sev.extend(server.drain_events());
+        c0ev.extend(c0.drain_events());
+        if c0ev.iter().any(|e| matches!(e, Event::ConnClosed(..))) {
+            break;
+        }
+    }
+    assert!(c1.drain_events().contains(&Event::ConnEstablished(id1)));
+    assert!(
+        c0ev.iter()
+            .any(|e| matches!(e, Event::ConnClosed(c, r) if *c == id0 && r.code == 0x1002)),
+        "{c0ev:?}"
+    );
+    let news = new_conns(&sev);
+    assert!(matches!(news[..], [(_, ConnProto::H3)]), "{news:?}");
+    assert_eq!(count(&server), (1, 0));
+    let s1 = news[0].0;
+    server.call(now, move |t, _| t.mark_conn_authed(s1));
+
+    // The second H3 client is refused at the shared cap, before any slot: s1 is authed.
+    let (c2, id2) = client(1, now);
+    run(&[&c1, &c2, &server], &mut now, 50);
+    assert!(!c2.drain_events().contains(&Event::ConnEstablished(id2)));
+    assert!(new_conns(&server.drain_events()).is_empty());
+    assert_eq!(count(&server), (1, 0));
+
+    // Closing the first H3 connection releases its unit.
+    c1.call(now, move |t, now| t.close_conn(now, id1));
+    let mut sev = Vec::new();
+    for _ in 0..1000 {
+        run(&[&c1, &c2, &server], &mut now, 10);
+        sev.extend(server.drain_events());
+        if sev.iter().any(|e| matches!(e, Event::ConnClosed(..))) {
+            break;
+        }
+    }
+    assert!(
+        sev.iter().any(|e| matches!(e, Event::ConnClosed(..))),
+        "{sev:?}"
+    );
+    assert_eq!(count(&server), (0, 0));
+}
+
+/// Raw-H3 uses the same server_accept backlog cap and 10 s provisional deadline.
+#[test]
+fn raw_h3_provisional_cap_and_expiry() {
+    let mut scfg = raw_h3_cfg(server_role());
+    scfg.max_conns = 1;
+    let server = Peer::spawn(scfg, vec![srv_addr()]);
+    for i in 0..65u8 {
+        let from = SocketAddr::from(([10, 2, 0, i], 40000));
+        let pkt = initial(
+            &[0xd0, i, 1, 1, 2, 3, 4, 5],
+            &[0x5c, i, 1, 5, 4, 3, 2, 1],
+            0,
+            0,
+            &client_hello_fragment(0, 300),
+        );
+        server.deliver(T0, srv_addr(), from, pkt);
+        assert_eq!(
+            server.call(Time::ZERO, |t, _| t.n_provisional()),
+            u32::from(i + 1).min(64),
+            "refused beyond the cap in server_accept"
+        );
+    }
+    server.drive(T0);
+    server.pump_out(T0);
+    assert_eq!(server.call(T0, |t, _| t.conn_count()), 0);
+    let mut now = T0;
+    while server.call(Time::ZERO, |t, _| t.n_provisional()) > 0 {
+        let d = server.next_timeout().expect("provisional deadline");
+        now = now.max(d);
+        server.drive(now);
+        server.pump_out(now);
+        assert!(now < T0 + Duration::from_secs(60), "never released");
+    }
+    assert!(
+        now >= T0 + Duration::from_secs(10),
+        "not before the 10 s deadline"
+    );
+    assert_eq!(server.call(now, |t, _| t.conn_count()), 0);
+    assert_eq!(server.drain_events(), vec![], "never admitted: no events");
+}
+
+/// Bidi and uni streams on raw-H3 share the 8192-slot ceiling.
+#[test]
+fn raw_h3_streams_share_8192_ceiling() {
+    const CEILING: u32 = 8192;
+    let mut p = Pair::with(h3raw_opts());
+    let uni = open_uni(&p.client, p.now, p.conn).expect("first uni");
+    assert_eq!(send(&p.client, p.now, uni, vec![1], false), Ok(1));
+    p.exchange();
+    for _ in 1..CEILING {
+        let c = p.conn;
+        let s = (0..100)
+            .find_map(
+                |_| match p.client.call(p.now, move |t, now| t.open_stream(now, c)) {
+                    Ok(s) => Some(s),
+                    Err(_) => {
+                        p.tick(MS);
+                        None
+                    }
+                },
+            )
+            .expect("bidi credit");
+        assert_eq!(send(&p.client, p.now, s, vec![1], false), Ok(1));
+        p.exchange();
+        p.cev.clear();
+    }
+    assert_eq!(stream_count(&p.client, p.conn), CEILING);
+    p.tick(MS);
+    assert_eq!(stream_count(&p.server, p.srv_conn), CEILING);
+    assert_eq!(new_streams(&p.sev).len(), CEILING as usize);
+    let c = p.conn;
+    assert_eq!(
+        p.client.call(p.now, move |t, now| t.open_stream(now, c)),
+        Err(Error::Ceiling)
+    );
+    assert_eq!(open_uni(&p.client, p.now, c), Err(Error::Ceiling));
+    assert_eq!(stream_count(&p.client, c), CEILING, "no refused slot");
+    for _ in 0..100 {
+        p.tick(10 * MS);
+    }
+    assert_eq!(p.client_closed(), None);
+    assert_eq!(p.server_closed(), None);
+}

From 79656bf78b34ad5a450d8bb3d3af6b4e2f0b6bb0 Mon Sep 17 00:00:00 2001
From: mp0rta <3p0rta26@gmail.com>
Date: Wed, 7 Oct 2026 00:56:45 +0900
Subject: [PATCH 6/7] test: confirm partial response body before H3Wire
 teardown

---
 crates/mq-integration/tests/pair_h3.rs | 60 ++++++++++++++++----------
 1 file changed, 38 insertions(+), 22 deletions(-)

diff --git a/crates/mq-integration/tests/pair_h3.rs b/crates/mq-integration/tests/pair_h3.rs
index f103b464..3e8e4135 100644
--- a/crates/mq-integration/tests/pair_h3.rs
+++ b/crates/mq-integration/tests/pair_h3.rs
@@ -10,8 +10,9 @@ use mq_integration::matrix;
 use mq_integration::raw_h3::{RawH3Handle, RawH3Peer, RawH3Script, field, headers_frame};
 use mq_runtime::Shard;
 use mq_runtime::testing::{RecordHandle, Recorded, RecordingApp};
-use mq_transport_api::{ConnConfig, ConnProto, Event, H3Header, Role};
+use mq_transport_api::{ConnConfig, ConnProto, Event, H3Header, Role, StreamError};
 use std::net::Ipv4Addr;
+use std::sync::mpsc;
 use std::thread;
 use std::time::{Duration, Instant};
 
@@ -281,9 +282,10 @@ fn raw_peer_smoke() {
 fn live_wire_pair(
     idle: Option<Duration>,
     close_on_response: bool,
-) -> LoopbackPair<RecordHandle, RecordHandle> {
+) -> (LoopbackPair<RecordHandle, RecordHandle>, mpsc::Receiver<()>) {
+    let (ready_tx, ready_rx) = mpsc::channel();
     let lo = Ipv4Addr::LOCALHOST.into();
-    LoopbackPair::spawn(
+    let p = LoopbackPair::spawn(
         (lo, lo),
         Vec::new(),
         move |local| {
@@ -310,7 +312,7 @@ fn live_wire_pair(
         },
         move |local, server| {
             let (app, rec) = RecordingApp::new();
-            let mut close_on_response = close_on_response;
+            let mut prefix_read = false;
             rec.on(move |r, cx| match r {
                 Recorded::Start => {
                     cx.connect(&ConnConfig {
@@ -345,10 +347,24 @@ fn live_wire_pair(
                         assert_eq!(cx.h3_send_headers(req, &headers, fin), Ok(()));
                     }
                 }
-                Recorded::TransportEvent(Event::H3Readable(req)) if close_on_response => {
-                    close_on_response = false;
-                    let conn = cx.h3_req_info(*req).expect("live request").conn;
-                    cx.close_conn(conn);
+                Recorded::TransportEvent(Event::H3Readable(req)) if !prefix_read => {
+                    let _ = cx.h3_recv_headers(*req, &mut |_, _| {});
+                    let mut prefix = [0; 1];
+                    match cx.h3_recv_body(*req, &mut prefix) {
+                        Ok((n, fin)) => {
+                            assert_eq!((n, fin), (1, false), "positive body prefix, no FIN");
+                            assert_eq!(&prefix, b"p");
+                            // Only one of the seven sent bytes is consumed; six stay unread.
+                            prefix_read = true;
+                            ready_tx.send(()).expect("test awaiting body prefix");
+                            if close_on_response {
+                                let conn = cx.h3_req_info(*req).expect("live request").conn;
+                                cx.close_conn(conn);
+                            }
+                        }
+                        Err(StreamError::Blocked) => {} // HEADERS may precede DATA.
+                        Err(e) => panic!("body prefix: {e:?}"),
+                    }
                 }
                 Recorded::Shutdown => cx.request_exit(0),
                 _ => {}
@@ -358,7 +374,8 @@ fn live_wire_pair(
                 rec,
             )
         },
-    )
+    );
+    (p, ready_rx)
 }
 
 fn wait_records(rec: &RecordHandle, pred: impl Fn(&[Recorded]) -> bool) {
@@ -373,12 +390,10 @@ fn wait_records(rec: &RecordHandle, pred: impl Fn(&[Recorded]) -> bool) {
 #[test]
 fn wire_idle_timeout_mid_response_aborts() {
     let idle = Duration::from_secs(1);
-    let mut p = live_wire_pair(Some(idle), false);
-    wait_records(&p.client.handle, |records| {
-        records
-            .iter()
-            .any(|r| matches!(r, Recorded::TransportEvent(Event::H3Readable(_))))
-    });
+    let (mut p, ready) = live_wire_pair(Some(idle), false);
+    ready
+        .recv_timeout(Duration::from_secs(10))
+        .expect("unfinished body prefix received");
     let start = Instant::now();
     // The server exits without sending CONNECTION_CLOSE, so only idle expiry can close it.
     p.server.shutdown.trigger();
@@ -408,7 +423,10 @@ fn wire_idle_timeout_mid_response_aborts() {
 /// Local close reports every live request before ConnClosed and rescues no partial body.
 #[test]
 fn wire_local_close_with_live_requests_is_clean() {
-    let p = live_wire_pair(None, true);
+    let (p, ready) = live_wire_pair(None, true);
+    ready
+        .recv_timeout(Duration::from_secs(10))
+        .expect("unfinished body prefix received before local close");
     wait_records(&p.client.handle, |records| {
         records
             .iter()
@@ -438,12 +456,10 @@ fn wire_local_close_with_live_requests_is_clean() {
 /// Engine teardown with open requests on both sides, including an unread partial response.
 #[test]
 fn wire_drop_transport_with_live_requests_is_clean() {
-    let p = live_wire_pair(None, false);
-    wait_records(&p.client.handle, |records| {
-        records
-            .iter()
-            .any(|r| matches!(r, Recorded::TransportEvent(Event::H3Readable(_))))
-    });
+    let (p, ready) = live_wire_pair(None, false);
+    ready
+        .recv_timeout(Duration::from_secs(10))
+        .expect("unfinished body prefix received");
     wait_records(&p.server.handle, |records| {
         records
             .iter()

From 2ceb17ffb8a02dc742b2659f2fd0462089d65e87 Mon Sep 17 00:00:00 2001
From: mp0rta <3p0rta26@gmail.com>
Date: Wed, 7 Oct 2026 01:23:20 +0900
Subject: [PATCH 7/7] refactor: delete the xqc_h3 backend and its workarounds

---
 crates/mq-h3/src/conn.rs                      |    2 +-
 crates/mq-h3/src/lib.rs                       |   99 +-
 crates/mq-h3/src/recv.rs                      |    1 -
 crates/mq-h3/src/send.rs                      |    6 +-
 crates/mq-h3/tests/common/mod.rs              |    4 +-
 crates/mq-h3/tests/lifecycle.rs               |    7 +-
 crates/mq-h3/tests/passthrough.rs             |  282 ----
 crates/mq-h3/tests/recv.rs                    |   11 +-
 crates/mq-h3/tests/send.rs                    |    2 +-
 crates/mq-h3/tests/stats.rs                   |    1 -
 crates/mq-integration/Cargo.toml              |    2 +-
 crates/mq-integration/src/h3_apps.rs          |   75 +-
 crates/mq-integration/src/loopback.rs         |  193 +--
 crates/mq-integration/src/raw_h3.rs           |    2 +-
 crates/mq-integration/src/shard_pair.rs       |    1 -
 .../mq-integration/tests/loop_engine_boot.rs  |    1 -
 crates/mq-integration/tests/pair_gateway.rs   | 1308 ++++++++---------
 crates/mq-integration/tests/pair_h3.rs        |  279 ++--
 crates/mq-integration/tests/pair_mitm.rs      |  624 ++++----
 crates/mq-proxy/src/client/exchange/mod.rs    |  186 +--
 crates/mq-proxy/tests/client_exchange.rs      |  140 +-
 crates/mq-proxy/tests/client_gateway_ends.rs  |   47 +-
 .../mq-proxy/tests/client_gateway_upload.rs   |   20 +-
 crates/mq-proxy/tests/client_mitm_stream.rs   |   45 +-
 .../mq-proxy/tests/server_gateway_metrics.rs  |    8 +-
 crates/mq-proxy/tests/server_gateway_relay.rs |    8 +-
 crates/mq-runtime/tests/scripted.rs           |   20 +-
 crates/mq-transport-api/src/config.rs         |   12 +-
 crates/mq-transport-api/src/event.rs          |   14 +-
 crates/mq-transport-api/src/lib.rs            |    4 +-
 crates/mq-transport-api/src/ops.rs            |    2 +-
 crates/mq-transport/src/conn.rs               |   56 +-
 crates/mq-transport/src/engine.rs             |   35 +-
 crates/mq-transport/src/events.rs             |  141 +-
 crates/mq-transport/src/ffi/mod.rs            |   17 +-
 crates/mq-transport/src/ffi/trampolines.rs    |  484 +-----
 crates/mq-transport/src/h3.rs                 |  326 ----
 crates/mq-transport/src/lib.rs                |   75 +-
 crates/mq-transport/src/slots.rs              |   35 +-
 crates/mq-transport/src/stream.rs             |   22 +-
 crates/mq-transport/tests/common/lockstep.rs  |    1 -
 crates/mq-transport/tests/engine.rs           |    1 -
 crates/mq-transport/tests/fabric_h3.rs        |  688 ---------
 crates/mq-transport/tests/fabric_h3raw.rs     |   27 +-
 crates/mqproxy/src/cli.rs                     |    2 +-
 crates/mqproxy/src/run.rs                     |    1 -
 crates/mqproxy/tests/cli.rs                   |    2 +-
 crates/xquic-sys/src/bindings.rs              | 1034 +------------
 crates/xquic-sys/wrapper.h                    |    1 -
 49 files changed, 1228 insertions(+), 5126 deletions(-)
 delete mode 100644 crates/mq-h3/tests/passthrough.rs
 delete mode 100644 crates/mq-transport/src/h3.rs
 delete mode 100644 crates/mq-transport/tests/fabric_h3.rs

diff --git a/crates/mq-h3/src/conn.rs b/crates/mq-h3/src/conn.rs
index 478db536..27f551f9 100644
--- a/crates/mq-h3/src/conn.rs
+++ b/crates/mq-h3/src/conn.rs
@@ -74,7 +74,7 @@ impl<T: TransportOps> H3Wire<T> {
         self.service(now, c);
     }
 
-    /// An inner event, active mode. Returns it if it passes through; the raw stream events
+    /// An inner event. Returns it if it passes through; the raw stream events
     /// of H3 conns are consumed here (adoption spec §4.1).
     pub(crate) fn on_event(&mut self, now: Time, e: Event) -> Option<Event> {
         match e {
diff --git a/crates/mq-h3/src/lib.rs b/crates/mq-h3/src/lib.rs
index 42b6a734..d1619402 100644
--- a/crates/mq-h3/src/lib.rs
+++ b/crates/mq-h3/src/lib.rs
@@ -1,6 +1,6 @@
 //! `H3Wire<T>`: a `TransportOps` decorator serving HTTP/3 from h3wire (adoption spec §4.1).
 //!
-//! Active mode (`H3Wire::new`) runs one h3wire `Connection` per H3 conn and serves the
+//! Runs one h3wire `Connection` per H3 conn and serves the
 //! requests from it.
 #![forbid(unsafe_code)]
 
@@ -26,8 +26,6 @@ pub const BOOT_READ: usize = 4096;
 
 pub struct H3Wire<T> {
     inner: T,
-    /// `false`: create no H3 state; every op and event passes through (adoption spec §4.1).
-    active: bool,
     queue: OutQueue,
     /// Request streams of H3 conns, by request id (adoption spec §4.3).
     reqs: HashMap<H3ReqId, Req>,
@@ -49,20 +47,10 @@ pub struct H3Wire<T> {
 }
 
 impl<T: TransportOps> H3Wire<T> {
-    /// Serves H3 conns from h3wire (inner must be `h3_backend: Raw`).
+    /// Serves H3 conns over the raw transport.
     pub fn new(inner: T) -> Self {
-        Self::make(inner, true)
-    }
-
-    /// Creates no H3 state: every op and event passes through unfiltered (inner may be xqc_h3).
-    pub fn passthrough(inner: T) -> Self {
-        Self::make(inner, false)
-    }
-
-    fn make(inner: T, active: bool) -> Self {
         H3Wire {
             inner,
-            active,
             queue: OutQueue::default(),
             reqs: HashMap::new(),
             conns: HashMap::new(),
@@ -141,11 +129,7 @@ impl<T: TransportOps> H3Wire<T> {
             self.service(now, c);
         }
         while let Some(e) = self.inner.poll_event() {
-            let out = if self.active {
-                self.on_event(now, e)
-            } else {
-                Some(e)
-            };
+            let out = self.on_event(now, e);
             if let Some(e) = out {
                 self.queue.push(e);
             }
@@ -192,11 +176,7 @@ impl<T: TransportOps> TransportOps for H3Wire<T> {
     /// stale between that drain and this pop, so the same checks run again here.
     fn poll_event(&mut self) -> Option<Event> {
         let Self {
-            inner,
-            active,
-            queue,
-            reqs,
-            ..
+            inner, queue, reqs, ..
         } = self;
         queue.pop(|e| match e {
             Event::ConnEstablished(c)
@@ -209,9 +189,6 @@ impl<T: TransportOps> TransportOps for H3Wire<T> {
             | Event::StreamWritable(s)
             | Event::StreamPeerReset(s, _)
             | Event::StreamStopSending(s, _) => inner.stream_info(*s).is_ok(),
-            Event::H3Request(_, r) | Event::H3Readable(r) | Event::H3Writable(r) if !*active => {
-                inner.h3_req_info(*r).is_ok()
-            }
             // An H3Readable after the receive end was handed over has nothing to deliver.
             Event::H3Readable(r) => reqs.get(r).is_some_and(|q| !q.handed),
             Event::H3Request(_, r) | Event::H3Writable(r) => reqs.contains_key(r),
@@ -228,7 +205,7 @@ impl<T: TransportOps> TransportOps for H3Wire<T> {
 
     fn connect(&mut self, now: Time, cfg: &ConnConfig) -> Result<ConnId, ConnectError> {
         let r = self.inner.connect(now, cfg);
-        if let (true, ConnProto::H3, Ok(c)) = (self.active, cfg.proto, r) {
+        if let (ConnProto::H3, Ok(c)) = (cfg.proto, r) {
             self.add_conn(now, c, h3wire::Role::Client);
         }
         self.drive_inner(now);
@@ -314,13 +291,10 @@ impl<T: TransportOps> TransportOps for H3Wire<T> {
         self.inner.datagram_recv(conn, buf)
     }
 
-    // H3 ops. Active: served from h3wire, never forwarded; an id not held is stale
+    // H3 ops are served from h3wire; an id not held is stale
     // (adoption spec §4.1).
     fn open_h3_request(&mut self, now: Time, conn: ConnId) -> Result<H3ReqId, Error> {
-        if self.active {
-            return self.open_req(now, conn);
-        }
-        fwd!(self, now, self.inner.open_h3_request(now, conn))
+        self.open_req(now, conn)
     }
 
     fn h3_send_headers(
@@ -330,11 +304,8 @@ impl<T: TransportOps> TransportOps for H3Wire<T> {
         hs: &[H3Header<'_>],
         fin: bool,
     ) -> Result<(), StreamError> {
-        if self.active {
-            self.touch(r);
-            return self.send_headers(now, r, hs, fin);
-        }
-        fwd!(self, now, self.inner.h3_send_headers(now, r, hs, fin))
+        self.touch(r);
+        self.send_headers(now, r, hs, fin)
     }
 
     fn h3_send_body(
@@ -344,19 +315,13 @@ impl<T: TransportOps> TransportOps for H3Wire<T> {
         data: &[u8],
         fin: bool,
     ) -> Result<usize, StreamError> {
-        if self.active {
-            self.touch(r);
-            return self.send_body(now, r, data, fin);
-        }
-        fwd!(self, now, self.inner.h3_send_body(now, r, data, fin))
+        self.touch(r);
+        self.send_body(now, r, data, fin)
     }
 
     fn h3_finish(&mut self, now: Time, r: H3ReqId) -> Result<(), StreamError> {
-        if self.active {
-            self.touch(r);
-            return self.finish(now, r);
-        }
-        fwd!(self, now, self.inner.h3_finish(now, r))
+        self.touch(r);
+        self.finish(now, r)
     }
 
     fn h3_recv_headers(
@@ -365,11 +330,8 @@ impl<T: TransportOps> TransportOps for H3Wire<T> {
         r: H3ReqId,
         each: &mut dyn FnMut(&[u8], &[u8]),
     ) -> Result<bool, StreamError> {
-        if self.active {
-            self.touch(r);
-            return self.recv_headers(now, r, each);
-        }
-        fwd!(self, now, self.inner.h3_recv_headers(now, r, each))
+        self.touch(r);
+        self.recv_headers(now, r, each)
     }
 
     fn h3_recv_body(
@@ -382,32 +344,23 @@ impl<T: TransportOps> TransportOps for H3Wire<T> {
         {
             self.max_buf = self.max_buf.max(buf.len());
         }
-        if self.active {
-            self.touch(r);
-            return self.recv_body(now, r, buf);
-        }
-        fwd!(self, now, self.inner.h3_recv_body(now, r, buf))
+        self.touch(r);
+        self.recv_body(now, r, buf)
     }
 
     fn h3_reset(&mut self, now: Time, r: H3ReqId) {
-        if self.active {
-            self.touch(r);
-            return self.reset(now, r);
-        }
-        fwd!(self, now, self.inner.h3_reset(now, r))
+        self.touch(r);
+        self.reset(now, r)
     }
 
     fn h3_req_info(&self, r: H3ReqId) -> Result<H3ReqInfo, Error> {
-        if self.active {
-            // Cached at request start: the inner slot is gone before StreamClosed.
-            return match self.reqs.get(&r) {
-                Some(q) if q.known => Ok(H3ReqInfo {
-                    conn: q.conn,
-                    quic_id: q.quic_id,
-                }),
-                _ => Err(Error::Stale),
-            };
+        // Cached at request start: the inner slot is gone before StreamClosed.
+        match self.reqs.get(&r) {
+            Some(q) if q.known => Ok(H3ReqInfo {
+                conn: q.conn,
+                quic_id: q.quic_id,
+            }),
+            _ => Err(Error::Stale),
         }
-        self.inner.h3_req_info(r)
     }
 }
diff --git a/crates/mq-h3/src/recv.rs b/crates/mq-h3/src/recv.rs
index 74477725..96a9221d 100644
--- a/crates/mq-h3/src/recv.rs
+++ b/crates/mq-h3/src/recv.rs
@@ -431,7 +431,6 @@ impl<T: TransportOps> H3Wire<T> {
         if req.known {
             let close = H3Close {
                 stats: req.stats(conn_err),
-                unread: None,
             };
             self.queue.push(Event::H3Closed(id, Box::new(close)));
         }
diff --git a/crates/mq-h3/src/send.rs b/crates/mq-h3/src/send.rs
index b2c0d952..cce0663d 100644
--- a/crates/mq-h3/src/send.rs
+++ b/crates/mq-h3/src/send.rs
@@ -95,7 +95,7 @@ impl<T: TransportOps> H3Wire<T> {
     /// Client request start (adoption spec §4.3): the request exists from `open_stream`;
     /// h3wire holds state for it once `send_headers` succeeds.
     pub(crate) fn open_req(&mut self, now: Time, c: ConnId) -> Result<H3ReqId, Error> {
-        // The xqc_h3 backend's order (`reserve_local`): role, conn, protocol.
+        // Request admission order: role, conn, protocol.
         let r = match self.conns.get(&c) {
             _ if self.server => Err(Error::Role),
             None if self.inner.conn_stats(c).is_ok() => Err(Error::Other), // a raw conn
@@ -186,7 +186,7 @@ impl<T: TransportOps> H3Wire<T> {
         // A retained request (client only) accepts and discards like after SendStopped,
         // so a running upload pump cannot abort the response (adoption spec §4.3).
         if req.send_stopped || self.conns[&req.conn].gone {
-            // RFC 9114 §4.1: the client's response keeps flowing; xqc_h3 resets the server.
+            // RFC 9114 §4.1: the client's response keeps flowing after cancelling the upload.
             return if client {
                 Ok(data.len())
             } else {
@@ -284,7 +284,7 @@ impl<T: TransportOps> H3Wire<T> {
     }
 
     /// `h3_finish`: latches the finish intent and returns `Ok` while HEADERS bytes are
-    /// queued, as xqc_h3 does (adoption spec §4.5).
+    /// queued (adoption spec §4.5).
     pub(crate) fn finish(&mut self, now: Time, id: H3ReqId) -> Result<(), StreamError> {
         let client = self.client_of(id)?;
         let r = self.body(now, id, &[], true, client).map(drop);
diff --git a/crates/mq-h3/tests/common/mod.rs b/crates/mq-h3/tests/common/mod.rs
index 6dc062b0..ac48484d 100644
--- a/crates/mq-h3/tests/common/mod.rs
+++ b/crates/mq-h3/tests/common/mod.rs
@@ -345,8 +345,8 @@ impl Rig {
         }
     }
 
-    /// A RESET_STREAM on `q` from a peer stack that resets whatever its h3 state (e.g.
-    /// xqc_h3, even after its FIN); the h3wire peer is not told and its later bytes on `q`
+    /// A RESET_STREAM on `q` from a peer stack that resets even after its FIN;
+    /// the h3wire peer is not told and its later bytes on `q`
     /// are dropped.
     pub fn peer_raw_reset(&mut self, q: u64, code: u64) {
         let Some(s) = self.stream_of(q) else {
diff --git a/crates/mq-h3/tests/lifecycle.rs b/crates/mq-h3/tests/lifecycle.rs
index e885dff9..e343301b 100644
--- a/crates/mq-h3/tests/lifecycle.rs
+++ b/crates/mq-h3/tests/lifecycle.rs
@@ -77,14 +77,11 @@ fn started(r: &mut Rig) -> H3ReqId {
     ids[0]
 }
 
-/// The `H3Closed` ids in `ev`, each asserting `unread: None`.
+/// The `H3Closed` ids in `ev`, with their close stats.
 fn closed(ev: &[Event]) -> Vec<H3ReqId> {
     ev.iter()
         .filter_map(|e| match e {
-            Event::H3Closed(id, c) => {
-                assert_eq!(c.unread, None);
-                Some(*id)
-            }
+            Event::H3Closed(id, _) => Some(*id),
             _ => None,
         })
         .collect()
diff --git a/crates/mq-h3/tests/passthrough.rs b/crates/mq-h3/tests/passthrough.rs
deleted file mode 100644
index d7c29005..00000000
--- a/crates/mq-h3/tests/passthrough.rs
+++ /dev/null
@@ -1,282 +0,0 @@
-//! Pass-through behaviour of `H3Wire` over `ScriptedTransport` (adoption spec §4.1).
-
-use mq_h3::H3Wire;
-use mq_runtime::testing::{Call, ScriptedHandle, ScriptedTransport};
-use mq_transport_api::{
-    CloseReason, ConnConfig, ConnProto, ErrType, Error, Event, H3Close, H3ReqStats, StreamError,
-    StreamInfo, StreamKind, Time, TransportOps,
-};
-use std::net::SocketAddr;
-
-fn mk(active: bool) -> (H3Wire<ScriptedTransport>, ScriptedHandle) {
-    let (t, h) = ScriptedTransport::new();
-    (
-        if active {
-            H3Wire::new(t)
-        } else {
-            H3Wire::passthrough(t)
-        },
-        h,
-    )
-}
-
-const NOW: Time = Time::ZERO;
-
-fn addr() -> SocketAddr {
-    "127.0.0.1:4433".parse().unwrap()
-}
-
-fn raw_ops(active: bool) {
-    let (mut w, h) = mk(active);
-    let cfg = ConnConfig {
-        peer: addr(),
-        sni: "mqproxy",
-        idle_timeout: None,
-        proto: ConnProto::Raw,
-    };
-    let c = w.connect(NOW, &cfg).unwrap();
-    let s = w.open_stream(NOW, c).unwrap();
-    assert_eq!(w.stream_send(NOW, s, b"abc", true), Ok(3));
-    let mut buf = [0u8; 8];
-    assert_eq!(w.stream_recv(NOW, s, &mut buf), Err(StreamError::Blocked));
-    w.stream_reset(NOW, s);
-    w.stream_reset_send(NOW, s, 0x10c);
-    w.stream_stop_sending(NOW, s, 0x10b);
-    let u = w.open_uni(NOW, c).unwrap();
-    assert_eq!(w.add_path(NOW, c, true).map(|_| ()), Ok(()));
-    assert_eq!(w.datagram_send(NOW, c, b"dg"), Ok(()));
-    w.close_conn(NOW, c);
-    w.close_conn_with(NOW, c, 0x101);
-    let _ = w.conn_stats(c);
-    let _ = w.stream_info(s);
-    let log = h.log();
-    let want = [
-        Call::Connect(cfg),
-        Call::OpenStream(c),
-        Call::StreamSend {
-            s,
-            bytes: b"abc".to_vec(),
-            fin: true,
-        },
-        Call::StreamRecv { s, cap: 8 },
-        Call::StreamReset(s),
-        Call::StreamResetSend { s, code: 0x10c },
-        Call::StreamStopSending { s, code: 0x10b },
-        Call::OpenUni(c),
-        Call::AddPath {
-            conn: c,
-            standby: true,
-        },
-        Call::DatagramSend {
-            conn: c,
-            bytes: b"dg".to_vec(),
-        },
-        Call::CloseConn(c),
-        Call::CloseConnWith {
-            conn: c,
-            code: 0x101,
-        },
-    ];
-    assert_eq!(log, want);
-    let _ = u;
-}
-
-#[test]
-fn raw_ops_reach_inner() {
-    raw_ops(false);
-    raw_ops(true);
-}
-
-fn raw_events(active: bool) {
-    let (mut w, h) = mk(active);
-    let c = h.new_conn_id();
-    let s = h.new_stream_id();
-    let info = StreamInfo {
-        conn: c,
-        quic_id: 0,
-        kind: StreamKind::Bidi,
-    };
-    h.set_stream_info(s, info);
-    h.set_conn_stats(c, Default::default()); // the conn is live
-    let reason = CloseReason {
-        err_type: ErrType::Unknown,
-        code: 0,
-    };
-    let evs = vec![
-        Event::NewConn(c, ConnProto::Raw),
-        Event::ConnEstablished(c),
-        Event::NewStream(c, s, info),
-        Event::StreamReadable(s),
-        Event::StreamWritable(s),
-        Event::StreamPeerReset(s, 0x10c),
-        Event::StreamStopSending(s, 0x10b),
-        Event::MpReady(c),
-        Event::DatagramReadable(c),
-        Event::StreamClosed(s),
-        Event::ConnClosed(c, reason),
-    ];
-    for e in &evs {
-        h.push_event(e.clone());
-    }
-    w.drive(NOW);
-    let got: Vec<_> = std::iter::from_fn(|| w.poll_event()).collect();
-    assert_eq!(got, evs);
-}
-
-#[test]
-fn raw_events_pop_out() {
-    raw_events(false);
-    raw_events(true);
-}
-
-#[test]
-fn passthrough_h3_ops_and_events() {
-    let (mut w, h) = mk(false);
-    let c = h.new_conn_id();
-    let r = h.new_h3_request(c);
-    h.expect_open_h3_request(c, Ok(r));
-    assert_eq!(w.open_h3_request(NOW, c), Ok(r));
-    assert_eq!(w.h3_send_body(NOW, r, b"x", false), Ok(1));
-    assert_eq!(w.h3_finish(NOW, r), Ok(()));
-    let mut buf = [0u8; 4];
-    assert_eq!(w.h3_recv_body(NOW, r, &mut buf), Err(StreamError::Blocked));
-    assert_eq!(
-        w.h3_recv_headers(NOW, r, &mut |_, _| {}),
-        Err(StreamError::Blocked)
-    );
-    w.h3_reset(NOW, r);
-    let log = h.log();
-    for call in [
-        Call::OpenH3Request(c),
-        Call::H3Finish(r),
-        Call::H3Reset(r),
-        Call::H3RecvHeaders(r),
-    ] {
-        assert!(log.contains(&call), "{call:?} missing in {log:?}");
-    }
-    assert!(log.contains(&Call::H3RecvBody { r, cap: 4 }));
-
-    // Events for ids the wrapper never saw pass unchanged.
-    let r2 = h.new_h3_request(c);
-    let stats = H3ReqStats {
-        send_body: 0,
-        recv_body: 0,
-        begin_us: 0,
-        header_send_us: 0,
-        fin_send_us: 0,
-        fin_ack_us: 0,
-        mp_state: 0,
-        stream_err: 0,
-        close_msg: None,
-    };
-    let closed = Event::H3Closed(
-        r2,
-        Box::new(H3Close {
-            stats,
-            unread: None,
-        }),
-    );
-    h.push_event(Event::H3Readable(r2));
-    h.push_event(Event::H3Writable(r2));
-    h.push_event(closed.clone());
-    w.drive(NOW);
-    let got: Vec<_> = std::iter::from_fn(|| w.poll_event()).collect();
-    assert_eq!(
-        got,
-        vec![
-            Event::H3Request(c, r),
-            Event::H3Request(c, r2),
-            Event::H3Readable(r2),
-            Event::H3Writable(r2),
-            closed
-        ]
-    );
-}
-
-#[test]
-fn active_unknown_id_is_stale_and_not_forwarded() {
-    let (mut w, h) = mk(true);
-    let c = h.new_conn_id();
-    let r = h.new_h3_request(c);
-    let mut buf = [0u8; 4];
-    assert_eq!(w.h3_recv_body(NOW, r, &mut buf), Err(StreamError::Stale));
-    assert_eq!(w.h3_send_body(NOW, r, b"x", false), Err(StreamError::Stale));
-    assert_eq!(w.h3_finish(NOW, r), Err(StreamError::Stale));
-    assert_eq!(w.h3_req_info(r), Err(Error::Stale));
-    w.h3_reset(NOW, r);
-    let log = h.log();
-    assert!(
-        !log.iter().any(|c| matches!(
-            c,
-            Call::H3RecvBody { .. }
-                | Call::H3SendBody { .. }
-                | Call::H3Finish(_)
-                | Call::H3Reset(_)
-        )),
-        "forwarded: {log:?}"
-    );
-}
-
-/// Pops are filtered as the bare transport filters them (adoption spec §4.1): in passthrough,
-/// an H3 event whose request the inner transport no longer knows is dropped; in both modes a
-/// readiness or creation event of a gone conn is dropped. Close events always pop.
-#[test]
-fn stale_on_pop_dropped_like_bare_transport() {
-    for active in [false, true] {
-        let (mut w, h) = mk(active);
-        let (live, gone) = (h.new_conn_id(), h.new_conn_id());
-        h.set_conn_stats(live, Default::default());
-        let r = h.new_h3_request(live);
-        h.inject_h3_headers(r, vec![(b":method".to_vec(), b"GET".to_vec())], true);
-        h.push_event(Event::MpReady(gone));
-        h.push_event(Event::DatagramReadable(gone));
-        h.push_event(Event::MpReady(live));
-        w.drive(NOW); // drained while everything was still live in the inner queue
-        let close = H3Close {
-            stats: H3ReqStats {
-                send_body: 0,
-                recv_body: 0,
-                begin_us: 0,
-                header_send_us: 0,
-                fin_send_us: 0,
-                fin_ack_us: 0,
-                mp_state: 0,
-                stream_err: 0,
-                close_msg: None,
-            },
-            unread: None,
-        };
-        h.close_h3(r, close.clone()); // the request goes stale between drain and pop
-        let got: Vec<_> = std::iter::from_fn(|| w.poll_event()).collect();
-        assert_eq!(got, vec![Event::MpReady(live)], "active={active}");
-        w.drive(NOW);
-        let got: Vec<_> = std::iter::from_fn(|| w.poll_event()).collect();
-        assert_eq!(
-            got,
-            vec![Event::H3Closed(r, Box::new(close))],
-            "active={active}"
-        );
-    }
-}
-
-/// The liveness check of a conn-level pop is the cheap `conn_live`, not `conn_stats` (which
-/// collects path stats on xquic): after the cutover the UDP lane pops these constantly.
-#[test]
-fn conn_pops_do_not_collect_stats() {
-    for active in [false, true] {
-        let (mut w, h) = mk(active);
-        let (live, gone) = (h.new_conn_id(), h.new_conn_id());
-        h.set_conn_stats(live, Default::default());
-        h.push_event(Event::DatagramReadable(live));
-        h.push_event(Event::MpReady(gone));
-        w.drive(NOW);
-        let before = h.conn_stats_calls();
-        let got: Vec<_> = std::iter::from_fn(|| w.poll_event()).collect();
-        assert_eq!(got, [Event::DatagramReadable(live)], "active={active}");
-        assert_eq!(
-            h.conn_stats_calls(),
-            before,
-            "conn_stats probed, active={active}"
-        );
-    }
-}
diff --git a/crates/mq-h3/tests/recv.rs b/crates/mq-h3/tests/recv.rs
index c114fbda..edbd9aaa 100644
--- a/crates/mq-h3/tests/recv.rs
+++ b/crates/mq-h3/tests/recv.rs
@@ -383,11 +383,11 @@ fn reset_code_pending_then_stream_closed() {
         .filter(|e| matches!(e, Event::H3Closed(..)))
         .collect();
     assert_eq!(closed.len(), 1, "{ev:?}");
-    let Event::H3Closed(cid, close) = closed[0] else {
+    let Event::H3Closed(cid, _) = closed[0] else {
         unreachable!()
     };
     assert_eq!(*cid, id);
-    assert_eq!(close.unread, None);
+
     assert_eq!(aborts(&r, s), [], "actions on the gone stream are dropped");
     // The id is stale from now on.
     let now = r.now;
@@ -461,7 +461,7 @@ fn abort_in_feed_retires() {
     );
 }
 
-/// The xqc_h3 backend's order (`reserve_local`): role, then conn, then protocol.
+/// Request admission order: role, then conn, then protocol.
 #[test]
 fn open_h3_request_errors() {
     let mut r = Rig::client();
@@ -536,7 +536,7 @@ fn oversized_headers_closes() {
 }
 
 /// The MITM's terminal probe `h3_recv_body(id, &mut [])` (mq-proxy `client/mitm/stream.rs`)
-/// answers as on xqc_h3: `Blocked` while payload or nothing is left, `(0, true)` once only
+/// answers: `Blocked` while payload or nothing is left, `(0, true)` once only
 /// the FIN is. The FIN comes alone here: the probe reads it into the empty carry and feeds
 /// it as a bare carried FIN (a carried FIN never outlives a feed otherwise: a slice passes it
 /// with the whole carry).
@@ -559,8 +559,7 @@ fn empty_probe_bare_fin() {
 }
 
 /// Framing alone (an empty DATA frame) left before the FIN: the probe feeds no byte (slices
-/// of at most `buf.len()`, adoption spec §4.4) and stays `Blocked`, where xqc_h3, which parsed
-/// the frame on arrival, answers `(0, true)`. Open against the spec (final-fix report, I3);
+/// of at most `buf.len()`, adoption spec §4.4) and stays `Blocked`;
 /// the next read with a buffer ends the body.
 #[test]
 fn empty_probe_framing_before_fin() {
diff --git a/crates/mq-h3/tests/send.rs b/crates/mq-h3/tests/send.rs
index fa9c6c1c..495da96f 100644
--- a/crates/mq-h3/tests/send.rs
+++ b/crates/mq-h3/tests/send.rs
@@ -620,7 +620,7 @@ fn invalid_field_maps_to_reset() {
     assert!(r.h.sent_bytes(s).is_empty());
 }
 
-/// A peer RESET_STREAM after the request's FIN (xqc_h3 sends one on any cancel): h3wire
+/// A peer RESET_STREAM after the request's FIN (a peer cancels its stream): h3wire
 /// resets our send side but emits no `StreamAborted` after `Finished`, so it ends the send
 /// side as `SendStopped` does, here with a DATA frame in flight.
 #[test]
diff --git a/crates/mq-h3/tests/stats.rs b/crates/mq-h3/tests/stats.rs
index 9ba8f920..80e5a429 100644
--- a/crates/mq-h3/tests/stats.rs
+++ b/crates/mq-h3/tests/stats.rs
@@ -106,7 +106,6 @@ fn stats_clean() {
                     stream_err: 0,
                     close_msg: Some("finished".into()),
                 },
-                unread: None,
             }
         )]
     );
diff --git a/crates/mq-integration/Cargo.toml b/crates/mq-integration/Cargo.toml
index 9263d4ca..01918bca 100644
--- a/crates/mq-integration/Cargo.toml
+++ b/crates/mq-integration/Cargo.toml
@@ -36,7 +36,7 @@ mq-transport = { path = "../mq-transport" }
 mq-transport-api = { path = "../mq-transport-api" }
 mq-linux = { path = "../mq-linux" }
 mq-wire = { path = "../mq-wire", optional = true }
-# The h3wire backend (loopback::Backend::Wire) and the raw-H3 peer's byte builders (raw_h3.rs).
+# The h3wire transport (loopback::h3_transport) and the raw-H3 peer's byte builders (raw_h3.rs).
 mq-h3 = { path = "../mq-h3", optional = true, features = ["test-support"] }
 h3wire = { path = "../../third_party/h3wire/h3wire", optional = true }
 log = { workspace = true, optional = true }
diff --git a/crates/mq-integration/src/h3_apps.rs b/crates/mq-integration/src/h3_apps.rs
index 50a30068..206cc7af 100644
--- a/crates/mq-integration/src/h3_apps.rs
+++ b/crates/mq-integration/src/h3_apps.rs
@@ -6,12 +6,12 @@ use mq_runtime::{
     AcceptMeta, App, Cx, DialError, DialOpId, ListenerTag, SocketOpId, TcpEnd, TcpId, TimerId,
     UdpSocketId,
 };
-use mq_transport_api::{ConnConfig, ConnId, ConnProto, Event, H3Close, H3Header, H3ReqId};
+use mq_transport_api::{ConnConfig, ConnProto, Event, H3Close, H3Header, H3ReqId};
 use std::collections::HashMap;
 use std::io;
 use std::net::SocketAddr;
 use std::sync::{Arc, Mutex, MutexGuard};
-use std::time::{Duration, Instant};
+use std::time::Instant;
 
 /// What an app observed.
 #[derive(Debug, Default)]
@@ -26,10 +26,6 @@ pub struct H3Recorded {
     pub request_headers: Vec<(Vec<u8>, Vec<u8>)>,
     /// Every `H3Closed`, with its arrival time.
     pub closed: Vec<(H3Close, Instant)>,
-    /// `ResetBeforeFin` / `CloseConnMidResponse`: when the server cut the response, and the
-    /// connection's srtt then.
-    pub cut_at: Option<Instant>,
-    pub srtt_us: u64,
 }
 
 /// `Clone + Send` view of an app's `H3Recorded`.
@@ -116,19 +112,12 @@ pub enum EchoMode {
     /// The request body + FIN.
     #[default]
     Echo,
-    /// The request body without FIN, then (100 ms later) `h3_reset`.
-    ResetBeforeFin,
-    /// The request body without FIN, then (100 ms later) `close_conn` (CONNECTION_CLOSE 0).
-    CloseConnMidResponse,
     /// `content-length: cl` over a complete `sent`-byte DATA frame + FIN.
     ShortCl { cl: u64, sent: usize },
 }
 
-const CUT_DELAY: Duration = Duration::from_millis(100);
-
 #[derive(Default)]
 struct EchoReq {
-    conn: Option<ConnId>,
     body: Vec<u8>,
     resp: Vec<u8>,
     sent: usize,
@@ -143,7 +132,6 @@ pub struct H3EchoServer {
     resp_headers: Vec<(String, String)>,
     h: H3Handle,
     reqs: HashMap<H3ReqId, EchoReq>,
-    timers: HashMap<TimerId, H3ReqId>,
 }
 
 impl H3EchoServer {
@@ -154,7 +142,6 @@ impl H3EchoServer {
             resp_headers: Vec::new(),
             h: h.clone(),
             reqs: HashMap::new(),
-            timers: HashMap::new(),
         };
         (app, h)
     }
@@ -175,10 +162,6 @@ impl H3EchoServer {
         let cl = |n: u64| ("content-length".to_owned(), n.to_string());
         match self.mode {
             EchoMode::Echo => (q.resp, q.fin) = (std::mem::take(&mut q.body), true),
-            EchoMode::ResetBeforeFin | EchoMode::CloseConnMidResponse => {
-                q.resp = std::mem::take(&mut q.body);
-                self.timers.insert(cx.set_timer(CUT_DELAY), r);
-            }
             EchoMode::ShortCl { cl: n, sent } => {
                 hs.push(cl(n));
                 (q.resp, q.fin) = (vec![b'x'; sent], true);
@@ -189,37 +172,16 @@ impl H3EchoServer {
             push(cx, r, &q.resp, &mut q.sent, q.fin);
         }
     }
-
-    fn cut(&mut self, cx: &mut Cx<'_>, r: H3ReqId) {
-        let Some(conn) = self.reqs.get(&r).and_then(|q| q.conn) else {
-            return;
-        };
-        let srtt = cx
-            .conn_stats(conn)
-            .map_or(0, |s| s.paths.iter().map(|p| p.srtt_us).max().unwrap_or(0));
-        {
-            let mut rec = self.h.lock();
-            rec.cut_at = Some(Instant::now());
-            rec.srtt_us = srtt;
-        }
-        if self.mode == EchoMode::ResetBeforeFin {
-            cx.h3_reset(r);
-        } else {
-            cx.close_conn(conn);
-        }
-    }
 }
 
 impl App for H3EchoServer {
+    fn on_timer(&mut self, _: &mut Cx<'_>, _: TimerId) {}
     fn on_start(&mut self, _: &mut Cx<'_>) {}
 
     fn on_transport_event(&mut self, cx: &mut Cx<'_>, ev: Event) {
         match ev {
-            Event::H3Request(c, r) => {
-                let q = EchoReq {
-                    conn: Some(c),
-                    ..EchoReq::default()
-                };
+            Event::H3Request(_, r) => {
+                let q = EchoReq::default();
                 self.reqs.insert(r, q);
                 self.h.lock().requests += 1;
             }
@@ -250,12 +212,6 @@ impl App for H3EchoServer {
         }
     }
 
-    fn on_timer(&mut self, cx: &mut Cx<'_>, id: TimerId) {
-        if let Some(r) = self.timers.remove(&id) {
-            self.cut(cx, r);
-        }
-    }
-
     no_io!();
 }
 
@@ -265,9 +221,6 @@ pub struct H3Script {
     pub headers: Vec<(String, String)>,
     /// Sent with FIN (on the headers when empty).
     pub body: Vec<u8>,
-    /// On the first `H3Readable`, read nothing for this long (reading the FIN would set
-    /// `fin_consumed` and nothing would be rescued, spec §3.3), then read everything.
-    pub pause_reads: Option<Duration>,
 }
 
 /// An `App` that connects (H3) to `peer` on start, sends its one scripted request once the
@@ -278,7 +231,6 @@ pub struct H3Client {
     h: H3Handle,
     req: Option<H3ReqId>,
     sent: usize,
-    held: bool,
 }
 
 impl H3Client {
@@ -290,7 +242,6 @@ impl H3Client {
             h: h.clone(),
             req: None,
             sent: 0,
-            held: false,
         };
         (app, h)
     }
@@ -329,25 +280,13 @@ impl App for H3Client {
                 self.send(cx, r);
             }
             Event::H3Writable(r) => self.send(cx, r),
-            Event::H3Readable(r) => {
-                if let Some(d) = self.s.pause_reads.take() {
-                    self.held = true;
-                    cx.set_timer(d);
-                } else if !self.held {
-                    self.read(cx, r);
-                }
-            }
+            Event::H3Readable(r) => self.read(cx, r),
             Event::H3Closed(_, close) => self.h.lock().closed.push((*close, Instant::now())),
             _ => {}
         }
     }
 
-    fn on_timer(&mut self, cx: &mut Cx<'_>, _: TimerId) {
-        self.held = false;
-        if let Some(r) = self.req {
-            self.read(cx, r);
-        }
-    }
+    fn on_timer(&mut self, _: &mut Cx<'_>, _: TimerId) {}
 
     no_io!();
 }
diff --git a/crates/mq-integration/src/loopback.rs b/crates/mq-integration/src/loopback.rs
index d555fc61..a3e6ece6 100644
--- a/crates/mq-integration/src/loopback.rs
+++ b/crates/mq-integration/src/loopback.rs
@@ -15,9 +15,7 @@ use mq_runtime::{
     TcpId, TimerId, UdpSocketId,
 };
 use mq_transport::Transport;
-use mq_transport_api::{
-    CongestionControl, Event, H3Backend, Role, Scheduler, TransportConfig, TransportOps,
-};
+use mq_transport_api::{CongestionControl, Event, Role, Scheduler, TransportConfig, TransportOps};
 use std::io;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::path::{Path, PathBuf};
@@ -34,7 +32,7 @@ pub struct LoopbackPair<S, C> {
     pub client: DriverThread<C>,
     /// `restart_server`'s factory (pairs built by `spawn_mitm`).
     respawn: Option<Respawn<S>>,
-    /// `H3Request`s the server app was handed (`spawn_gateway_on` pairs; 0 elsewhere): what
+    /// `H3Request`s the server app was handed (`spawn_gateway` pairs; 0 elsewhere): what
     /// the gateway saw of the requests, whatever it logged.
     pub server_h3_requests: Arc<AtomicUsize>,
 }
@@ -168,95 +166,8 @@ impl<S: Send + 'static, C: Send + 'static> LoopbackPair<S, C> {
 /// (`client.listen_addrs[0]`) and an HTTP CONNECT (`[1]`) listener.
 pub type LoopbackProxy = LoopbackPair<(), ()>;
 
-/// A real transport as the proxy runs it (test cert, ALPN "mqproxy-tcp/1", BBR/MinRtt); `h3`
-/// registers the H3 ctx.
+/// A real transport with optional raw ALPN `h3` enabled.
 pub fn transport(role: Role, h3: bool) -> Transport {
-    transport_on(role, h3, H3Backend::XqcH3)
-}
-
-/// `transport(role, true)` on `h3_backend: Raw`: H3 conns get raw streams and no H3 stack
-/// (adoption spec §3).
-pub fn raw_h3_transport(role: Role) -> Transport {
-    transport_on(role, true, H3Backend::Raw)
-}
-
-/// Which H3 stack serves one endpoint (adoption spec §6.2).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Backend {
-    /// xquic's xqc_h3, behind a passthrough `H3Wire`.
-    XqcH3,
-    /// h3wire, in an active `H3Wire` over `h3_backend: Raw`.
-    Wire,
-    /// No H3 stack: a passthrough `H3Wire` over `h3_backend: Raw`, for a `RawH3Peer` side.
-    Raw,
-}
-
-/// The differential matrix (adoption spec §6.2): `matrix!(name, |cells: (Backend, Backend),
-/// tag: &str| body)` runs `body` once per (client, server) backend cell, as the tests
-/// `name::{xx, xw, wx, ww}`; `tag` is the cell's name.
-#[macro_export]
-macro_rules! matrix {
-    ($name:ident, |$cells:ident: (Backend, Backend), $tag:ident: &str| $body:block $(,)?) => {
-        mod $name {
-            use super::*;
-            use $crate::loopback::Backend::{Wire, XqcH3};
-
-            fn body($cells: ($crate::loopback::Backend, $crate::loopback::Backend), $tag: &str)
-                $body
-
-            #[test]
-            fn xx() {
-                body((XqcH3, XqcH3), "xx")
-            }
-            #[test]
-            fn xw() {
-                body((XqcH3, Wire), "xw")
-            }
-            #[test]
-            fn wx() {
-                body((Wire, XqcH3), "wx")
-            }
-            #[test]
-            fn ww() {
-                body((Wire, Wire), "ww")
-            }
-        }
-    };
-}
-
-/// Malformed input against each receiver (adoption spec §6.2): `receivers!(name, |b: Backend,
-/// tag: &str| body)` runs `body` as the tests `name::{x, w}`, with `b` the receiving side's
-/// backend (`XqcH3`, `Wire`) and `tag` the cell's name; a `RawH3Peer` is the other side.
-#[macro_export]
-macro_rules! receivers {
-    ($name:ident, |$b:ident: Backend, $tag:ident: &str| $body:block $(,)?) => {
-        mod $name {
-            use super::*;
-
-            fn body($b: $crate::loopback::Backend, $tag: &str) $body
-
-            #[test]
-            fn x() {
-                body($crate::loopback::Backend::XqcH3, "x")
-            }
-            #[test]
-            fn w() {
-                body($crate::loopback::Backend::Wire, "w")
-            }
-        }
-    };
-}
-
-/// An H3 transport on backend `b` (adoption spec §6.2).
-pub fn h3_transport(role: Role, b: Backend) -> H3Wire<Transport> {
-    match b {
-        Backend::XqcH3 => H3Wire::passthrough(transport(role, true)),
-        Backend::Wire => H3Wire::new(raw_h3_transport(role)),
-        Backend::Raw => H3Wire::passthrough(raw_h3_transport(role)),
-    }
-}
-
-fn transport_on(role: Role, h3: bool, h3_backend: H3Backend) -> Transport {
     Transport::new(TransportConfig {
         role,
         alpn: "mqproxy-tcp/1",
@@ -265,12 +176,21 @@ fn transport_on(role: Role, h3: bool, h3_backend: H3Backend) -> Transport {
         cc: CongestionControl::Bbr,
         realtime_offset_us: 0,
         h3,
-        h3_backend,
         qlog: None,
     })
     .expect("transport")
 }
 
+/// A raw transport for a peer that writes HTTP/3 bytes directly.
+pub fn raw_h3_transport(role: Role) -> Transport {
+    transport(role, true)
+}
+
+/// HTTP/3 over the raw transport.
+pub fn h3_transport(role: Role) -> H3Wire<Transport> {
+    H3Wire::new(raw_h3_transport(role))
+}
+
 /// `tests/certs/<name>`.
 pub fn cert(name: &str) -> PathBuf {
     PathBuf::from(concat!(env!("CARGO_MANIFEST_DIR"), "/../../tests/certs")).join(name)
@@ -322,24 +242,11 @@ impl LoopbackProxy {
         self.client.listen_addrs[1]
     }
 
-    /// The gateway pair (spec §5, §6): the fetch client against `Server::with_gateway`, H3
-    /// on both transports. The FETCH listener is the client's only listener (no TCP ingress,
-    /// so no raw tunnel); `origin_ca` is the bridge's only trust root. A `None` gateway in
-    /// either config is filled with a placeholder / `GatewayConfig::default()`.
+    /// The fetch client against the production gateway over HTTP/3.
     pub fn spawn_gateway(
-        client: ClientConfig,
-        server: ServerConfig,
-        origin_ca: &Path,
-    ) -> LoopbackProxy {
-        Self::spawn_gateway_on(client, server, origin_ca, (Backend::XqcH3, Backend::XqcH3))
-    }
-
-    /// `spawn_gateway` with the (client, server) H3 backends (adoption spec §6.2).
-    pub fn spawn_gateway_on(
         client: ClientConfig,
         mut server: ServerConfig,
         origin_ca: &Path,
-        backends: (Backend, Backend),
     ) -> LoopbackProxy {
         server.gateway.get_or_insert_with(GatewayConfig::default);
         let tls = build_client_config(Some(origin_ca), &Vec::new).expect("origin CA");
@@ -350,33 +257,24 @@ impl LoopbackProxy {
             app: Server::with_gateway(server, tls),
             n: n2,
         };
-        let mut p = Self::gateway_pair(client, app, backends);
+        let mut p = Self::gateway_pair(client, app, || h3_transport(server_role()));
         p.server_h3_requests = n;
         p
     }
 
-    /// The fetch client of `spawn_gateway` against an arbitrary H3 server `App` (a
-    /// malformed peer).
-    pub fn spawn_gateway_against<A: App + Send + 'static>(
-        client: ClientConfig,
-        server_app: A,
-    ) -> LoopbackProxy {
-        Self::spawn_gateway_against_on(client, server_app, (Backend::XqcH3, Backend::XqcH3))
-    }
-
-    /// `spawn_gateway_against` with the (client, server) H3 backends (adoption spec §6.2).
-    pub fn spawn_gateway_against_on<A: App + Send + 'static>(
+    /// The fetch client against a supplied server app and transport.
+    pub fn spawn_gateway_against<A: App + Send + 'static, T: TransportOps + 'static>(
         client: ClientConfig,
         server_app: A,
-        backends: (Backend, Backend),
+        transport: impl FnOnce() -> T + Send + 'static,
     ) -> LoopbackProxy {
-        Self::gateway_pair(client, move || server_app, backends)
+        Self::gateway_pair(client, move || server_app, transport)
     }
 
-    fn gateway_pair<A: App + 'static>(
+    fn gateway_pair<A: App + 'static, T: TransportOps + 'static>(
         mut client: ClientConfig,
         server_app: impl FnOnce() -> A + Send + 'static,
-        (client_b, server_b): (Backend, Backend),
+        transport: impl FnOnce() -> T + Send + 'static,
     ) -> LoopbackProxy {
         // The bound address is what `fetch_addr` reports; `Client::new` only needs `Some`.
         client
@@ -388,18 +286,12 @@ impl LoopbackProxy {
             (lo, lo),
             vec![(ListenKind::Plain, FETCH)],
             move |local| {
-                let t = h3_transport(
-                    Role::Server {
-                        cert: cert("test.crt"),
-                        key: cert("test.key"),
-                    },
-                    server_b,
-                );
+                let t = transport();
                 (Shard::new(t, server_app(), local, 1), ())
             },
             move |local, server_udp| {
                 client.server = server_udp;
-                let t = h3_transport(Role::Client, client_b);
+                let t = h3_transport(Role::Client);
                 (Shard::new(t, Client::new(client), local, 2), ())
             },
         )
@@ -409,42 +301,23 @@ impl LoopbackProxy {
         self.client.listen_addrs[0]
     }
 
-    /// The MITM pair (SP4 spec §7, §11.3): `client.mitm = mitm` on one `TRANSPARENT`
-    /// listener whose accepts all carry `fixed_dst` as their original destination (R3),
-    /// against `Server::with_gateway` (`origin_ca` its only trust root); H3 on both
-    /// transports. The client keeps its raw tunnel for the opaque relay.
+    /// A transparent MITM client against the production gateway, with server respawn support.
     pub fn spawn_mitm(
-        client: ClientConfig,
-        server: ServerConfig,
-        origin_ca: &Path,
-        mitm: MitmConfig,
-        fixed_dst: SocketAddr,
-    ) -> LoopbackProxy {
-        let cells = (Backend::XqcH3, Backend::XqcH3);
-        Self::spawn_mitm_on(client, server, origin_ca, mitm, fixed_dst, cells)
-    }
-
-    /// `spawn_mitm` with the (client, server) H3 backends (adoption spec §6.2).
-    pub fn spawn_mitm_on(
         mut client: ClientConfig,
         mut server: ServerConfig,
         origin_ca: &Path,
         mitm: MitmConfig,
         fixed_dst: SocketAddr,
-        (client_b, server_b): (Backend, Backend),
     ) -> LoopbackProxy {
         server.gateway.get_or_insert_with(GatewayConfig::default);
         let tls = build_client_config(Some(origin_ca), &Vec::new).expect("origin CA");
         let respawn = move |udp: SocketAddr| {
             let (server, tls) = (server.clone(), tls.clone());
             DriverThread::spawn_on_addr(udp, driver_config(), Vec::new(), move |local| {
-                let t = h3_transport(
-                    Role::Server {
-                        cert: cert("test.crt"),
-                        key: cert("test.key"),
-                    },
-                    server_b,
-                );
+                let t = h3_transport(Role::Server {
+                    cert: cert("test.crt"),
+                    key: cert("test.key"),
+                });
                 let app = Server::with_gateway(server, tls);
                 (Shard::new(t, app, local, 1), ())
             })
@@ -457,7 +330,7 @@ impl LoopbackProxy {
             vec![(ListenKind::Fixed(fixed_dst), TRANSPARENT)],
             move |local, server_udp| {
                 client.server = server_udp;
-                let t = h3_transport(Role::Client, client_b);
+                let t = h3_transport(Role::Client);
                 (Shard::new(t, Client::new(client), local, 2), ())
             },
         );
@@ -481,3 +354,11 @@ impl LoopbackProxy {
         self.server.start();
     }
 }
+
+/// The loopback test certificate and key.
+pub fn server_role() -> Role {
+    Role::Server {
+        cert: cert("test.crt"),
+        key: cert("test.key"),
+    }
+}
diff --git a/crates/mq-integration/src/raw_h3.rs b/crates/mq-integration/src/raw_h3.rs
index c125dfe8..3be31331 100644
--- a/crates/mq-integration/src/raw_h3.rs
+++ b/crates/mq-integration/src/raw_h3.rs
@@ -45,7 +45,7 @@ pub struct RawH3Script {
 }
 
 /// A peer that speaks HTTP/3 by writing fixed bytes on raw streams (spec §6.2): no H3 stack,
-/// so it can send what no compliant stack sends. Runs on `Transport` with `h3_backend: Raw`
+/// so it can send what no compliant stack sends. Runs on the raw `Transport` with ALPN `h3` enabled
 /// (`loopback::raw_h3_transport`).
 pub struct RawH3Peer {
     /// Client role: the server to connect to.
diff --git a/crates/mq-integration/src/shard_pair.rs b/crates/mq-integration/src/shard_pair.rs
index 794979ef..ba5dc464 100644
--- a/crates/mq-integration/src/shard_pair.rs
+++ b/crates/mq-integration/src/shard_pair.rs
@@ -75,7 +75,6 @@ pub fn transport_cfg(role: Role, max_conns: u32) -> TransportConfig {
         cc: CongestionControl::Bbr,
         realtime_offset_us: 0,
         h3: false,
-        h3_backend: mq_transport_api::H3Backend::XqcH3,
         qlog: None,
     }
 }
diff --git a/crates/mq-integration/tests/loop_engine_boot.rs b/crates/mq-integration/tests/loop_engine_boot.rs
index e97c412e..1196f7cb 100644
--- a/crates/mq-integration/tests/loop_engine_boot.rs
+++ b/crates/mq-integration/tests/loop_engine_boot.rs
@@ -26,7 +26,6 @@ fn cfg(role: Role) -> TransportConfig {
         cc: CongestionControl::Bbr,
         realtime_offset_us: 0,
         h3: false,
-        h3_backend: mq_transport_api::H3Backend::XqcH3,
         qlog: None,
     }
 }
diff --git a/crates/mq-integration/tests/pair_gateway.rs b/crates/mq-integration/tests/pair_gateway.rs
index ae450b80..4dd7158f 100644
--- a/crates/mq-integration/tests/pair_gateway.rs
+++ b/crates/mq-integration/tests/pair_gateway.rs
@@ -7,17 +7,14 @@
 use mq_integration::driver_harness::DriverThread;
 use mq_integration::h3_apps::{EchoMode, H3Client, H3EchoServer, H3Handle, H3Recorded, H3Script};
 use mq_integration::log_tap;
-use mq_integration::loopback::{Backend, LoopbackProxy, h3_transport};
+use mq_integration::loopback::{LoopbackProxy, h3_transport, raw_h3_transport, server_role};
 use mq_integration::origin_server::{Handler, ORIGIN_CA, OriginServer, OriginServerMode, Proto};
-use mq_integration::raw_h3::{
-    RawH3Handle, RawH3Peer, RawH3Script, data_frame, field, headers_frame,
-};
-use mq_integration::{matrix, receivers};
+use mq_integration::raw_h3::{RawH3Handle, RawH3Peer, RawH3Script, data_frame, headers_frame};
 use mq_proxy::config::{ClientConfig, GatewayConfig, ServerConfig};
 use mq_proxy::server::origin::host::upload_byte;
 use mq_runtime::driver::{DriverConfig, StdResolver};
 use mq_runtime::{App, Shard};
-use mq_transport_api::{CloseReason, ErrType, Role};
+use mq_transport_api::{CloseReason, ErrType, Role, TransportOps};
 use std::io::{self, Read, Write};
 use std::net::{Ipv4Addr, SocketAddr, TcpListener, TcpStream};
 use std::path::Path;
@@ -41,15 +38,15 @@ fn server_cfg() -> ServerConfig {
     }
 }
 
-/// The gateway pair on the (client, server) backends `cells` (adoption spec §6.2).
-fn gateway_with(server: ServerConfig, cells: (Backend, Backend)) -> LoopbackProxy {
+/// The gateway pair over HTTP/3.
+fn gateway_with(server: ServerConfig) -> LoopbackProxy {
     log_tap::install();
     let client = ClientConfig::default();
-    LoopbackProxy::spawn_gateway_on(client, server, Path::new(ORIGIN_CA), cells)
+    LoopbackProxy::spawn_gateway(client, server, Path::new(ORIGIN_CA))
 }
 
-fn gateway(cells: (Backend, Backend)) -> LoopbackProxy {
-    gateway_with(server_cfg(), cells)
+fn gateway() -> LoopbackProxy {
+    gateway_with(server_cfg())
 }
 
 /// Polls `cond` every 5 ms until it holds (at most `T`).
@@ -120,11 +117,6 @@ fn req_line(path: &str) -> String {
     wait_log(&["mq.req", &format!("path=\"{path}\"")])
 }
 
-/// The cell's index (xx 0, xw 1, wx 2, ww 3), for a marker unique to the cell.
-fn cell_index((c, s): (Backend, Backend)) -> usize {
-    2 * usize::from(c == Backend::Wire) + usize::from(s == Backend::Wire)
-}
-
 // ---- the local fetch caller ----
 
 /// Sends `POST /_mqproxy/fetch` with `headers` and `body` (written on its own thread, so a
@@ -258,10 +250,9 @@ fn pattern(len: usize) -> Vec<u8> {
 
 // ---- direct H3 ----
 
-/// The client app `make()` builds, on its own driver on backend `b`.
-fn client_on<A: App + 'static, H: Send + 'static>(
-    b: Backend,
-    make: impl FnOnce() -> (A, H) + Send + 'static,
+/// The app and transport `make()` builds, on their own driver.
+fn client_on<A: App + 'static, H: Send + 'static, T: TransportOps + 'static>(
+    make: impl FnOnce() -> (T, A, H) + Send + 'static,
 ) -> DriverThread<H> {
     let cfg = DriverConfig {
         resolver: Arc::new(StdResolver),
@@ -270,22 +261,26 @@ fn client_on<A: App + 'static, H: Send + 'static>(
     };
     let lo = Ipv4Addr::LOCALHOST.into();
     let mut d = DriverThread::spawn_on(lo, cfg, Vec::new(), move |local| {
-        let (app, h) = make();
-        (Shard::new(h3_transport(Role::Client, b), app, local, 3), h)
+        let (t, app, h) = make();
+        (Shard::new(t, app, local, 3), h)
     });
     d.start();
     d
 }
 
-/// An `H3Client` on backend `b` against the gateway server.
-fn h3_client(server: SocketAddr, s: H3Script, b: Backend) -> DriverThread<H3Handle> {
-    client_on(b, move || H3Client::new(server, s))
+/// An `H3Client` against the gateway server.
+fn h3_client(server: SocketAddr, s: H3Script) -> DriverThread<H3Handle> {
+    client_on(move || {
+        let (app, h) = H3Client::new(server, s);
+        (h3_transport(Role::Client), app, h)
+    })
 }
 
 /// A `RawH3Peer` client writing `stream` + FIN to the gateway server.
 fn raw_client(server: SocketAddr, stream: Vec<u8>) -> DriverThread<RawH3Handle> {
-    client_on(Backend::Raw, move || {
-        RawH3Peer::client(server, RawH3Script { stream, fin: true })
+    client_on(move || {
+        let (app, h) = RawH3Peer::client(server, RawH3Script { stream, fin: true });
+        (raw_h3_transport(Role::Client), app, h)
     })
 }
 
@@ -312,11 +307,7 @@ fn script(
     .chain(extra)
     .map(|(n, v)| ((*n).into(), (*v).into()))
     .collect();
-    H3Script {
-        headers,
-        body,
-        ..H3Script::default()
-    }
+    H3Script { headers, body }
 }
 
 fn bearer() -> String {
@@ -474,88 +465,87 @@ fn capture_one(mut tcp: TcpStream) -> Seen {
 // ---- fetch API end to end ----
 
 // spec §5.4, §6.4, §10.3: an 8 MiB download with `content-length` over an h2 TLS origin.
-matrix!(
-    fetch_download_8mib_cl,
-    |cells: (Backend, Backend), tag: &str| {
-        let len = 8 * MIB;
-        let o = OriginServer::spawn(OriginServerMode::new(
-            Proto::H2Tls,
-            Handler::FileBytes(len as u64),
-        ));
-        let p = gateway(cells);
-        wait_up(&p, tag);
-        let url = format!("https://127.0.0.1:{}/dl-{tag}", o.addr.port());
-        let r = parse(&fetch(&p, &url, &[], b"").expect("download"));
-        let want = [
-            ("x-mq-origin-protocol", "h2"),
-            ("date", "T"),
-            ("content-length", "8388608"),
-            ("connection", "close"),
-        ];
-        assert_headers(&r.headers, &want);
-        assert_eq!(r.status, 200);
-        assert_eq!(r.header("content-length"), Some("8388608"));
-        assert!(
-            r.body == pattern(len),
-            "body differs ({} bytes)",
-            r.body.len()
-        );
-        let path = format!("/dl-{tag}");
-        let a = format!("127.0.0.1:{}", o.addr.port());
-        let want = format!(
-            "sid=4 method=GET status=200 authority=\"{a}\" path=\"{path}\" req_bytes=0 resp_bytes=8388608 ttfb_ms=T duration_ms=T origin_protocol=h2 origin_tls=ok content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\""
-        );
-        assert_req(&req_line(&path), &want);
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn fetch_download_8mib_cl() {
+    let tag = "ww";
+    let len = 8 * MIB;
+    let o = OriginServer::spawn(OriginServerMode::new(
+        Proto::H2Tls,
+        Handler::FileBytes(len as u64),
+    ));
+    let p = gateway();
+    wait_up(&p, tag);
+    let url = format!("https://127.0.0.1:{}/dl-{tag}", o.addr.port());
+    let r = parse(&fetch(&p, &url, &[], b"").expect("download"));
+    let want = [
+        ("x-mq-origin-protocol", "h2"),
+        ("date", "T"),
+        ("content-length", "8388608"),
+        ("connection", "close"),
+    ];
+    assert_headers(&r.headers, &want);
+    assert_eq!(r.status, 200);
+    assert_eq!(r.header("content-length"), Some("8388608"));
+    assert!(
+        r.body == pattern(len),
+        "body differs ({} bytes)",
+        r.body.len()
+    );
+    let path = format!("/dl-{tag}");
+    let a = format!("127.0.0.1:{}", o.addr.port());
+    let want = format!(
+        "sid=4 method=GET status=200 authority=\"{a}\" path=\"{path}\" req_bytes=0 resp_bytes=8388608 ttfb_ms=T duration_ms=T origin_protocol=h2 origin_tls=ok content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\""
+    );
+    assert_req(&req_line(&path), &want);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // spec §5.3, §6.3, §10.3: an 8 MiB `PUT` upload, streamed back by an h1 echo origin.
-matrix!(
-    fetch_upload_8mib_put,
-    |cells: (Backend, Backend), tag: &str| {
-        let o = OriginServer::spawn(OriginServerMode::new(Proto::H1Plain, Handler::Echo));
-        let p = gateway(cells);
-        wait_up(&p, tag);
-        let body = pattern(8 * MIB);
-        let url = format!("http://{}/up-{tag}", o.addr);
-        let r = parse(&fetch(&p, &url, &[("X-Mq-Method", "PUT")], &body).expect("upload"));
-        let want = [
-            ("x-mq-origin-protocol", "http/1.1"),
-            ("content-length", "8388608"),
-            ("date", "T"),
-            ("connection", "close"),
-        ];
-        assert_headers(&r.headers, &want);
-        assert_eq!(r.status, 200);
-        assert_eq!(r.header("content-length"), Some("8388608"));
-        assert!(r.body == body, "echo differs ({} bytes)", r.body.len());
-        let path = format!("/up-{tag}");
-        let want = format!(
-            "sid=4 method=PUT status=200 authority=\"{}\" path=\"{path}\" req_bytes=8388608 resp_bytes=8388608 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
-            o.addr
-        );
-        assert_req(&req_line(&path), &want);
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn fetch_upload_8mib_put() {
+    let tag = "ww";
+    let o = OriginServer::spawn(OriginServerMode::new(Proto::H1Plain, Handler::Echo));
+    let p = gateway();
+    wait_up(&p, tag);
+    let body = pattern(8 * MIB);
+    let url = format!("http://{}/up-{tag}", o.addr);
+    let r = parse(&fetch(&p, &url, &[("X-Mq-Method", "PUT")], &body).expect("upload"));
+    let want = [
+        ("x-mq-origin-protocol", "http/1.1"),
+        ("content-length", "8388608"),
+        ("date", "T"),
+        ("connection", "close"),
+    ];
+    assert_headers(&r.headers, &want);
+    assert_eq!(r.status, 200);
+    assert_eq!(r.header("content-length"), Some("8388608"));
+    assert!(r.body == body, "echo differs ({} bytes)", r.body.len());
+    let path = format!("/up-{tag}");
+    let want = format!(
+        "sid=4 method=PUT status=200 authority=\"{}\" path=\"{path}\" req_bytes=8388608 resp_bytes=8388608 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
+        o.addr
+    );
+    assert_req(&req_line(&path), &want);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // spec §5.4, §5.5, §10.3: `content-length: 100` over a complete 50-byte DATA frame + FIN
-// from a peer: the local socket is aborted. On an xqc_h3 client its own body check does it; a
-// `Wire` client's h3wire finds the malformed response (RFC 9114 §4.1.2) and aborts the
+// from a peer: the local socket is aborted. h3wire finds the malformed response
+// (RFC 9114 §4.1.2) and aborts the
 // stream, which reaches the client as `Err(Reset)`.
-matrix!(
-    fetch_short_cl_response_aborts_client,
-    |cells: (Backend, Backend), tag: &str| {
-        let (app, h) = H3EchoServer::new(EchoMode::ShortCl { cl: 100, sent: 50 });
-        let p = LoopbackProxy::spawn_gateway_against_on(ClientConfig::default(), app, cells);
-        let target = format!("http://x/short-{tag}");
-        let r = fetch_when_up(p.fetch_addr(), &auth(&target, "any"));
-        assert!(is_reset(&r), "{r:?}");
-        assert!(h.lock().requests >= 1);
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn fetch_short_cl_response_aborts_client() {
+    let tag = "ww";
+    let (app, h) = H3EchoServer::new(EchoMode::ShortCl { cl: 100, sent: 50 });
+    let p = LoopbackProxy::spawn_gateway_against(ClientConfig::default(), app, || {
+        h3_transport(server_role())
+    });
+    let target = format!("http://x/short-{tag}");
+    let r = fetch_when_up(p.fetch_addr(), &auth(&target, "any"));
+    assert!(is_reset(&r), "{r:?}");
+    assert!(h.lock().requests >= 1);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 /// The declared length of a cut DATA frame, and what the raw peer sends of it.
 const CUT_DECLARED: u64 = 32 << 20;
@@ -574,487 +564,442 @@ const EXCESSIVE_LOAD: CloseReason = CloseReason {
 };
 
 // spec §3.7 (3), §5.4, Review Focus 5: the response's DATA frame is cut by FIN inside its
-// declared length; the local fetch socket is reset in both cells. An xqc_h3 client reads the
-// cut as a clean EOF and its body check (or the `H3Closed.unread` path) resets; h3wire closes
+// declared length; the local fetch socket is reset. h3wire closes
 // the connection with `H3_FRAME_ERROR` (adoption spec §5.3 (1)).
-receivers!(
-    fetch_response_cut_inside_frame_aborts,
-    |b: Backend, tag: &str| {
-        let cl = CUT_DECLARED.to_string();
-        let mut stream = headers_frame(&[(b":status", b"200"), (b"content-length", cl.as_bytes())]);
-        stream.extend(data_frame(CUT_DECLARED, &[0; CUT_SENT]));
-        let (app, h) = RawH3Peer::server(RawH3Script { stream, fin: true });
-        let p = LoopbackProxy::spawn_gateway_against_on(
-            ClientConfig::default(),
-            app,
-            (b, Backend::Raw),
-        );
-        let target = format!("http://x/cut-{tag}");
-        let r = fetch_when_up(p.fetch_addr(), &auth(&target, "any"));
-        assert!(is_reset(&r), "{:?}", r.as_ref().map(|b| b.len()));
-        if b == Backend::Wire {
-            wait_until("the peer's ConnClosed", || !h.lock().closed.is_empty());
-            assert_eq!(h.lock().closed, [FRAME_ERROR]);
-        }
-        assert_eq!(p.join_both(), (0, 0));
+#[test]
+fn fetch_response_cut_inside_frame_aborts() {
+    let tag = "w";
+    let cl = CUT_DECLARED.to_string();
+    let mut stream = headers_frame(&[(b":status", b"200"), (b"content-length", cl.as_bytes())]);
+    stream.extend(data_frame(CUT_DECLARED, &[0; CUT_SENT]));
+    let (app, h) = RawH3Peer::server(RawH3Script { stream, fin: true });
+    let p = LoopbackProxy::spawn_gateway_against(ClientConfig::default(), app, || {
+        raw_h3_transport(server_role())
+    });
+    let target = format!("http://x/cut-{tag}");
+    let r = fetch_when_up(p.fetch_addr(), &auth(&target, "any"));
+    assert!(is_reset(&r), "{:?}", r.as_ref().map(|b| b.len()));
+    {
+        wait_until("the peer's ConnClosed", || !h.lock().closed.is_empty());
+        assert_eq!(h.lock().closed, [FRAME_ERROR]);
     }
-);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
-/// adoption spec §6.2: a `RawH3Peer::server` hosts the server side of the gateway pair
-/// (`Backend::Raw`); its fixed 200 reaches the fetch socket through each client backend.
+/// A `RawH3Peer::server` hosts the gateway pair's server side; its fixed 200 reaches
+/// the fetch socket through H3Wire.
 #[test]
 fn raw_server_smoke() {
-    for b in [Backend::XqcH3, Backend::Wire] {
-        let mut stream = headers_frame(&[(b":status", b"200"), (b"content-length", b"2")]);
-        stream.extend(data_frame(2, b"ok"));
-        let (app, h) = RawH3Peer::server(RawH3Script { stream, fin: true });
-        let p = LoopbackProxy::spawn_gateway_against_on(
-            ClientConfig::default(),
-            app,
-            (b, Backend::Raw),
-        );
-        let r = fetch_when_up(p.fetch_addr(), &auth("http://x/raw", "any"));
-        let r = parse(&r.unwrap_or_else(|e| panic!("{b:?}: {e}")));
-        assert_eq!((r.status, r.body.as_slice()), (200, &b"ok"[..]), "{b:?}");
-        assert!(
-            !h.lock().read.is_empty(),
-            "{b:?}: the peer read the request"
-        );
-        assert_eq!(p.join_both(), (0, 0), "{b:?}");
-    }
+    let mut stream = headers_frame(&[(b":status", b"200"), (b"content-length", b"2")]);
+    stream.extend(data_frame(2, b"ok"));
+    let (app, h) = RawH3Peer::server(RawH3Script { stream, fin: true });
+    let p = LoopbackProxy::spawn_gateway_against(ClientConfig::default(), app, || {
+        raw_h3_transport(server_role())
+    });
+    let r = fetch_when_up(p.fetch_addr(), &auth("http://x/raw", "any"));
+    let r = parse(&r.unwrap_or_else(|e| panic!("{e}")));
+    assert_eq!((r.status, r.body.as_slice()), (200, &b"ok"[..]));
+    assert!(!h.lock().read.is_empty(), "the peer read the request");
+    assert_eq!(p.join_both(), (0, 0));
 }
 
 // spec §5.4, §6.4, §10.3: a HEAD response and a 304, each carrying `content-length`,
 // finish cleanly (the HEAD reply's length is rewritten to 0, §12).
-matrix!(
-    head_and_304_with_cl_finish_cleanly,
-    |cells: (Backend, Backend), tag: &str| {
-        let raw = |reply: &[u8]| {
-            let proto = Proto::RawH1 {
-                tls: false,
-                reply: reply.to_vec(),
-            };
-            OriginServer::spawn(OriginServerMode::new(proto, Handler::Echo))
-        };
-        let head = raw(b"HTTP/1.1 200 OK\r\ncontent-length: 100\r\n\r\n");
-        let nm = raw(b"HTTP/1.1 304 Not Modified\r\ncontent-length: 100\r\n\r\n");
-        let p = gateway(cells);
-        wait_up(&p, tag);
-        let r = fetch(
-            &p,
-            &format!("http://{}/h-{tag}", head.addr),
-            &[("X-Mq-Method", "HEAD")],
-            b"",
-        );
-        let r = parse(&r.expect("HEAD finishes cleanly"));
-        let want = [
-            ("x-mq-origin-protocol", "http/1.1"),
-            ("content-length", "0"),
-            ("connection", "close"),
-        ];
-        assert_headers(&r.headers, &want);
-        assert_eq!((r.status, r.header("content-length")), (200, Some("0")));
-        assert!(r.body.is_empty());
-        let r = parse(
-            &fetch(&p, &format!("http://{}/n-{tag}", nm.addr), &[], b"")
-                .expect("304 finishes cleanly"),
-        );
-        assert_eq!((r.status, r.header("content-length")), (304, Some("100")));
-        let want = [
-            ("x-mq-origin-protocol", "http/1.1"),
-            ("content-length", "100"),
-            ("connection", "close"),
-        ];
-        assert_headers(&r.headers, &want);
-        assert!(r.body.is_empty());
-        for (sid, method, status, addr, path) in [
-            (4, "HEAD", 200, head.addr, format!("/h-{tag}")),
-            (8, "GET", 304, nm.addr, format!("/n-{tag}")),
-        ] {
-            let want = format!(
-                "sid={sid} method={method} status={status} authority=\"{addr}\" path=\"{path}\" req_bytes=0 resp_bytes=0 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\""
-            );
-            assert_req(&req_line(&path), &want);
-        }
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
-
-// SP4 spec §5: an origin answering with about 30 KiB of headers (five 6 KiB values, under
-// `SECTION_MAX`) is relayed to the local caller; the fetch request itself stays small.
-matrix!(
-    fetch_30k_response_head_relayed,
-    |cells: (Backend, Backend), tag: &str| {
-        let value = "v".repeat(6 * 1024);
-        let mut reply = String::from("HTTP/1.1 200 OK\r\ncontent-length: 2\r\n");
-        for i in 0..5 {
-            reply += &format!("x-big-{i}: {value}\r\n");
-        }
-        reply += "\r\nok";
+#[test]
+fn head_and_304_with_cl_finish_cleanly() {
+    let tag = "ww";
+    let raw = |reply: &[u8]| {
         let proto = Proto::RawH1 {
             tls: false,
-            reply: reply.into_bytes(),
+            reply: reply.to_vec(),
         };
-        let origin = OriginServer::spawn(OriginServerMode::new(proto, Handler::Echo));
-        let p = gateway(cells);
-        wait_up(&p, tag);
-        let raw = fetch(&p, &format!("http://{}/big-{tag}", origin.addr), &[], b"");
-        let r = parse(&raw.expect("fetch"));
-        let names: Vec<String> = (0..5).map(|i| format!("x-big-{i}")).collect();
-        let mut want = vec![
-            ("x-mq-origin-protocol", "http/1.1"),
-            ("content-length", "2"),
-        ];
-        want.extend(names.iter().map(|n| (n.as_str(), value.as_str())));
-        want.push(("connection", "close"));
-        assert_headers(&r.headers, &want);
-        assert_eq!((r.status, r.body.as_slice()), (200, &b"ok"[..]));
-        for i in 0..5 {
-            assert_eq!(r.header(&format!("x-big-{i}")), Some(value.as_str()), "{i}");
-        }
-        let path = format!("/big-{tag}");
+        OriginServer::spawn(OriginServerMode::new(proto, Handler::Echo))
+    };
+    let head = raw(b"HTTP/1.1 200 OK\r\ncontent-length: 100\r\n\r\n");
+    let nm = raw(b"HTTP/1.1 304 Not Modified\r\ncontent-length: 100\r\n\r\n");
+    let p = gateway();
+    wait_up(&p, tag);
+    let r = fetch(
+        &p,
+        &format!("http://{}/h-{tag}", head.addr),
+        &[("X-Mq-Method", "HEAD")],
+        b"",
+    );
+    let r = parse(&r.expect("HEAD finishes cleanly"));
+    let want = [
+        ("x-mq-origin-protocol", "http/1.1"),
+        ("content-length", "0"),
+        ("connection", "close"),
+    ];
+    assert_headers(&r.headers, &want);
+    assert_eq!((r.status, r.header("content-length")), (200, Some("0")));
+    assert!(r.body.is_empty());
+    let r = parse(
+        &fetch(&p, &format!("http://{}/n-{tag}", nm.addr), &[], b"").expect("304 finishes cleanly"),
+    );
+    assert_eq!((r.status, r.header("content-length")), (304, Some("100")));
+    let want = [
+        ("x-mq-origin-protocol", "http/1.1"),
+        ("content-length", "100"),
+        ("connection", "close"),
+    ];
+    assert_headers(&r.headers, &want);
+    assert!(r.body.is_empty());
+    for (sid, method, status, addr, path) in [
+        (4, "HEAD", 200, head.addr, format!("/h-{tag}")),
+        (8, "GET", 304, nm.addr, format!("/n-{tag}")),
+    ] {
         let want = format!(
-            "sid=4 method=GET status=200 authority=\"{}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
-            origin.addr
+            "sid={sid} method={method} status={status} authority=\"{addr}\" path=\"{path}\" req_bytes=0 resp_bytes=0 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\""
         );
         assert_req(&req_line(&path), &want);
-        assert_eq!(p.join_both(), (0, 0));
     }
-);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
-// spec §7.4, §10.3: `/a/../b` reaches the origin as `/b` (the query untouched).
-matrix!(
-    dot_segments_normalised_at_origin,
-    |cells: (Backend, Backend), tag: &str| {
-        let o = Capture::spawn();
-        let p = gateway(cells);
-        wait_up(&p, tag);
-        let url = o.url(&format!("/a/../b-{tag}?q=/../x"));
-        let r = parse(&fetch(&p, &url, &[], b"").expect("fetch"));
-        let want = [
-            ("x-mq-origin-protocol", "http/1.1"),
-            ("content-length", "2"),
-            ("connection", "close"),
-        ];
-        assert_headers(&r.headers, &want);
-        assert_eq!((r.status, r.body.as_slice()), (200, &b"ok"[..]));
-        let head = o.one().head;
-        let want = format!("get /b-{tag}?q=/../x http/1.1\r\n");
-        assert!(head.starts_with(&want), "{head}");
-        // The line keeps the path as sent, cut at `?`.
-        let path = format!("/a/../b-{tag}");
-        let want = format!(
-            "sid=4 method=GET status=200 authority=\"{}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
-            o.authority()
-        );
-        assert_req(&req_line(&path), &want);
-        assert_eq!(p.join_both(), (0, 0));
+// SP4 spec §5: an origin answering with about 30 KiB of headers (five 6 KiB values, under
+// `SECTION_MAX`) is relayed to the local caller; the fetch request itself stays small.
+#[test]
+fn fetch_30k_response_head_relayed() {
+    let tag = "ww";
+    let value = "v".repeat(6 * 1024);
+    let mut reply = String::from("HTTP/1.1 200 OK\r\ncontent-length: 2\r\n");
+    for i in 0..5 {
+        reply += &format!("x-big-{i}: {value}\r\n");
     }
-);
+    reply += "\r\nok";
+    let proto = Proto::RawH1 {
+        tls: false,
+        reply: reply.into_bytes(),
+    };
+    let origin = OriginServer::spawn(OriginServerMode::new(proto, Handler::Echo));
+    let p = gateway();
+    wait_up(&p, tag);
+    let raw = fetch(&p, &format!("http://{}/big-{tag}", origin.addr), &[], b"");
+    let r = parse(&raw.expect("fetch"));
+    let names: Vec<String> = (0..5).map(|i| format!("x-big-{i}")).collect();
+    let mut want = vec![
+        ("x-mq-origin-protocol", "http/1.1"),
+        ("content-length", "2"),
+    ];
+    want.extend(names.iter().map(|n| (n.as_str(), value.as_str())));
+    want.push(("connection", "close"));
+    assert_headers(&r.headers, &want);
+    assert_eq!((r.status, r.body.as_slice()), (200, &b"ok"[..]));
+    for i in 0..5 {
+        assert_eq!(r.header(&format!("x-big-{i}")), Some(value.as_str()), "{i}");
+    }
+    let path = format!("/big-{tag}");
+    let want = format!(
+        "sid=4 method=GET status=200 authority=\"{}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
+        origin.addr
+    );
+    assert_req(&req_line(&path), &want);
+    assert_eq!(p.join_both(), (0, 0));
+}
+
+// spec §7.4, §10.3: `/a/../b` reaches the origin as `/b` (the query untouched).
+#[test]
+fn dot_segments_normalised_at_origin() {
+    let tag = "ww";
+    let o = Capture::spawn();
+    let p = gateway();
+    wait_up(&p, tag);
+    let url = o.url(&format!("/a/../b-{tag}?q=/../x"));
+    let r = parse(&fetch(&p, &url, &[], b"").expect("fetch"));
+    let want = [
+        ("x-mq-origin-protocol", "http/1.1"),
+        ("content-length", "2"),
+        ("connection", "close"),
+    ];
+    assert_headers(&r.headers, &want);
+    assert_eq!((r.status, r.body.as_slice()), (200, &b"ok"[..]));
+    let head = o.one().head;
+    let want = format!("get /b-{tag}?q=/../x http/1.1\r\n");
+    assert!(head.starts_with(&want), "{head}");
+    // The line keeps the path as sent, cut at `?`.
+    let path = format!("/a/../b-{tag}");
+    let want = format!(
+        "sid=4 method=GET status=200 authority=\"{}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
+        o.authority()
+    );
+    assert_req(&req_line(&path), &want);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §5: an empty forwarded `x-test:` is sent, and an empty `accept:`
 // is sent and suppresses the default `accept: */*`.
-matrix!(
-    empty_header_sent_empty_accept_suppresses_default,
-    |cells: (Backend, Backend), tag: &str| {
-        let o = Capture::spawn();
-        let p = gateway(cells);
-        wait_up(&p, tag);
-        let extra = [("X-Test", ""), ("Accept", ""), ("X-Kept", "yes")];
-        let r = parse(&fetch(&p, &o.url(&format!("/empty-{tag}")), &extra, b"").expect("fetch"));
-        let want = [
-            ("x-mq-origin-protocol", "http/1.1"),
-            ("content-length", "2"),
-            ("connection", "close"),
-        ];
-        assert_headers(&r.headers, &want);
-        assert_eq!(r.status, 200);
-        let head = o.one().head;
-        assert!(head.contains("\r\nx-kept: yes\r\n"), "{head}");
-        assert!(head.contains("\r\nx-test:"), "{head}");
-        assert!(head.contains("\r\naccept:"), "{head}");
-        assert!(!head.contains("*/*"), "{head}");
-        let path = format!("/empty-{tag}");
-        let want = format!(
-            "sid=4 method=GET status=200 authority=\"{}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
-            o.authority()
-        );
-        assert_req(&req_line(&path), &want);
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn empty_header_sent_empty_accept_suppresses_default() {
+    let tag = "ww";
+    let o = Capture::spawn();
+    let p = gateway();
+    wait_up(&p, tag);
+    let extra = [("X-Test", ""), ("Accept", ""), ("X-Kept", "yes")];
+    let r = parse(&fetch(&p, &o.url(&format!("/empty-{tag}")), &extra, b"").expect("fetch"));
+    let want = [
+        ("x-mq-origin-protocol", "http/1.1"),
+        ("content-length", "2"),
+        ("connection", "close"),
+    ];
+    assert_headers(&r.headers, &want);
+    assert_eq!(r.status, 200);
+    let head = o.one().head;
+    assert!(head.contains("\r\nx-kept: yes\r\n"), "{head}");
+    assert!(head.contains("\r\nx-test:"), "{head}");
+    assert!(head.contains("\r\naccept:"), "{head}");
+    assert!(!head.contains("*/*"), "{head}");
+    let path = format!("/empty-{tag}");
+    let want = format!(
+        "sid=4 method=GET status=200 authority=\"{}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
+        o.authority()
+    );
+    assert_req(&req_line(&path), &want);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // spec §7.2, §7.7, §10.3 (e2e case 13): an h1-forced request reuses the idle h1 conn a
 // default request left in the pool — against an origin that serves one conn at a time, a
 // second dial would hang until `curl:28`.
-matrix!(
-    h1_forced_reuses_idle_default_conn,
-    |cells: (Backend, Backend), tag: &str| {
-        let mode = OriginServerMode {
-            single_conn: true,
-            ..OriginServerMode::new(Proto::H1Tls, Handler::FileBytes(2))
-        };
-        let o = OriginServer::spawn(mode);
-        let mut cfg = server_cfg();
-        if let Some(g) = cfg.gateway.as_mut() {
-            g.origin_connect_timeout = Duration::from_secs(2);
-        }
-        let p = gateway_with(cfg, cells);
-        wait_up(&p, tag);
-        let url = format!("https://127.0.0.1:{}/c13-{tag}", o.addr.port());
-        let r = parse(&fetch(&p, &url, &[], b"").expect("default request"));
-        let want = [
-            ("x-mq-origin-protocol", "http/1.1"),
-            ("content-length", "2"),
-            ("date", "T"),
-            ("connection", "close"),
-        ];
-        assert_headers(&r.headers, &want);
-        assert_eq!((r.status, r.body.len()), (200, 2));
-        let r = fetch(&p, &url, &[("X-Mq-Origin-Protocol", "h1")], b"");
-        let r = parse(&r.expect("h1-forced request"));
-        assert_headers(&r.headers, &want);
-        assert_eq!((r.status, r.body.len()), (200, 2));
-        assert_eq!(o.accepted(), 1);
-        let path = format!("/c13-{tag}");
-        let a = format!("127.0.0.1:{}", o.addr.port());
-        // The two lines may close in either order: each is found by its stream id.
-        for (sid, reuse) in [(4, 0), (8, 1)] {
-            let marker = format!("path=\"{path}\"");
-            let line = wait_log(&["mq.req", &format!("sid={sid} "), &marker]);
-            let want = format!(
-                "sid={sid} method=GET status=200 authority=\"{a}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=ok content_encoding=none cache=bypass origin_reuse={reuse} origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\""
-            );
-            assert_req(&line, &want);
-        }
-        assert_eq!(p.join_both(), (0, 0));
+#[test]
+fn h1_forced_reuses_idle_default_conn() {
+    let tag = "ww";
+    let mode = OriginServerMode {
+        single_conn: true,
+        ..OriginServerMode::new(Proto::H1Tls, Handler::FileBytes(2))
+    };
+    let o = OriginServer::spawn(mode);
+    let mut cfg = server_cfg();
+    if let Some(g) = cfg.gateway.as_mut() {
+        g.origin_connect_timeout = Duration::from_secs(2);
     }
-);
+    let p = gateway_with(cfg);
+    wait_up(&p, tag);
+    let url = format!("https://127.0.0.1:{}/c13-{tag}", o.addr.port());
+    let r = parse(&fetch(&p, &url, &[], b"").expect("default request"));
+    let want = [
+        ("x-mq-origin-protocol", "http/1.1"),
+        ("content-length", "2"),
+        ("date", "T"),
+        ("connection", "close"),
+    ];
+    assert_headers(&r.headers, &want);
+    assert_eq!((r.status, r.body.len()), (200, 2));
+    let r = fetch(&p, &url, &[("X-Mq-Origin-Protocol", "h1")], b"");
+    let r = parse(&r.expect("h1-forced request"));
+    assert_headers(&r.headers, &want);
+    assert_eq!((r.status, r.body.len()), (200, 2));
+    assert_eq!(o.accepted(), 1);
+    let path = format!("/c13-{tag}");
+    let a = format!("127.0.0.1:{}", o.addr.port());
+    // The two lines may close in either order: each is found by its stream id.
+    for (sid, reuse) in [(4, 0), (8, 1)] {
+        let marker = format!("path=\"{path}\"");
+        let line = wait_log(&["mq.req", &format!("sid={sid} "), &marker]);
+        let want = format!(
+            "sid={sid} method=GET status=200 authority=\"{a}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=ok content_encoding=none cache=bypass origin_reuse={reuse} origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\""
+        );
+        assert_req(&line, &want);
+    }
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // spec §6.4, §10.3: an h2 origin declares `content-length: 100`, sends 50 bytes and then
 // RST_STREAM(NO_ERROR): the server's body check resets the H3 response (pinned by its
 // `mq.req`). The Rust client's local reply is an abort, or 502 `upstream-reset` when its
 // xquic processes HEADERS and RESET_STREAM in one pass (the reset discards the unread
 // head; `ClTooShort` leaves only 10 ms between them, too little on a slow CI).
-matrix!(
-    h2_cl_100_then_rst_resets_h3_end_to_end,
-    |cells: (Backend, Backend), tag: &str| {
-        let h = Handler::ClTooShort { cl: 100, send: 50 };
-        let o = OriginServer::spawn(OriginServerMode::new(Proto::H2Tls, h));
-        let p = gateway(cells);
-        wait_up(&p, tag);
-        let url = format!("https://127.0.0.1:{}/h2-short-{tag}", o.addr.port());
-        let r = fetch(&p, &url, &[], b"");
-        let upstream_reset = b"HTTP/1.1 502 \r\nX-Mq-Error: upstream-reset\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
-        assert!(
-            is_reset(&r) || matches!(&r, Ok(b) if b == upstream_reset),
-            "{:?}",
-            r.as_ref().map(|b| String::from_utf8_lossy(b).into_owned())
-        );
-        // The reset is the server's (its check), not only the client's own body check; it
-        // leaves no FIN stamps. `origin_tls=connect_fail` and `origin_connect_ms=-1` pin an
-        // existing gateway misreport, outside this plan: the origin connect succeeded. A
-        // later gateway fix that changes these two fields is not a regression.
-        let path = format!("/h2-short-{tag}");
-        let want = format!(
-            "sid=4 method=GET status=200 authority=\"127.0.0.1:{}\" path=\"{path}\" req_bytes=0 resp_bytes=50 ttfb_ms=T duration_ms=-1 origin_protocol=h2 origin_tls=connect_fail content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=-1 mp_state=0 completion_ms=-1 reset=\"local reset\"",
-            o.addr.port()
-        );
-        assert_req(&req_line(&path), &want);
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn h2_cl_100_then_rst_resets_h3_end_to_end() {
+    let tag = "ww";
+    let h = Handler::ClTooShort { cl: 100, send: 50 };
+    let o = OriginServer::spawn(OriginServerMode::new(Proto::H2Tls, h));
+    let p = gateway();
+    wait_up(&p, tag);
+    let url = format!("https://127.0.0.1:{}/h2-short-{tag}", o.addr.port());
+    let r = fetch(&p, &url, &[], b"");
+    let upstream_reset = b"HTTP/1.1 502 \r\nX-Mq-Error: upstream-reset\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
+    assert!(
+        is_reset(&r) || matches!(&r, Ok(b) if b == upstream_reset),
+        "{:?}",
+        r.as_ref().map(|b| String::from_utf8_lossy(b).into_owned())
+    );
+    // The reset is the server's (its check), not only the client's own body check; it
+    // leaves no FIN stamps. `origin_tls=connect_fail` and `origin_connect_ms=-1` pin an
+    // existing gateway misreport, outside this plan: the origin connect succeeded. A
+    // later gateway fix that changes these two fields is not a regression.
+    let path = format!("/h2-short-{tag}");
+    let want = format!(
+        "sid=4 method=GET status=200 authority=\"127.0.0.1:{}\" path=\"{path}\" req_bytes=0 resp_bytes=50 ttfb_ms=T duration_ms=-1 origin_protocol=h2 origin_tls=connect_fail content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=-1 mp_state=0 completion_ms=-1 reset=\"local reset\"",
+        o.addr.port()
+    );
+    assert_req(&req_line(&path), &want);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // spec §5.2, §6.2, §10.3: CONNECT is refused by the fetch listener (400 `bad-method`) and
 // by the server intake (400 `bad-request`). The direct-H3 CONNECT is the valid authority
-// form (RFC 9114 §4.4), so it reaches the gateway on both server backends (adoption spec
-// §6.2; the malformed form is a raw-peer case).
-matrix!(
-    connect_rejected_both_intakes,
-    |cells: (Backend, Backend), tag: &str| {
-        let p = gateway(cells);
-        let target = format!("http://127.0.0.1:1/connect-{tag}");
-        let r = fetch(&p, &target, &[("X-Mq-Method", "CONNECT")], b"");
-        let want = b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\nX-Mq-Error: bad-method\r\n\r\n";
-        assert_eq!(
-            String::from_utf8_lossy(&r.expect("reply")),
-            String::from_utf8_lossy(want)
-        );
-        let auth = bearer();
-        let headers = [
-            (":method", "CONNECT"),
-            (":authority", "127.0.0.1:1"),
-            ("x-mq-auth", &auth),
+// form (RFC 9114 §4.4), so it reaches the gateway over H3Wire (the malformed form is a raw-peer case).
+#[test]
+fn connect_rejected_both_intakes() {
+    let tag = "ww";
+    let p = gateway();
+    let target = format!("http://127.0.0.1:1/connect-{tag}");
+    let r = fetch(&p, &target, &[("X-Mq-Method", "CONNECT")], b"");
+    let want = b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\nX-Mq-Error: bad-method\r\n\r\n";
+    assert_eq!(
+        String::from_utf8_lossy(&r.expect("reply")),
+        String::from_utf8_lossy(want)
+    );
+    let auth = bearer();
+    let headers = [
+        (":method", "CONNECT"),
+        (":authority", "127.0.0.1:1"),
+        ("x-mq-auth", &auth),
+    ];
+    // Its line has `path="-"`: a body of four bytes (drained, `req_bytes`) marks it.
+    let n = 4;
+    let s = H3Script {
+        headers: headers.map(|(n, v)| (n.into(), v.into())).to_vec(),
+        body: vec![0; n],
+    };
+    let c = h3_client(p.server.udp_addr, s);
+    wait_h3(&c.handle, |r| r.fin);
+    {
+        let r = c.handle.lock();
+        let want = [
+            (":status", "400"),
+            ("x-mq-error", "bad-request"),
+            ("content-length", "0"),
         ];
-        // Its line has `path="-"`: a body of `cell + 1` bytes (drained, `req_bytes`) marks it.
-        let n = cell_index(cells) + 1;
-        let s = H3Script {
-            headers: headers.map(|(n, v)| (n.into(), v.into())).to_vec(),
-            body: vec![0; n],
-            ..H3Script::default()
-        };
-        let c = h3_client(p.server.udp_addr, s, cells.0);
-        wait_h3(&c.handle, |r| r.fin);
-        {
-            let r = c.handle.lock();
-            let want = [
-                (":status", "400"),
-                ("x-mq-error", "bad-request"),
-                ("content-length", "0"),
-            ];
-            assert_headers(&h3_headers(&r), &want);
-        }
-        let line = wait_log(&["mq.req", "status=400", &format!("req_bytes={n} ")]);
-        let want = format!(
-            "sid=0 method=- status=400 authority=\"-\" path=\"-\" req_bytes={n} resp_bytes=0 ttfb_ms=T duration_ms=T origin_protocol=none origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=-1 mp_state=0 completion_ms=T reset=\"\""
-        );
-        assert_req(&line, &want);
-        stop(c);
-        assert_eq!(p.join_both(), (0, 0));
+        assert_headers(&h3_headers(&r), &want);
     }
-);
+    let line = wait_log(&["mq.req", "status=400", &format!("req_bytes={n} ")]);
+    let want = format!(
+        "sid=0 method=- status=400 authority=\"-\" path=\"-\" req_bytes={n} resp_bytes=0 ttfb_ms=T duration_ms=T origin_protocol=none origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=-1 mp_state=0 completion_ms=T reset=\"\""
+    );
+    assert_req(&line, &want);
+    stop(c);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // ---- direct H3 against the gateway server ----
 
 // spec §3.7 (1), §6.3, Review Focus 3: a 4 MiB body sent after a 403 is drained, so the
 // server's `recv_body_size` (`req_bytes`) reports the whole body.
-// A 403 line has `path="-"`, so the cell's marker is its body length.
-matrix!(
-    drain_after_403_counts_whole_body,
-    |cells: (Backend, Backend), tag: &str| {
-        let p = gateway(cells);
-        let body_len = 4 * MIB + cell_index(cells);
-        let extra = [("x-mq-auth", "Bearer wrong")];
-        let path = format!("/drain-{tag}");
-        let s = script("POST", "127.0.0.1:1", &path, &extra, vec![7; body_len]);
-        let c = h3_client(p.server.udp_addr, s, cells.0);
-        wait_h3(&c.handle, |r| !r.closed.is_empty());
-        {
-            let r = c.handle.lock();
-            let want = [
-                (":status", "403"),
-                ("x-mq-error", "auth-failed"),
-                ("content-length", "0"),
-            ];
-            assert_headers(&h3_headers(&r), &want);
-            assert_eq!(r.closed[0].0.stats.stream_err, 0, "{:?}", r.closed);
-            assert_eq!(r.closed[0].0.stats.send_body, body_len as u64);
-        }
-        let line = wait_log(&["mq.req", "status=403", &format!("req_bytes={body_len} ")]);
-        let want = format!(
-            "sid=0 method=- status=403 authority=\"-\" path=\"-\" req_bytes={body_len} resp_bytes=0 ttfb_ms=T duration_ms=T origin_protocol=none origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=-1 mp_state=0 completion_ms=T reset=\"\""
-        );
-        assert_req(&line, &want);
-        stop(c);
-        assert_eq!(p.join_both(), (0, 0));
+// A 403 line has `path="-"`, so the test's marker is its body length.
+#[test]
+fn drain_after_403_counts_whole_body() {
+    let tag = "ww";
+    let p = gateway();
+    let body_len = 4 * MIB + 3;
+    let extra = [("x-mq-auth", "Bearer wrong")];
+    let path = format!("/drain-{tag}");
+    let s = script("POST", "127.0.0.1:1", &path, &extra, vec![7; body_len]);
+    let c = h3_client(p.server.udp_addr, s);
+    wait_h3(&c.handle, |r| !r.closed.is_empty());
+    {
+        let r = c.handle.lock();
+        let want = [
+            (":status", "403"),
+            ("x-mq-error", "auth-failed"),
+            ("content-length", "0"),
+        ];
+        assert_headers(&h3_headers(&r), &want);
+        assert_eq!(r.closed[0].0.stats.stream_err, 0, "{:?}", r.closed);
+        assert_eq!(r.closed[0].0.stats.send_body, body_len as u64);
     }
-);
+    let line = wait_log(&["mq.req", "status=403", &format!("req_bytes={body_len} ")]);
+    let want = format!(
+        "sid=0 method=- status=403 authority=\"-\" path=\"-\" req_bytes={body_len} resp_bytes=0 ttfb_ms=T duration_ms=T origin_protocol=none origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=-1 mp_state=0 completion_ms=T reset=\"\""
+    );
+    assert_req(&line, &want);
+    stop(c);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // spec §6.2 step 8, §10.3: `content-length: 10` with FIN on HEADERS reaches the origin
 // bodiless (no chunked framing, no positive length). adoption spec §5.3 (6): a `Wire` server
 // finds the mismatch in the read that delivers the HEADERS, so the gateway's intake read
 // fails and the origin sees nothing. Its line has `path="-"` and no field unique to the
-// cell, so the cell asserts no `mq.req` (as the brief rules); the client sees the reset.
-matrix!(
-    direct_h3_cl_with_fin_on_headers_is_bodiless,
-    |cells: (Backend, Backend), tag: &str| {
-        let o = Capture::spawn();
-        let p = gateway(cells);
-        let auth = bearer();
-        let extra = [("x-mq-auth", auth.as_str()), ("content-length", "10")];
-        let path = format!("/fin-{tag}");
-        let s = script("POST", &o.authority(), &path, &extra, Vec::new());
-        let c = h3_client(p.server.udp_addr, s, cells.0);
-        if cells.1 == Backend::Wire {
-            wait_h3(&c.handle, |r| !r.closed.is_empty());
-            {
-                let r = c.handle.lock();
-                assert_eq!(r.closed[0].0.stats.stream_err, 0x10e, "{r:?}");
-                assert!(r.headers.is_empty() && !r.fin, "{r:?}");
-            }
-            stop(c);
-            assert_eq!(p.join_both(), (0, 0));
-            assert!(o.settled().is_empty(), "the origin saw a request");
-            return;
+// test, so it asserts no `mq.req` (as the brief rules); the client sees the reset.
+#[test]
+fn direct_h3_cl_with_fin_on_headers_is_bodiless() {
+    let tag = "ww";
+    let o = Capture::spawn();
+    let p = gateway();
+    let auth = bearer();
+    let extra = [("x-mq-auth", auth.as_str()), ("content-length", "10")];
+    let path = format!("/fin-{tag}");
+    let s = script("POST", &o.authority(), &path, &extra, Vec::new());
+    let c = h3_client(p.server.udp_addr, s);
+    {
+        wait_h3(&c.handle, |r| !r.closed.is_empty());
+        {
+            let r = c.handle.lock();
+            assert_eq!(r.closed[0].0.stats.stream_err, 0x10e, "{r:?}");
+            assert!(r.headers.is_empty() && !r.fin, "{r:?}");
         }
-        wait_h3(&c.handle, |r| r.fin);
-        // The control of `assert_not_seen`: a request the gateway took is counted.
-        assert_eq!(p.server_h3_requests.load(Ordering::SeqCst), 1);
-        assert_headers(&h3_headers(&c.handle.lock()), &H3_OK);
-        let seen = o.one();
-        assert!(seen.complete && seen.body.is_empty(), "{seen:?}");
-        assert!(!seen.head.contains("transfer-encoding"), "{}", seen.head);
-        let cl = seen
-            .head
-            .lines()
-            .find_map(|l| l.strip_prefix("content-length:"));
-        assert!(cl.is_none_or(|v| v.trim() == "0"), "{}", seen.head);
-        let want = format!(
-            "sid=0 method=POST status=200 authority=\"{}\" path=\"{path}\" req_bytes=0 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
-            o.authority()
-        );
-        assert_req(&req_line(&path), &want);
         stop(c);
         assert_eq!(p.join_both(), (0, 0));
+        assert!(o.settled().is_empty(), "the origin saw a request");
     }
-);
+}
 
 // spec §7.4, §10.3: a GET with an unknown-length DATA body reaches an h1 origin chunked and
 // complete.
-matrix!(
-    direct_h3_get_with_body_is_chunked_on_h1,
-    |cells: (Backend, Backend), tag: &str| {
-        let o = Capture::spawn();
-        let p = gateway(cells);
-        let auth = bearer();
-        let extra = [("x-mq-auth", auth.as_str())];
-        let path = format!("/chunked-{tag}");
-        let s = script("GET", &o.authority(), &path, &extra, b"hello body".to_vec());
-        let c = h3_client(p.server.udp_addr, s, cells.0);
-        wait_h3(&c.handle, |r| r.fin);
-        assert_headers(&h3_headers(&c.handle.lock()), &H3_OK);
-        let seen = o.one();
-        assert!(
-            seen.head.contains("\r\ntransfer-encoding: chunked\r\n"),
-            "{}",
-            seen.head
-        );
-        assert_eq!(dechunk(&seen.body).as_deref(), Some(&b"hello body"[..]));
-        let want = format!(
-            "sid=0 method=GET status=200 authority=\"{}\" path=\"{path}\" req_bytes=10 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
-            o.authority()
-        );
-        assert_req(&req_line(&path), &want);
-        stop(c);
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn direct_h3_get_with_body_is_chunked_on_h1() {
+    let tag = "ww";
+    let o = Capture::spawn();
+    let p = gateway();
+    let auth = bearer();
+    let extra = [("x-mq-auth", auth.as_str())];
+    let path = format!("/chunked-{tag}");
+    let s = script("GET", &o.authority(), &path, &extra, b"hello body".to_vec());
+    let c = h3_client(p.server.udp_addr, s);
+    wait_h3(&c.handle, |r| r.fin);
+    assert_headers(&h3_headers(&c.handle.lock()), &H3_OK);
+    let seen = o.one();
+    assert!(
+        seen.head.contains("\r\ntransfer-encoding: chunked\r\n"),
+        "{}",
+        seen.head
+    );
+    assert_eq!(dechunk(&seen.body).as_deref(), Some(&b"hello body"[..]));
+    let want = format!(
+        "sid=0 method=GET status=200 authority=\"{}\" path=\"{path}\" req_bytes=10 resp_bytes=2 ttfb_ms=T duration_ms=T origin_protocol=h1 origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=T mp_state=0 completion_ms=T reset=\"\"",
+        o.authority()
+    );
+    assert_req(&req_line(&path), &want);
+    stop(c);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 /// A direct-H3 upload the server must reset (§6.3): the client sees the reset, the server
 /// logs the request, and the origin never received a complete body. On a `Wire` server the
 /// reset is h3wire's (`H3_MESSAGE_ERROR`, adoption spec §5.3 (6)) and comes before any body
-/// byte reaches the gateway (`req_bytes=0`, where xqc_h3 delivers the 50 bytes); the gateway
+/// byte reaches the gateway (`req_bytes=0`); the gateway
 /// still logs it as `local reset`.
-fn upload_reset(cells: (Backend, Backend), path: &str, cl: &str, body: Vec<u8>) {
+fn upload_reset(path: &str, cl: &str, body: Vec<u8>) {
     let o = Capture::spawn();
-    let p = gateway(cells);
+    let p = gateway();
     let auth = bearer();
     let extra = [("x-mq-auth", auth.as_str()), ("content-length", cl)];
     let s = script("POST", &o.authority(), path, &extra, body);
-    let c = h3_client(p.server.udp_addr, s, cells.0);
+    let c = h3_client(p.server.udp_addr, s);
     wait_h3(&c.handle, |r| !r.closed.is_empty());
-    let wire = cells.1 == Backend::Wire;
     {
         let r = c.handle.lock();
         let code = r.closed[0].0.stats.stream_err;
-        assert!(if wire { code == 0x10e } else { code != 0 }, "{r:?}");
+        assert_eq!(code, 0x10e, "{r:?}");
         assert!(!r.fin, "{r:?}");
         assert_headers(&h3_headers(&r), &[]);
     }
     let want = format!(
         "sid=0 method=POST status=0 authority=\"{}\" path=\"{path}\" req_bytes={} resp_bytes=0 ttfb_ms=-1 duration_ms=-1 origin_protocol=none origin_tls=na content_encoding=none cache=bypass origin_reuse=0 origin_connect_ms=-1 mp_state=0 completion_ms=-1 reset=\"local reset\"",
         o.authority(),
-        if wire { 0 } else { 50 },
+        0,
     );
     assert_req(&req_line(path), &want);
     let seen = o.settled();
@@ -1064,20 +1009,18 @@ fn upload_reset(cells: (Backend, Backend), path: &str, cl: &str, body: Vec<u8>)
 }
 
 // spec §6.3, §10.3: 50 bytes + FIN (a complete frame) under `content-length: 100`.
-matrix!(
-    direct_h3_short_request_body_resets,
-    |cells: (Backend, Backend), tag: &str| {
-        upload_reset(cells, &format!("/short-req-{tag}"), "100", vec![1; 50]);
-    }
-);
+#[test]
+fn direct_h3_short_request_body_resets() {
+    let tag = "ww";
+    upload_reset(&format!("/short-req-{tag}"), "100", vec![1; 50]);
+}
 
 // spec §6.3, §10.3: 50 bytes under `content-length: 10`.
-matrix!(
-    direct_h3_excess_request_body_resets,
-    |cells: (Backend, Backend), tag: &str| {
-        upload_reset(cells, &format!("/excess-req-{tag}"), "10", vec![1; 50]);
-    }
-);
+#[test]
+fn direct_h3_excess_request_body_resets() {
+    let tag = "ww";
+    upload_reset(&format!("/excess-req-{tag}"), "10", vec![1; 50]);
+}
 
 // ---- malformed input against each receiver (adoption spec §6.2) ----
 
@@ -1101,20 +1044,6 @@ fn assert_message_error(p: &LoopbackProxy, c: &DriverThread<RawH3Handle>) {
     assert_not_seen(p);
 }
 
-/// No `mq.req` line carries `marker` for 500 ms (the xqc_h3 receiver: it can log the
-/// request as `path="-"` before decoding, so only the submitted path is searched for).
-fn assert_no_req(marker: &str) {
-    let end = Instant::now() + Duration::from_millis(500);
-    while Instant::now() < end {
-        let lines = log_tap::lines();
-        let hit = lines
-            .iter()
-            .find(|l| l.contains("mq.req") && l.contains(marker));
-        assert!(hit.is_none(), "{hit:?}");
-        thread::sleep(Duration::from_millis(5));
-    }
-}
-
 /// The server never handed the gateway a request (`H3Request`) for 500 ms. Counted at the
 /// server app of this test's own pair, so neither a `path="-"` log line (the gateway's name
 /// for a request it has not accepted) nor another test's lines can hide a leak.
@@ -1127,66 +1056,58 @@ fn assert_not_seen(p: &LoopbackProxy) {
     }
 }
 
-/// The raw response's `name` field.
-fn raw_field(c: &DriverThread<RawH3Handle>, name: &str) -> Option<String> {
-    let v = field(&c.handle.lock().read, name.as_bytes());
-    v.map(|v| String::from_utf8_lossy(&v).into_owned())
-}
-
 // spec §3.7 (3), §6.3, Review Focus 5: the request's DATA frame is cut by FIN inside its
-// declared length. An xqc_h3 server reads the cut as a clean EOF and its upload check resets
-// the request. h3wire closes the connection with `H3_FRAME_ERROR` (adoption spec §5.3 (1));
+// declared length. h3wire closes the connection with `H3_FRAME_ERROR` (adoption spec §5.3 (1));
 // the valid HEADERS reached the gateway first, so the connection-close fan-out (§4.3) logs
 // the request once, reset.
-receivers!(
-    direct_h3_request_body_cut_inside_frame_resets,
-    |b: Backend, tag: &str| {
-        let o = Capture::spawn();
-        let p = gateway((Backend::XqcH3, b));
-        let (auth, cl, path) = (
-            bearer(),
-            CUT_DECLARED.to_string(),
-            format!("/cut-req-{tag}"),
-        );
-        let mut stream = raw_headers(&[
-            (":method", "POST"),
-            (":scheme", "http"),
-            (":authority", &o.authority()),
-            (":path", &path),
-            ("x-mq-auth", &auth),
-            ("content-length", &cl),
-        ]);
-        stream.extend(data_frame(CUT_DECLARED, &[2; CUT_SENT]));
-        let c = raw_client(p.server.udp_addr, stream);
-        let marker = format!("path=\"{path}\"");
-        let line = wait_log(&["mq.req", &marker]);
-        if b == Backend::Wire {
-            wait_until("the peer's ConnClosed", || {
-                !c.handle.lock().closed.is_empty()
-            });
-            assert_eq!(c.handle.lock().closed, [FRAME_ERROR]);
-            assert!(!line.contains("reset=\"\""), "{line}");
-            let n = log_tap::lines()
-                .iter()
-                .filter(|l| l.contains("mq.req") && l.contains(&marker))
-                .count();
-            assert_eq!(n, 1);
-        } else {
-            assert!(line.contains("reset=\"local reset\""), "{line}");
-        }
-        let seen = o.settled();
-        assert!(seen.iter().all(|s| !s.complete), "{seen:?}");
-        stop(c);
-        assert_eq!(p.join_both(), (0, 0));
+#[test]
+fn direct_h3_request_body_cut_inside_frame_resets() {
+    let tag = "w";
+    let o = Capture::spawn();
+    let p = gateway();
+    let (auth, cl, path) = (
+        bearer(),
+        CUT_DECLARED.to_string(),
+        format!("/cut-req-{tag}"),
+    );
+    let mut stream = raw_headers(&[
+        (":method", "POST"),
+        (":scheme", "http"),
+        (":authority", &o.authority()),
+        (":path", &path),
+        ("x-mq-auth", &auth),
+        ("content-length", &cl),
+    ]);
+    stream.extend(data_frame(CUT_DECLARED, &[2; CUT_SENT]));
+    let c = raw_client(p.server.udp_addr, stream);
+    let marker = format!("path=\"{path}\"");
+    let line = wait_log(&["mq.req", &marker]);
+    {
+        wait_until("the peer's ConnClosed", || {
+            !c.handle.lock().closed.is_empty()
+        });
+        assert_eq!(c.handle.lock().closed, [FRAME_ERROR]);
+        assert!(!line.contains("reset=\"\""), "{line}");
+        let n = log_tap::lines()
+            .iter()
+            .filter(|l| l.contains("mq.req") && l.contains(&marker))
+            .count();
+        assert_eq!(n, 1);
     }
-);
+    let seen = o.settled();
+    assert!(seen.iter().all(|s| !s.complete), "{seen:?}");
+    stop(c);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
-// spec §6.2, §12, §10.3: an embedded NUL in `x-mq-auth`, `:path` and `x-mq-class`. An
-// xqc_h3 server passes them to the gateway: 403 / 400 / `?` in the log. RFC 9114 §4.2 makes
+// spec §6.2, §12, §10.3: an embedded NUL in `x-mq-auth`, `:path` and `x-mq-class`.
+// RFC 9114 §4.2 makes
 // such a request malformed, and h3wire resets it (adoption spec §5.3 (6)).
-receivers!(nul_in_auth_path_class_direct_h3, |b: Backend, tag: &str| {
+#[test]
+fn nul_in_auth_path_class_direct_h3() {
+    let tag = "w";
     let o = Capture::spawn();
-    let p = gateway((Backend::XqcH3, b));
+    let p = gateway();
     let auth = bearer();
     let nul_auth = format!("{auth}\0junk");
     let class = format!("nul\0class-marker-{tag}");
@@ -1206,48 +1127,29 @@ receivers!(nul_in_auth_path_class_direct_h3, |b: Backend, tag: &str| {
         format!("/ok\0junk-{tag}"),
         format!("/nul-class-{tag}"),
     );
-    let cases = [
-        (
-            get(&p_auth, &[("x-mq-auth", &nul_auth)]),
-            &p_auth,
-            ("403", Some("auth-failed")),
-        ),
-        (
-            get(&p_path, &[("x-mq-auth", &auth)]),
-            &p_path,
-            ("400", Some("bad-target")),
-        ),
-        (
-            get(&p_class, &[("x-mq-auth", &auth), ("x-mq-class", &class)]),
-            &p_class,
-            ("200", None),
-        ),
-    ];
-    for (stream, _, (status, xmq)) in cases {
+    for stream in [
+        get(&p_auth, &[("x-mq-auth", &nul_auth)]),
+        get(&p_path, &[("x-mq-auth", &auth)]),
+        get(&p_class, &[("x-mq-auth", &auth), ("x-mq-class", &class)]),
+    ] {
         let c = raw_client(p.server.udp_addr, stream);
-        if b == Backend::Wire {
-            assert_message_error(&p, &c);
-        } else {
-            wait_until("the response", || c.handle.lock().fin);
-            assert_eq!(raw_field(&c, ":status").as_deref(), Some(status));
-            assert_eq!(raw_field(&c, "x-mq-error").as_deref(), xmq);
-        }
+        assert_message_error(&p, &c);
         stop(c);
     }
     let class_line = format!("x-mq-class='nul?class-marker-{tag}'");
-    if b == Backend::Wire {
+    {
         assert!(!log_tap::lines().iter().any(|l| l.contains(&class_line)));
-    } else {
-        wait_log(&[&class_line]);
     }
     assert_eq!(p.join_both(), (0, 0));
-});
+}
 
-// spec §5.2, §6.2: CONNECT with `:scheme` and `:path` (RFC 9114 §4.4 forbids both). An
-// xqc_h3 server passes it to the gateway, which answers 400 `bad-request`; h3wire resets it
+// spec §5.2, §6.2: CONNECT with `:scheme` and `:path` (RFC 9114 §4.4 forbids both).
+// h3wire resets it
 // as malformed (adoption spec §5.3 (6)).
-receivers!(connect_malformed_direct_h3, |b: Backend, tag: &str| {
-    let p = gateway((Backend::XqcH3, b));
+#[test]
+fn connect_malformed_direct_h3() {
+    let tag = "w";
+    let p = gateway();
     let (auth, path) = (bearer(), format!("/connect-{tag}"));
     let stream = raw_headers(&[
         (":method", "CONNECT"),
@@ -1257,87 +1159,62 @@ receivers!(connect_malformed_direct_h3, |b: Backend, tag: &str| {
         ("x-mq-auth", &auth),
     ]);
     let c = raw_client(p.server.udp_addr, stream);
-    if b == Backend::Wire {
+    {
         assert_message_error(&p, &c);
-    } else {
-        wait_until("the response", || c.handle.lock().fin);
-        assert_eq!(raw_field(&c, ":status").as_deref(), Some("400"));
-        assert_eq!(raw_field(&c, "x-mq-error").as_deref(), Some("bad-request"));
     }
     stop(c);
     assert_eq!(p.join_both(), (0, 0));
-});
+}
 
 // adoption spec §5.3 (3): a request HEADERS frame over 64 KiB encoded (`~` has no Huffman
 // gain, so ten 7000-byte values stay raw). h3wire closes the connection with
-// `H3_EXCESSIVE_LOAD` at the frame header. xqc_h3 limits the decoded size instead and resets
-// the stream with `H3_MESSAGE_ERROR`, keeping the connection. Neither reaches the gateway.
-receivers!(
-    direct_h3_oversize_headers_rejected,
-    |b: Backend, tag: &str| {
-        let p = gateway((Backend::XqcH3, b));
-        let (auth, path, pad) = (bearer(), format!("/big-req-{tag}"), "~".repeat(7000));
-        let names: Vec<String> = (0..10).map(|i| format!("x-pad-{i}")).collect();
-        let mut fs = vec![
-            (":method", "GET"),
-            (":scheme", "http"),
-            (":authority", "127.0.0.1:1"),
-            (":path", path.as_str()),
-            ("x-mq-auth", auth.as_str()),
-        ];
-        fs.extend(names.iter().map(|n| (n.as_str(), pad.as_str())));
-        let stream = raw_headers(&fs);
-        assert!(stream.len() > 64 * 1024, "{}", stream.len());
-        let c = raw_client(p.server.udp_addr, stream);
-        if b == Backend::Wire {
-            wait_until("the peer's ConnClosed", || {
-                !c.handle.lock().closed.is_empty()
-            });
-            assert_eq!(c.handle.lock().closed, [EXCESSIVE_LOAD]);
-            {
-                let g = c.handle.lock();
-                assert!(g.resets.is_empty(), "{g:?}");
-            }
-        } else {
-            wait_until("the peer's reset", || !c.handle.lock().resets.is_empty());
-            {
-                let g = c.handle.lock();
-                assert_eq!(g.resets[0].1, 0x10e, "{g:?}");
-            }
-            {
-                let g = c.handle.lock();
-                assert!(g.closed.is_empty(), "{g:?}");
-            }
-        }
-        if b == Backend::Wire {
-            assert_not_seen(&p);
-        } else {
-            // xqc_h3 hands the gateway the stream before it decodes (and rejects) the block.
-            assert_no_req(&format!("path=\"{path}\""));
+// `H3_EXCESSIVE_LOAD` at the frame header. The request never reaches the gateway.
+#[test]
+fn direct_h3_oversize_headers_rejected() {
+    let tag = "w";
+    let p = gateway();
+    let (auth, path, pad) = (bearer(), format!("/big-req-{tag}"), "~".repeat(7000));
+    let names: Vec<String> = (0..10).map(|i| format!("x-pad-{i}")).collect();
+    let mut fs = vec![
+        (":method", "GET"),
+        (":scheme", "http"),
+        (":authority", "127.0.0.1:1"),
+        (":path", path.as_str()),
+        ("x-mq-auth", auth.as_str()),
+    ];
+    fs.extend(names.iter().map(|n| (n.as_str(), pad.as_str())));
+    let stream = raw_headers(&fs);
+    assert!(stream.len() > 64 * 1024, "{}", stream.len());
+    let c = raw_client(p.server.udp_addr, stream);
+    {
+        wait_until("the peer's ConnClosed", || {
+            !c.handle.lock().closed.is_empty()
+        });
+        assert_eq!(c.handle.lock().closed, [EXCESSIVE_LOAD]);
+        {
+            let g = c.handle.lock();
+            assert!(g.resets.is_empty(), "{g:?}");
         }
-        stop(c);
-        assert_eq!(p.join_both(), (0, 0));
     }
-);
+    {
+        assert_not_seen(&p);
+    }
+    stop(c);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // adoption spec §5.3 (2), server: a request stream that ends without HEADERS. h3wire resets it
-// with `H3_REQUEST_INCOMPLETE`; xqc_h3 drops it with no reset and no close (none within
-// 500 ms).
-receivers!(direct_h3_fin_without_headers, |b: Backend, _tag: &str| {
-    let p = gateway((Backend::XqcH3, b));
+// with `H3_REQUEST_INCOMPLETE`.
+#[test]
+fn direct_h3_fin_without_headers() {
+    let p = gateway();
     let c = raw_client(p.server.udp_addr, Vec::new());
-    if b == Backend::Wire {
+    {
         wait_until("the peer's reset", || !c.handle.lock().resets.is_empty());
         {
             let g = c.handle.lock();
             assert_eq!(g.resets[0].1, 0x10d, "{g:?}");
         }
-    } else {
-        thread::sleep(Duration::from_millis(500));
-        {
-            let g = c.handle.lock();
-            assert!(g.resets.is_empty(), "{g:?}");
-        }
     }
     {
         let g = c.handle.lock();
@@ -1345,35 +1222,26 @@ receivers!(direct_h3_fin_without_headers, |b: Backend, _tag: &str| {
     }
     stop(c);
     assert_eq!(p.join_both(), (0, 0));
-});
+}
 
 // adoption spec §5.3 (2), client: the response stream ends without a final response, after a
 // bare FIN or after a 103. h3wire aborts it with `H3_MESSAGE_ERROR`, which the fetch client
-// answers with 502 `upstream-reset`. xqc_h3 does the same after the bare FIN, but takes the
-// 103 for the final response and relays it with an empty body (RFC 9114 §4.1 makes it
-// interim).
-receivers!(
-    fetch_response_without_final_fails,
-    |b: Backend, tag: &str| {
-        let reset = "HTTP/1.1 502 \r\nX-Mq-Error: upstream-reset\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
-        let relayed_103 =
-            "HTTP/1.1 103 \r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n0\r\n\r\n";
-        for (i, stream) in [Vec::new(), headers_frame(&[(b":status", b"103")])]
-            .into_iter()
-            .enumerate()
-        {
-            let (app, _) = RawH3Peer::server(RawH3Script { stream, fin: true });
-            let cells = (b, Backend::Raw);
-            let p = LoopbackProxy::spawn_gateway_against_on(ClientConfig::default(), app, cells);
-            let target = format!("http://x/no-final-{i}-{tag}");
-            let r = fetch_when_up(p.fetch_addr(), &auth(&target, "any")).expect("a reply");
-            let want = if b == Backend::XqcH3 && i == 1 {
-                relayed_103
-            } else {
-                reset
-            };
-            assert_eq!(String::from_utf8_lossy(&r), want, "case {i}");
-            assert_eq!(p.join_both(), (0, 0));
-        }
+// answers with 502 `upstream-reset`.
+#[test]
+fn fetch_response_without_final_fails() {
+    let tag = "w";
+    let reset = "HTTP/1.1 502 \r\nX-Mq-Error: upstream-reset\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
+    for (i, stream) in [Vec::new(), headers_frame(&[(b":status", b"103")])]
+        .into_iter()
+        .enumerate()
+    {
+        let (app, _) = RawH3Peer::server(RawH3Script { stream, fin: true });
+        let p = LoopbackProxy::spawn_gateway_against(ClientConfig::default(), app, || {
+            raw_h3_transport(server_role())
+        });
+        let target = format!("http://x/no-final-{i}-{tag}");
+        let r = fetch_when_up(p.fetch_addr(), &auth(&target, "any")).expect("a reply");
+        assert_eq!(String::from_utf8_lossy(&r), reset, "case {i}");
+        assert_eq!(p.join_both(), (0, 0));
     }
-);
+}
diff --git a/crates/mq-integration/tests/pair_h3.rs b/crates/mq-integration/tests/pair_h3.rs
index 3e8e4135..45eb4e87 100644
--- a/crates/mq-integration/tests/pair_h3.rs
+++ b/crates/mq-integration/tests/pair_h3.rs
@@ -3,10 +3,7 @@
 #![forbid(unsafe_code)]
 
 use mq_integration::h3_apps::{EchoMode, H3Client, H3EchoServer, H3Handle, H3Script};
-use mq_integration::loopback::{
-    Backend, LoopbackPair, cert, h3_transport, raw_h3_transport, transport,
-};
-use mq_integration::matrix;
+use mq_integration::loopback::{LoopbackPair, cert, h3_transport, raw_h3_transport};
 use mq_integration::raw_h3::{RawH3Handle, RawH3Peer, RawH3Script, field, headers_frame};
 use mq_runtime::Shard;
 use mq_runtime::testing::{RecordHandle, Recorded, RecordingApp};
@@ -16,31 +13,7 @@ use std::sync::mpsc;
 use std::thread;
 use std::time::{Duration, Instant};
 
-/// Bare xqc_h3 on both sides (the rescue tests).
-fn pair(mode: EchoMode, script: H3Script) -> LoopbackPair<H3Handle, H3Handle> {
-    let lo = Ipv4Addr::LOCALHOST.into();
-    LoopbackPair::spawn(
-        (lo, lo),
-        Vec::new(),
-        move |local| {
-            let t = transport(
-                Role::Server {
-                    cert: cert("test.crt"),
-                    key: cert("test.key"),
-                },
-                true,
-            );
-            let (app, h) = H3EchoServer::new(mode);
-            (Shard::new(t, app, local, 1), h)
-        },
-        move |local, server| {
-            let (app, h) = H3Client::new(server, script);
-            (Shard::new(transport(Role::Client, true), app, local, 2), h)
-        },
-    )
-}
-
-fn post(body: Vec<u8>, pause_reads: Option<Duration>) -> H3Script {
+fn post(body: Vec<u8>) -> H3Script {
     H3Script {
         headers: [
             (":method", "POST"),
@@ -51,7 +24,6 @@ fn post(body: Vec<u8>, pause_reads: Option<Duration>) -> H3Script {
         .map(|(n, v)| (n.into(), v.into()))
         .to_vec(),
         body,
-        pause_reads,
     }
 }
 
@@ -64,63 +36,6 @@ fn wait(h: &H3Handle, cond: impl Fn(&mq_integration::h3_apps::H3Recorded) -> boo
     }
 }
 
-// The rescue tests below read `H3Closed.unread`, which only xqc_h3 fills: they stay on the
-// xqc_h3 backend, outside the differential matrix (adoption spec §6.2).
-
-/// spec §3.7 (2): the client stops reading for longer than 3 PTO after the server's FIN; every
-/// byte still arrives, through `H3Closed.unread`.
-#[test]
-fn h3_unread_rescued_after_close_timer() {
-    let body: Vec<u8> = (0..200_000u32).map(|k| k as u8).collect();
-    let p = pair(
-        EchoMode::Echo,
-        post(body.clone(), Some(Duration::from_secs(1))),
-    );
-    wait(&p.client.handle, |r| !r.closed.is_empty());
-    {
-        let r = p.client.handle.lock();
-        let (close, _) = &r.closed[0];
-        assert_eq!(close.stats.stream_err, 0, "{close:?}");
-        let u = close.unread.as_ref().expect("rescued");
-        assert_eq!(u.body, body);
-        assert_eq!(
-            u.headers.as_ref().map(|h| h[0].0.as_slice()),
-            Some(&b":status"[..])
-        );
-        assert!(r.body.is_empty() && !r.fin, "the app read nothing itself");
-    }
-    p.join_both();
-}
-
-/// spec §3.7, §10.3: a server reset before its FIN while the client holds unread body gives
-/// `H3Closed` with `stream_err != 0` and no `unread` within 1 RTT + 3 PTO (plus margin).
-#[test]
-fn h3_reset_with_unread_body_within_margin() {
-    let p = pair(
-        EchoMode::ResetBeforeFin,
-        post(vec![9; 50_000], Some(Duration::from_secs(5))),
-    );
-    wait(&p.client.handle, |r| !r.closed.is_empty());
-    let (cut_at, srtt) = {
-        let s = p.server.handle.lock();
-        (
-            s.cut_at.expect("server reset"),
-            Duration::from_micros(s.srtt_us),
-        )
-    };
-    {
-        let r = p.client.handle.lock();
-        let (close, at) = &r.closed[0];
-        assert_ne!(close.stats.stream_err, 0, "{close:?}");
-        assert_eq!(close.unread, None);
-        // PTO ≤ srtt + 4 × rttvar + max_ack_delay (25 ms), with rttvar ≤ srtt.
-        let pto = 5 * srtt + Duration::from_millis(25);
-        let margin = srtt + 3 * pto + Duration::from_millis(500);
-        assert!(*at - cut_at <= margin, "{:?} > {margin:?}", *at - cut_at);
-    }
-    p.join_both();
-}
-
 /// `n` fields of `len` bytes (`x-<i>`).
 fn fields(n: usize, len: usize) -> Vec<(String, String)> {
     (0..n)
@@ -141,50 +56,41 @@ fn bytes(hs: &[(String, String)]) -> Vec<(Vec<u8>, Vec<u8>)> {
 
 // SP4 spec §5: both engines accept a 40 KiB field section (xquic's default limit was 32 KiB;
 // `H3_FIELD_SECTION_MAX` is 64 KiB): a request section reaches the server and a response
-// section comes back, each exactly as sent. Matrixed over (client, server) backends
-// (adoption spec §6.2).
-matrix!(
-    h3_40k_section_both_ways,
-    |cells: (Backend, Backend), _tag: &str| {
-        let mut script = post(Vec::new(), None);
-        script.headers.extend(fields(6, 7000));
-        let want_req = bytes(&script.headers);
-        let mut want_resp = vec![(b":status".to_vec(), b"200".to_vec())];
-        want_resp.extend(bytes(&fields(6, 7000)));
-        let lo = Ipv4Addr::LOCALHOST.into();
-        let p = LoopbackPair::spawn(
-            (lo, lo),
-            Vec::new(),
-            move |local| {
-                let (app, h) = H3EchoServer::new(EchoMode::Echo);
-                let app = app.with_response_headers(fields(6, 7000));
-                (
-                    Shard::new(h3_transport(server_role(), cells.1), app, local, 1),
-                    h,
-                )
-            },
-            move |local, server| {
-                let (app, h) = H3Client::new(server, script);
-                (
-                    Shard::new(h3_transport(Role::Client, cells.0), app, local, 2),
-                    h,
-                )
-            },
-        );
-        wait(&p.client.handle, |r| r.fin);
-        {
-            let s = p.server.handle.lock();
-            assert!(section(&want_req) >= 40 * 1024, "{}", section(&want_req));
-            assert!(s.request_headers == want_req, "request headers differ");
-        }
-        {
-            let c = p.client.handle.lock();
-            assert!(section(&want_resp) >= 40 * 1024, "{}", section(&want_resp));
-            assert!(c.headers == want_resp, "response headers differ");
-        }
-        p.join_both();
+// section comes back, each exactly as sent (adoption spec §6.2).
+#[test]
+fn h3_40k_section_both_ways() {
+    let mut script = post(Vec::new());
+    script.headers.extend(fields(6, 7000));
+    let want_req = bytes(&script.headers);
+    let mut want_resp = vec![(b":status".to_vec(), b"200".to_vec())];
+    want_resp.extend(bytes(&fields(6, 7000)));
+    let lo = Ipv4Addr::LOCALHOST.into();
+    let p = LoopbackPair::spawn(
+        (lo, lo),
+        Vec::new(),
+        move |local| {
+            let (app, h) = H3EchoServer::new(EchoMode::Echo);
+            let app = app.with_response_headers(fields(6, 7000));
+            (Shard::new(h3_transport(server_role()), app, local, 1), h)
+        },
+        move |local, server| {
+            let (app, h) = H3Client::new(server, script);
+            (Shard::new(h3_transport(Role::Client), app, local, 2), h)
+        },
+    );
+    wait(&p.client.handle, |r| r.fin);
+    {
+        let s = p.server.handle.lock();
+        assert!(section(&want_req) >= 40 * 1024, "{}", section(&want_req));
+        assert!(s.request_headers == want_req, "request headers differ");
+    }
+    {
+        let c = p.client.handle.lock();
+        assert!(section(&want_resp) >= 40 * 1024, "{}", section(&want_resp));
+        assert!(c.headers == want_resp, "response headers differ");
     }
-);
+    p.join_both();
+}
 
 fn server_role() -> Role {
     Role::Server {
@@ -199,18 +105,18 @@ fn server_role() -> Role {
 fn wire_pair_smoke() {
     let body: Vec<u8> = (0..1u32 << 20).map(|k| (k % 251) as u8).collect();
     let lo = Ipv4Addr::LOCALHOST.into();
-    let script = post(body.clone(), None);
+    let script = post(body.clone());
     let p = LoopbackPair::spawn(
         (lo, lo),
         Vec::new(),
         move |local| {
             let (app, h) = H3EchoServer::new(EchoMode::Echo);
-            let t = h3_transport(server_role(), Backend::Wire);
+            let t = h3_transport(server_role());
             (Shard::new(t, app, local, 1), h)
         },
         move |local, server| {
             let (app, h) = H3Client::new(server, script);
-            let t = h3_transport(Role::Client, Backend::Wire);
+            let t = h3_transport(Role::Client);
             (Shard::new(t, app, local, 2), h)
         },
     );
@@ -225,57 +131,52 @@ fn wire_pair_smoke() {
 }
 
 /// adoption spec §6.2: the raw-H3 peer's valid GET (fixed bytes) gets a 200 from an
-/// `H3EchoServer` on each backend.
+/// `H3EchoServer` over H3Wire.
 #[test]
 fn raw_peer_smoke() {
-    for b in [Backend::XqcH3, Backend::Wire] {
-        let get = headers_frame(&[
-            (b":method", b"GET"),
-            (b":scheme", b"https"),
-            (b":authority", b"x"),
-            (b":path", b"/"),
-        ]);
-        let lo = Ipv4Addr::LOCALHOST.into();
-        let p: LoopbackPair<H3Handle, RawH3Handle> = LoopbackPair::spawn(
-            (lo, lo),
-            Vec::new(),
-            move |local| {
-                let (app, h) = H3EchoServer::new(EchoMode::Echo);
-                (Shard::new(h3_transport(server_role(), b), app, local, 1), h)
-            },
-            move |local, server| {
-                let s = RawH3Script {
-                    stream: get,
-                    fin: true,
-                };
-                let (app, h) = RawH3Peer::client(server, s);
-                (Shard::new(raw_h3_transport(Role::Client), app, local, 2), h)
-            },
+    let get = headers_frame(&[
+        (b":method", b"GET"),
+        (b":scheme", b"https"),
+        (b":authority", b"x"),
+        (b":path", b"/"),
+    ]);
+    let lo = Ipv4Addr::LOCALHOST.into();
+    let p: LoopbackPair<H3Handle, RawH3Handle> = LoopbackPair::spawn(
+        (lo, lo),
+        Vec::new(),
+        move |local| {
+            let (app, h) = H3EchoServer::new(EchoMode::Echo);
+            (Shard::new(h3_transport(server_role()), app, local, 1), h)
+        },
+        move |local, server| {
+            let s = RawH3Script {
+                stream: get,
+                fin: true,
+            };
+            let (app, h) = RawH3Peer::client(server, s);
+            (Shard::new(raw_h3_transport(Role::Client), app, local, 2), h)
+        },
+    );
+    let end = Instant::now() + Duration::from_secs(10);
+    while !p.client.handle.lock().fin {
+        assert!(
+            Instant::now() < end,
+            "timed out: {:?}",
+            p.client.handle.lock()
+        );
+        thread::sleep(Duration::from_millis(5));
+    }
+    {
+        let seen = p.client.handle.lock();
+        assert_eq!(
+            field(&seen.read, b":status").as_deref(),
+            Some(&b"200"[..]),
+            "{seen:?}"
         );
-        let end = Instant::now() + Duration::from_secs(10);
-        while !p.client.handle.lock().fin {
-            assert!(
-                Instant::now() < end,
-                "{b:?}: timed out: {:?}",
-                p.client.handle.lock()
-            );
-            thread::sleep(Duration::from_millis(5));
-        }
-        {
-            let seen = p.client.handle.lock();
-            assert_eq!(
-                field(&seen.read, b":status").as_deref(),
-                Some(&b"200"[..]),
-                "{b:?}: {seen:?}"
-            );
-            assert!(
-                seen.resets.is_empty() && seen.closed.is_empty(),
-                "{b:?}: {seen:?}"
-            );
-        }
-        assert_eq!(p.server.handle.lock().requests, 1, "{b:?}");
-        p.join_both();
+        assert!(seen.resets.is_empty() && seen.closed.is_empty(), "{seen:?}");
     }
+    assert_eq!(p.server.handle.lock().requests, 1);
+    p.join_both();
 }
 
 /// Two live H3Wire requests: an unread partial response and an unfinished request.
@@ -305,10 +206,7 @@ fn live_wire_pair(
                 Recorded::Shutdown => cx.request_exit(0),
                 _ => {}
             });
-            (
-                Shard::new(h3_transport(server_role(), Backend::Wire), app, local, 1),
-                rec,
-            )
+            (Shard::new(h3_transport(server_role()), app, local, 1), rec)
         },
         move |local, server| {
             let (app, rec) = RecordingApp::new();
@@ -369,10 +267,7 @@ fn live_wire_pair(
                 Recorded::Shutdown => cx.request_exit(0),
                 _ => {}
             });
-            (
-                Shard::new(h3_transport(Role::Client, Backend::Wire), app, local, 2),
-                rec,
-            )
+            (Shard::new(h3_transport(Role::Client), app, local, 2), rec)
         },
     );
     (p, ready_rx)
@@ -413,14 +308,11 @@ fn wire_idle_timeout_mid_response_aborts() {
         })
         .collect();
     assert_eq!(closed.len(), 2, "{records:?}");
-    for close in closed {
-        assert_eq!(close.unread, None, "{close:?}");
-    }
     p.client.shutdown.trigger();
     assert_eq!(p.client.join(), 0);
 }
 
-/// Local close reports every live request before ConnClosed and rescues no partial body.
+/// Local close reports every live request before ConnClosed.
 #[test]
 fn wire_local_close_with_live_requests_is_clean() {
     let (p, ready) = live_wire_pair(None, true);
@@ -446,9 +338,8 @@ fn wire_local_close_with_live_requests_is_clean() {
         })
         .collect();
     assert_eq!(closed.len(), 2, "{records:?}");
-    for (i, close) in closed {
+    for (i, _) in closed {
         assert!(i < conn, "{records:?}");
-        assert_eq!(close.unread, None, "{close:?}");
     }
     assert_eq!(p.join_both(), (0, 0));
 }
diff --git a/crates/mq-integration/tests/pair_mitm.rs b/crates/mq-integration/tests/pair_mitm.rs
index 26cd5b2b..46cb8dc6 100644
--- a/crates/mq-integration/tests/pair_mitm.rs
+++ b/crates/mq-integration/tests/pair_mitm.rs
@@ -6,8 +6,7 @@
 
 use mq_integration::browser::{Body, Resp, TestBrowser, roots};
 use mq_integration::log_tap;
-use mq_integration::loopback::{Backend, LoopbackProxy};
-use mq_integration::matrix;
+use mq_integration::loopback::LoopbackProxy;
 use mq_integration::origin_server::{
     Handler, ORIGIN_CA, ORIGIN_CRT, OriginServer, OriginServerMode, Proto,
 };
@@ -67,7 +66,7 @@ fn p256() -> MitmConfig {
 }
 
 /// The pair, its `TRANSPARENT` accepts stamped with `origin` (R3).
-fn proxy(origin: SocketAddr, mitm: MitmConfig, cells: (Backend, Backend)) -> LoopbackProxy {
+fn proxy(origin: SocketAddr, mitm: MitmConfig) -> LoopbackProxy {
     // The routing decisions are logged at debug (SP4 spec §7.10). Once: `install` resets
     // the level to Info, which would race a parallel test's debug line.
     static TAP: Once = Once::new();
@@ -84,7 +83,7 @@ fn proxy(origin: SocketAddr, mitm: MitmConfig, cells: (Backend, Backend)) -> Loo
         token: TOKEN.into(),
         ..ServerConfig::default()
     };
-    LoopbackProxy::spawn_mitm_on(client, server, Path::new(ORIGIN_CA), mitm, origin, cells)
+    LoopbackProxy::spawn_mitm(client, server, Path::new(ORIGIN_CA), mitm, origin)
 }
 
 fn origin(proto: Proto, handler: Handler) -> OriginServer {
@@ -140,12 +139,10 @@ fn wait_until(what: &str, cond: impl Fn() -> bool) {
     }
 }
 
-/// The cells of every test that waits for a log line run one at a time: lines accumulate
-/// across the tests of this binary, and each opaque reason is produced by one test only,
-/// but by every cell of it.
+/// Tests that wait for a log line run one at a time: lines accumulate across this binary.
 static SERIAL: Mutex<()> = Mutex::new(());
 
-/// A log marker one cell waits for, with `SERIAL` held from before the cell starts.
+/// A log marker a test waits for, with `SERIAL` held from before the test starts.
 struct Logged {
     marker: &'static str,
     before: usize,
@@ -203,206 +200,188 @@ fn header<'a>(h: &'a [(String, Vec<u8>)], name: &str) -> Vec<&'a [u8]> {
 // ---- data ----
 
 // SP4 spec §11.3: a byte-exact 8 MiB download, from an h1 and an h2 TLS origin.
-matrix!(
-    mitm_8mib_download_byte_exact_h1_and_h2_origin,
-    |cells: (Backend, Backend), _tag: &str| {
-        let len = 8 * MIB;
-        for proto in [Proto::H1Tls, Proto::H2Tls] {
-            let o = origin(proto, Handler::FileBytes(len as u64));
-            let p = proxy(o.addr, p256(), cells);
-            let b = mitm_browser(&p, o.addr);
-            let (status, h, body) = b.get("/dl", &[]);
-            assert_eq!(status, 200);
-            assert_eq!(h.get("content-length").unwrap(), "8388608");
-            assert!(body == pattern(len), "body differs ({} bytes)", body.len());
-            assert_eq!(p.join_both(), (0, 0));
-        }
+#[test]
+fn mitm_8mib_download_byte_exact_h1_and_h2_origin() {
+    let len = 8 * MIB;
+    for proto in [Proto::H1Tls, Proto::H2Tls] {
+        let o = origin(proto, Handler::FileBytes(len as u64));
+        let p = proxy(o.addr, p256());
+        let b = mitm_browser(&p, o.addr);
+        let (status, h, body) = b.get("/dl", &[]);
+        assert_eq!(status, 200);
+        assert_eq!(h.get("content-length").unwrap(), "8388608");
+        assert!(body == pattern(len), "body differs ({} bytes)", body.len());
+        assert_eq!(p.join_both(), (0, 0));
     }
-);
+}
 
 // SP4 spec §7.5 step 6, §11.3: 8 MiB uploads echoed back, with a known length (forwarded
 // as `content-length`) and streamed (none).
-matrix!(
-    mitm_8mib_upload_known_cl_and_streaming,
-    |cells: (Backend, Backend), _tag: &str| {
-        let o = origin(Proto::H2Tls, Handler::Echo);
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        let data = pattern(8 * MIB);
-        for (path, known) in [("/known", true), ("/streaming", false)] {
-            let (status, _, body) = b.post(path, &[], data.clone(), known);
-            assert_eq!(status, 200, "{path}");
-            assert!(body == data, "{path}: echo differs ({} bytes)", body.len());
-        }
-        let reqs = o.requests();
-        let cl = |path: &str| {
-            let r = reqs.iter().find(|r| r.path == path).expect("request");
-            header(&r.headers, "content-length").concat()
-        };
-        assert_eq!(cl("/known"), b"8388608");
-        assert_eq!(cl("/streaming"), b"");
-        assert_eq!(p.join_both(), (0, 0));
+#[test]
+fn mitm_8mib_upload_known_cl_and_streaming() {
+    let o = origin(Proto::H2Tls, Handler::Echo);
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    let data = pattern(8 * MIB);
+    for (path, known) in [("/known", true), ("/streaming", false)] {
+        let (status, _, body) = b.post(path, &[], data.clone(), known);
+        assert_eq!(status, 200, "{path}");
+        assert!(body == data, "{path}: echo differs ({} bytes)", body.len());
     }
-);
+    let reqs = o.requests();
+    let cl = |path: &str| {
+        let r = reqs.iter().find(|r| r.path == path).expect("request");
+        header(&r.headers, "content-length").concat()
+    };
+    assert_eq!(cl("/known"), b"8388608");
+    assert_eq!(cl("/streaming"), b"");
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §11.3: 16 concurrent streams on one browser connection.
-matrix!(
-    mitm_16_parallel_streams,
-    |cells: (Backend, Backend), _tag: &str| {
-        let len = 256 * 1024;
-        let o = origin(Proto::H2Tls, Handler::FileBytes(len as u64));
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        let all = b.get_parallel(16, "/p");
-        assert_eq!(all.len(), 16);
-        for (status, _, body) in all {
-            assert_eq!(status, 200);
-            assert!(body == pattern(len), "body differs ({} bytes)", body.len());
-        }
-        assert_eq!(p.join_both(), (0, 0));
+#[test]
+fn mitm_16_parallel_streams() {
+    let len = 256 * 1024;
+    let o = origin(Proto::H2Tls, Handler::FileBytes(len as u64));
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    let all = b.get_parallel(16, "/p");
+    assert_eq!(all.len(), 16);
+    for (status, _, body) in all {
+        assert_eq!(status, 200);
+        assert!(body == pattern(len), "body differs ({} bytes)", body.len());
     }
-);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // ---- request and response shape ----
 
 // SP4 spec §7.5 step 4: a 6 KiB cookie sent as crumbs arrives as one joined field at an
 // h1 origin.
-matrix!(
-    mitm_split_cookie_joined_at_h1_origin,
-    |cells: (Backend, Backend), _tag: &str| {
-        let o = origin(Proto::H1Tls, Handler::Status(200));
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        let crumbs: Vec<String> = (0..6)
-            .map(|i| format!("c{i}={}", "x".repeat(1020)))
-            .collect();
-        let hs: Vec<(&str, &[u8])> = crumbs.iter().map(|c| ("cookie", c.as_bytes())).collect();
-        assert_eq!(b.get("/cookie", &hs).0, 200);
-        let reqs = o.requests();
-        let r = reqs.iter().find(|r| r.path == "/cookie").expect("request");
-        assert_eq!(header(&r.headers, "cookie"), [crumbs.join("; ").as_bytes()]);
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn mitm_split_cookie_joined_at_h1_origin() {
+    let o = origin(Proto::H1Tls, Handler::Status(200));
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    let crumbs: Vec<String> = (0..6)
+        .map(|i| format!("c{i}={}", "x".repeat(1020)))
+        .collect();
+    let hs: Vec<(&str, &[u8])> = crumbs.iter().map(|c| ("cookie", c.as_bytes())).collect();
+    assert_eq!(b.get("/cookie", &hs).0, 200);
+    let reqs = o.requests();
+    let r = reqs.iter().find(|r| r.path == "/cookie").expect("request");
+    assert_eq!(header(&r.headers, "cookie"), [crumbs.join("; ").as_bytes()]);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §5, §11.3: a 4 KiB `:path` and a 6 KiB CSP response header pass.
-matrix!(
-    mitm_4k_path_and_6k_csp,
-    |cells: (Backend, Backend), _tag: &str| {
-        let csp = "a".repeat(6 * 1024);
-        let h = Handler::WithHeaders(
-            vec![("content-security-policy", csp.clone())],
-            Box::new(Handler::Status(200)),
-        );
-        let o = origin(Proto::H2Tls, h);
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        let path = format!("/long?q={}", "q".repeat(4 * 1024));
-        let (status, h, _) = b.get(&path, &[]);
-        assert_eq!(status, 200);
-        assert_eq!(h.get("content-security-policy").unwrap(), &csp[..]);
-        assert!(o.requests().iter().any(|r| r.path == path), "path not seen");
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn mitm_4k_path_and_6k_csp() {
+    let csp = "a".repeat(6 * 1024);
+    let h = Handler::WithHeaders(
+        vec![("content-security-policy", csp.clone())],
+        Box::new(Handler::Status(200)),
+    );
+    let o = origin(Proto::H2Tls, h);
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    let path = format!("/long?q={}", "q".repeat(4 * 1024));
+    let (status, h, _) = b.get(&path, &[]);
+    assert_eq!(status, 200);
+    assert_eq!(h.get("content-security-policy").unwrap(), &csp[..]);
+    assert!(o.requests().iter().any(|r| r.path == path), "path not seen");
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §5 "Methods", "Empty header values": both reach the origin unchanged.
-matrix!(
-    mitm_lowercase_method_and_empty_header_reach_origin,
-    |cells: (Backend, Backend), _tag: &str| {
-        let o = origin(Proto::H1Tls, Handler::Status(200));
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        let r = b.request("purgeit", None, "/m", &[("x-empty", b"")], Body::Empty);
-        assert_eq!(r.expect("request").0, 200);
-        let reqs = o.requests();
-        let r = reqs.iter().find(|r| r.path == "/m").expect("request");
-        assert_eq!(r.method, "purgeit");
-        assert_eq!(header(&r.headers, "x-empty"), [b""]);
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn mitm_lowercase_method_and_empty_header_reach_origin() {
+    let o = origin(Proto::H1Tls, Handler::Status(200));
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    let r = b.request("purgeit", None, "/m", &[("x-empty", b"")], Body::Empty);
+    assert_eq!(r.expect("request").0, 200);
+    let reqs = o.requests();
+    let r = reqs.iter().find(|r| r.path == "/m").expect("request");
+    assert_eq!(r.method, "purgeit");
+    assert_eq!(header(&r.headers, "x-empty"), [b""]);
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §5 "Browser h2 side" and "Errors": a browser section over `SECTION_MAX` gets
 // h2's own 431 or a reset; a rendered head over a limit gets 400 `header-too-long`; a
 // response over a limit gets 502 `upstream-protocol`.
-matrix!(
-    mitm_over_limit_400_or_431_and_502,
-    |cells: (Backend, Backend), _tag: &str| {
-        let h = Handler::PerPath(vec![("/big-resp", Handler::HeaderListBytes(9000))]);
-        let o = origin(Proto::H2Tls, h);
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
+#[test]
+fn mitm_over_limit_400_or_431_and_502() {
+    let h = Handler::PerPath(vec![("/big-resp", Handler::HeaderListBytes(9000))]);
+    let o = origin(Proto::H2Tls, h);
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+
+    // 5 × 7000 bytes: every field within FIELD_MAX, the section over SECTION_MAX.
+    let v = vec![b'v'; 7000];
+    let names: Vec<String> = (0..5).map(|i| format!("x-big{i}")).collect();
+    let hs: Vec<(&str, &[u8])> = names.iter().map(|n| (n.as_str(), &v[..])).collect();
+    match b.request("GET", None, "/section", &hs, Body::Empty) {
+        Ok(r) => assert_eq!(r.0, 431),
+        Err(e) => assert!(e.is_reset(), "{e}"),
+    }
 
-        // 5 × 7000 bytes: every field within FIELD_MAX, the section over SECTION_MAX.
-        let v = vec![b'v'; 7000];
-        let names: Vec<String> = (0..5).map(|i| format!("x-big{i}")).collect();
-        let hs: Vec<(&str, &[u8])> = names.iter().map(|n| (n.as_str(), &v[..])).collect();
-        match b.request("GET", None, "/section", &hs, Body::Empty) {
-            Ok(r) => assert_eq!(r.0, 431),
-            Err(e) => assert!(e.is_reset(), "{e}"),
-        }
+    // One 9000-byte field: under SECTION_MAX for h2, over FIELD_MAX for the render.
+    let v = vec![b'v'; 9000];
+    let r = b.request("GET", None, "/field", &[("x-big", &v)], Body::Empty);
+    let r = r.expect("request");
+    assert_eq!(
+        (r.0.as_u16(), xmq_error(&r)),
+        (400, Some("header-too-long"))
+    );
 
-        // One 9000-byte field: under SECTION_MAX for h2, over FIELD_MAX for the render.
-        let v = vec![b'v'; 9000];
-        let r = b.request("GET", None, "/field", &[("x-big", &v)], Body::Empty);
-        let r = r.expect("request");
-        assert_eq!(
-            (r.0.as_u16(), xmq_error(&r)),
-            (400, Some("header-too-long"))
-        );
-
-        let r = b.get("/big-resp", &[]);
-        assert_eq!(
-            (r.0.as_u16(), xmq_error(&r)),
-            (502, Some("upstream-protocol"))
-        );
-        assert!(
-            !o.requests()
-                .iter()
-                .any(|r| r.path == "/section" || r.path == "/field")
-        );
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+    let r = b.get("/big-resp", &[]);
+    assert_eq!(
+        (r.0.as_u16(), xmq_error(&r)),
+        (502, Some("upstream-protocol"))
+    );
+    assert!(
+        !o.requests()
+            .iter()
+            .any(|r| r.path == "/section" || r.path == "/field")
+    );
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §7.7 (D9): `alt-svc` is dropped; other headers stay.
-matrix!(
-    mitm_alt_svc_stripped,
-    |cells: (Backend, Backend), _tag: &str| {
-        let h = Handler::WithHeaders(
-            vec![
-                ("alt-svc", "h3=\":443\"; ma=86400".into()),
-                ("x-kept", "yes".into()),
-            ],
-            Box::new(Handler::Status(200)),
-        );
-        let o = origin(Proto::H2Tls, h);
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        let (status, h, _) = b.get("/alt", &[]);
-        assert_eq!(status, 200);
-        assert_eq!(h.get("x-kept").unwrap(), "yes");
-        assert!(h.get("alt-svc").is_none(), "{h:?}");
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn mitm_alt_svc_stripped() {
+    let h = Handler::WithHeaders(
+        vec![
+            ("alt-svc", "h3=\":443\"; ma=86400".into()),
+            ("x-kept", "yes".into()),
+        ],
+        Box::new(Handler::Status(200)),
+    );
+    let o = origin(Proto::H2Tls, h);
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    let (status, h, _) = b.get("/alt", &[]);
+    assert_eq!(status, 200);
+    assert_eq!(h.get("x-kept").unwrap(), "yes");
+    assert!(h.get("alt-svc").is_none(), "{h:?}");
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §7.5 step 3: `:authority` ≠ SNI → 421, no `x-mq-error`, nothing forwarded.
-matrix!(
-    mitm_421_on_authority_mismatch,
-    |cells: (Backend, Backend), _tag: &str| {
-        let o = origin(Proto::H2Tls, Handler::Status(200));
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        let other = format!("other.localhost:{}", o.addr.port());
-        let r = b.request("GET", Some(&other), "/misdirected", &[], Body::Empty);
-        let r = r.expect("request");
-        assert_eq!((r.0.as_u16(), xmq_error(&r)), (421, None));
-        assert!(!o.requests().iter().any(|r| r.path == "/misdirected"));
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn mitm_421_on_authority_mismatch() {
+    let o = origin(Proto::H2Tls, Handler::Status(200));
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    let other = format!("other.localhost:{}", o.addr.port());
+    let r = b.request("GET", Some(&other), "/misdirected", &[], Body::Empty);
+    let r = r.expect("request");
+    assert_eq!((r.0.as_u16(), xmq_error(&r)), (421, None));
+    assert!(!o.requests().iter().any(|r| r.path == "/misdirected"));
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // ---- tunnel ----
 
@@ -441,143 +420,130 @@ fn during_outage(b: &TestBrowser, path: &str, unavailable: &Cell<bool>) -> Outag
 
 // SP4 spec §10: with the tunnel down, a request gets 502 `tunnel-unavailable` and the
 // browser connection stays usable.
-matrix!(
-    mitm_tunnel_down_502,
-    |cells: (Backend, Backend), _tag: &str| {
-        let o = origin(Proto::H2Tls, Handler::Status(200));
-        let p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        assert_eq!(b.get("/before", &[]).0, 200);
-        p.server.shutdown.trigger();
-        let seen = Cell::new(false);
-        wait_until("502 tunnel-unavailable", || {
-            during_outage(&b, "/down", &seen) == Outage::Unavailable
-        });
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn mitm_tunnel_down_502() {
+    let o = origin(Proto::H2Tls, Handler::Status(200));
+    let p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    assert_eq!(b.get("/before", &[]).0, 200);
+    p.server.shutdown.trigger();
+    let seen = Cell::new(false);
+    wait_until("502 tunnel-unavailable", || {
+        during_outage(&b, "/down", &seen) == Outage::Unavailable
+    });
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // Review Focus 1: the tunnel drops (server restart) while a MITM stream is in flight.
 // That stream ends with 502 `upstream-reset` (SP4 spec §10) or a stream reset; requests during the outage follow
 // `during_outage`'s order; once the tunnel is back, the same browser
 // connection is served on it. `TestBrowser` never redials, so a success on its one
 // `SendRequest` after the restart is that connection.
-matrix!(
-    mitm_survives_tunnel_reconnect,
-    |cells: (Backend, Backend), _tag: &str| {
-        let h = Handler::PerPath(vec![
-            ("/hang", Handler::HangNoResponse),
-            ("/before", Handler::Status(200)),
-            ("/after", Handler::Status(200)),
-        ]);
-        let o = origin(Proto::H2Tls, h);
-        let mut p = proxy(o.addr, p256(), cells);
-        let b = mitm_browser(&p, o.addr);
-        assert_eq!(b.get("/before", &[]).0, 200);
-
-        let hang = b.start_get("/hang");
-        b.drive_until(|| o.requests().iter().any(|r| r.path == "/hang"));
-        p.restart_server();
-        match b.finish(hang) {
-            Ok(r) => assert_eq!((r.0.as_u16(), xmq_error(&r)), (502, Some("upstream-reset"))),
-            Err(e) => assert!(e.is_reset() && !e.is_go_away() && !e.is_io(), "{e}"),
-        }
-
-        let seen = Cell::new(false);
-        wait_until("a 200 on the new tunnel", || {
-            during_outage(&b, "/after", &seen) == Outage::Served
-        });
-        assert_eq!(p.join_both(), (0, 0));
+#[test]
+fn mitm_survives_tunnel_reconnect() {
+    let h = Handler::PerPath(vec![
+        ("/hang", Handler::HangNoResponse),
+        ("/before", Handler::Status(200)),
+        ("/after", Handler::Status(200)),
+    ]);
+    let o = origin(Proto::H2Tls, h);
+    let mut p = proxy(o.addr, p256());
+    let b = mitm_browser(&p, o.addr);
+    assert_eq!(b.get("/before", &[]).0, 200);
+
+    let hang = b.start_get("/hang");
+    b.drive_until(|| o.requests().iter().any(|r| r.path == "/hang"));
+    p.restart_server();
+    match b.finish(hang) {
+        Ok(r) => assert_eq!((r.0.as_u16(), xmq_error(&r)), (502, Some("upstream-reset"))),
+        Err(e) => assert!(e.is_reset() && !e.is_go_away() && !e.is_io(), "{e}"),
     }
-);
+
+    let seen = Cell::new(false);
+    wait_until("a 200 on the new tunnel", || {
+        during_outage(&b, "/after", &seen) == Outage::Served
+    });
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // ---- opaque routes: the origin's own certificate, verified with the origin CA ----
 
 // SP4 spec §7.3 route step 3: no `h2` in ALPN → opaque.
-matrix!(opaque_no_h2_alpn, |cells: (Backend, Backend),
-                            _tag: &str| {
+#[test]
+fn opaque_no_h2_alpn() {
     let log = Logged::start("opaque(NoH2)");
     let o = origin(Proto::H2Tls, Handler::Status(200));
-    let p = proxy(o.addr, p256(), cells);
+    let p = proxy(o.addr, p256());
     let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
     assert_origin_chain(&b.tls_only(&[b"http/1.1"], "localhost"));
     log.wait();
     assert_eq!(p.join_both(), (0, 0));
-});
+}
 
 // SP4 spec §7.3 route step 4: an ignored host → opaque; h2 then runs with the origin.
-matrix!(
-    opaque_ignored_host,
-    |cells: (Backend, Backend), _tag: &str| {
-        let log = Logged::start("opaque(Ignored)");
-        let o = origin(Proto::H2Tls, Handler::Status(200));
-        let p = proxy(
-            o.addr,
-            mitm_cfg("ca-p256", &["localhost"], MitmTuning::default()),
-            cells,
-        );
-        let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
-        assert_origin_chain(&b.tls_only(&[b"h2"], "localhost"));
-        assert_eq!(b.get("/direct", &[]).0, 200);
-        assert!(o.requests().iter().any(|r| r.path == "/direct"));
-        log.wait();
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn opaque_ignored_host() {
+    let log = Logged::start("opaque(Ignored)");
+    let o = origin(Proto::H2Tls, Handler::Status(200));
+    let p = proxy(
+        o.addr,
+        mitm_cfg("ca-p256", &["localhost"], MitmTuning::default()),
+    );
+    let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
+    assert_origin_chain(&b.tls_only(&[b"h2"], "localhost"));
+    assert_eq!(b.get("/direct", &[]).0, 200);
+    assert!(o.requests().iter().any(|r| r.path == "/direct"));
+    log.wait();
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §7.3 "Peek": bytes that are not TLS → opaque, relayed as they are.
-matrix!(
-    opaque_non_tls_bytes,
-    |cells: (Backend, Backend), _tag: &str| {
-        let log = Logged::start("opaque(NotTls)");
-        let o = origin(Proto::H1Plain, Handler::Status(200));
-        let p = proxy(o.addr, p256(), cells);
-        let mut s = TcpStream::connect(p.mitm_addr()).unwrap();
-        s.set_read_timeout(Some(T)).unwrap();
-        s.write_all(b"GET /plain HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
-            .unwrap();
-        let mut reply = Vec::new();
-        s.read_to_end(&mut reply).unwrap();
-        assert!(reply.starts_with(b"HTTP/1.1 200"), "{reply:?}");
-        log.wait();
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn opaque_non_tls_bytes() {
+    let log = Logged::start("opaque(NotTls)");
+    let o = origin(Proto::H1Plain, Handler::Status(200));
+    let p = proxy(o.addr, p256());
+    let mut s = TcpStream::connect(p.mitm_addr()).unwrap();
+    s.set_read_timeout(Some(T)).unwrap();
+    s.write_all(b"GET /plain HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
+        .unwrap();
+    let mut reply = Vec::new();
+    s.read_to_end(&mut reply).unwrap();
+    assert!(reply.starts_with(b"HTTP/1.1 200"), "{reply:?}");
+    log.wait();
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §7.3 route step 5: an SNI outside a NameConstraints CA's scope → opaque.
-matrix!(
-    opaque_out_of_scope_constrained_ca,
-    |cells: (Backend, Backend), _tag: &str| {
-        let log = Logged::start("opaque(OutOfCaScope)");
-        let o = origin(Proto::H2Tls, Handler::Status(200));
-        let mitm = mitm_cfg("ca-dns-constraint", &[], MitmTuning::default());
-        let p = proxy(o.addr, mitm, cells);
-        let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
-        assert_origin_chain(&b.tls_only(&[b"h2"], "localhost"));
-        log.wait();
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn opaque_out_of_scope_constrained_ca() {
+    let log = Logged::start("opaque(OutOfCaScope)");
+    let o = origin(Proto::H2Tls, Handler::Status(200));
+    let mitm = mitm_cfg("ca-dns-constraint", &[], MitmTuning::default());
+    let p = proxy(o.addr, mitm);
+    let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
+    assert_origin_chain(&b.tls_only(&[b"h2"], "localhost"));
+    log.wait();
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §7.3: no ClientHello within the peek deadline → opaque; a handshake started
 // afterwards reaches the origin.
-matrix!(
-    opaque_peek_timeout,
-    |cells: (Backend, Backend), _tag: &str| {
-        let log = Logged::start("opaque(Timeout)");
-        let o = origin(Proto::H2Tls, Handler::Status(200));
-        let tuning = MitmTuning {
-            peek: Duration::from_millis(200),
-            ..MitmTuning::default()
-        };
-        let p = proxy(o.addr, mitm_cfg("ca-p256", &[], tuning), cells);
-        let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
-        let tcp = TcpStream::connect(p.mitm_addr()).unwrap();
-        log.wait();
-        assert_origin_chain(&b.tls_on(tcp, &[b"h2"], "localhost"));
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn opaque_peek_timeout() {
+    let log = Logged::start("opaque(Timeout)");
+    let o = origin(Proto::H2Tls, Handler::Status(200));
+    let tuning = MitmTuning {
+        peek: Duration::from_millis(200),
+        ..MitmTuning::default()
+    };
+    let p = proxy(o.addr, mitm_cfg("ca-p256", &[], tuning));
+    let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
+    let tcp = TcpStream::connect(p.mitm_addr()).unwrap();
+    log.wait();
+    assert_origin_chain(&b.tls_on(tcp, &[b"h2"], "localhost"));
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 /// A plain TCP origin that reads to EOF, writes back what it read, and closes.
 fn echo_to_eof() -> (SocketAddr, JoinHandle<Vec<u8>>) {
@@ -596,44 +562,40 @@ fn echo_to_eof() -> (SocketAddr, JoinHandle<Vec<u8>>) {
 
 // SP4 spec §7.3 "EOF and errors while peeking": a half-close with bytes in rx → opaque;
 // the relay carries the bytes and the EOF, and the answer still comes back.
-matrix!(
-    opaque_peek_eof_half_close,
-    |cells: (Backend, Backend), _tag: &str| {
-        let log = Logged::start("opaque(Eof)");
-        let (addr, origin) = echo_to_eof();
-        let p = proxy(addr, p256(), cells);
-        let mut s = TcpStream::connect(p.mitm_addr()).unwrap();
-        s.set_read_timeout(Some(T)).unwrap();
-        // A TLS record header prefix: the peek waits for more, then sees the EOF.
-        let sent = [0x16, 0x03, 0x01, 0x00];
-        s.write_all(&sent).unwrap();
-        s.shutdown(Shutdown::Write).unwrap();
-        let mut reply = Vec::new();
-        s.read_to_end(&mut reply).unwrap();
-        assert_eq!(reply, sent);
-        assert_eq!(origin.join().unwrap(), sent);
-        log.wait();
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn opaque_peek_eof_half_close() {
+    let log = Logged::start("opaque(Eof)");
+    let (addr, origin) = echo_to_eof();
+    let p = proxy(addr, p256());
+    let mut s = TcpStream::connect(p.mitm_addr()).unwrap();
+    s.set_read_timeout(Some(T)).unwrap();
+    // A TLS record header prefix: the peek waits for more, then sees the EOF.
+    let sent = [0x16, 0x03, 0x01, 0x00];
+    s.write_all(&sent).unwrap();
+    s.shutdown(Shutdown::Write).unwrap();
+    let mut reply = Vec::new();
+    s.read_to_end(&mut reply).unwrap();
+    assert_eq!(reply, sent);
+    assert_eq!(origin.join().unwrap(), sent);
+    log.wait();
+    assert_eq!(p.join_both(), (0, 0));
+}
 
 // SP4 spec §7.3 "Accept" step 2: at `max_conns` (lowered to 1) a new flow goes opaque.
-matrix!(
-    opaque_at_capacity,
-    |cells: (Backend, Backend), _tag: &str| {
-        let log = Logged::start("opaque(AtCapacity)");
-        let o = origin(Proto::H2Tls, Handler::Status(200));
-        let tuning = MitmTuning {
-            max_conns: 1,
-            ..MitmTuning::default()
-        };
-        let p = proxy(o.addr, mitm_cfg("ca-p256", &[], tuning), cells);
-        // The one MITM conn, live.
-        let held = mitm_browser(&p, o.addr);
-        let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
-        assert_origin_chain(&b.tls_only(&[b"h2"], "localhost"));
-        assert_eq!(held.get("/still", &[]).0, 200);
-        log.wait();
-        assert_eq!(p.join_both(), (0, 0));
-    }
-);
+#[test]
+fn opaque_at_capacity() {
+    let log = Logged::start("opaque(AtCapacity)");
+    let o = origin(Proto::H2Tls, Handler::Status(200));
+    let tuning = MitmTuning {
+        max_conns: 1,
+        ..MitmTuning::default()
+    };
+    let p = proxy(o.addr, mitm_cfg("ca-p256", &[], tuning));
+    // The one MITM conn, live.
+    let held = mitm_browser(&p, o.addr);
+    let b = browser(&p, o.addr, Path::new(ORIGIN_CA));
+    assert_origin_chain(&b.tls_only(&[b"h2"], "localhost"));
+    assert_eq!(held.get("/still", &[]).0, 200);
+    log.wait();
+    assert_eq!(p.join_both(), (0, 0));
+}
diff --git a/crates/mq-proxy/src/client/exchange/mod.rs b/crates/mq-proxy/src/client/exchange/mod.rs
index a0313f1a..103f4c8c 100644
--- a/crates/mq-proxy/src/client/exchange/mod.rs
+++ b/crates/mq-proxy/src/client/exchange/mod.rs
@@ -7,7 +7,7 @@ pub(crate) mod wire;
 
 use mq_http::headers::{HttpVer, Method, Reject, Target, body_check_applies};
 use mq_runtime::Cx;
-use mq_transport_api::{ConnId, Event, H3Header, H3ReqId, StreamError, Unread};
+use mq_transport_api::{ConnId, Event, H3Header, H3ReqId, StreamError};
 use resp::{HeadCollector, RespHead};
 use std::collections::HashMap;
 
@@ -97,8 +97,8 @@ enum Up {
 /// SP4 spec §4.2: the response side.
 enum Down {
     AwaitHead,
-    /// `H3Closed` arrived first: rescue or none.
-    ClosedBeforeHead(Option<Unread>),
+    /// `H3Closed` arrived before the response head.
+    ClosedBeforeHead,
     /// `fin`: the transport fin was observed.
     Body {
         status: u16,
@@ -106,13 +106,6 @@ enum Down {
         delivered: u64,
         fin: bool,
     },
-    Rescued {
-        status: u16,
-        cl: Option<u64>,
-        delivered: u64,
-        body: Vec<u8>,
-        off: usize,
-    },
     /// The next `read_head` / `read_body` returns `Fail`.
     Failed,
 }
@@ -254,36 +247,21 @@ impl<O: Copy> Exchanges<O> {
     }
 
     /// SP4 spec §4.3: readiness goes to the owner; `H3Closed` ends the upload,
-    /// moves the response side (rescue or failure) and reads as `Readable`.
+    /// settles the response side and reads as `Readable`.
     /// Events for unknown ids give `None` and are left as they were; a known
-    /// `H3Closed`'s rescue is taken out of `ev` (no second copy of the body).
+    /// `H3Closed` preserves a response whose FIN was already consumed.
     pub fn on_event(&mut self, ev: &mut Event) -> Option<(O, H3ReqId, Ready)> {
         let (id, ready) = match ev {
             Event::H3Readable(id) => (*id, Ready::Readable),
             Event::H3Writable(id) => (*id, Ready::Writable),
-            Event::H3Closed(id, close) => {
+            Event::H3Closed(id, _) => {
                 let x = self.by_id.get_mut(id)?;
                 // The transport already removed the request slot: later ops are `Stale`.
                 x.live = false;
                 x.up = Up::Done;
                 x.down = match std::mem::replace(&mut x.down, Down::Failed) {
-                    Down::AwaitHead => Down::ClosedBeforeHead(close.unread.take()),
-                    // `fin: true` keeps `Body`: nothing is rescued after a consumed fin.
-                    Down::Body {
-                        status,
-                        cl,
-                        delivered,
-                        fin: false,
-                    } => match close.unread.take() {
-                        Some(u) => Down::Rescued {
-                            status,
-                            cl,
-                            delivered,
-                            body: u.body,
-                            off: 0,
-                        },
-                        None => Down::Failed,
-                    },
+                    Down::AwaitHead => Down::ClosedBeforeHead,
+                    Down::Body { fin: false, .. } => Down::Failed,
                     d => d,
                 };
                 (*id, Ready::Readable)
@@ -306,7 +284,7 @@ impl<O: Copy> Exchanges<O> {
     }
 
     /// SP4 spec §4.3 `read_head`: collect the head under the §5 limits, from
-    /// the transport or from a rescue. `Blocked` / `Stale` wait (a stale
+    /// the transport. `Blocked` / `Stale` wait (a stale
     /// readiness waits for `H3Closed`, SP3-1). A `Fail` removes the exchange.
     /// After `Head` it is a no-op `Wait`.
     pub fn read_head(&mut self, cx: &mut Cx<'_>, id: H3ReqId) -> HeadOut {
@@ -314,53 +292,36 @@ impl<O: Copy> Exchanges<O> {
             return HeadOut::Fail(Reject::UpstreamReset);
         };
         let mut col = HeadCollector::default();
-        // `rescue`: `Ok(body)` from a rescue, else `Err(fin)` of the section.
-        let (head, rescue) = match &mut x.down {
+        let (head, fin) = match &mut x.down {
             Down::AwaitHead => match cx.h3_recv_headers(id, &mut |n, v| col.push(n, v)) {
-                Ok(fin) => (col.finish(), Err(fin)),
+                Ok(fin) => (col.finish(), fin),
                 Err(StreamError::Blocked | StreamError::Stale) => return HeadOut::Wait,
                 Err(StreamError::Reset | StreamError::Conn) => {
                     self.fail(cx, id);
                     return HeadOut::Fail(Reject::UpstreamReset);
                 }
             },
-            Down::ClosedBeforeHead(Some(u)) if u.headers.is_some() => {
-                for (n, v) in u.headers.iter().flatten() {
-                    col.push(n, v);
-                }
-                // The end comes from the rescue, through `read_body`.
-                (col.finish(), Ok(std::mem::take(&mut u.body)))
-            }
-            Down::ClosedBeforeHead(_) | Down::Failed => {
+            Down::ClosedBeforeHead | Down::Failed => {
                 self.fail(cx, id);
                 return HeadOut::Fail(Reject::UpstreamReset);
             }
-            Down::Body { .. } | Down::Rescued { .. } => return HeadOut::Wait,
+            Down::Body { .. } => return HeadOut::Wait,
         };
         let Ok(head) = head else {
             self.fail(cx, id);
             return HeadOut::Fail(Reject::UpstreamProtocol);
         };
         let (status, cl) = (head.status, head.cl);
-        x.down = match rescue {
-            Err(fin) => Down::Body {
-                status,
-                cl,
-                delivered: 0,
-                fin,
-            },
-            Ok(body) => Down::Rescued {
-                status,
-                cl,
-                delivered: 0,
-                body,
-                off: 0,
-            },
+        x.down = Down::Body {
+            status,
+            cl,
+            delivered: 0,
+            fin,
         };
         HeadOut::Head(head)
     }
 
-    /// SP4 spec §4.3 `read_body`: the transport's bytes, or the rescue in
+    /// SP4 spec §4.3 `read_body`: the transport's bytes in
     /// `buf`-sized slices; the read that ends the body goes through the end
     /// rule. An empty `buf` consumes nothing; on a live body it is still one
     /// transport read, which xquic answers with the fin only when no body is
@@ -377,7 +338,7 @@ impl<O: Copy> Exchanges<O> {
         };
         // `(n, Some(short))` when this read ends the body.
         let (n, end) = match &mut x.down {
-            Down::AwaitHead | Down::ClosedBeforeHead(_) => return BodyOut::Wait,
+            Down::AwaitHead | Down::ClosedBeforeHead => return BodyOut::Wait,
             Down::Failed => {
                 self.fail(cx, id);
                 return BodyOut::Fail;
@@ -406,23 +367,6 @@ impl<O: Copy> Exchanges<O> {
                     return BodyOut::Fail;
                 }
             },
-            Down::Rescued {
-                status,
-                cl,
-                delivered,
-                body,
-                off,
-            } => {
-                let n = buf.len().min(body.len() - *off);
-                if n == 0 && *off < body.len() {
-                    return BodyOut::Wait;
-                }
-                buf[..n].copy_from_slice(&body[*off..*off + n]);
-                *off += n;
-                *delivered += n as u64;
-                let end = *off == body.len();
-                (n, end.then(|| short(*status, *cl, *delivered)))
-            }
         };
         match end {
             None => BodyOut::Data(n),
@@ -480,8 +424,6 @@ mod tests {
     use std::net::{Ipv4Addr, SocketAddr};
 
     const IDS: usize = 4;
-    /// Every rescue carries these bytes (`Unread.body`).
-    const RESCUE: &[u8] = b"xyz";
 
     #[derive(Clone, Debug)]
     enum Op {
@@ -499,8 +441,6 @@ mod tests {
         Writable(usize),
         Closed {
             id: usize,
-            unread: bool,
-            headers: bool,
         },
         /// `err` queues a `Reset` for the next `h3_send_body`.
         Send {
@@ -543,13 +483,7 @@ mod tests {
                     err
                 }),
             id.clone().prop_map(Op::Writable),
-            (id.clone(), any::<bool>(), any::<bool>()).prop_map(|(id, unread, headers)| {
-                Op::Closed {
-                    id,
-                    unread,
-                    headers,
-                }
-            }),
+            id.clone().prop_map(|id| Op::Closed { id }),
             (id.clone(), 0..4usize, any::<bool>(), rare())
                 .prop_map(|(id, len, fin, err)| Op::Send { id, len, fin, err }),
             (id.clone(), 0..6u64).prop_map(|(id, buffered)| Op::Eof { id, buffered }),
@@ -582,18 +516,12 @@ mod tests {
     #[derive(Clone, Copy, Debug, PartialEq)]
     enum MDown {
         AwaitHead,
-        /// `Some(headers present)` with a rescue.
-        ClosedBeforeHead(Option<bool>),
+        ClosedBeforeHead,
         Body {
             fin: bool,
             cl: Option<u64>,
             delivered: u64,
         },
-        Rescued {
-            cl: Option<u64>,
-            delivered: u64,
-            left: usize,
-        },
         Failed,
     }
 
@@ -678,7 +606,7 @@ mod tests {
             (BodyOut::Last(n), r)
         }
 
-        fn on_closed(&mut self, unread: Option<bool>) {
+        fn on_closed(&mut self) {
             self.closed = true;
             if self.removed {
                 return;
@@ -686,19 +614,8 @@ mod tests {
             self.live = false;
             self.up = MUp::Done;
             self.down = match self.down {
-                MDown::AwaitHead => MDown::ClosedBeforeHead(unread),
-                MDown::Body {
-                    fin: false,
-                    cl,
-                    delivered,
-                } => match unread {
-                    Some(_) => MDown::Rescued {
-                        cl,
-                        delivered,
-                        left: RESCUE.len(),
-                    },
-                    None => MDown::Failed,
-                },
+                MDown::AwaitHead => MDown::ClosedBeforeHead,
+                MDown::Body { fin: false, .. } => MDown::Failed,
                 d => d,
             };
         }
@@ -779,18 +696,10 @@ mod tests {
                         }
                     }
                 }
-                MDown::ClosedBeforeHead(Some(true)) => {
-                    self.down = MDown::Rescued {
-                        cl: None,
-                        delivered: 0,
-                        left: RESCUE.len(),
-                    };
-                    (MHead::Head(200, None), 0)
-                }
-                MDown::ClosedBeforeHead(_) | MDown::Failed => {
+                MDown::ClosedBeforeHead | MDown::Failed => {
                     (MHead::Fail(Reject::UpstreamReset), self.fail())
                 }
-                MDown::Body { .. } | MDown::Rescued { .. } => (MHead::Wait, 0),
+                MDown::Body { .. } => (MHead::Wait, 0),
             }
         }
 
@@ -800,7 +709,7 @@ mod tests {
                 return (BodyOut::Fail, vec![], 0);
             }
             match self.down {
-                MDown::AwaitHead | MDown::ClosedBeforeHead(_) => (BodyOut::Wait, vec![], 0),
+                MDown::AwaitHead | MDown::ClosedBeforeHead => (BodyOut::Wait, vec![], 0),
                 MDown::Failed => (BodyOut::Fail, vec![], self.fail()),
                 MDown::Body {
                     fin: true,
@@ -842,34 +751,11 @@ mod tests {
                     let (o, c) = self.end(n, cl, delivered);
                     (o, bytes, 1 + c)
                 }
-                MDown::Rescued {
-                    cl,
-                    delivered,
-                    left,
-                } => {
-                    let n = cap.min(left);
-                    if n == 0 && left > 0 {
-                        return (BodyOut::Wait, vec![], 0);
-                    }
-                    let off = RESCUE.len() - left;
-                    let bytes = RESCUE[off..off + n].to_vec();
-                    let (delivered, left) = (delivered + n as u64, left - n);
-                    self.down = MDown::Rescued {
-                        cl,
-                        delivered,
-                        left,
-                    };
-                    if left > 0 {
-                        return (BodyOut::Data(n), bytes, 0);
-                    }
-                    let (o, c) = self.end(n, cl, delivered);
-                    (o, bytes, c)
-                }
             }
         }
     }
 
-    fn close(unread: Option<Unread>) -> H3Close {
+    fn close() -> H3Close {
         let stats = H3ReqStats {
             send_body: 0,
             recv_body: 0,
@@ -881,7 +767,7 @@ mod tests {
             stream_err: 0,
             close_msg: None,
         };
-        H3Close { stats, unread }
+        H3Close { stats }
     }
 
     fn resets(t: &ScriptedHandle, r: H3ReqId) -> usize {
@@ -970,18 +856,14 @@ mod tests {
                         prop_assert_eq!(got, want);
                         0
                     }
-                    Op::Closed { id, unread, headers } => {
+                    Op::Closed { id } => {
                         let (r, s) = (ids[id], &mut m[id]);
                         if !s.closed {
-                            let u = unread.then(|| Unread {
-                                headers: headers.then(|| hs(&[(":status", "200".to_owned())])),
-                                body: RESCUE.to_vec(),
-                            });
-                            t.close_h3(r, close(u.clone()));
-                            let got = ex.on_event(&mut Event::H3Closed(r, Box::new(close(u))));
+                            t.close_h3(r, close());
+                            let got = ex.on_event(&mut Event::H3Closed(r, Box::new(close())));
                             let want = (!s.removed).then_some((owner(id), r, Ready::Readable));
                             prop_assert_eq!(got, want);
-                            s.on_closed(unread.then_some(headers));
+                            s.on_closed();
                         }
                         0
                     }
diff --git a/crates/mq-proxy/tests/client_exchange.rs b/crates/mq-proxy/tests/client_exchange.rs
index f942f827..a77feb14 100644
--- a/crates/mq-proxy/tests/client_exchange.rs
+++ b/crates/mq-proxy/tests/client_exchange.rs
@@ -1,6 +1,6 @@
 //! SP4 spec §4.2/§4.3: the H3 exchange core — open, the upload send rules,
 //! the upload EOF rule, reset, event routing, the pull reads, the `H3Closed`
-//! rescue, the end rule and failure settlement — on a
+//! close handling, the end rule and failure settlement — on a
 //! `Shard<ScriptedTransport, ExApp>`.
 
 use mq_http::headers::{Reject, parse_method, parse_target};
@@ -12,9 +12,7 @@ use mq_runtime::{
     AcceptMeta, App, Cx, DialError, DialOpId, ListenerTag, Shard, SocketOpId, TcpEnd, TcpId,
     TimerId, UdpSocketId,
 };
-use mq_transport_api::{
-    ConnId, Error, Event, H3Close, H3ReqId, H3ReqStats, StreamError, Time, Unread,
-};
+use mq_transport_api::{ConnId, Error, Event, H3Close, H3ReqId, H3ReqStats, StreamError, Time};
 use std::io;
 use std::net::{Ipv4Addr, SocketAddr};
 
@@ -171,15 +169,9 @@ impl H {
             .with_app(self.now, |a, _| std::mem::take(&mut a.out))
     }
 
-    /// `H3Closed` for `r` with `unread`; the recorded outputs.
-    fn closed(&mut self, r: H3ReqId, unread: Option<Unread>) -> Vec<(u32, H3ReqId, Ready)> {
-        self.t.close_h3(
-            r,
-            H3Close {
-                stats: stats(),
-                unread,
-            },
-        );
+    /// `H3Closed` for `r`; the recorded outputs.
+    fn closed(&mut self, r: H3ReqId) -> Vec<(u32, H3ReqId, Ready)> {
+        self.t.close_h3(r, H3Close { stats: stats() });
         self.drive()
     }
 
@@ -225,13 +217,6 @@ fn hs(pairs: &[(&str, &str)]) -> Vec<(Vec<u8>, Vec<u8>)> {
         .collect()
 }
 
-fn unread(headers: Option<&[(&str, &str)]>, body: &[u8]) -> Option<Unread> {
-    Some(Unread {
-        headers: headers.map(hs),
-        body: body.to_vec(),
-    })
-}
-
 const OK: &[(&str, &str)] = &[(":status", "200")];
 
 fn stats() -> H3ReqStats {
@@ -381,7 +366,7 @@ fn send_stale_is_blocked_then_done_after_h3closed() {
     h.t.expect_h3_send_body(r, Err(StreamError::Stale));
     assert_eq!(h.send(r, b"hello", false), SendOut::Blocked);
     assert_eq!(h.resets(r), 0);
-    assert_eq!(h.closed(r, None), [(9, r, Ready::Readable)]);
+    assert_eq!(h.closed(r), [(9, r, Ready::Readable)]);
     assert_eq!(h.send(r, b"hello", false), SendOut::Done);
     assert!(h.contains(r));
     assert_eq!(h.send_calls(r).len(), 1);
@@ -468,7 +453,7 @@ fn on_event_unknown_id_none() {
     let never = h.t.new_h3_req_id();
     assert!(h.event(Event::H3Readable(never)).is_empty());
     assert!(h.event(Event::H3Writable(never)).is_empty());
-    assert!(h.closed(never, None).is_empty());
+    assert!(h.closed(never).is_empty());
     assert!(h.event(Event::ConnEstablished(h.conn)).is_empty());
     let r = h.open(BodyLen::Unknown, 3);
     assert_eq!(h.event(Event::H3Readable(r)), [(3, r, Ready::Readable)]);
@@ -483,7 +468,7 @@ fn drain_owner_resets_only_matching() {
     let b = h.open(BodyLen::Unknown, 2);
     let c = h.open(BodyLen::Unknown, 1);
     // `c` is closed already: drained without a reset.
-    assert_eq!(h.closed(c, None), [(1, c, Ready::Readable)]);
+    assert_eq!(h.closed(c), [(1, c, Ready::Readable)]);
     h.ex(|ex, cx| ex.drain_owner(cx, |o| *o == 1));
     assert_eq!((h.resets(a), h.resets(b), h.resets(c)), (1, 0, 0));
     assert!(!h.contains(a) && h.contains(b) && !h.contains(c));
@@ -502,13 +487,7 @@ fn send_done_never_removes_exchange() {
     assert_eq!(h.send(empty, b"x", false), SendOut::Done);
     assert_eq!(h.send(known, b"ab", false), SendOut::Accepted(2));
     assert_eq!(h.send(known, b"c", false), SendOut::Done);
-    h.closed(
-        closed,
-        Some(Unread {
-            headers: None,
-            body: vec![],
-        }),
-    );
+    h.closed(closed);
     assert_eq!(h.send(closed, b"x", true), SendOut::Done);
     assert!(h.contains(empty) && h.contains(known) && h.contains(closed));
     assert_eq!(h.len(), 3);
@@ -570,15 +549,14 @@ fn head_fin_then_h3closed_none_still_last_zero() {
     let r = h.open(BodyLen::Empty, 7);
     h.respond(r, OK, true);
     h.head_status(r);
-    assert_eq!(h.closed(r, None), [(7, r, Ready::Readable)]);
+    assert_eq!(h.closed(r), [(7, r, Ready::Readable)]);
     assert_eq!(h.read_body(r, 16), (BodyOut::Last(0), vec![]));
     assert!(!h.contains(r));
     assert_eq!(h.resets(r), 0);
 }
 
 /// A stale `H3Readable` (xquic signalled readability, then destroyed the
-/// request: QPACK-blocked HEADERS decoded after the close timer) queued
-/// ahead of `H3Closed`: the read waits, and the rescue still completes.
+/// request) queued ahead of `H3Closed`: the read waits for the terminal event.
 #[test]
 fn stale_head_readiness_waits_for_h3closed() {
     let mut h = H::new();
@@ -587,12 +565,11 @@ fn stale_head_readiness_waits_for_h3closed() {
     assert_eq!(h.drive(), [(7, r, Ready::Readable)]);
     assert_eq!(h.read_head(r), HeadOut::Wait);
     assert!(h.contains(r));
-    h.closed(r, unread(Some(OK), b"hello"));
-    assert_eq!(h.head_status(r), 200);
-    assert_eq!(h.read_body(r, 16), (BodyOut::Last(5), b"hello".to_vec()));
+    h.closed(r);
+    assert_eq!(h.read_head(r), HeadOut::Fail(Reject::UpstreamReset));
     assert_eq!(h.resets(r), 0);
 
-    // The same in the body: the stale read waits, the rescue finishes it.
+    // The same in the body: the stale read waits for the terminal event.
     let r = h.open(BodyLen::Empty, 7);
     h.respond(r, OK, false);
     h.head_status(r);
@@ -601,42 +578,18 @@ fn stale_head_readiness_waits_for_h3closed() {
     h.t.inject_h3_error(r, StreamError::Stale);
     h.drive();
     assert_eq!(h.read_body(r, 16).0, BodyOut::Wait);
-    h.closed(r, unread(None, b"de"));
-    assert_eq!(h.read_body(r, 16), (BodyOut::Last(2), b"de".to_vec()));
+    h.closed(r);
+    assert_eq!(h.read_body(r, 16).0, BodyOut::Fail);
     assert_eq!(h.resets(r), 0);
     assert_eq!(h.len(), 0);
 }
 
-#[test]
-fn closed_before_head_with_headers_rescued_head_then_body() {
-    let mut h = H::new();
-    let r = h.open(BodyLen::Empty, 7);
-    let hd = [(":status", "200"), ("content-length", "5")];
-    assert_eq!(
-        h.closed(r, unread(Some(&hd), b"hello")),
-        [(7, r, Ready::Readable)]
-    );
-    match h.read_head(r) {
-        HeadOut::Head(hd) => assert_eq!((hd.status, hd.cl), (200, Some(5))),
-        o => panic!("{o:?}"),
-    }
-    assert_eq!(h.read_body(r, 16), (BodyOut::Last(5), b"hello".to_vec()));
-    assert!(!h.contains(r));
-    // Malformed rescued headers: `UpstreamProtocol`; the request is gone, no reset.
-    let r = h.open(BodyLen::Empty, 7);
-    h.closed(r, unread(Some(&[("x", "y")]), b"hello"));
-    assert_eq!(h.read_head(r), HeadOut::Fail(Reject::UpstreamProtocol));
-    assert!(!h.contains(r));
-    assert_eq!(h.count(|c| matches!(c, Call::H3Reset(_))), 0);
-    assert_eq!(h.count(|c| matches!(c, Call::H3RecvHeaders(_))), 0);
-}
-
 #[test]
 fn closed_before_head_without_headers_upstream_reset() {
-    for u in [None, unread(None, b"abc")] {
+    {
         let mut h = H::new();
         let r = h.open(BodyLen::Empty, 7);
-        h.closed(r, u);
+        h.closed(r);
         assert_eq!(h.read_head(r), HeadOut::Fail(Reject::UpstreamReset));
         assert!(!h.contains(r));
         assert_eq!(h.resets(r), 0, "the H3 side is gone");
@@ -644,50 +597,14 @@ fn closed_before_head_without_headers_upstream_reset() {
 }
 
 #[test]
-fn body_h3closed_with_unread_serves_rescue_in_slices() {
-    let mut h = H::new();
-    let r = h.open(BodyLen::Empty, 7);
-    h.respond(r, OK, false);
-    h.head_status(r);
-    h.body(r, b"abc", false);
-    assert_eq!(h.read_body(r, 16).0, BodyOut::Data(3));
-    h.closed(r, unread(None, b"0123456789"));
-    assert_eq!(h.read_body(r, 4), (BodyOut::Data(4), b"0123".to_vec()));
-    assert_eq!(h.read_body(r, 4), (BodyOut::Data(4), b"4567".to_vec()));
-    assert_eq!(h.read_body(r, 4), (BodyOut::Last(2), b"89".to_vec()));
-    assert!(!h.contains(r));
-    assert_eq!(h.resets(r), 0);
-
-    // The body check counts delivered plus rescued bytes: 10 + 50 < 100
-    // fails, 10 + 90 completes.
-    for (rescued, last) in [(50, false), (90, true)] {
-        let r = h.open(BodyLen::Empty, 7);
-        h.respond(r, &[(":status", "200"), ("content-length", "100")], false);
-        h.head_status(r);
-        h.body(r, &[b'x'; 10], false);
-        assert_eq!(h.read_body(r, 16).0, BodyOut::Data(10));
-        h.closed(r, unread(None, &vec![b'y'; rescued]));
-        let got = h.read_body(r, 1000).0;
-        let want = if last {
-            BodyOut::Last(rescued)
-        } else {
-            BodyOut::Fail
-        };
-        assert_eq!(got, want, "rescued={rescued}");
-        assert!(!h.contains(r));
-        assert_eq!(h.resets(r), 0);
-    }
-}
-
-#[test]
-fn body_h3closed_without_unread_fail() {
+fn body_h3closed_fails() {
     let mut h = H::new();
     let r = h.open(BodyLen::Empty, 7);
     h.respond(r, OK, false);
     h.head_status(r);
     h.body(r, b"abc", false);
     assert_eq!(h.read_body(r, 16).0, BodyOut::Data(3));
-    assert_eq!(h.closed(r, None), [(7, r, Ready::Readable)]);
+    assert_eq!(h.closed(r), [(7, r, Ready::Readable)]);
     assert_eq!(h.read_body(r, 16).0, BodyOut::Fail);
     assert!(!h.contains(r));
     assert_eq!(h.resets(r), 0, "the H3 side is gone");
@@ -760,7 +677,7 @@ fn cl_shortfall_fail_resets_live_request() {
     let r = h.open(BodyLen::Empty, 7);
     h.respond(r, &[(":status", "200"), ("content-length", "100")], true);
     h.head_status(r);
-    h.closed(r, None);
+    h.closed(r);
     assert_eq!(h.read_body(r, 16).0, BodyOut::Fail);
     assert_eq!(h.resets(r), 0);
     // An unparsable or repeated content-length is not checked.
@@ -812,7 +729,7 @@ fn early_response_resets_unfinished_upload() {
     let r = h.open(BodyLen::Known(10), 7);
     h.respond(r, OK, true);
     h.head_status(r);
-    h.closed(r, None);
+    h.closed(r);
     assert_eq!(h.read_body(r, 16).0, BodyOut::Last(0));
     assert_eq!(h.resets(r), 0);
     assert_eq!(h.len(), 0);
@@ -861,19 +778,6 @@ fn empty_buf_probe() {
     h.body(r, b"", true);
     assert_eq!(h.read_body(r, 0).0, BodyOut::Fail);
     assert!(!h.contains(r));
-    // `Rescued`: `Wait` while bytes remain, `Last(0)` once empty.
-    let r = h.open(BodyLen::Empty, 7);
-    h.respond(r, OK, false);
-    h.head_status(r);
-    h.closed(r, unread(None, b"xy"));
-    assert_eq!(h.read_body(r, 0).0, BodyOut::Wait);
-    assert_eq!(h.read_body(r, 1), (BodyOut::Data(1), b"x".to_vec()));
-    assert_eq!(h.read_body(r, 1), (BodyOut::Last(1), b"y".to_vec()));
-    let r = h.open(BodyLen::Empty, 7);
-    h.respond(r, OK, false);
-    h.head_status(r);
-    h.closed(r, unread(None, b""));
-    assert_eq!(h.read_body(r, 0).0, BodyOut::Last(0));
     assert_eq!(h.len(), 0);
 }
 
diff --git a/crates/mq-proxy/tests/client_gateway_ends.rs b/crates/mq-proxy/tests/client_gateway_ends.rs
index fd147a27..8b9549f3 100644
--- a/crates/mq-proxy/tests/client_gateway_ends.rs
+++ b/crates/mq-proxy/tests/client_gateway_ends.rs
@@ -1,6 +1,6 @@
 //! SP3 spec §5.5 the fetch request's ends (the finish write order with
-//! rescued leftovers, `H3Closed` after `ConnClosed`, abort), §5.9 shutdown,
-//! and §5.7 the metrics tick's two blocks. The stale readiness, rescue,
+//! pending output, `H3Closed` after `ConnClosed`, abort), §5.9 shutdown,
+//! and §5.7 the metrics tick's two blocks. The stale readiness,
 //! body check and early-response rules are the core's, tested in
 //! `client_exchange.rs` (SP4 spec §4.3).
 
@@ -11,7 +11,7 @@ use mq_proxy::config::ClientConfig;
 use mq_runtime::testing::{Call, log_capture};
 use mq_runtime::{IoRequest, IoResult, TcpId};
 use mq_transport_api::{
-    CloseReason, ConnId, ConnStats, ErrType, Event, H3Close, H3ReqId, H3ReqStats, PathStats, Unread,
+    CloseReason, ConnId, ConnStats, ErrType, Event, H3Close, H3ReqId, H3ReqStats, PathStats,
 };
 use std::io;
 use std::time::Duration;
@@ -59,8 +59,8 @@ fn body(h: &mut H, r: H3ReqId, bytes: &[u8], fin: bool) {
     h.drive();
 }
 
-/// `H3Closed` for `r` with `unread`, then let the client run.
-fn closed(h: &mut H, r: H3ReqId, unread: Option<Unread>) {
+/// `H3Closed` for `r`, then let the client run.
+fn closed(h: &mut H, r: H3ReqId) {
     let stats = H3ReqStats {
         send_body: 0,
         recv_body: 0,
@@ -72,17 +72,10 @@ fn closed(h: &mut H, r: H3ReqId, unread: Option<Unread>) {
         stream_err: 0,
         close_msg: None,
     };
-    h.t.close_h3(r, H3Close { stats, unread });
+    h.t.close_h3(r, H3Close { stats });
     h.drive();
 }
 
-fn unread(headers: Option<&[(&str, &str)]>, body: &[u8]) -> Option<Unread> {
-    Some(Unread {
-        headers: headers.map(hs),
-        body: body.to_vec(),
-    })
-}
-
 fn resets(h: &H, r: H3ReqId) -> usize {
     h.count(|c| *c == Call::H3Reset(r))
 }
@@ -119,17 +112,15 @@ const UPSTREAM_RESET: &[u8] =
     b"HTTP/1.1 502 \r\nX-Mq-Error: upstream-reset\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
 
 #[test]
-fn finish_write_order_pending_src_terminator_close() {
+fn finish_write_order_pending_terminator_close() {
     // Review Focus 2: a consumer > 3 PTO behind a completed download.
     let (mut h, tcp, r) = open();
     respond(&mut h, r, &[(":status", "200")], false);
     let first = pattern(4 * 16_384, 0);
-    body(&mut h, r, &first, false); // the fourth frame is stuck (`SendBufFull`)
-    let rescued = pattern(100 * 1024, 7);
-    closed(&mut h, r, unread(None, &rescued));
+    body(&mut h, r, &first, true); // the fourth frame is stuck (`SendBufFull`)
+    closed(&mut h, r);
     let mut want = HEAD_CHUNKED.to_vec();
     want.extend(chunked(&first));
-    want.extend(chunked(&rescued));
     want.extend_from_slice(b"0\r\n\r\n");
     let mut out = Vec::new();
     for _ in 0..16 {
@@ -141,21 +132,7 @@ fn finish_write_order_pending_src_terminator_close() {
         }
     }
     assert_eq!(out.len(), want.len());
-    assert!(out == want, "pending, then rescued frames, then terminator");
-    assert!(!owned(&h, tcp));
-    assert_eq!(resets(&h, r), 0);
-}
-
-/// A rescue that arrives before the head: the core serves head and body,
-/// the front renders head, chunked body and terminator.
-#[test]
-fn finish_from_unread_src() {
-    let (mut h, tcp, r) = open();
-    closed(&mut h, r, unread(Some(&[(":status", "200")]), b"hello"));
-    let mut want = HEAD_CHUNKED.to_vec();
-    want.extend_from_slice(b"5\r\nhello\r\n0\r\n\r\n");
-    assert_eq!(h.tx_all(tcp), want);
-    assert_eq!(close_of(&mut h, tcp), Some(false));
+    assert!(out == want, "pending, then terminator");
     assert!(!owned(&h, tcp));
     assert_eq!(resets(&h, r), 0);
 }
@@ -213,7 +190,7 @@ fn h3closed_after_tunnel_closed_still_ends_request() {
             },
         ));
         assert!(owned(&h, tcp), "ConnClosed alone does not end it");
-        closed(&mut h, r, None);
+        closed(&mut h, r);
         if started {
             assert_eq!(close_of(&mut h, tcp), Some(true));
         } else {
@@ -255,7 +232,7 @@ fn shutdown_aborts_live_fetch_requests() {
         assert!(!owned(&h, t));
     }
     assert_eq!(resets(&h, r), 1);
-    closed(&mut h, r, None); // the reset's own close: ignored
+    closed(&mut h, r); // the reset's own close: ignored
     assert_eq!(resets(&h, r), 1);
 }
 
diff --git a/crates/mq-proxy/tests/client_gateway_upload.rs b/crates/mq-proxy/tests/client_gateway_upload.rs
index f259e06c..37723e4a 100644
--- a/crates/mq-proxy/tests/client_gateway_upload.rs
+++ b/crates/mq-proxy/tests/client_gateway_upload.rs
@@ -8,7 +8,7 @@ use common::*;
 use mq_proxy::config::ClientConfig;
 use mq_runtime::testing::Call;
 use mq_runtime::{IoRequest, IoResult, TcpId};
-use mq_transport_api::{ConnId, Event, H3Close, H3ReqId, H3ReqStats, StreamError, Unread};
+use mq_transport_api::{ConnId, Event, H3Close, H3ReqId, H3ReqStats, StreamError};
 use std::io;
 
 /// A gateway-only client whose tunnel is established.
@@ -172,9 +172,9 @@ fn send_body_conn_error_aborts() {
 }
 
 /// SP4 spec §4.3 / §13.20: a `Stale` send is `Blocked` — the request's
-/// `H3Closed` is queued; its rescue completes the request (SP3 aborted).
+/// `H3Closed` is queued; it settles the failed response.
 #[test]
-fn send_stale_waits_for_h3closed_then_rescues() {
+fn send_stale_waits_for_h3closed_then_fails() {
     let (mut h, tcp, r) = open(5, b"hello", &[Err(StreamError::Stale)]);
     assert_eq!(close_of(&mut h, tcp), None, "no abort");
     assert_eq!(resets(&h, r), 0);
@@ -189,21 +189,11 @@ fn send_stale_waits_for_h3closed_then_rescues() {
         stream_err: 0,
         close_msg: None,
     };
-    let unread = Unread {
-        headers: Some(vec![(b":status".to_vec(), b"200".to_vec())]),
-        body: b"ok".to_vec(),
-    };
-    h.t.close_h3(
-        r,
-        H3Close {
-            stats,
-            unread: Some(unread),
-        },
-    );
+    h.t.close_h3(r, H3Close { stats });
     h.drive();
     assert_eq!(
         h.tx_all(tcp),
-        b"HTTP/1.1 200 \r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n2\r\nok\r\n0\r\n\r\n"
+        b"HTTP/1.1 502 \r\nX-Mq-Error: upstream-reset\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
     );
     assert_eq!(close_of(&mut h, tcp), Some(false));
     assert_eq!(resets(&h, r), 0);
diff --git a/crates/mq-proxy/tests/client_mitm_stream.rs b/crates/mq-proxy/tests/client_mitm_stream.rs
index a9da73ad..566eceda 100644
--- a/crates/mq-proxy/tests/client_mitm_stream.rs
+++ b/crates/mq-proxy/tests/client_mitm_stream.rs
@@ -10,7 +10,7 @@ use mitm_harness::*;
 use mq_proxy::client::mitm::MitmTuning;
 use mq_runtime::TcpId;
 use mq_runtime::testing::Call;
-use mq_transport_api::{ConnId, Event, H3Close, H3ReqId, H3ReqStats, StreamError, Unread};
+use mq_transport_api::{ConnId, Event, H3ReqId, StreamError};
 use std::time::Duration;
 
 const US: Duration = Duration::from_micros(1);
@@ -32,20 +32,6 @@ fn hs(pairs: &[(&str, &str)]) -> Vec<(Vec<u8>, Vec<u8>)> {
         .collect()
 }
 
-fn stats() -> H3ReqStats {
-    H3ReqStats {
-        send_body: 0,
-        recv_body: 0,
-        begin_us: 0,
-        header_send_us: 0,
-        fin_send_us: 0,
-        fin_ack_us: 0,
-        mp_state: 0,
-        stream_err: 0,
-        close_msg: None,
-    }
-}
-
 /// A MITM conn with a live tunnel conn and a handshaken browser.
 struct T {
     mh: MH,
@@ -431,7 +417,7 @@ fn empty_end_stream_with_zero_capacity_completes() {
 
 /// R1: a separate empty H3 FIN after a bodyless head is seen by the terminal
 /// probe, so its END_STREAM needs no h2 credit, even with the upload open
-/// (no `H3Closed` to rescue it).
+/// before `H3Closed` arrives.
 #[test]
 fn separate_empty_fin_with_zero_capacity_and_open_upload_completes() {
     let mut t = T::new();
@@ -476,33 +462,6 @@ fn buffered_data_capacity_grant_without_new_h3_event_delivers() {
     assert!(t.b.response(&s).expect("complete").1 == body);
 }
 
-#[test]
-fn rescued_body_capacity_grant_without_new_h3_event_delivers() {
-    let mut t = T::new();
-    t.b.hold_capacity(true);
-    let (s, r) = t.req("GET", "/x", &[], b"");
-    t.head(r, "200", &[], false);
-    let body = pattern(WIN + 1000);
-    t.body(r, &body[..WIN], false);
-    assert_eq!(t.b.received(&s).len(), WIN);
-    let unread = Unread {
-        headers: None,
-        body: body[WIN..].to_vec(),
-    };
-    let close = H3Close {
-        stats: stats(),
-        unread: Some(unread),
-    };
-    t.mh.t.close_h3(r, close);
-    t.flow();
-    assert_eq!(t.b.received(&s).len(), WIN, "no capacity yet");
-    t.b.hold_capacity(false);
-    t.b.release(&s);
-    t.flow();
-    assert!(t.b.response(&s).expect("complete").1 == body);
-    assert_eq!(t.streams(), 0);
-}
-
 #[test]
 fn idle_sse_quiescent_no_continuation() {
     let mut t = T::new();
diff --git a/crates/mq-proxy/tests/server_gateway_metrics.rs b/crates/mq-proxy/tests/server_gateway_metrics.rs
index 00a6894a..d5a49fe9 100644
--- a/crates/mq-proxy/tests/server_gateway_metrics.rs
+++ b/crates/mq-proxy/tests/server_gateway_metrics.rs
@@ -126,13 +126,7 @@ fn stats0() -> H3ReqStats {
 /// `H3Closed` with `stats`; returns every log line it produced.
 fn close_log(h: &mut H, r: H3ReqId, stats: H3ReqStats) -> Vec<String> {
     log_capture::take();
-    h.t.close_h3(
-        r,
-        H3Close {
-            stats,
-            unread: None,
-        },
-    );
+    h.t.close_h3(r, H3Close { stats });
     h.drive();
     log_capture::take()
 }
diff --git a/crates/mq-proxy/tests/server_gateway_relay.rs b/crates/mq-proxy/tests/server_gateway_relay.rs
index 168ff071..64f9d342 100644
--- a/crates/mq-proxy/tests/server_gateway_relay.rs
+++ b/crates/mq-proxy/tests/server_gateway_relay.rs
@@ -120,13 +120,7 @@ fn closed(h: &mut H, r: H3ReqId) {
         stream_err: 0,
         close_msg: None,
     };
-    h.t.close_h3(
-        r,
-        H3Close {
-            stats,
-            unread: None,
-        },
-    );
+    h.t.close_h3(r, H3Close { stats });
     h.drive();
 }
 
diff --git a/crates/mq-runtime/tests/scripted.rs b/crates/mq-runtime/tests/scripted.rs
index 7c2b54da..19c443a8 100644
--- a/crates/mq-runtime/tests/scripted.rs
+++ b/crates/mq-runtime/tests/scripted.rs
@@ -3,7 +3,7 @@
 use mq_runtime::testing::{Call, ScriptedTransport};
 use mq_transport_api::{
     ConnConfig, ConnProto, DatagramError, Error, Event, H3Close, H3Header, H3ReqStats, PathId,
-    StreamError, Time, TransportOps, Unread,
+    StreamError, Time, TransportOps,
 };
 use std::net::{Ipv4Addr, SocketAddr};
 use std::time::Duration;
@@ -435,17 +435,11 @@ fn scripted_h3_recv_error_injected() {
 }
 
 #[test]
-fn scripted_h3_close_carries_unread() {
+fn scripted_h3_close_carries_stats() {
     let (mut t, h) = ScriptedTransport::new();
     let c = h.new_conn_id();
     let r = h.new_h3_request(c);
-    let close = H3Close {
-        stats: stats(),
-        unread: Some(Unread {
-            headers: Some(pairs(&[("k", "v")])),
-            body: b"tail".to_vec(),
-        }),
-    };
+    let close = H3Close { stats: stats() };
     h.close_h3(r, close.clone());
     let _ = t.poll_event(); // H3Request
     assert_eq!(t.poll_event(), Some(Event::H3Closed(r, Box::new(close))));
@@ -456,13 +450,7 @@ fn scripted_h3_stale_after_close() {
     let (mut t, h) = ScriptedTransport::new();
     let c = h.new_conn_id();
     let r = h.new_h3_request(c);
-    h.close_h3(
-        r,
-        H3Close {
-            stats: stats(),
-            unread: None,
-        },
-    );
+    h.close_h3(r, H3Close { stats: stats() });
     let mut buf = [0u8; 8];
     assert_eq!(t.h3_send_headers(T, r, &[], false), Err(StreamError::Stale));
     assert_eq!(t.h3_send_body(T, r, b"x", false), Err(StreamError::Stale));
diff --git a/crates/mq-transport-api/src/config.rs b/crates/mq-transport-api/src/config.rs
index 268735c0..ece1731e 100644
--- a/crates/mq-transport-api/src/config.rs
+++ b/crates/mq-transport-api/src/config.rs
@@ -16,23 +16,13 @@ pub struct TransportConfig {
     pub cc: CongestionControl,
     /// Wall clock minus monotonic, fixed at creation (spec §4.3).
     pub realtime_offset_us: i64,
-    /// Register the H3 context (spec §3.1).
+    /// Register ALPN `h3` on raw stream callbacks (adoption spec §3).
     pub h3: bool,
-    /// Which stack serves ALPN `h3`; read only when `h3` is true (adoption spec §3).
-    pub h3_backend: H3Backend,
     /// Write `<dir>/{client,server}.qlog`, opened (truncated) at creation. xquic formats qlog
     /// events only when this is set (spec §4.9).
     pub qlog: Option<PathBuf>,
 }
 
-/// Which stack serves ALPN `h3` (adoption spec §3); read only when `h3` is true.
-#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
-pub enum H3Backend {
-    #[default]
-    XqcH3,
-    Raw,
-}
-
 /// Client or server; the server needs a cert and key (spec §4.2).
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Role {
diff --git a/crates/mq-transport-api/src/event.rs b/crates/mq-transport-api/src/event.rs
index 0c071221..c77c5138 100644
--- a/crates/mq-transport-api/src/event.rs
+++ b/crates/mq-transport-api/src/event.rs
@@ -25,8 +25,7 @@ pub enum Event {
     StreamPeerReset(StreamId, u64),
     /// The peer's STOP_SENDING code; once, raw-H3 conns only (adoption spec §3).
     StreamStopSending(StreamId, u64),
-    /// H3-proto conns only (`ConnProto::H3`; equivalent to raw-H3 today, since xqc_h3-backend
-    /// conns never reach the raw stream-close path): directly before that stream's
+    /// H3-proto conns only (`ConnProto::H3`): directly before that stream's
     /// `StreamClosed`, never dropped (adoption spec §3).
     StreamCloseStats(StreamId, Box<StreamCloseStats>),
     /// "A path can be created now"; may repeat.
@@ -84,17 +83,6 @@ pub struct StreamCloseStats {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct H3Close {
     pub stats: H3ReqStats,
-    /// Present iff the app had not yet consumed the request's fin AND the drain inside
-    /// the close notification ended with xquic's `fin` set (a complete body); a partial
-    /// body (idle timeout, CONNECTION_CLOSE, reset, local close) is never rescued (§3.7).
-    pub unread: Option<Unread>,
-}
-
-/// What the close-time drain read; the fin is implied (spec §3.1).
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Unread {
-    pub headers: Option<Vec<(Vec<u8>, Vec<u8>)>>,
-    pub body: Vec<u8>,
 }
 
 /// Facade request metadata (spec §3.1).
diff --git a/crates/mq-transport-api/src/lib.rs b/crates/mq-transport-api/src/lib.rs
index 74ae9c41..056efb2b 100644
--- a/crates/mq-transport-api/src/lib.rs
+++ b/crates/mq-transport-api/src/lib.rs
@@ -10,13 +10,13 @@ pub mod ringbuf;
 mod time;
 
 pub use config::{
-    CongestionControl, ConnConfig, ConnProto, ConnStats, H3Backend, PathStats, Role, Scheduler,
+    CongestionControl, ConnConfig, ConnProto, ConnStats, PathStats, Role, Scheduler,
     TransportConfig,
 };
 pub use error::{ConnectError, DatagramError, Error, PathError, StreamError};
 pub use event::{
     CloseReason, ErrType, Event, H3Close, H3Header, H3ReqInfo, H3ReqStats, StreamCloseStats,
-    StreamInfo, StreamKind, Transmit, Unread,
+    StreamInfo, StreamKind, Transmit,
 };
 pub use ids::{ConnId, H3ReqId, PathId, SlotId, StreamId, TxKey};
 pub use ops::TransportOps;
diff --git a/crates/mq-transport-api/src/ops.rs b/crates/mq-transport-api/src/ops.rs
index 88cb1271..63c599d8 100644
--- a/crates/mq-transport-api/src/ops.rs
+++ b/crates/mq-transport-api/src/ops.rs
@@ -51,7 +51,7 @@ pub trait TransportOps {
     ) -> Result<(usize, bool), StreamError>;
     fn stream_reset(&mut self, now: Time, s: StreamId);
     /// A local unidirectional stream, either role (adoption spec §3). `Err(Stale)` for a dead
-    /// conn, `Err(Other)` on an xqc_h3 conn or when the peer's uni credit is exhausted,
+    /// conn, `Err(Other)` when the peer's uni credit is exhausted,
     /// `Err(Ceiling)` at 8192 streams.
     fn open_uni(&mut self, now: Time, conn: ConnId) -> Result<StreamId, Error>;
     /// RESET_STREAM only; the receive side keeps reporting. Stale id: no-op (adoption spec §3).
diff --git a/crates/mq-transport/src/conn.rs b/crates/mq-transport/src/conn.rs
index 75a5a8e5..d6245ed1 100644
--- a/crates/mq-transport/src/conn.rs
+++ b/crates/mq-transport/src/conn.rs
@@ -7,8 +7,8 @@ use crate::slots::ConnSlot;
 use crate::{Inner, Transport, clock};
 use core::ptr;
 use mq_transport_api::{
-    ConnConfig, ConnId, ConnProto, ConnStats, ConnectError, Error, H3Backend, PathError, PathId,
-    PathStats, SlotId, Time,
+    ConnConfig, ConnId, ConnProto, ConnStats, ConnectError, Error, PathError, PathId, PathStats,
+    SlotId, Time,
 };
 use std::ffi::CString;
 use std::net::SocketAddr;
@@ -115,11 +115,10 @@ pub(crate) fn connect(
     let sni = CString::new(cfg.sni).map_err(|_| ConnectError::Other(-1))?;
     let settings = conn_settings(&t.inner.cfg, cfg.idle_timeout);
     let (peer, peerlen) = to_sockaddr(cfg.peer);
-    let alpn = t.inner.alpn.as_ptr();
-    // adoption spec §3: an H3 conn on the raw backend is a raw conn on ALPN `h3`.
-    let raw_h3 =
-        cfg.proto == ConnProto::H3 && t.inner.cfg.h3 && t.inner.cfg.h3_backend == H3Backend::Raw;
-    let raw_alpn = raw_h3.then(|| c"h3".as_ptr());
+    let alpn = match cfg.proto {
+        ConnProto::Raw => t.inner.alpn.as_ptr(),
+        ConnProto::H3 => c"h3".as_ptr(),
+    };
     // SAFETY: a plain C struct; all-zero is valid and what C passes.
     let zero_cid: xqc_cid_t = unsafe { core::mem::zeroed() };
     let s = t
@@ -133,35 +132,20 @@ pub(crate) fn connect(
             let ssl: xqc_conn_ssl_config_t = core::mem::zeroed();
             let peer = (&peer as *const libc::sockaddr_storage).cast();
             // spec §3.2: same settings and user data (the conn slot) for both protocols; the
-            // create notification fires synchronously inside either call and binds the slot.
-            let cid = if cfg.proto == ConnProto::Raw || raw_h3 {
-                xqc_connect(
-                    engine,
-                    &settings,
-                    ptr::null(),
-                    0,
-                    sni.as_ptr(),
-                    0,
-                    &ssl,
-                    peer,
-                    peerlen,
-                    raw_alpn.unwrap_or(alpn),
-                    ud_of(s),
-                )
-            } else {
-                xqc_h3_connect(
-                    engine,
-                    &settings,
-                    ptr::null(),
-                    0,
-                    sni.as_ptr(),
-                    0,
-                    &ssl,
-                    peer,
-                    peerlen,
-                    ud_of(s),
-                )
-            };
+            // create notification fires synchronously inside the call and binds the slot.
+            let cid = xqc_connect(
+                engine,
+                &settings,
+                ptr::null(),
+                0,
+                sni.as_ptr(),
+                0,
+                &ssl,
+                peer,
+                peerlen,
+                alpn,
+                ud_of(s),
+            );
             // Copied before any other xquic call (spec §4.8 "Borrowed data").
             (!cid.is_null()).then(|| cid.read_unaligned())
         }
diff --git a/crates/mq-transport/src/engine.rs b/crates/mq-transport/src/engine.rs
index a88221ac..29d8b476 100644
--- a/crates/mq-transport/src/engine.rs
+++ b/crates/mq-transport/src/engine.rs
@@ -1,12 +1,10 @@
 //! Engine creation, connection settings, logs and qlog (spec §4.9).
 
-use crate::ffi::{app_proto_callbacks, guard, h3_callbacks, transport_callbacks};
+use crate::ffi::{app_proto_callbacks, guard, transport_callbacks};
 use crate::{Error, Inner, Transport, clock};
 use core::ffi::{c_char, c_void};
 use core::ptr;
-use mq_transport_api::{
-    CongestionControl, ConnProto, H3Backend, Role, Scheduler, Time, TransportConfig,
-};
+use mq_transport_api::{CongestionControl, ConnProto, Role, Scheduler, Time, TransportConfig};
 use std::ffi::CString;
 use std::io::Write;
 use std::time::Duration;
@@ -67,8 +65,7 @@ fn server_settings(cfg: &TransportConfig) -> xqc_conn_settings_t {
     conn_settings(cfg, None)
 }
 
-/// xquic's default engine config with the fields this tree pins. The log level stays WARN:
-/// `xqc_h3_request_close` reads a destroyed request in a DEBUG log (spec §3.1).
+/// xquic's default engine config with the fields this tree pins.
 fn engine_config(ty: xqc_engine_type_t, qlog: bool) -> Option<xqc_config_t> {
     // SAFETY: a plain C struct; xquic fills it.
     let mut config: xqc_config_t = unsafe { core::mem::zeroed() };
@@ -129,7 +126,6 @@ impl Transport {
         let alpn_ptr = t.inner.alpn.as_ptr();
         let alpn_len = t.inner.alpn.as_bytes().len();
         let h3_on = t.inner.cfg.h3;
-        let h3_raw = h3_on && t.inner.cfg.h3_backend == H3Backend::Raw;
         let inner: *mut Inner = &mut *t.inner;
 
         let engine = clock::enter(inner, Time(0), || {
@@ -171,8 +167,8 @@ impl Transport {
                     xqc_engine_destroy(engine);
                     return ptr::null_mut();
                 }
-                if h3_raw {
-                    // adoption spec §3, §7 item 1: ALPN `h3` on raw stream callbacks, no h3 ctx.
+                if h3_on {
+                    // adoption spec §3, §7 item 1: ALPN `h3` on raw stream callbacks.
                     let mut ap = app_proto_callbacks(ConnProto::H3);
                     if xqc_engine_register_alpn(engine, c"h3".as_ptr(), 2, &mut ap, ptr::null_mut())
                         != 0
@@ -181,15 +177,6 @@ impl Transport {
                         return ptr::null_mut();
                     }
                 }
-                // spec §3.2: registers `h3` and `h3-29`; cleans up after itself on failure.
-                let mut h3 = h3_callbacks();
-                if h3_on && !h3_raw && xqc_h3_ctx_init(engine, &mut h3) != 0 {
-                    xqc_engine_destroy(engine);
-                    return ptr::null_mut();
-                }
-                if h3_on && !h3_raw {
-                    xqc_h3_engine_set_max_field_section_size(engine, H3_FIELD_SECTION_MAX);
-                }
                 if let Some(s) = &settings {
                     xqc_server_set_conn_settings(engine, s);
                 }
@@ -214,15 +201,8 @@ impl Transport {
             return;
         }
         let inner: *mut Inner = &mut *self.inner;
-        let h3 = self.inner.cfg.h3 && self.inner.cfg.h3_backend == H3Backend::XqcH3;
         // SAFETY: `engine` is live (non-null) and destroyed exactly once: it is nulled below.
-        // spec §3.2: the H3 ctx is freed through the live engine, so it goes first.
-        clock::enter(inner, now, || unsafe {
-            if h3 {
-                xqc_h3_ctx_destroy(engine);
-            }
-            xqc_engine_destroy(engine)
-        });
+        clock::enter(inner, now, || unsafe { xqc_engine_destroy(engine) });
         self.inner.engine = ptr::null_mut();
     }
 }
@@ -310,7 +290,6 @@ mod tests {
             cc,
             realtime_offset_us: 0,
             h3: false,
-            h3_backend: mq_transport_api::H3Backend::XqcH3,
             qlog: None,
         }
     }
@@ -395,7 +374,7 @@ mod tests {
         assert!(d.datagram_mss_updated_notify.is_none());
     }
 
-    /// spec §3.1: `xqc_h3_request_close` reads freed memory in a DEBUG log; never raise it.
+    /// The transport pins the engine log level to WARN.
     #[test]
     fn engine_config_pins_log_level_warn() {
         for ty in [XQC_ENGINE_CLIENT, XQC_ENGINE_SERVER] {
diff --git a/crates/mq-transport/src/events.rs b/crates/mq-transport/src/events.rs
index 4ece303a..20bd44a3 100644
--- a/crates/mq-transport/src/events.rs
+++ b/crates/mq-transport/src/events.rs
@@ -1,13 +1,13 @@
 //! Coalescing event queue (spec §4.2 "Event coalescing").
 //!
-//! `StreamReadable`/`StreamWritable`/`MpReady`/`DatagramReadable`/`H3Readable`/`H3Writable` are
+//! `StreamReadable`/`StreamWritable`/`MpReady`/`DatagramReadable` are
 //! level flags: at most one is queued per object (tracked by the `*_queued` flag on the slot); lifecycle events never
 //! coalesce.
 //! Ids are invalidated inside notifications (spec §4.8), so a queued event may outlive its
 //! slot; `pop` returns it as-is and the consumer drops stale ones.
 
-use crate::slots::{ConnSlot, H3ReqSlot, Slots, StreamSlot};
-use mq_transport_api::{ConnId, Event, H3ReqId, StreamId};
+use crate::slots::{ConnSlot, Slots, StreamSlot};
+use mq_transport_api::{ConnId, Event, StreamId};
 use std::collections::VecDeque;
 
 #[derive(Default)]
@@ -58,26 +58,6 @@ impl Events {
         }
     }
 
-    /// spec §3.4: enqueue iff the request is live and no `H3Readable` is already queued.
-    pub fn push_h3_readable(&mut self, reqs: &mut Slots<H3ReqSlot>, id: H3ReqId) {
-        if let Some(r) = reqs.get_mut(id.slot())
-            && !r.readable_queued
-        {
-            r.readable_queued = true;
-            self.queue.push_back(Event::H3Readable(id));
-        }
-    }
-
-    /// spec §3.4: as `push_h3_readable`, with the writable flag.
-    pub fn push_h3_writable(&mut self, reqs: &mut Slots<H3ReqSlot>, id: H3ReqId) {
-        if let Some(r) = reqs.get_mut(id.slot())
-            && !r.writable_queued
-        {
-            r.writable_queued = true;
-            self.queue.push_back(Event::H3Writable(id));
-        }
-    }
-
     /// Lifecycle events: unconditional, never coalesced.
     pub fn push(&mut self, e: Event) {
         self.queue.push_back(e);
@@ -89,7 +69,6 @@ impl Events {
         &mut self,
         streams: &mut Slots<StreamSlot>,
         conns: &mut Slots<ConnSlot>,
-        reqs: &mut Slots<H3ReqSlot>,
     ) -> Option<Event> {
         let e = self.queue.pop_front()?;
         match &e {
@@ -113,16 +92,6 @@ impl Events {
                     c.dgram_readable_queued = false;
                 }
             }
-            Event::H3Readable(id) => {
-                if let Some(r) = reqs.get_mut(id.slot()) {
-                    r.readable_queued = false;
-                }
-            }
-            Event::H3Writable(id) => {
-                if let Some(r) = reqs.get_mut(id.slot()) {
-                    r.writable_queued = false;
-                }
-            }
             // Never coalesced. Listed, not wildcarded: a new level flag must clear here.
             Event::ConnEstablished(_)
             | Event::ConnClosed(..)
@@ -134,7 +103,9 @@ impl Events {
             | Event::StreamCloseStats(..)
             | Event::PathRemoved(..)
             | Event::H3Request(..)
-            | Event::H3Closed(..) => {}
+            | Event::H3Closed(..)
+            | Event::H3Readable(_)
+            | Event::H3Writable(_) => {}
         }
         Some(e)
     }
@@ -181,20 +152,12 @@ mod tests {
 
     #[test]
     fn readable_coalesced_until_popped() {
-        let (mut st, mut cs, mut rs, mut ev) = (
-            Slots::default(),
-            Slots::default(),
-            Slots::default(),
-            Events::default(),
-        );
+        let (mut st, mut cs, mut ev) = (Slots::default(), Slots::default(), Events::default());
         let id = sid(&mut st, false);
         ev.push_readable(&mut st, id);
         ev.push_readable(&mut st, id);
         assert_eq!(ev.len(), 1);
-        assert_eq!(
-            ev.pop(&mut st, &mut cs, &mut rs),
-            Some(Event::StreamReadable(id))
-        );
+        assert_eq!(ev.pop(&mut st, &mut cs), Some(Event::StreamReadable(id)));
         assert!(ev.is_empty());
         ev.push_readable(&mut st, id);
         assert_eq!(ev.len(), 1);
@@ -202,100 +165,43 @@ mod tests {
 
     #[test]
     fn writable_coalesced() {
-        let (mut st, mut cs, mut rs, mut ev) = (
-            Slots::default(),
-            Slots::default(),
-            Slots::default(),
-            Events::default(),
-        );
+        let (mut st, mut cs, mut ev) = (Slots::default(), Slots::default(), Events::default());
         let id = sid(&mut st, false);
         ev.push_writable(&mut st, id);
         ev.push_writable(&mut st, id);
         assert_eq!(ev.len(), 1);
-        assert_eq!(
-            ev.pop(&mut st, &mut cs, &mut rs),
-            Some(Event::StreamWritable(id))
-        );
+        assert_eq!(ev.pop(&mut st, &mut cs), Some(Event::StreamWritable(id)));
         ev.push_writable(&mut st, id);
         assert_eq!(ev.len(), 1);
     }
 
     #[test]
     fn mp_ready_coalesced() {
-        let (mut st, mut cs, mut rs, mut ev) = (
-            Slots::default(),
-            Slots::default(),
-            Slots::default(),
-            Events::default(),
-        );
+        let (mut st, mut cs, mut ev) = (Slots::default(), Slots::default(), Events::default());
         let id = ConnId::from_slot(cs.insert(conn())).unwrap();
         ev.push_mp_ready(&mut cs, id);
         ev.push_mp_ready(&mut cs, id);
         assert_eq!(ev.len(), 1);
-        assert_eq!(ev.pop(&mut st, &mut cs, &mut rs), Some(Event::MpReady(id)));
+        assert_eq!(ev.pop(&mut st, &mut cs), Some(Event::MpReady(id)));
         ev.push_mp_ready(&mut cs, id);
         assert_eq!(ev.len(), 1);
     }
 
     #[test]
     fn datagram_readable_coalesced() {
-        let (mut st, mut cs, mut rs, mut ev) = (
-            Slots::default(),
-            Slots::default(),
-            Slots::default(),
-            Events::default(),
-        );
+        let (mut st, mut cs, mut ev) = (Slots::default(), Slots::default(), Events::default());
         let id = ConnId::from_slot(cs.insert(conn())).unwrap();
         ev.push_datagram_readable(&mut cs, id);
         ev.push_datagram_readable(&mut cs, id);
         assert_eq!(ev.len(), 1);
-        assert_eq!(
-            ev.pop(&mut st, &mut cs, &mut rs),
-            Some(Event::DatagramReadable(id))
-        );
+        assert_eq!(ev.pop(&mut st, &mut cs), Some(Event::DatagramReadable(id)));
         ev.push_datagram_readable(&mut cs, id);
         assert_eq!(ev.len(), 1);
     }
 
-    #[test]
-    fn h3_readable_and_writable_coalesced() {
-        let (mut st, mut cs, mut rs, mut ev) = (
-            Slots::default(),
-            Slots::default(),
-            Slots::default(),
-            Events::default(),
-        );
-        let c = mq_transport_api::SlotId::new(0, 1);
-        let id = H3ReqId::from_slot(rs.insert(H3ReqSlot::new(c, std::ptr::null_mut(), 0))).unwrap();
-        ev.push_h3_readable(&mut rs, id);
-        ev.push_h3_writable(&mut rs, id);
-        ev.push_h3_readable(&mut rs, id);
-        ev.push_h3_writable(&mut rs, id);
-        assert_eq!(ev.len(), 2);
-        assert_eq!(
-            ev.pop(&mut st, &mut cs, &mut rs),
-            Some(Event::H3Readable(id))
-        );
-        ev.push_h3_readable(&mut rs, id);
-        ev.push_h3_writable(&mut rs, id);
-        assert_eq!(ev.len(), 2, "readable re-queued, writable still pending");
-        assert_eq!(
-            ev.pop(&mut st, &mut cs, &mut rs),
-            Some(Event::H3Writable(id))
-        );
-        rs.remove(id.slot());
-        ev.push_h3_writable(&mut rs, id);
-        assert_eq!(ev.len(), 1, "nothing queued for a released request");
-    }
-
     #[test]
     fn lifecycle_not_coalesced() {
-        let (mut st, mut cs, mut rs, mut ev) = (
-            Slots::default(),
-            Slots::default(),
-            Slots::default(),
-            Events::default(),
-        );
+        let (mut st, mut cs, mut ev) = (Slots::default(), Slots::default(), Events::default());
         let c = ConnId::from_slot(cs.insert(conn())).unwrap();
         let r = CloseReason {
             err_type: ErrType::Unknown,
@@ -305,10 +211,7 @@ mod tests {
         ev.push(Event::ConnEstablished(c));
         ev.push(Event::ConnClosed(c, r));
         assert_eq!(ev.len(), 3);
-        assert_eq!(
-            ev.pop(&mut st, &mut cs, &mut rs),
-            Some(Event::ConnEstablished(c))
-        );
+        assert_eq!(ev.pop(&mut st, &mut cs), Some(Event::ConnEstablished(c)));
     }
 
     #[test]
@@ -322,18 +225,10 @@ mod tests {
 
     #[test]
     fn pop_after_slot_release_returns_owned_event() {
-        let (mut st, mut cs, mut rs, mut ev) = (
-            Slots::default(),
-            Slots::default(),
-            Slots::default(),
-            Events::default(),
-        );
+        let (mut st, mut cs, mut ev) = (Slots::default(), Slots::default(), Events::default());
         let id = sid(&mut st, false);
         ev.push_readable(&mut st, id);
         st.remove(id.slot());
-        assert_eq!(
-            ev.pop(&mut st, &mut cs, &mut rs),
-            Some(Event::StreamReadable(id))
-        );
+        assert_eq!(ev.pop(&mut st, &mut cs), Some(Event::StreamReadable(id)));
     }
 }
diff --git a/crates/mq-transport/src/ffi/mod.rs b/crates/mq-transport/src/ffi/mod.rs
index c09d6690..9615ef05 100644
--- a/crates/mq-transport/src/ffi/mod.rs
+++ b/crates/mq-transport/src/ffi/mod.rs
@@ -50,7 +50,7 @@ pub(crate) fn transport_callbacks() -> xqc_transport_callbacks_t {
     }
 }
 
-/// ALPN callbacks (`"mqproxy-tcp/1"`, or `"h3"` on the raw-H3 backend; adoption spec §3). Of
+/// ALPN callbacks (`"mqproxy-tcp/1"`, or `"h3"`; adoption spec §3). Of
 /// the datagram callbacks only read and write are registered (SP2 spec §3.3).
 pub(crate) fn app_proto_callbacks(proto: ConnProto) -> xqc_app_proto_callbacks_t {
     xqc_app_proto_callbacks_t {
@@ -85,21 +85,6 @@ pub(crate) fn app_proto_callbacks(proto: ConnProto) -> xqc_app_proto_callbacks_t
     }
 }
 
-/// H3 callbacks (spec §3.3): connection and request notifications only; the h3-ext datagram
-/// and bytestream tables stay empty (xquic null-checks them).
-pub(crate) fn h3_callbacks() -> xqc_h3_callbacks_t {
-    // SAFETY: a C struct of `Option<fn>` fields; all-zero is all `None`.
-    let mut cbs: xqc_h3_callbacks_t = unsafe { core::mem::zeroed() };
-    cbs.h3c_cbs.h3_conn_create_notify = Some(h3_conn_create_notify);
-    cbs.h3c_cbs.h3_conn_close_notify = Some(h3_conn_close_notify);
-    cbs.h3c_cbs.h3_conn_handshake_finished = Some(h3_conn_handshake_finished);
-    cbs.h3r_cbs.h3_request_create_notify = Some(h3_request_create_notify);
-    cbs.h3r_cbs.h3_request_close_notify = Some(h3_request_close_notify);
-    cbs.h3r_cbs.h3_request_read_notify = Some(h3_request_read_notify);
-    cbs.h3r_cbs.h3_request_write_notify = Some(h3_request_write_notify);
-    cbs
-}
-
 // ── callbacks with no state ─────────────────────────────────────────────
 
 /// spec §4.7: accept any certificate (as the C client does).
diff --git a/crates/mq-transport/src/ffi/trampolines.rs b/crates/mq-transport/src/ffi/trampolines.rs
index 6eaa5f53..88fb2e22 100644
--- a/crates/mq-transport/src/ffi/trampolines.rs
+++ b/crates/mq-transport/src/ffi/trampolines.rs
@@ -7,14 +7,14 @@
 //! xquic getters/setters a trampoline needs run before or after that scope.
 
 use super::{from_sockaddr, guard};
-use crate::slots::{ConnSlot, H3ReqSlot, StreamSlot};
+use crate::slots::{ConnSlot, StreamSlot};
 use crate::txq::Refusal;
 use crate::{Inner, clock, datagram, stream};
 use core::ffi::{c_int, c_uchar, c_void};
 use libc::{sockaddr, socklen_t};
 use mq_transport_api::{
-    CloseReason, ConnId, ConnProto, ErrType, Event, H3Close, H3ReqId, H3ReqStats, PathId, Role,
-    SlotId, StreamCloseStats, StreamId, StreamInfo, StreamKind, Time, Unread,
+    CloseReason, ConnId, ConnProto, ErrType, Event, PathId, SlotId, StreamCloseStats, StreamId,
+    StreamInfo, StreamKind, Time,
 };
 use std::time::Duration;
 use xquic_sys::*;
@@ -44,14 +44,6 @@ fn stream_id(s: SlotId) -> StreamId {
     StreamId::from_slot(s).expect("live slot ids have a non-zero generation")
 }
 
-pub(crate) fn req_id(s: SlotId) -> H3ReqId {
-    H3ReqId::from_slot(s).expect("live slot ids have a non-zero generation")
-}
-
-/// spec §3.4: the `XQC_REQ_NOTIFY_READ_*` bits the transport acts on.
-pub(crate) const READ_HEADER: u8 = XQC_REQ_NOTIFY_READ_HEADER as u8;
-pub(crate) const READ_TRAILER: u8 = XQC_REQ_NOTIFY_READ_TRAILER as u8;
-
 /// Runs `f` on the transport that entered xquic; `default` outside a transport call.
 fn with_inner<R>(default: R, f: impl FnOnce(&mut Inner) -> R) -> R {
     guard(|| {
@@ -328,111 +320,6 @@ pub(crate) fn on_peer_abort(
     }
 }
 
-/// Server: the peer opened a request (spec §3.3). `None` = refused: the request keeps NULL
-/// user data, so every later notification for it is a no-op, and the connection closes at the
-/// next `drive` (xquic ignores the create notification's return value).
-pub(crate) fn on_h3_request_create(
-    inner: &mut Inner,
-    conn: SlotId,
-    h3r: *mut xqc_h3_request_t,
-    quic_id: u64,
-) -> Option<SlotId> {
-    if !admit_peer(inner.conns.get_mut(conn)?) {
-        return None;
-    }
-    let s = inner.h3reqs.insert(H3ReqSlot::new(conn, h3r, quic_id));
-    inner
-        .events
-        .push(Event::H3Request(conn_id(conn), req_id(s)));
-    Some(s)
-}
-
-/// spec §3.3/§3.4: accumulate the read flags and queue `H3Readable`. `true` → the trampoline
-/// drains (and discards) the trailer section now: the app already read the header section.
-/// A trailer that arrives before that keeps its bit for `h3_recv_headers`.
-pub(crate) fn on_h3_read(inner: &mut Inner, s: SlotId, flag: u8) -> bool {
-    let Some(r) = inner.h3reqs.get_mut(s) else {
-        return false;
-    };
-    r.read_flags |= flag;
-    let drain = r.header_consumed && r.read_flags & READ_TRAILER != 0;
-    if drain {
-        r.read_flags &= !READ_TRAILER;
-    }
-    inner.events.push_h3_readable(&mut inner.h3reqs, req_id(s));
-    drain
-}
-
-/// Request close notification: every request slot is released here (spec §3.3, §3.5). The
-/// connection slot may already be gone (a QPACK-blocked request outlives its connection).
-pub(crate) fn on_h3_request_close(
-    inner: &mut Inner,
-    s: SlotId,
-    stats: H3ReqStats,
-    unread: Option<Unread>,
-) {
-    let Some(r) = inner.h3reqs.remove(s) else {
-        return;
-    };
-    if let Some(c) = inner.conns.get_mut(r.conn) {
-        c.streams -= 1;
-    }
-    let close = Box::new(H3Close { stats, unread });
-    inner.events.push(Event::H3Closed(req_id(s), close));
-}
-
-/// spec §3.3 close row: a client request whose fin the app has not consumed is drained before
-/// the release; `Some(read_flags)` then.
-fn rescue_flags(inner: &Inner, s: SlotId) -> Option<u8> {
-    if inner.cfg.role != Role::Client {
-        return None;
-    }
-    inner
-        .h3reqs
-        .get(s)
-        .filter(|r| !r.fin_consumed)
-        .map(|r| r.read_flags)
-}
-
-/// spec §3.7: drains the pending header section (when `header`) and the whole body; `Some` only
-/// when the drain ends with xquic's fin — a partial body is never rescued.
-///
-/// # Safety
-/// `h3r` is the request inside its close notification (intact until it returns).
-unsafe fn drain_unread(h3r: *mut xqc_h3_request_t, header: bool) -> Option<Unread> {
-    let headers = if header {
-        let mut fin = 0u8; // xquic logs it before writing it
-        // SAFETY: guaranteed by the caller.
-        let hs = unsafe { xqc_h3_request_recv_headers(h3r, &mut fin) };
-        if hs.is_null() {
-            return None;
-        }
-        let mut v = Vec::new();
-        // SAFETY: the section just returned, unchanged for this call.
-        unsafe { crate::h3::for_each_header(hs, &mut |n, x| v.push((n.to_vec(), x.to_vec()))) };
-        Some(v)
-    } else {
-        None
-    };
-    const CHUNK: usize = 64 * 1024;
-    let mut body = Vec::new();
-    loop {
-        let len = body.len();
-        body.resize(len + CHUNK, 0);
-        let mut fin = 0u8;
-        // SAFETY: guaranteed by the caller; `CHUNK` writable bytes at `len`.
-        let n =
-            unsafe { xqc_h3_request_recv_body(h3r, body.as_mut_ptr().add(len), CHUNK, &mut fin) };
-        if n < 0 {
-            return None; // EAGAIN: no fin behind the buffered body
-        }
-        body.truncate(len + n as usize);
-        if fin != 0 {
-            return Some(Unread { headers, body });
-        }
-    }
-}
-
 /// `msg` is null or a NUL-terminated string; at most 64 bytes are copied.
 ///
 /// # Safety
@@ -449,26 +336,6 @@ unsafe fn close_msg(msg: *const core::ffi::c_char) -> Option<String> {
     })
 }
 
-/// spec §3.1: the fields C's call site reads; `close_msg` copied up to 64 bytes.
-///
-/// # Safety
-/// `st.stream_close_msg` is null or a NUL-terminated string (xquic's static messages).
-pub(crate) unsafe fn h3_stats(st: &xqc_request_stats_t) -> H3ReqStats {
-    // SAFETY: guaranteed by the caller.
-    let close_msg = unsafe { close_msg(st.stream_close_msg) };
-    H3ReqStats {
-        send_body: st.send_body_size as u64,
-        recv_body: st.recv_body_size as u64,
-        begin_us: st.h3r_begin_time,
-        header_send_us: st.h3r_header_send_time,
-        fin_send_us: st.stream_fin_send_time,
-        fin_ack_us: st.stream_fin_ack_time,
-        mp_state: st.mp_state,
-        stream_err: st.stream_err,
-        close_msg,
-    }
-}
-
 /// SP2 spec §3.2: into the connection's receive ring; a stale slot drops it, a full ring
 /// counts the drop.
 pub(crate) fn on_datagram_read(inner: &mut Inner, s: SlotId, data: &[u8]) {
@@ -755,132 +622,6 @@ pub(super) unsafe extern "C" fn conn_handshake_finished(
     established(slot_of(proto))
 }
 
-// ── H3 connection callbacks (spec §3.3): `ud` is the transport user data = the conn slot.
-// Never `xqc_h3_conn_set_user_data` (it overwrites that user data, spec §3.2).
-
-pub(super) unsafe extern "C" fn h3_conn_create_notify(
-    h3c: *mut xqc_h3_conn_t,
-    cid: *const xqc_cid_t,
-    ud: *mut c_void,
-) -> c_int {
-    // SAFETY: `cid` is null or valid for this call; copied. `h3c` is being created: a getter.
-    let (cid, conn) = unsafe {
-        (
-            (!cid.is_null()).then(|| cid.read_unaligned()),
-            xqc_h3_conn_get_xqc_conn(h3c),
-        )
-    };
-    let s = slot_of(ud);
-    let ok = with_inner(false, |i| {
-        if !on_conn_create(i, conn, cid, s, ConnProto::H3) {
-            return false;
-        }
-        if let Some(slot) = i.conns.get_mut(s) {
-            slot.h3c = h3c;
-        }
-        true
-    });
-    if ok { 0 } else { -1 }
-}
-
-pub(super) unsafe extern "C" fn h3_conn_close_notify(
-    h3c: *mut xqc_h3_conn_t,
-    _cid: *const xqc_cid_t,
-    ud: *mut c_void,
-) -> c_int {
-    // SAFETY: the H3 connection being destroyed and its live QUIC connection.
-    let reason = unsafe { close_reason(xqc_h3_conn_get_xqc_conn(h3c)) };
-    with_inner((), |i| on_conn_close(i, slot_of(ud), reason));
-    0
-}
-
-pub(super) unsafe extern "C" fn h3_conn_handshake_finished(
-    _h3c: *mut xqc_h3_conn_t,
-    ud: *mut c_void,
-) {
-    established(slot_of(ud))
-}
-
-// Request callbacks (spec §3.3): `ud` is the request's user data = its slot, or NULL for a
-// request we refused (every notification for it is then a no-op).
-
-/// The role decides: a server's `ud` is NULL on both xquic creation paths and the peer opened
-/// the request; a client's `ud` is the slot `open_h3_request` preallocated.
-pub(super) unsafe extern "C" fn h3_request_create_notify(
-    h3r: *mut xqc_h3_request_t,
-    ud: *mut c_void,
-) -> c_int {
-    // SAFETY: plain getters on the request being created.
-    let (conn, quic_id) = unsafe {
-        (
-            slot_of(xqc_h3_get_conn_user_data_by_request(h3r)),
-            xqc_h3_stream_id(h3r),
-        )
-    };
-    let admitted = with_inner(None, |i| {
-        if matches!(i.cfg.role, Role::Server { .. }) {
-            return on_h3_request_create(i, conn, h3r, quic_id);
-        }
-        if let Some(r) = i.h3reqs.get_mut(slot_of(ud)) {
-            r.xqc = h3r;
-            r.quic_id = quic_id;
-        }
-        None
-    });
-    if let Some(s) = admitted {
-        // SAFETY: a plain setter on the request being created.
-        unsafe { xqc_h3_request_set_user_data(h3r, ud_of(s)) };
-    }
-    0 // ignored by xquic
-}
-
-pub(super) unsafe extern "C" fn h3_request_close_notify(
-    h3r: *mut xqc_h3_request_t,
-    ud: *mut c_void,
-) -> c_int {
-    let s = slot_of(ud);
-    if s.is_none() {
-        return 0;
-    }
-    // SAFETY: the request is intact for the duration of its close notification (spec §3.7);
-    // xquic's close messages are static strings.
-    let stats = unsafe { h3_stats(&xqc_h3_request_get_stats(h3r)) };
-    let unread = with_inner(None, |i| rescue_flags(i, s))
-        // SAFETY: as above; the drain calls getters that fire no notification.
-        .and_then(|flags| unsafe { drain_unread(h3r, flags & READ_HEADER != 0) });
-    with_inner((), |i| on_h3_request_close(i, s, stats, unread));
-    0
-}
-
-pub(super) unsafe extern "C" fn h3_request_read_notify(
-    h3r: *mut xqc_h3_request_t,
-    flag: xqc_request_notify_flag_t,
-    ud: *mut c_void,
-) -> c_int {
-    let s = slot_of(ud);
-    if s.is_none() {
-        return 0;
-    }
-    if with_inner(false, |i| on_h3_read(i, s, flag as u8)) {
-        let mut fin = 0u8; // xquic logs it before writing it
-        // SAFETY: the request being notified; a getter that fires no notification. The trailer
-        // section is discarded and its fin ignored (spec §3.3).
-        unsafe { xqc_h3_request_recv_headers(h3r, &mut fin) };
-    }
-    0
-}
-
-pub(super) unsafe extern "C" fn h3_request_write_notify(
-    _h3r: *mut xqc_h3_request_t,
-    ud: *mut c_void,
-) -> c_int {
-    let s = slot_of(ud);
-    if !s.is_none() {
-        with_inner((), |i| i.events.push_h3_writable(&mut i.h3reqs, req_id(s)));
-    }
-    0
-}
-
 pub(super) unsafe extern "C" fn stream_create_notify(
     xs: *mut xqc_stream_t,
     ud: *mut c_void,
@@ -1041,7 +782,6 @@ mod tests {
                 cc: CongestionControl::Bbr,
                 realtime_offset_us: 0,
                 h3: false,
-                h3_backend: mq_transport_api::H3Backend::XqcH3,
                 qlog: None,
             },
             CString::new("mqproxy-tcp/1").unwrap(),
@@ -1090,16 +830,8 @@ mod tests {
             Some(Time(0) + PROVISIONAL_TIMEOUT)
         );
         assert_eq!((i.n_provisional, i.n_counted), (1, 1));
-        assert!(
-            i.events
-                .pop(&mut i.streams, &mut i.conns, &mut i.h3reqs)
-                .is_some()
-        ); // a's NewConn
-        assert!(
-            i.events
-                .pop(&mut i.streams, &mut i.conns, &mut i.h3reqs)
-                .is_none()
-        );
+        assert!(i.events.pop(&mut i.streams, &mut i.conns).is_some()); // a's NewConn
+        assert!(i.events.pop(&mut i.streams, &mut i.conns).is_none());
         on_server_refuse(&mut i, b);
         assert!(!i.conns.is_live(b));
         assert_eq!((i.n_provisional, i.n_counted), (0, 1));
@@ -1138,8 +870,7 @@ mod tests {
         on_conn_close(&mut i, a, r);
         assert_eq!(i.n_counted, 0);
         let evs: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .collect();
+            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns)).collect();
         assert_eq!(
             evs,
             vec![
@@ -1162,13 +893,12 @@ mod tests {
         };
         on_conn_close(&mut i, a, echoed);
         on_conn_close(&mut i, b, echoed);
-        let closes: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .filter_map(|e| match e {
-                    Event::ConnClosed(c, r) => Some((c, r)),
-                    _ => None,
-                })
-                .collect();
+        let closes: Vec<_> = std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns))
+            .filter_map(|e| match e {
+                Event::ConnClosed(c, r) => Some((c, r)),
+                _ => None,
+            })
+            .collect();
         let unknown = CloseReason {
             err_type: ErrType::Unknown,
             code: 0x1001,
@@ -1296,12 +1026,12 @@ mod tests {
         let c = accept(&mut i);
         assert!(create(&mut i, c, ConnProto::Raw));
         i.conns.get_mut(c).unwrap().streams = STREAM_CEILING - 1;
-        let _ = i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs); // NewConn
+        let _ = i.events.pop(&mut i.streams, &mut i.conns); // NewConn
         let first = on_peer_stream_create(&mut i, c, core::ptr::null_mut(), 4, StreamKind::Bidi);
         let s = first.expect("the 8192nd stream is admitted");
         assert_eq!(i.streams.len_live(), 1);
         assert!(matches!(
-            i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs),
+            i.events.pop(&mut i.streams, &mut i.conns),
             Some(Event::NewStream(_, id, _)) if id == stream_id(s)
         ));
         assert_eq!(i.conns.get(c).unwrap().streams, STREAM_CEILING);
@@ -1320,9 +1050,7 @@ mod tests {
             assert_eq!(conn.pending_close, Some(CEILING_CLOSE_CODE));
             assert_eq!(i.streams.len_live(), 1, "nothing allocated");
             assert!(
-                i.events
-                    .pop(&mut i.streams, &mut i.conns, &mut i.h3reqs)
-                    .is_none(),
+                i.events.pop(&mut i.streams, &mut i.conns).is_none(),
                 "nothing queued"
             );
         }
@@ -1349,8 +1077,7 @@ mod tests {
         on_stream_close(&mut i, s, no_stats());
         assert_eq!(i.conns.get(c).unwrap().streams, 0);
         let evs: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .collect();
+            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns)).collect();
         assert_eq!(evs.last(), Some(&Event::StreamClosed(stream_id(s))));
         assert_eq!(evs.len(), 3); // NewConn, NewStream, StreamClosed
     }
@@ -1367,8 +1094,7 @@ mod tests {
             on_peer_abort(&mut i, s, XQC_STREAM_PEER_STOP_SENDING, code);
         }
         let evs: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .collect();
+            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns)).collect();
         assert_eq!(
             evs[2..],
             [
@@ -1389,8 +1115,7 @@ mod tests {
         on_stream_close(&mut i, s, no_stats());
         on_peer_abort(&mut i, s, XQC_STREAM_PEER_RESET_STREAM, 8);
         let evs: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .collect();
+            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns)).collect();
         assert_eq!(
             evs[2..],
             [
@@ -1407,11 +1132,7 @@ mod tests {
         let c = accept(&mut i);
         on_server_refuse(&mut i, c);
         on_datagram_read(&mut i, c, b"x");
-        assert!(
-            i.events
-                .pop(&mut i.streams, &mut i.conns, &mut i.h3reqs)
-                .is_none()
-        );
+        assert!(i.events.pop(&mut i.streams, &mut i.conns).is_none());
     }
 
     #[test]
@@ -1441,7 +1162,7 @@ mod tests {
         let slot = i.conns.get(a).unwrap();
         assert!(slot.counted && slot.proto == ConnProto::H3);
         assert_eq!(
-            i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs),
+            i.events.pop(&mut i.streams, &mut i.conns),
             Some(Event::NewConn(conn_id(a), ConnProto::H3))
         );
     }
@@ -1455,8 +1176,7 @@ mod tests {
         assert!(!create(&mut i, b, ConnProto::H3));
         assert_eq!((i.n_counted, i.n_provisional), (1, 1));
         let evs: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .collect();
+            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns)).collect();
         assert_eq!(evs, vec![Event::NewConn(conn_id(a), ConnProto::H3)]);
     }
 
@@ -1471,8 +1191,7 @@ mod tests {
         assert!(!i.conns.is_live(a));
         assert_eq!((i.n_counted, i.n_provisional), (0, 0));
         let evs: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .collect();
+            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns)).collect();
         let unknown = CloseReason {
             err_type: ErrType::Unknown,
             code: 0,
@@ -1485,163 +1204,4 @@ mod tests {
             ]
         );
     }
-
-    fn h3_conn(i: &mut Inner) -> SlotId {
-        let c = accept(i);
-        assert!(create(i, c, ConnProto::H3));
-        let _ = i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs); // NewConn
-        c
-    }
-
-    fn stats() -> H3ReqStats {
-        H3ReqStats {
-            send_body: 1,
-            recv_body: 2,
-            begin_us: 3,
-            header_send_us: 4,
-            fin_send_us: 5,
-            fin_ack_us: 6,
-            mp_state: 0,
-            stream_err: 0,
-            close_msg: None,
-        }
-    }
-
-    /// spec §3.3: the server's ceiling, shared with raw streams, is checked before allocating;
-    /// a refusal allocates and queues nothing and closes the connection at the next `drive`.
-    #[test]
-    fn h3_request_create_refused_at_ceiling() {
-        let mut i = inner(0);
-        let c = h3_conn(&mut i);
-        i.conns.get_mut(c).unwrap().streams = STREAM_CEILING - 1;
-        let s = on_h3_request_create(&mut i, c, core::ptr::null_mut(), 0).expect("admitted");
-        assert_eq!(
-            i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs),
-            Some(Event::H3Request(conn_id(c), req_id(s)))
-        );
-        assert_eq!(i.conns.get(c).unwrap().streams, STREAM_CEILING);
-        assert_eq!(
-            on_h3_request_create(&mut i, c, core::ptr::null_mut(), 4),
-            None
-        );
-        let conn = i.conns.get(c).unwrap();
-        assert_eq!(conn.streams, STREAM_CEILING);
-        assert_eq!(conn.pending_close, Some(CEILING_CLOSE_CODE));
-        assert_eq!(i.h3reqs.len_live(), 1, "nothing allocated");
-        assert!(
-            i.events
-                .pop(&mut i.streams, &mut i.conns, &mut i.h3reqs)
-                .is_none()
-        );
-    }
-
-    #[test]
-    fn h3_request_close_decrements_streams() {
-        let mut i = inner(0);
-        let c = h3_conn(&mut i);
-        let s = on_h3_request_create(&mut i, c, core::ptr::null_mut(), 0).unwrap();
-        assert_eq!(i.conns.get(c).unwrap().streams, 1);
-        on_h3_request_close(&mut i, s, stats(), None);
-        on_h3_request_close(&mut i, s, stats(), None); // stale: released once
-        assert_eq!(i.conns.get(c).unwrap().streams, 0);
-        assert!(!i.h3reqs.is_live(s));
-        let evs: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .collect();
-        let close = Box::new(H3Close {
-            stats: stats(),
-            unread: None,
-        });
-        assert_eq!(
-            evs,
-            vec![
-                Event::H3Request(conn_id(c), req_id(s)),
-                Event::H3Closed(req_id(s), close)
-            ]
-        );
-    }
-
-    /// spec §3.5: a QPACK-blocked request can be destroyed after its connection closed.
-    #[test]
-    fn h3_close_tolerates_gone_conn_slot() {
-        let mut i = inner(0);
-        let c = h3_conn(&mut i);
-        let s = on_h3_request_create(&mut i, c, core::ptr::null_mut(), 0).unwrap();
-        let r = CloseReason {
-            err_type: ErrType::Unknown,
-            code: 0,
-        };
-        on_conn_close(&mut i, c, r);
-        on_h3_request_close(&mut i, s, stats(), None);
-        assert!(!i.h3reqs.is_live(s));
-        let last =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs)).last();
-        assert!(matches!(last, Some(Event::H3Closed(id, _)) if id == req_id(s)));
-    }
-
-    /// spec §3.3/§3.4: a trailer is drained in the notification only once the header section
-    /// was consumed; `H3Readable` coalesces.
-    #[test]
-    fn h3_trailer_drain_waits_for_header_section() {
-        let mut i = inner(0);
-        let c = h3_conn(&mut i);
-        let s = on_h3_request_create(&mut i, c, core::ptr::null_mut(), 0).unwrap();
-        let _ = i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs); // H3Request
-        assert!(!on_h3_read(&mut i, s, READ_HEADER | READ_TRAILER));
-        assert_eq!(
-            i.h3reqs.get(s).unwrap().read_flags,
-            READ_HEADER | READ_TRAILER
-        );
-        let r = i.h3reqs.get_mut(s).unwrap();
-        r.read_flags = 0;
-        r.header_consumed = true;
-        assert!(on_h3_read(&mut i, s, READ_TRAILER));
-        assert_eq!(i.h3reqs.get(s).unwrap().read_flags, 0);
-        let evs: Vec<_> =
-            std::iter::from_fn(|| i.events.pop(&mut i.streams, &mut i.conns, &mut i.h3reqs))
-                .collect();
-        assert_eq!(evs, vec![Event::H3Readable(req_id(s))]);
-        assert!(
-            !on_h3_read(&mut i, SlotId::NONE, READ_TRAILER),
-            "stale: no-op"
-        );
-    }
-
-    #[test]
-    fn h3_stats_maps_fields_and_caps_close_msg() {
-        // SAFETY: a plain C struct; all-zero is valid (null close message).
-        let mut st: xqc_request_stats_t = unsafe { core::mem::zeroed() };
-        st.send_body_size = 5;
-        st.recv_body_size = 7;
-        st.h3r_begin_time = 1;
-        st.h3r_header_send_time = 2;
-        st.stream_fin_send_time = 3;
-        st.stream_fin_ack_time = 4;
-        st.mp_state = 3;
-        st.stream_err = 0x10c;
-        // SAFETY: null close message.
-        let got = unsafe { h3_stats(&st) };
-        let want = H3ReqStats {
-            send_body: 5,
-            recv_body: 7,
-            begin_us: 1,
-            header_send_us: 2,
-            fin_send_us: 3,
-            fin_ack_us: 4,
-            mp_state: 3,
-            stream_err: 0x10c,
-            close_msg: None,
-        };
-        assert_eq!(got, want);
-        let long = std::ffi::CString::new("m".repeat(100)).unwrap();
-        st.stream_close_msg = long.as_ptr();
-        // SAFETY: a NUL-terminated string that outlives the call.
-        assert_eq!(unsafe { h3_stats(&st) }.close_msg, Some("m".repeat(64)));
-        st.stream_close_msg = c"remote reset".as_ptr();
-        // SAFETY: as above.
-        assert_eq!(
-            unsafe { h3_stats(&st) }.close_msg.as_deref(),
-            Some("remote reset")
-        );
-    }
 }
diff --git a/crates/mq-transport/src/h3.rs b/crates/mq-transport/src/h3.rs
deleted file mode 100644
index ed35cb95..00000000
--- a/crates/mq-transport/src/h3.rs
+++ /dev/null
@@ -1,326 +0,0 @@
-//! H3 requests: open, send, recv, reset, info (spec §3.1 contracts, §3.3, §3.4).
-//!
-//! Every op that calls xquic can run connection logic, whose notifications may release this or
-//! any other request (spec §3.1 "Synchronous notifications"): no reference into `Inner` is held
-//! across the call, and the slot is looked up again afterwards.
-
-use crate::Transport;
-use crate::ffi::trampolines::{READ_HEADER, READ_TRAILER, req_id, ud_of};
-use crate::slots::H3ReqSlot;
-use crate::stream::{reserve_local, stream_err};
-use core::ptr;
-use libc::iovec;
-use mq_transport_api::{ConnId, Error, H3Header, H3ReqId, H3ReqInfo, StreamError, Time};
-use xquic_sys::*;
-
-/// spec §3.3: client only; shares the connection's stream ceiling. The slot is allocated before
-/// `xqc_h3_request_create`, whose create notification binds it, and released if xquic fails.
-pub(crate) fn open_h3_request(t: &mut Transport, now: Time, c: ConnId) -> Result<H3ReqId, Error> {
-    t.inner.last_now = now;
-    let cid = reserve_local(&mut t.inner, c, true)?;
-    let s = t
-        .inner
-        .h3reqs
-        .insert(H3ReqSlot::new(c.slot(), ptr::null_mut(), 0));
-    // SAFETY: the engine is live; the cid outlives the call.
-    let created = t.with_engine(now, |_, engine| unsafe {
-        !xqc_h3_request_create(engine, &cid, ptr::null_mut(), ud_of(s)).is_null()
-    });
-    let inner = &mut *t.inner;
-    match (created, inner.h3reqs.is_live(s)) {
-        (true, true) => Ok(req_id(s)),
-        (false, true) => {
-            inner.h3reqs.remove(s);
-            if let Some(conn) = inner.conns.get_mut(c.slot()) {
-                conn.streams -= 1;
-            }
-            Err(Error::Other)
-        }
-        // Released by a close notification inside the call (spec §3.1).
-        (_, false) => Err(Error::Other),
-    }
-}
-
-/// The request's xquic pointer; `Stale` for a released (or not yet bound) slot.
-fn xqc_of(t: &Transport, r: H3ReqId) -> Result<*mut xqc_h3_request_t, StreamError> {
-    t.inner
-        .h3reqs
-        .get(r.slot())
-        .map(|x| x.xqc)
-        .filter(|x| !x.is_null())
-        .ok_or(StreamError::Stale)
-}
-
-fn iov(b: &[u8]) -> iovec {
-    iovec {
-        iov_base: b.as_ptr().cast_mut().cast(),
-        iov_len: b.len(),
-    }
-}
-
-/// spec §3.1: all-or-error (xquic buffers the whole HEADERS frame); `Blocked` never occurs.
-pub(crate) fn h3_send_headers(
-    t: &mut Transport,
-    now: Time,
-    r: H3ReqId,
-    hs: &[H3Header<'_>],
-    fin: bool,
-) -> Result<(), StreamError> {
-    t.inner.last_now = now;
-    let h3r = xqc_of(t, r)?;
-    let mut v: Vec<xqc_http_header_t> = hs
-        .iter()
-        .map(|h| xqc_http_header_t {
-            name: iov(h.name),
-            value: iov(h.value),
-            flags: 0, // XQC_HTTP_HEADER_FLAG_NONE, as C
-            save_nv_hit_flags: 0,
-            nv_hit_flags: 0,
-            src_header: ptr::null_mut(),
-        })
-        .collect();
-    let mut headers = xqc_http_headers_t {
-        headers: v.as_mut_ptr(),
-        count: v.len(),
-        capacity: v.len(),
-        total_len: hs.iter().map(|h| h.name.len() + h.value.len()).sum(),
-    };
-    // SAFETY: a live slot holds a valid request; xquic copies the headers and does not write
-    // through the name/value pointers.
-    let n = t.with_engine(now, |_, _| unsafe {
-        xqc_h3_request_send_headers(h3r, &mut headers, u8::from(fin))
-    });
-    match n {
-        0.. => Ok(()),
-        n if n == -(XQC_ESTREAM_RESET as isize) => Err(StreamError::Reset),
-        _ => Err(StreamError::Conn),
-    }
-}
-
-/// spec §3.1: the `stream_send` contract.
-pub(crate) fn h3_send_body(
-    t: &mut Transport,
-    now: Time,
-    r: H3ReqId,
-    data: &[u8],
-    fin: bool,
-) -> Result<usize, StreamError> {
-    t.inner.last_now = now;
-    let h3r = xqc_of(t, r)?;
-    // SAFETY: as in `h3_send_headers`; xquic does not write through the data pointer.
-    let n = t.with_engine(now, |_, _| unsafe {
-        xqc_h3_request_send_body(h3r, data.as_ptr().cast_mut(), data.len(), u8::from(fin))
-    });
-    if n < 0 {
-        Err(stream_err(n))
-    } else {
-        Ok(n as usize)
-    }
-}
-
-/// spec §3.1: a bare FIN; EAGAIN means queued (the write notify flushes it).
-pub(crate) fn h3_finish(t: &mut Transport, now: Time, r: H3ReqId) -> Result<(), StreamError> {
-    t.inner.last_now = now;
-    let h3r = xqc_of(t, r)?;
-    // SAFETY: as in `h3_send_headers`.
-    let n = t.with_engine(now, |_, _| unsafe { xqc_h3_request_finish(h3r) });
-    if n >= 0 || n == -(XQC_EAGAIN as isize) {
-        Ok(())
-    } else {
-        Err(StreamError::Conn)
-    }
-}
-
-/// Calls `each` for every field of a section xquic returned.
-///
-/// # Safety
-/// `hs` is a header section of a live request, unchanged for this call.
-pub(crate) unsafe fn for_each_header(
-    hs: *const xqc_http_headers_t,
-    each: &mut dyn FnMut(&[u8], &[u8]),
-) {
-    let bytes = |v: &iovec| {
-        if v.iov_len == 0 {
-            &[][..]
-        } else {
-            // SAFETY: xquic's decoded field: `iov_len` readable bytes.
-            unsafe { core::slice::from_raw_parts(v.iov_base.cast::<u8>(), v.iov_len) }
-        }
-    };
-    // SAFETY: guaranteed by the caller.
-    let hs = unsafe { &*hs };
-    for k in 0..hs.count {
-        // SAFETY: `count` entries are initialised.
-        let h = unsafe { &*hs.headers.add(k) };
-        each(bytes(&h.name), bytes(&h.value));
-    }
-}
-
-/// spec §3.4: gated on the HEADER flag; a pending trailer section is drained (discarded) right
-/// after the header section. Returns the header call's own fin.
-pub(crate) fn h3_recv_headers(
-    t: &mut Transport,
-    now: Time,
-    r: H3ReqId,
-    each: &mut dyn FnMut(&[u8], &[u8]),
-) -> Result<bool, StreamError> {
-    t.inner.last_now = now;
-    let h3r = xqc_of(t, r)?;
-    let flags = t.inner.h3reqs.get(r.slot()).map_or(0, |x| x.read_flags);
-    if flags & READ_HEADER == 0 {
-        return Err(StreamError::Blocked);
-    }
-    let fin = t.with_engine(now, |_, _| {
-        let mut fin = 0u8; // xquic logs it before writing it
-        // SAFETY: a live slot holds a valid request; getters that fire no notification.
-        unsafe {
-            let hs = xqc_h3_request_recv_headers(h3r, &mut fin);
-            if hs.is_null() {
-                return None;
-            }
-            for_each_header(hs, each);
-            if flags & READ_TRAILER != 0 {
-                let mut trailer_fin = 0u8;
-                xqc_h3_request_recv_headers(h3r, &mut trailer_fin);
-            }
-        }
-        Some(fin != 0)
-    });
-    let fin = fin.ok_or(StreamError::Conn)?;
-    if let Some(x) = t.inner.h3reqs.get_mut(r.slot()) {
-        x.read_flags &= !(READ_HEADER | READ_TRAILER);
-        x.header_consumed = true;
-        x.fin_consumed |= fin;
-    }
-    Ok(fin)
-}
-
-/// spec §3.4: `(n, fin)`; nothing and no fin is `Blocked`; an empty FIN is `(0, true)`.
-pub(crate) fn h3_recv_body(
-    t: &mut Transport,
-    now: Time,
-    r: H3ReqId,
-    buf: &mut [u8],
-) -> Result<(usize, bool), StreamError> {
-    t.inner.last_now = now;
-    let h3r = xqc_of(t, r)?;
-    let mut fin = 0u8;
-    // SAFETY: as in `h3_recv_headers`; `buf` is writable for its length.
-    let n = t.with_engine(now, |_, _| unsafe {
-        xqc_h3_request_recv_body(h3r, buf.as_mut_ptr(), buf.len(), &mut fin)
-    });
-    if n < 0 {
-        return Err(stream_err(n));
-    }
-    if fin == 0 {
-        return if n == 0 {
-            Err(StreamError::Blocked)
-        } else {
-            Ok((n as usize, false))
-        };
-    }
-    if let Some(x) = t.inner.h3reqs.get_mut(r.slot()) {
-        x.fin_consumed = true;
-    }
-    Ok((n as usize, true))
-}
-
-/// spec §3.1: RESET_STREAM (+ STOP_SENDING); the slot is released in the close notification.
-pub(crate) fn h3_reset(t: &mut Transport, now: Time, r: H3ReqId) {
-    t.inner.last_now = now;
-    if let Ok(h3r) = xqc_of(t, r) {
-        // SAFETY: as in `h3_send_headers`.
-        t.with_engine(now, |_, _| unsafe { xqc_h3_request_close(h3r) });
-    }
-}
-
-pub(crate) fn h3_req_info(t: &Transport, r: H3ReqId) -> Result<H3ReqInfo, Error> {
-    let x = t.inner.h3reqs.get(r.slot()).ok_or(Error::Stale)?;
-    Ok(H3ReqInfo {
-        conn: ConnId::from_slot(x.conn).ok_or(Error::Stale)?,
-        quic_id: x.quic_id,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ffi::trampolines::STREAM_CEILING;
-    use mq_transport_api::{
-        CongestionControl, ConnConfig, ConnProto, Role, Scheduler, TransportConfig, TransportOps,
-    };
-
-    /// A client transport with one (unestablished) connection of `proto`.
-    fn client(proto: ConnProto) -> (Transport, ConnId) {
-        let mut t = Transport::new(TransportConfig {
-            role: Role::Client,
-            alpn: "mqproxy-tcp/1",
-            max_conns: 0,
-            scheduler: Scheduler::MinRtt,
-            cc: CongestionControl::Bbr,
-            realtime_offset_us: 0,
-            h3: true,
-            h3_backend: mq_transport_api::H3Backend::XqcH3,
-            qlog: None,
-        })
-        .expect("transport");
-        let cc = ConnConfig {
-            peer: "10.0.0.1:4433".parse().unwrap(),
-            sni: "mqproxy",
-            idle_timeout: None,
-            proto,
-        };
-        let c = t.connect(Time(1), &cc).expect("connect");
-        (t, c)
-    }
-
-    /// spec §3.3: requests share the per-connection 8192 ceiling with streams.
-    #[test]
-    fn h3_open_request_shares_stream_ceiling() {
-        let (mut t, c) = client(ConnProto::H3);
-        t.inner.conns.get_mut(c.slot()).unwrap().streams = STREAM_CEILING - 1;
-        t.open_h3_request(Time(1), c)
-            .expect("the 8192nd is admitted");
-        assert_eq!(t.inner.conns.get(c.slot()).unwrap().streams, STREAM_CEILING);
-        assert_eq!(t.open_h3_request(Time(1), c), Err(Error::Ceiling));
-        assert_eq!(t.inner.h3reqs.len_live(), 1, "no slot for the refused one");
-        assert_eq!(t.inner.conns.get(c.slot()).unwrap().streams, STREAM_CEILING);
-    }
-
-    /// A request needs an H3 connection and a raw stream a raw one: the other protocol's
-    /// callbacks would take our slot id for their own state.
-    #[test]
-    fn open_checks_the_connection_protocol() {
-        let (mut t, c) = client(ConnProto::Raw);
-        assert_eq!(t.open_h3_request(Time(1), c), Err(Error::Other));
-        assert!(t.open_stream(Time(1), c).is_ok());
-        drop(t);
-        let (mut t, c) = client(ConnProto::H3);
-        assert_eq!(t.open_stream(Time(1), c), Err(Error::Other));
-        assert_eq!(t.inner.conns.get(c.slot()).unwrap().streams, 0);
-    }
-
-    /// spec §3.4: no HEADER bit → `Blocked` without calling xquic; with the bit but nothing
-    /// in xquic → `Conn`.
-    #[test]
-    fn h3_read_flags_gate_recv_headers() {
-        let (mut t, c) = client(ConnProto::H3);
-        let r = t.open_h3_request(Time(1), c).unwrap();
-        let mut each = |_: &[u8], _: &[u8]| panic!("no header section");
-        assert_eq!(
-            t.h3_recv_headers(Time(1), r, &mut each),
-            Err(StreamError::Blocked)
-        );
-        t.inner.h3reqs.get_mut(r.slot()).unwrap().read_flags = READ_TRAILER;
-        assert_eq!(
-            t.h3_recv_headers(Time(1), r, &mut each),
-            Err(StreamError::Blocked)
-        );
-        t.inner.h3reqs.get_mut(r.slot()).unwrap().read_flags = READ_HEADER;
-        assert_eq!(
-            t.h3_recv_headers(Time(1), r, &mut each),
-            Err(StreamError::Conn)
-        );
-        assert!(!t.inner.h3reqs.get(r.slot()).unwrap().header_consumed);
-    }
-}
diff --git a/crates/mq-transport/src/lib.rs b/crates/mq-transport/src/lib.rs
index 514a266b..c0b6049f 100644
--- a/crates/mq-transport/src/lib.rs
+++ b/crates/mq-transport/src/lib.rs
@@ -13,17 +13,15 @@ mod engine;
 pub use engine::H3_FIELD_SECTION_MAX;
 mod events;
 mod ffi;
-mod h3;
 mod slots;
 mod stream;
 mod txq;
 
 use mq_transport_api::{
-    ConnConfig, ConnId, ConnStats, ConnectError, DatagramError, Event, H3Header, H3ReqId,
-    H3ReqInfo, PathError, PathId, StreamError, StreamId, StreamInfo, Time, Transmit,
-    TransportConfig, TransportOps, TxKey,
+    ConnConfig, ConnId, ConnStats, ConnectError, DatagramError, Event, PathError, PathId,
+    StreamError, StreamId, StreamInfo, Time, Transmit, TransportConfig, TransportOps, TxKey,
 };
-use slots::{ConnSlot, H3ReqSlot, Slots, StreamSlot};
+use slots::{ConnSlot, Slots, StreamSlot};
 use std::ffi::CString;
 use std::fs::File;
 use std::net::SocketAddr;
@@ -45,7 +43,6 @@ pub(crate) struct Inner {
     n_admitted: u64,
     conns: Slots<ConnSlot>,
     streams: Slots<StreamSlot>,
-    h3reqs: Slots<H3ReqSlot>,
     txq: txq::TxQueues,
     events: events::Events,
     /// Recorded by `set_event_timer` (spec §4.3).
@@ -67,7 +64,6 @@ impl Inner {
             n_admitted: 0,
             conns: Default::default(),
             streams: Default::default(),
-            h3reqs: Default::default(),
             txq: Default::default(),
             events: Default::default(),
             deadline: None,
@@ -142,11 +138,10 @@ impl TransportOps for Transport {
             events,
             streams,
             conns,
-            h3reqs,
             ..
         } = &mut *self.inner;
         loop {
-            let e = events.pop(streams, conns, h3reqs)?;
+            let e = events.pop(streams, conns)?;
             let live = match &e {
                 Event::ConnEstablished(c)
                 | Event::NewConn(c, _)
@@ -158,9 +153,7 @@ impl TransportOps for Transport {
                 | Event::StreamWritable(s)
                 | Event::StreamPeerReset(s, _)
                 | Event::StreamStopSending(s, _) => streams.is_live(s.slot()),
-                Event::H3Request(_, r) | Event::H3Readable(r) | Event::H3Writable(r) => {
-                    h3reqs.is_live(r.slot())
-                }
+                Event::H3Request(..) | Event::H3Readable(_) | Event::H3Writable(_) => true,
                 Event::ConnClosed(..)
                 | Event::StreamClosed(_)
                 | Event::StreamCloseStats(..)
@@ -260,64 +253,6 @@ impl TransportOps for Transport {
     fn datagram_recv(&mut self, c: ConnId, buf: &mut [u8]) -> Option<usize> {
         datagram::ring_pop(self.inner.conns.get_mut(c.slot())?, buf)
     }
-
-    fn open_h3_request(
-        &mut self,
-        now: Time,
-        c: ConnId,
-    ) -> Result<H3ReqId, mq_transport_api::Error> {
-        h3::open_h3_request(self, now, c)
-    }
-
-    fn h3_send_headers(
-        &mut self,
-        now: Time,
-        r: H3ReqId,
-        hs: &[H3Header<'_>],
-        fin: bool,
-    ) -> Result<(), StreamError> {
-        h3::h3_send_headers(self, now, r, hs, fin)
-    }
-
-    fn h3_send_body(
-        &mut self,
-        now: Time,
-        r: H3ReqId,
-        data: &[u8],
-        fin: bool,
-    ) -> Result<usize, StreamError> {
-        h3::h3_send_body(self, now, r, data, fin)
-    }
-
-    fn h3_finish(&mut self, now: Time, r: H3ReqId) -> Result<(), StreamError> {
-        h3::h3_finish(self, now, r)
-    }
-
-    fn h3_recv_headers(
-        &mut self,
-        now: Time,
-        r: H3ReqId,
-        each: &mut dyn FnMut(&[u8], &[u8]),
-    ) -> Result<bool, StreamError> {
-        h3::h3_recv_headers(self, now, r, each)
-    }
-
-    fn h3_recv_body(
-        &mut self,
-        now: Time,
-        r: H3ReqId,
-        buf: &mut [u8],
-    ) -> Result<(usize, bool), StreamError> {
-        h3::h3_recv_body(self, now, r, buf)
-    }
-
-    fn h3_reset(&mut self, now: Time, r: H3ReqId) {
-        h3::h3_reset(self, now, r)
-    }
-
-    fn h3_req_info(&self, r: H3ReqId) -> Result<H3ReqInfo, mq_transport_api::Error> {
-        h3::h3_req_info(self, r)
-    }
 }
 
 /// Accessors for the fabric, shard-pair and loopback tests (spec §8.1).
diff --git a/crates/mq-transport/src/slots.rs b/crates/mq-transport/src/slots.rs
index 6084cb10..328fbeed 100644
--- a/crates/mq-transport/src/slots.rs
+++ b/crates/mq-transport/src/slots.rs
@@ -3,7 +3,7 @@
 
 use mq_transport_api::ringbuf::RingBuf;
 use mq_transport_api::{ConnProto, SlotId, StreamKind, Time};
-use xquic_sys::{xqc_cid_t, xqc_connection_t, xqc_h3_conn_t, xqc_h3_request_t, xqc_stream_t};
+use xquic_sys::{xqc_cid_t, xqc_connection_t, xqc_stream_t};
 
 pub(crate) struct Slots<T> {
     entries: Vec<Entry<T>>,
@@ -85,8 +85,6 @@ pub(crate) struct ConnSlot {
     pub server: bool,
     /// Set by the create notification (spec §3.2).
     pub proto: ConnProto,
-    /// Bound in the H3 create notification; null for raw connections (spec §3.2).
-    pub h3c: *mut xqc_h3_conn_t,
     /// Counted in `n_provisional` while true; cleared only by a successful ALPN admission (spec §4.7).
     pub provisional: bool,
     /// Scheduling input for `next_timeout()`; cleared when the deadline closes the connection.
@@ -118,7 +116,6 @@ impl ConnSlot {
             counted: false,
             server,
             proto: ConnProto::Raw,
-            h3c: core::ptr::null_mut(),
             provisional: false,
             provisional_deadline: None,
             streams: 0,
@@ -167,36 +164,6 @@ impl StreamSlot {
     }
 }
 
-/// An H3 request (spec §3.3). Counted in its connection's `streams` (the shared ceiling).
-pub(crate) struct H3ReqSlot {
-    /// Bound in the create notification; null until then (client) — ops report `Stale`.
-    pub xqc: *mut xqc_h3_request_t,
-    pub conn: SlotId,
-    pub quic_id: u64,
-    /// `XQC_REQ_NOTIFY_READ_*` bits accumulated from read notifications (spec §3.4).
-    pub read_flags: u8,
-    pub header_consumed: bool,
-    /// The app has seen the request's fin (`h3_recv_headers` / `h3_recv_body`).
-    pub fin_consumed: bool,
-    pub readable_queued: bool,
-    pub writable_queued: bool,
-}
-
-impl H3ReqSlot {
-    pub fn new(conn: SlotId, xqc: *mut xqc_h3_request_t, quic_id: u64) -> Self {
-        Self {
-            xqc,
-            conn,
-            quic_id,
-            read_flags: 0,
-            header_consumed: false,
-            fin_consumed: false,
-            readable_queued: false,
-            writable_queued: false,
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/mq-transport/src/stream.rs b/crates/mq-transport/src/stream.rs
index e9f55ce5..e3dfe4ea 100644
--- a/crates/mq-transport/src/stream.rs
+++ b/crates/mq-transport/src/stream.rs
@@ -26,7 +26,7 @@ pub(crate) fn open_stream(t: &mut Transport, now: Time, c: ConnId) -> Result<Str
         now,
         c,
         StreamKind::Bidi,
-        |i, c| reserve_local(i, c, false),
+        reserve_local,
         |engine, cid, ud| unsafe { xqc_stream_create(engine, cid, ptr::null_mut(), ud) },
     )
 }
@@ -60,7 +60,7 @@ pub(crate) fn open_stream_with_id(
         now,
         c,
         StreamKind::Bidi,
-        |i, c| reserve_local(i, c, false),
+        reserve_local,
         |engine, cid, ud| unsafe { xqc_stream_create_with_id(engine, cid, quic_id, ud) },
     )
 }
@@ -105,19 +105,14 @@ fn open_with<R>(
     }
 }
 
-/// A client's local stream (`h3 = false`) or H3 request (`h3 = true`) on `c`: role, protocol,
-/// then the per-connection ceiling both share (spec §4.2, §3.3). Counts it; the caller undoes
+/// A client's local stream on `c`: role, then the per-connection ceiling (spec §4.2).
+/// Counts it; the caller undoes
 /// the count if xquic then fails to create it.
-pub(crate) fn reserve_local(inner: &mut Inner, c: ConnId, h3: bool) -> Result<xqc_cid_t, Error> {
+pub(crate) fn reserve_local(inner: &mut Inner, c: ConnId) -> Result<xqc_cid_t, Error> {
     if matches!(inner.cfg.role, Role::Server { .. }) {
         return Err(Error::Role); // xquic creates only client-initiated ids
     }
     let conn = inner.conns.get_mut(c.slot()).ok_or(Error::Stale)?;
-    // A raw stream on an H3 conn (or a request on a raw one) would reach the other protocol's
-    // callbacks with our slot id as their user data.
-    if conn.h3c.is_null() == h3 {
-        return Err(Error::Other);
-    }
     if conn.streams >= STREAM_CEILING {
         return Err(Error::Ceiling);
     }
@@ -125,13 +120,9 @@ pub(crate) fn reserve_local(inner: &mut Inner, c: ConnId, h3: bool) -> Result<xq
     Ok(conn.cid)
 }
 
-/// adoption spec §3: both roles may open uni streams; raw conns only (an xqc_h3 conn's stream
-/// callbacks would take our slot id for their own state). Counts the stream.
+/// adoption spec §3: both roles may open uni streams. Counts the stream.
 pub(crate) fn reserve_uni(inner: &mut Inner, c: ConnId) -> Result<*mut xqc_connection_t, Error> {
     let conn = inner.conns.get_mut(c.slot()).ok_or(Error::Stale)?;
-    if !conn.h3c.is_null() {
-        return Err(Error::Other);
-    }
     if conn.streams >= STREAM_CEILING {
         return Err(Error::Ceiling);
     }
@@ -326,7 +317,6 @@ mod tests {
             cc: CongestionControl::Bbr,
             realtime_offset_us: 0,
             h3: false,
-            h3_backend: mq_transport_api::H3Backend::XqcH3,
             qlog: None,
         })
         .expect("transport");
diff --git a/crates/mq-transport/tests/common/lockstep.rs b/crates/mq-transport/tests/common/lockstep.rs
index 4774c3dd..e52cebb1 100644
--- a/crates/mq-transport/tests/common/lockstep.rs
+++ b/crates/mq-transport/tests/common/lockstep.rs
@@ -24,7 +24,6 @@ pub fn cfg(role: Role) -> TransportConfig {
         cc: CongestionControl::Bbr,
         realtime_offset_us: 0,
         h3: false,
-        h3_backend: mq_transport_api::H3Backend::XqcH3,
         qlog: None,
     }
 }
diff --git a/crates/mq-transport/tests/engine.rs b/crates/mq-transport/tests/engine.rs
index faedaedf..8785dd5c 100644
--- a/crates/mq-transport/tests/engine.rs
+++ b/crates/mq-transport/tests/engine.rs
@@ -15,7 +15,6 @@ fn cfg(role: Role) -> TransportConfig {
         cc: CongestionControl::Bbr,
         realtime_offset_us: 0,
         h3: false,
-        h3_backend: mq_transport_api::H3Backend::XqcH3,
         qlog: None,
     }
 }
diff --git a/crates/mq-transport/tests/fabric_h3.rs b/crates/mq-transport/tests/fabric_h3.rs
deleted file mode 100644
index 87e212d2..00000000
--- a/crates/mq-transport/tests/fabric_h3.rs
+++ /dev/null
@@ -1,688 +0,0 @@
-//! spec §3.2, §3.3: H3 connections share the raw connections' slot table, admission,
-//! provisional expiry and close reporting; H3 requests (spec §3.1, §3.4).
-mod common;
-
-use common::initial::{client_hello_fragment, initial};
-use common::lockstep::{Peer, cfg, exchange_many, server_role};
-use common::pair::{MS, Opts, Pair, T0, cli_addr, conn_cfg, srv_addr, stream_count};
-use mq_transport_api::{
-    ConnId, ConnProto, Event, H3Close, H3Header, H3ReqId, Role, StreamError, Time, TransportConfig,
-    TransportOps,
-};
-use std::net::SocketAddr;
-use std::time::Duration;
-
-fn h3_cfg(role: Role) -> TransportConfig {
-    TransportConfig {
-        h3: true,
-        qlog: None,
-        ..cfg(role)
-    }
-}
-
-fn h3_opts(proto: ConnProto) -> Opts {
-    Opts {
-        server: h3_cfg(server_role()),
-        client: h3_cfg(Role::Client),
-        proto,
-        ..Opts::default()
-    }
-}
-
-fn new_conns(ev: &[Event]) -> Vec<(ConnId, ConnProto)> {
-    ev.iter()
-        .filter_map(|e| match e {
-            Event::NewConn(c, p) => Some((*c, *p)),
-            _ => None,
-        })
-        .collect()
-}
-
-#[test]
-fn h3_connect_established_both_sides() {
-    let p = Pair::with(h3_opts(ConnProto::H3)); // asserts ConnEstablished on both sides
-    assert_eq!(new_conns(&p.sev), vec![(p.srv_conn, ConnProto::H3)]);
-}
-
-#[test]
-fn raw_and_h3_on_one_engine() {
-    let mut p = Pair::with(h3_opts(ConnProto::Raw));
-    assert_eq!(new_conns(&p.sev), vec![(p.srv_conn, ConnProto::Raw)]);
-    let mut cc = conn_cfg(None);
-    cc.proto = ConnProto::H3;
-    let c2 = p
-        .client
-        .call(p.now, move |t, now| t.connect(now, &cc))
-        .expect("connect h3");
-    p.exchange();
-    assert!(p.cev.contains(&Event::ConnEstablished(c2)), "{:?}", p.cev);
-    let news = new_conns(&p.sev);
-    assert_eq!(news.len(), 2, "{news:?}");
-    assert_eq!(news[1].1, ConnProto::H3);
-    assert!(p.sev.contains(&Event::ConnEstablished(news[1].0)));
-    assert_eq!(p.server.call(p.now, |t, _| t.conn_count()), 2);
-}
-
-#[test]
-fn h3_conn_counts_toward_max_conns() {
-    let mut scfg = h3_cfg(server_role());
-    scfg.max_conns = 1;
-    let server = Peer::spawn(scfg, vec![srv_addr()]);
-    let mut now = T0;
-    let client = |k: usize, now: Time| {
-        let c = Peer::spawn(h3_cfg(Role::Client), vec![cli_addr(k)]);
-        let mut cc = conn_cfg(None);
-        cc.proto = ConnProto::H3;
-        let id = c.call(now, move |t, now| t.connect(now, &cc)).unwrap();
-        (c, id)
-    };
-    let run = |peers: &[&Peer], now: &mut Time, steps: usize| {
-        for _ in 0..steps {
-            *now = *now + MS;
-            for p in peers {
-                p.drive(*now);
-            }
-            exchange_many(*now, peers);
-        }
-    };
-    let count = |s: &Peer| s.call(T0, |t, _| (t.conn_count(), t.n_provisional()));
-
-    let (c0, id0) = client(3, now);
-    run(&[&c0, &server], &mut now, 5);
-    assert!(c0.drain_events().contains(&Event::ConnEstablished(id0)));
-    let news = new_conns(&server.drain_events());
-    assert!(matches!(news[..], [(_, ConnProto::H3)]), "{news:?}");
-    assert_eq!(count(&server), (1, 0));
-
-    // spec §4.7: an unauthenticated H3 conn (no request yet) is evicted by a newcomer.
-    let (c1, id1) = client(0, now);
-    let (mut sev, mut c0ev) = (Vec::new(), Vec::new());
-    for _ in 0..1000 {
-        run(&[&c0, &c1, &server], &mut now, 10);
-        sev.extend(server.drain_events());
-        c0ev.extend(c0.drain_events());
-        if c0ev.iter().any(|e| matches!(e, Event::ConnClosed(..))) {
-            break;
-        }
-    }
-    assert!(c1.drain_events().contains(&Event::ConnEstablished(id1)));
-    assert!(
-        c0ev.iter()
-            .any(|e| matches!(e, Event::ConnClosed(c, r) if *c == id0 && r.code == 0x1002)),
-        "{c0ev:?}"
-    );
-    let news = new_conns(&sev);
-    assert!(matches!(news[..], [(_, ConnProto::H3)]), "{news:?}");
-    assert_eq!(count(&server), (1, 0));
-    let s1 = news[0].0;
-    server.call(now, move |t, _| t.mark_conn_authed(s1));
-
-    // The second H3 client is refused at the shared cap, before any slot: s1 is authed.
-    let (c2, id2) = client(1, now);
-    run(&[&c1, &c2, &server], &mut now, 50);
-    assert!(!c2.drain_events().contains(&Event::ConnEstablished(id2)));
-    assert!(new_conns(&server.drain_events()).is_empty());
-    assert_eq!(count(&server), (1, 0));
-
-    // Closing the first H3 connection releases its unit.
-    c1.call(now, move |t, now| t.close_conn(now, id1));
-    let mut sev = Vec::new();
-    for _ in 0..1000 {
-        run(&[&c1, &c2, &server], &mut now, 10);
-        sev.extend(server.drain_events());
-        if sev.iter().any(|e| matches!(e, Event::ConnClosed(..))) {
-            break;
-        }
-    }
-    assert!(
-        sev.iter().any(|e| matches!(e, Event::ConnClosed(..))),
-        "{sev:?}"
-    );
-    assert_eq!(count(&server), (0, 0));
-}
-
-/// The canned ClientHello carries no ALPN: this only pins that an `h3: true` engine still
-/// expires provisionals (the provisional path is ALPN-agnostic, `fabric_provisional.rs`).
-#[test]
-fn h3_conn_provisional_expiry() {
-    let server = Peer::spawn(h3_cfg(server_role()), vec![srv_addr()]);
-    let from: SocketAddr = "10.2.0.1:40000".parse().unwrap();
-    let pkt = initial(
-        &[0xd0, 0, 1, 1, 2, 3, 4, 5],
-        &[0x5c, 0, 1, 5, 4, 3, 2, 1],
-        0,
-        0,
-        &client_hello_fragment(0, 300),
-    );
-    server.deliver(T0, srv_addr(), from, pkt);
-    server.drive(T0);
-    server.pump_out(T0);
-    let n_prov = |s: &Peer| s.call(Time::ZERO, |t, _| t.n_provisional());
-    assert_eq!(n_prov(&server), 1);
-    let mut now = T0;
-    while n_prov(&server) > 0 {
-        let d = server.next_timeout().expect("provisional deadline");
-        now = now.max(d);
-        server.drive(now);
-        server.pump_out(now);
-        assert!(now < T0 + Duration::from_secs(60), "never released");
-    }
-    assert!(
-        now >= T0 + Duration::from_secs(10),
-        "not before the 10 s deadline"
-    );
-    assert_eq!(server.call(now, |t, _| t.conn_count()), 0);
-    assert_eq!(server.drain_events(), vec![], "never admitted: no events");
-}
-
-#[test]
-fn h3_conn_close_reported() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let c = p.conn;
-    p.client.call(p.now, move |t, now| t.close_conn(now, c));
-    assert!(p.pump_until(10 * MS, 1000, |p| {
-        p.client_closed().is_some() && p.server_closed().is_some()
-    }));
-    assert_eq!(p.server.call(p.now, |t, _| t.conn_count()), 0);
-}
-
-// ── requests (spec §3.1 contracts, §3.3 request rows, §3.4) ─────────────
-
-const REQ: &[(&str, &str)] = &[
-    (":method", "POST"),
-    (":scheme", "https"),
-    (":authority", "x"),
-    (":path", "/"),
-];
-const RESP: &[(&str, &str)] = &[(":status", "200")];
-
-fn owned(hs: &[(&str, &str)]) -> Vec<(String, String)> {
-    hs.iter()
-        .map(|(n, v)| (n.to_string(), v.to_string()))
-        .collect()
-}
-
-fn open_req(p: &Pair) -> H3ReqId {
-    let c = p.conn;
-    p.client
-        .call(p.now, move |t, now| t.open_h3_request(now, c))
-        .expect("open_h3_request")
-}
-
-fn send_headers(
-    peer: &Peer,
-    now: Time,
-    r: H3ReqId,
-    hs: &'static [(&'static str, &'static str)],
-    fin: bool,
-) -> Result<(), StreamError> {
-    peer.call(now, move |t, now| {
-        let v: Vec<H3Header<'_>> = hs
-            .iter()
-            .map(|(n, v)| H3Header {
-                name: n.as_bytes(),
-                value: v.as_bytes(),
-            })
-            .collect();
-        t.h3_send_headers(now, r, &v, fin)
-    })
-}
-
-fn send_body(
-    peer: &Peer,
-    now: Time,
-    r: H3ReqId,
-    data: &'static [u8],
-    fin: bool,
-) -> Result<usize, StreamError> {
-    peer.call(now, move |t, now| t.h3_send_body(now, r, data, fin))
-}
-
-/// One `h3_recv_headers` call.
-fn recv_headers(
-    peer: &Peer,
-    now: Time,
-    r: H3ReqId,
-) -> Result<(Vec<(String, String)>, bool), StreamError> {
-    peer.call(now, move |t, now| {
-        let mut out = Vec::new();
-        let mut each = |n: &[u8], v: &[u8]| {
-            out.push((
-                String::from_utf8_lossy(n).into_owned(),
-                String::from_utf8_lossy(v).into_owned(),
-            ))
-        };
-        t.h3_recv_headers(now, r, &mut each).map(|fin| (out, fin))
-    })
-}
-
-/// One `h3_recv_body` call into a 64 KiB buffer.
-fn recv_body(peer: &Peer, now: Time, r: H3ReqId) -> Result<(Vec<u8>, bool), StreamError> {
-    peer.call(now, move |t, now| {
-        let mut buf = vec![0u8; 64 * 1024];
-        t.h3_recv_body(now, r, &mut buf)
-            .map(|(n, fin)| (buf[..n].to_vec(), fin))
-    })
-}
-
-fn h3_requests(ev: &[Event]) -> Vec<(ConnId, H3ReqId)> {
-    ev.iter()
-        .filter_map(|e| match e {
-            Event::H3Request(c, r) => Some((*c, *r)),
-            _ => None,
-        })
-        .collect()
-}
-
-fn h3_closed(ev: &[Event], r: H3ReqId) -> Option<H3Close> {
-    ev.iter().find_map(|e| match e {
-        Event::H3Closed(x, c) if *x == r => Some((**c).clone()),
-        _ => None,
-    })
-}
-
-fn readables(ev: &[Event], r: H3ReqId) -> usize {
-    ev.iter().filter(|e| **e == Event::H3Readable(r)).count()
-}
-
-/// The server's one request.
-fn server_req(p: &Pair) -> H3ReqId {
-    match h3_requests(&p.sev)[..] {
-        [(c, r)] => {
-            assert_eq!(c, p.srv_conn);
-            r
-        }
-        ref other => panic!("expected one H3Request, got {other:?}"),
-    }
-}
-
-/// Follows timeouts until both requests reported `H3Closed`.
-fn wait_closed(p: &mut Pair, cr: H3ReqId, sr: H3ReqId) -> (H3Close, H3Close) {
-    for _ in 0..500 {
-        if let (Some(c), Some(s)) = (h3_closed(&p.cev, cr), h3_closed(&p.sev, sr)) {
-            return (c, s);
-        }
-        if !p.follow_timeout() {
-            p.tick(10 * MS);
-        }
-    }
-    panic!("H3Closed never arrived: {:?} / {:?}", p.cev, p.sev);
-}
-
-/// POST "hello" → 200 "hello", every byte read on both sides (`h3_request_echo`).
-// Body writes defer their flush to the next drive (`defer_send_flush`, SP2 spec §3.3), so the
-// tests move packets with `tick(ZERO)` (drive both, then exchange), as the runtime drives.
-fn echo(p: &mut Pair) -> (H3ReqId, H3ReqId) {
-    let cr = open_req(p);
-    send_headers(&p.client, p.now, cr, REQ, false).unwrap();
-    assert_eq!(send_body(&p.client, p.now, cr, b"hello", true), Ok(5));
-    p.tick(Duration::ZERO);
-    let sr = server_req(p);
-    assert!(p.sev.contains(&Event::H3Readable(sr)), "{:?}", p.sev);
-    assert_eq!(recv_headers(&p.server, p.now, sr), Ok((owned(REQ), false)));
-    assert_eq!(
-        recv_body(&p.server, p.now, sr),
-        Ok((b"hello".to_vec(), true))
-    );
-    send_headers(&p.server, p.now, sr, RESP, false).unwrap();
-    assert_eq!(send_body(&p.server, p.now, sr, b"hello", true), Ok(5));
-    p.tick(Duration::ZERO);
-    assert!(p.cev.contains(&Event::H3Readable(cr)), "{:?}", p.cev);
-    assert_eq!(recv_headers(&p.client, p.now, cr), Ok((owned(RESP), false)));
-    assert_eq!(
-        recv_body(&p.client, p.now, cr),
-        Ok((b"hello".to_vec(), true))
-    );
-    (cr, sr)
-}
-
-#[test]
-fn h3_request_echo() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let (cr, sr) = echo(&mut p);
-    let info = p.client.call(p.now, move |t, _| t.h3_req_info(cr)).unwrap();
-    assert_eq!(info.conn, p.conn);
-    let sinfo = p.server.call(p.now, move |t, _| t.h3_req_info(sr)).unwrap();
-    assert_eq!((sinfo.conn, sinfo.quic_id), (p.srv_conn, info.quic_id));
-    let (c, s) = wait_closed(&mut p, cr, sr);
-    for x in [&c, &s] {
-        assert_eq!(x.stats.stream_err, 0, "{x:?}");
-        assert_eq!((x.stats.send_body, x.stats.recv_body), (5, 5), "{x:?}");
-        assert_eq!(x.unread, None);
-    }
-    assert_eq!(stream_count(&p.client, p.conn), 0);
-    assert_eq!(stream_count(&p.server, p.srv_conn), 0);
-}
-
-#[test]
-fn h3_stats_monotone() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let cr = open_req(&p);
-    p.tick(MS);
-    send_headers(&p.client, p.now, cr, REQ, false).unwrap();
-    p.tick(MS);
-    assert_eq!(send_body(&p.client, p.now, cr, b"x", true), Ok(1));
-    p.tick(Duration::ZERO);
-    let sr = server_req(&p);
-    recv_headers(&p.server, p.now, sr).unwrap();
-    recv_body(&p.server, p.now, sr).unwrap();
-    send_headers(&p.server, p.now, sr, RESP, true).unwrap();
-    p.tick(Duration::ZERO);
-    recv_headers(&p.client, p.now, cr).unwrap();
-    let (c, _) = wait_closed(&mut p, cr, sr);
-    let s = &c.stats;
-    assert!(s.begin_us > 0, "{s:?}");
-    assert!(s.begin_us < s.header_send_us, "{s:?}");
-    assert!(s.header_send_us < s.fin_send_us, "{s:?}");
-    assert!(s.fin_send_us <= s.fin_ack_us, "{s:?}");
-}
-
-#[test]
-fn h3_server_reset_reaches_client() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let cr = open_req(&p);
-    send_headers(&p.client, p.now, cr, REQ, false).unwrap();
-    p.tick(Duration::ZERO);
-    let sr = server_req(&p);
-    p.server.call(p.now, move |t, now| t.h3_reset(now, sr));
-    let (c, s) = wait_closed(&mut p, cr, sr);
-    assert_ne!(c.stats.stream_err, 0, "{c:?}");
-    assert_eq!(c.stats.close_msg.as_deref(), Some("remote reset"));
-    assert_eq!(c.unread, None);
-    assert_eq!(s.stats.close_msg.as_deref(), Some("local reset"));
-    assert_eq!(stream_count(&p.client, p.conn), 0);
-    assert_eq!(stream_count(&p.server, p.srv_conn), 0);
-}
-
-#[test]
-fn h3_readable_coalesces() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let cr = open_req(&p);
-    send_headers(&p.client, p.now, cr, REQ, false).unwrap();
-    p.tick(Duration::ZERO);
-    let sr = server_req(&p);
-    recv_headers(&p.server, p.now, sr).unwrap();
-    // Two body injections reach the server before anyone polls it.
-    for chunk in [&b"a"[..], &b"b"[..]] {
-        assert_eq!(send_body(&p.client, p.now, cr, chunk, false), Ok(1));
-        p.client.drive(p.now);
-        let out = p.client.pump_out(p.now);
-        assert!(!out.is_empty());
-        for d in out {
-            p.server.deliver(p.now, d.to, d.from, d.data);
-        }
-        p.server.drive(p.now);
-    }
-    let ev = p.server.drain_events();
-    assert_eq!(readables(&ev, sr), 1, "{ev:?}");
-    assert_eq!(recv_body(&p.server, p.now, sr), Ok((b"ab".to_vec(), false)));
-    assert_eq!(recv_body(&p.server, p.now, sr), Err(StreamError::Blocked));
-}
-
-#[test]
-fn h3_trailer_drained_inside_transport() {
-    // (a) The trailer arrives before the app read the header section: drained right after it.
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let cr = open_req(&p);
-    send_headers(&p.client, p.now, cr, REQ, true).unwrap();
-    p.tick(Duration::ZERO);
-    let sr = server_req(&p);
-    send_headers(&p.server, p.now, sr, RESP, false).unwrap();
-    assert_eq!(send_body(&p.server, p.now, sr, b"body", false), Ok(4));
-    send_headers(&p.server, p.now, sr, &[("x-trailer", "v")], true).unwrap();
-    p.tick(Duration::ZERO);
-    assert_eq!(recv_headers(&p.client, p.now, cr), Ok((owned(RESP), false)));
-    assert_eq!(
-        recv_headers(&p.client, p.now, cr),
-        Err(StreamError::Blocked)
-    );
-    assert_eq!(
-        recv_body(&p.client, p.now, cr),
-        Ok((b"body".to_vec(), true))
-    );
-
-    // (b) The trailer arrives after the header section was read: drained in the notification.
-    let cr = open_req(&p);
-    send_headers(&p.client, p.now, cr, REQ, true).unwrap();
-    p.sev.clear();
-    p.tick(Duration::ZERO);
-    let sr = server_req(&p);
-    send_headers(&p.server, p.now, sr, RESP, false).unwrap();
-    p.tick(Duration::ZERO);
-    assert_eq!(recv_headers(&p.client, p.now, cr), Ok((owned(RESP), false)));
-    assert_eq!(send_body(&p.server, p.now, sr, b"body", false), Ok(4));
-    send_headers(&p.server, p.now, sr, &[("x-trailer", "v")], true).unwrap();
-    p.tick(Duration::ZERO);
-    assert_eq!(
-        recv_headers(&p.client, p.now, cr),
-        Err(StreamError::Blocked)
-    );
-    assert_eq!(
-        recv_body(&p.client, p.now, cr),
-        Ok((b"body".to_vec(), true))
-    );
-}
-
-#[test]
-fn h3_ops_stale_after_close() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let (cr, sr) = echo(&mut p);
-    wait_closed(&mut p, cr, sr);
-    for (peer, r) in [(&p.client, cr), (&p.server, sr)] {
-        let now = p.now;
-        assert_eq!(
-            send_headers(peer, now, r, RESP, false),
-            Err(StreamError::Stale)
-        );
-        assert_eq!(send_body(peer, now, r, b"x", true), Err(StreamError::Stale));
-        assert_eq!(
-            peer.call(now, move |t, now| t.h3_finish(now, r)),
-            Err(StreamError::Stale)
-        );
-        assert_eq!(recv_headers(peer, now, r), Err(StreamError::Stale));
-        assert_eq!(recv_body(peer, now, r), Err(StreamError::Stale));
-        assert_eq!(
-            peer.call(now, move |t, _| t.h3_req_info(r)),
-            Err(mq_transport_api::Error::Stale)
-        );
-        peer.call(now, move |t, now| t.h3_reset(now, r)); // a no-op
-    }
-}
-
-#[test]
-fn h3_empty_fin_is_zero_true() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let cr = open_req(&p);
-    send_headers(&p.client, p.now, cr, REQ, true).unwrap();
-    p.tick(Duration::ZERO);
-    let sr = server_req(&p);
-    send_headers(&p.server, p.now, sr, RESP, false).unwrap();
-    p.tick(Duration::ZERO);
-    assert_eq!(recv_headers(&p.client, p.now, cr), Ok((owned(RESP), false)));
-    let before = p.cev.len();
-    assert_eq!(
-        p.server.call(p.now, move |t, now| t.h3_finish(now, sr)),
-        Ok(())
-    );
-    p.tick(Duration::ZERO);
-    assert_eq!(readables(&p.cev[before..], cr), 1, "{:?}", p.cev);
-    assert_eq!(recv_body(&p.client, p.now, cr), Ok((Vec::new(), true)));
-}
-
-// ── H3Closed stats and the client-side unread rescue (spec §3.3 close row, §3.5, §3.7) ──
-
-/// The server's response `RESP` + `body` (+ fin), the client reading nothing.
-fn respond(p: &mut Pair, body: &'static [u8], fin: bool) -> (H3ReqId, H3ReqId) {
-    let cr = open_req(p);
-    send_headers(&p.client, p.now, cr, REQ, true).unwrap();
-    p.tick(Duration::ZERO);
-    let sr = server_req(p);
-    recv_headers(&p.server, p.now, sr).unwrap();
-    send_headers(&p.server, p.now, sr, RESP, body.is_empty() && fin).unwrap();
-    if !body.is_empty() {
-        assert_eq!(send_body(&p.server, p.now, sr, body, fin), Ok(body.len()));
-    }
-    p.tick(Duration::ZERO);
-    (cr, sr)
-}
-
-/// Follows timeouts until `side`'s events hold `r`'s `H3Closed`.
-fn wait_one(p: &mut Pair, client: bool, r: H3ReqId) -> H3Close {
-    for _ in 0..2000 {
-        if let Some(c) = h3_closed(if client { &p.cev } else { &p.sev }, r) {
-            return c;
-        }
-        if !p.follow_timeout() {
-            p.tick(10 * MS);
-        }
-    }
-    panic!("H3Closed never arrived: {:?} / {:?}", p.cev, p.sev);
-}
-
-#[test]
-fn h3_closed_carries_stats_before_drain() {
-    const BODY: &[u8] = &[7u8; 100];
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let (cr, sr) = respond(&mut p, BODY, true);
-    let (c, _) = wait_closed(&mut p, cr, sr); // past the 3 × PTO close timer
-    assert_eq!(c.stats.recv_body, 0, "stats read before the drain: {c:?}");
-    assert_eq!(c.stats.stream_err, 0);
-    let u = c.unread.expect("a complete unread response is rescued");
-    assert_eq!(u.body, BODY);
-    let hs: Vec<_> = u
-        .headers
-        .expect("never read")
-        .into_iter()
-        .map(|(n, v)| (String::from_utf8(n).unwrap(), String::from_utf8(v).unwrap()))
-        .collect();
-    assert_eq!(hs, owned(RESP));
-}
-
-#[test]
-fn h3_unread_none_on_reset() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let (cr, sr) = respond(&mut p, b"partial", false);
-    p.server.call(p.now, move |t, now| t.h3_reset(now, sr));
-    let c = wait_one(&mut p, true, cr);
-    assert_eq!(c.unread, None, "{c:?}");
-    assert_ne!(c.stats.stream_err, 0, "{c:?}");
-}
-
-#[test]
-fn h3_unread_none_on_conn_close_code_0() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let (cr, _) = respond(&mut p, b"partial", false);
-    let sc = p.srv_conn;
-    p.server.call(p.now, move |t, now| t.close_conn(now, sc));
-    let c = wait_one(&mut p, true, cr);
-    assert_eq!(c.unread, None, "{c:?}");
-}
-
-#[test]
-fn h3_unread_headers_when_never_read() {
-    // (a) A header-only response (fin on HEADERS) the client never read.
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let (cr, _) = respond(&mut p, b"", true);
-    let u = wait_one(&mut p, true, cr).unread.expect("rescued");
-    assert_eq!(u.headers.map(|h| h.len()), Some(RESP.len()));
-    assert!(u.body.is_empty());
-
-    // (b) Headers read, body not: only the body is rescued.
-    p.sev.clear();
-    let (cr, _) = respond(&mut p, b"tail", true);
-    assert_eq!(recv_headers(&p.client, p.now, cr), Ok((owned(RESP), false)));
-    let u = wait_one(&mut p, true, cr).unread.expect("rescued");
-    assert_eq!(u.headers, None);
-    assert_eq!(u.body, b"tail");
-}
-
-/// An empty `buf` reads nothing and reports the fin only once no body is
-/// buffered (the MITM terminal probe, SP4 R1); a separate empty FIN that is
-/// never read is rescued as an empty body, not `None`.
-#[test]
-fn h3_empty_buf_probe_and_unread_empty_fin_rescued() {
-    let probe = |p: &Pair, r| {
-        p.client
-            .call(p.now, move |t, now| t.h3_recv_body(now, r, &mut []))
-    };
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let (cr, sr) = respond(&mut p, b"", false);
-    assert_eq!(recv_headers(&p.client, p.now, cr), Ok((owned(RESP), false)));
-    assert_eq!(probe(&p, cr), Err(StreamError::Blocked));
-    assert_eq!(send_body(&p.server, p.now, sr, b"ab", false), Ok(2));
-    p.tick(Duration::ZERO);
-    assert_eq!(probe(&p, cr), Err(StreamError::Blocked), "bytes buffered");
-    assert_eq!(recv_body(&p.client, p.now, cr), Ok((b"ab".to_vec(), false)));
-    let fin = p.server.call(p.now, move |t, now| t.h3_finish(now, sr));
-    assert_eq!(fin, Ok(()));
-    p.tick(Duration::ZERO);
-    assert_eq!(probe(&p, cr), Ok((0, true)));
-
-    // The same empty FIN, never read: `H3Closed` rescues an empty body.
-    p.sev.clear();
-    let (cr, sr) = respond(&mut p, b"", false);
-    assert_eq!(recv_headers(&p.client, p.now, cr), Ok((owned(RESP), false)));
-    let fin = p.server.call(p.now, move |t, now| t.h3_finish(now, sr));
-    assert_eq!(fin, Ok(()));
-    p.tick(Duration::ZERO);
-    let u = wait_one(&mut p, true, cr).unread.expect("rescued");
-    assert_eq!(u.headers, None);
-    assert!(u.body.is_empty());
-}
-
-#[test]
-fn h3_server_never_rescues() {
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let cr = open_req(&p);
-    send_headers(&p.client, p.now, cr, REQ, false).unwrap();
-    assert_eq!(send_body(&p.client, p.now, cr, b"unread", true), Ok(6));
-    p.tick(Duration::ZERO);
-    let sr = server_req(&p);
-    // The server answers without reading anything of the request.
-    send_headers(&p.server, p.now, sr, RESP, true).unwrap();
-    p.tick(Duration::ZERO);
-    let (_, s) = wait_closed(&mut p, cr, sr);
-    assert_eq!(s.unread, None, "{s:?}");
-    assert_eq!(s.stats.stream_err, 0, "{s:?}");
-}
-
-#[test]
-fn h3_idle_timeout_mid_response_aborts() {
-    let idle = Duration::from_secs(30);
-    let mut p = Pair::with(Opts {
-        idle: Some(idle),
-        ..h3_opts(ConnProto::H3)
-    });
-    let (cr, _) = respond(&mut p, b"partial", false);
-    p.lose = true; // the server goes silent mid-response
-    let start = p.now;
-    let c = wait_one(&mut p, true, cr);
-    assert!(p.client_closed().is_some(), "closed by the idle timeout");
-    assert!(p.now - start <= 2 * idle, "after {:?}", p.now - start);
-    assert_eq!(c.unread, None, "{c:?}");
-}
-
-#[test]
-fn h3_drop_transport_with_live_requests_is_clean() {
-    // (a) A local close with a request holding unread data: its `H3Closed` precedes
-    // `ConnClosed` and rescues nothing (no fin).
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    let (cr, _) = respond(&mut p, b"partial", false);
-    let c = p.conn;
-    p.client.call(p.now, move |t, now| t.close_conn(now, c));
-    assert!(p.pump_until(10 * MS, 1000, |p| p.client_closed().is_some()));
-    let at = |e: &dyn Fn(&Event) -> bool| p.cev.iter().position(e);
-    let closed = at(&|e| matches!(e, Event::H3Closed(r, _) if *r == cr)).expect("H3Closed");
-    let conn = at(&|e| matches!(e, Event::ConnClosed(x, _) if *x == c)).expect("ConnClosed");
-    assert!(closed < conn, "{:?}", p.cev);
-    assert_eq!(h3_closed(&p.cev, cr).unwrap().unread, None);
-
-    // (b) Both transports dropped with open requests on both sides (one holding unread body):
-    // the close notifications fire inside the engine teardown, without a panic.
-    let mut p = Pair::with(h3_opts(ConnProto::H3));
-    respond(&mut p, b"partial", false);
-    let cr = open_req(&p);
-    send_headers(&p.client, p.now, cr, REQ, false).unwrap();
-    p.tick(Duration::ZERO);
-    drop(p);
-}
diff --git a/crates/mq-transport/tests/fabric_h3raw.rs b/crates/mq-transport/tests/fabric_h3raw.rs
index 02340171..0662b113 100644
--- a/crates/mq-transport/tests/fabric_h3raw.rs
+++ b/crates/mq-transport/tests/fabric_h3raw.rs
@@ -8,8 +8,8 @@ use common::pair::{
     stream_count,
 };
 use mq_transport_api::{
-    ConnId, ConnProto, ErrType, Error, Event, H3Backend, Role, StreamCloseStats, StreamError,
-    StreamId, StreamKind, Time, TransportConfig, TransportOps,
+    ConnId, ConnProto, ErrType, Error, Event, Role, StreamCloseStats, StreamError, StreamId,
+    StreamKind, Time, TransportConfig, TransportOps,
 };
 
 use std::net::SocketAddr;
@@ -18,7 +18,6 @@ use std::time::Duration;
 fn raw_h3_cfg(role: Role) -> TransportConfig {
     TransportConfig {
         h3: true,
-        h3_backend: H3Backend::Raw,
         qlog: None,
         ..cfg(role)
     }
@@ -85,7 +84,7 @@ fn raw_h3_rejects_open_h3_request() {
     let r = p
         .client
         .call(p.now, move |t, now| t.open_h3_request(now, c));
-    assert_eq!(r.err(), Some(Error::Other));
+    assert_eq!(r.err(), Some(Error::Role));
 }
 
 #[test]
@@ -496,26 +495,6 @@ fn open_uni_credit_exhausted() {
     assert_eq!(stream_count(&p.client, p.conn), 1024);
 }
 
-#[test]
-fn open_uni_on_xqc_h3_conn() {
-    let p = Pair::with(Opts {
-        server: TransportConfig {
-            h3: true,
-            qlog: None,
-            ..cfg(server_role())
-        },
-        client: TransportConfig {
-            h3: true,
-            qlog: None,
-            ..cfg(Role::Client)
-        },
-        proto: ConnProto::H3,
-        ..Opts::default()
-    });
-    assert_eq!(open_uni(&p.client, p.now, p.conn), Err(Error::Other));
-    assert_eq!(stream_count(&p.client, p.conn), 0);
-}
-
 fn close_conn_with(p: &Peer, now: Time, c: ConnId, code: u64) {
     p.call(now, move |t, now| t.close_conn_with(now, c, code))
 }
diff --git a/crates/mqproxy/src/cli.rs b/crates/mqproxy/src/cli.rs
index 918dde2a..18430476 100644
--- a/crates/mqproxy/src/cli.rs
+++ b/crates/mqproxy/src/cli.rs
@@ -563,7 +563,7 @@ pub fn ip_port(flag: &str, s: &str) -> Result<SocketAddr, String> {
 }
 
 /// spec §8: the transport's H3 layer — the server's gateway, or the client's
-/// fetch ingress or MITM front (their tunnel conn is an `xqc_h3_connect`).
+/// fetch ingress or MITM front (their gateway conn uses ALPN `h3`).
 pub fn wants_h3(r: &Resolved) -> bool {
     match &r.mode {
         Mode::Server(s) => s.config.gateway.is_some(),
diff --git a/crates/mqproxy/src/run.rs b/crates/mqproxy/src/run.rs
index 46c3d8bf..12439685 100644
--- a/crates/mqproxy/src/run.rs
+++ b/crates/mqproxy/src/run.rs
@@ -87,7 +87,6 @@ fn transport(
         cc: r.cc,
         realtime_offset_us: realtime_offset_us(),
         h3: cli::wants_h3(r),
-        h3_backend: mq_transport_api::H3Backend::Raw,
         qlog: r.qlog.clone(),
     })
     .map_err(|e| match (&e, &r.qlog) {
diff --git a/crates/mqproxy/tests/cli.rs b/crates/mqproxy/tests/cli.rs
index 3aae7ea6..d7141ba4 100644
--- a/crates/mqproxy/tests/cli.rs
+++ b/crates/mqproxy/tests/cli.rs
@@ -350,7 +350,7 @@ fn client_gateway_counts_as_ingress() {
     );
 }
 
-/// spec §8: the client's H3 ctx exists only with `--gateway` (`xqc_h3_connect`).
+/// spec §8: the client enables H3 only with `--gateway`.
 #[test]
 fn client_gateway_enables_h3() {
     let r = parse(CLIENT, &[]).unwrap();
diff --git a/crates/xquic-sys/src/bindings.rs b/crates/xquic-sys/src/bindings.rs
index 57fbfb18..4c287e77 100644
--- a/crates/xquic-sys/src/bindings.rs
+++ b/crates/xquic-sys/src/bindings.rs
@@ -38,11 +38,6 @@ pub const XQC_SOCKET_EAGAIN: i32 = -2;
 pub const XQC_PATH_HARD_CAP: u32 = 256;
 pub const XQC_CONN_INFO_LEN: u32 = 400;
 pub const XQC_EXTERN_CONN_INFO_LEN: u32 = 128;
-pub const XQC_STREAM_INFO_LEN: u32 = 128;
-pub const XQC_H3_CAPSULE_DATAGRAM: u32 = 0;
-pub const XQC_H3_CAPSULE_ADDRESS_ASSIGN: u32 = 1;
-pub const XQC_H3_CAPSULE_ADDRESS_REQUEST: u32 = 2;
-pub const XQC_H3_CAPSULE_ROUTE_ADVERTISEMENT: u32 = 3;
 pub type __socklen_t = ::core::ffi::c_uint;
 #[doc = " no peer CONNECTION_CLOSE frame has been received"]
 pub const XQC_CONN_ERR_TYPE_UNKNOWN: xqc_conn_err_type_t = 0;
@@ -411,7 +406,11 @@ pub type xqc_engine_t = xqc_engine_s;
 pub type xqc_log_callbacks_t = xqc_log_callbacks_s;
 #[doc = " @brief tranport callback functions are more related to attributes of QUIC [Transport]\n but not ALPN.\n\n These callback functions are events of QUIC Transport layer, and need to\n interact with application-layer, which have less thing to do with ALPN layer.\n\n These callback functions shall directly call back to application layer, with user_data\n from struct xqc_connection_t. unless Application-Layer-Protocol take over them.\n\n Generally, xquic defines callbacks as below:\n 1. Callbacks between Transport and Application:\n QUIC events that are common between different Application Protocols,\n and is much more convenient to interact with Application and Application Protocol.\n\n 2. Callbacks between Application Protocol and Application:\n Application-Protocol events will interact with Application Layer. these callback\n functions are defined by Application Protocol Layers.\n\n 3. Callbacks between Transport and Application Protocol:\n QUIC events that might be more essential to Application-Layer-Protocols, especially\n stream data\n\n +------------------------------------------------------------------------------+\n |                             Application                                      |\n |                                 +-- Application Protocol defined callbacks --+\n |                                 |             Application Protocol           |\n +-------- transport callbacks ----+--------- app protocol callbacks -----------+\n |                              Transport                                       |\n +------------------------------------------------------------------------------+"]
 pub type xqc_transport_callbacks_t = xqc_transport_callbacks_s;
-#[doc = " @brief http3 connection callbacks for application layer"]
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xqc_h3_conn_callbacks_s {
+    _unused: [u8; 0],
+}
 pub type xqc_h3_conn_callbacks_t = xqc_h3_conn_callbacks_s;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -3207,1026 +3206,3 @@ unsafe extern "C" {
         settings_type: xqc_conn_settings_type_t,
     ) -> xqc_conn_settings_t;
 }
-#[doc = " nothing readable"]
-pub const XQC_REQ_NOTIFY_READ_NULL: xqc_request_notify_flag_t = 0;
-#[doc = " read header section flag, this will be set when the first HEADERS is processed"]
-pub const XQC_REQ_NOTIFY_READ_HEADER: xqc_request_notify_flag_t = 1;
-#[doc = " read body flag, this will be set when a DATA frame is processed"]
-pub const XQC_REQ_NOTIFY_READ_BODY: xqc_request_notify_flag_t = 2;
-#[doc = " read trailer section flag, this will be set when trailer HEADERS frame is processed"]
-pub const XQC_REQ_NOTIFY_READ_TRAILER: xqc_request_notify_flag_t = 4;
-#[doc = " read empty fin flag, notify callback will be triggered when a single fin frame is received\nwhile HEADERS and DATA were notified. This flag will NEVER be set with other flags"]
-pub const XQC_REQ_NOTIFY_READ_EMPTY_FIN: xqc_request_notify_flag_t = 8;
-#[doc = " @brief read flag of xqc_h3_request_read_notify_pt"]
-pub type xqc_request_notify_flag_t = ::core::ffi::c_uint;
-#[doc = " @brief definition for http3 connection state callback function. including create and close"]
-pub type xqc_h3_conn_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        h3_conn: *mut xqc_h3_conn_t,
-        cid: *const xqc_cid_t,
-        h3c_user_data: *mut ::core::ffi::c_void,
-    ) -> ::core::ffi::c_int,
->;
-pub type xqc_h3_handshake_finished_pt = ::core::option::Option<
-    unsafe extern "C" fn(h3_conn: *mut xqc_h3_conn_t, h3c_user_data: *mut ::core::ffi::c_void),
->;
-pub type xqc_h3_conn_ping_ack_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        h3_conn: *mut xqc_h3_conn_t,
-        cid: *const xqc_cid_t,
-        ping_user_data: *mut ::core::ffi::c_void,
-        h3c_user_data: *mut ::core::ffi::c_void,
-    ),
->;
-#[doc = " @brief connection settings for http3"]
-pub type xqc_h3_conn_settings_t = xqc_h3_conn_settings_s;
-#[doc = " @brief In this callback, only operations related to modifying current_settings is allowed.\n        This callback is triggered before the connection has been fully initialized.\n        PLEASE DO NOT call any XQUIC APIs in this callback."]
-pub type xqc_h3_conn_init_settings_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        h3_conn: *mut xqc_h3_conn_t,
-        current_settings: *mut xqc_h3_conn_settings_t,
-        h3c_user_data: *mut ::core::ffi::c_void,
-    ),
->;
-#[doc = " @brief http3 request callbacks"]
-pub type xqc_h3_request_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        h3_request: *mut xqc_h3_request_t,
-        h3s_user_data: *mut ::core::ffi::c_void,
-    ) -> ::core::ffi::c_int,
->;
-#[doc = " @brief read data callback function"]
-pub type xqc_h3_request_read_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        h3_request: *mut xqc_h3_request_t,
-        flag: xqc_request_notify_flag_t,
-        h3s_user_data: *mut ::core::ffi::c_void,
-    ) -> ::core::ffi::c_int,
->;
-pub type xqc_h3_request_closing_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        h3_request: *mut xqc_h3_request_t,
-        err: xqc_int_t,
-        h3s_user_data: *mut ::core::ffi::c_void,
-    ),
->;
-#[doc = " no flag is set. encode header with default strategy."]
-pub const XQC_HTTP_HEADER_FLAG_NONE: xqc_http3_nv_flag_s = 0;
-#[doc = " header's name and value shall be encoded as literal, and shall never be indexed."]
-pub const XQC_HTTP_HEADER_FLAG_NEVER_INDEX: xqc_http3_nv_flag_s = 1;
-#[doc = " header's value is variant and shall never be put into dynamic table and be indexed. this\n will reduce useless data in dynamic table and might increase the hit rate.\n\n some headers might be frequent but with different values, it is a waste to put these value\n into dynamic table. application layer can use this flag to tell QPACK not to put value into\n dynamic table."]
-pub const XQC_HTTP_HEADER_FLAG_NEVER_INDEX_VALUE: xqc_http3_nv_flag_s = 2;
-#[doc = " @brief encode flags of http headers"]
-pub type xqc_http3_nv_flag_s = ::core::ffi::c_uint;
-#[doc = " @brief encode flags of http headers"]
-pub use self::xqc_http3_nv_flag_s as xqc_http3_nv_flag_t;
-#[doc = "< none is matched"]
-pub const XQC_NV_HIT_NONE: xqc_http3_nv_hit_flag_s = 0;
-#[doc = "< only name is matched"]
-pub const XQC_NV_HIT_NAME: xqc_http3_nv_hit_flag_s = 1;
-#[doc = "< both name and value are matched"]
-pub const XQC_NV_HIT_BOTH: xqc_http3_nv_hit_flag_s = 2;
-pub type xqc_http3_nv_hit_flag_s = ::core::ffi::c_uint;
-pub use self::xqc_http3_nv_hit_flag_s as xqc_http3_nv_hit_flag_t;
-pub type xqc_http_header_t = xqc_http_header_s;
-#[repr(C)]
-pub struct xqc_http_header_s {
-    #[doc = " name of http header"]
-    pub name: iovec,
-    #[doc = " value of http header"]
-    pub value: iovec,
-    #[doc = " flags of xqc_http3_nv_flag_t with OR operator"]
-    pub flags: u8,
-    #[doc = " save the nv hit status or not (0 means do not save)"]
-    pub save_nv_hit_flags: u8,
-    #[doc = " flags of nv hit status (used as return values)"]
-    pub nv_hit_flags: u8,
-    #[doc = " src header (if this one is copied from another using xqc_h3_request_copy_header)"]
-    pub src_header: *mut xqc_http_header_t,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_http_header_s"][::core::mem::size_of::<xqc_http_header_s>() - 48usize];
-    ["Alignment of xqc_http_header_s"][::core::mem::align_of::<xqc_http_header_s>() - 8usize];
-    ["Offset of field: xqc_http_header_s::name"]
-        [::core::mem::offset_of!(xqc_http_header_s, name) - 0usize];
-    ["Offset of field: xqc_http_header_s::value"]
-        [::core::mem::offset_of!(xqc_http_header_s, value) - 16usize];
-    ["Offset of field: xqc_http_header_s::flags"]
-        [::core::mem::offset_of!(xqc_http_header_s, flags) - 32usize];
-    ["Offset of field: xqc_http_header_s::save_nv_hit_flags"]
-        [::core::mem::offset_of!(xqc_http_header_s, save_nv_hit_flags) - 33usize];
-    ["Offset of field: xqc_http_header_s::nv_hit_flags"]
-        [::core::mem::offset_of!(xqc_http_header_s, nv_hit_flags) - 34usize];
-    ["Offset of field: xqc_http_header_s::src_header"]
-        [::core::mem::offset_of!(xqc_http_header_s, src_header) - 40usize];
-};
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_http_headers_s {
-    #[doc = " array of http headers"]
-    pub headers: *mut xqc_http_header_t,
-    #[doc = " count of headers"]
-    pub count: usize,
-    #[doc = " capacity of headers"]
-    pub capacity: usize,
-    #[doc = " total byte count of headers"]
-    pub total_len: usize,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_http_headers_s"][::core::mem::size_of::<xqc_http_headers_s>() - 32usize];
-    ["Alignment of xqc_http_headers_s"][::core::mem::align_of::<xqc_http_headers_s>() - 8usize];
-    ["Offset of field: xqc_http_headers_s::headers"]
-        [::core::mem::offset_of!(xqc_http_headers_s, headers) - 0usize];
-    ["Offset of field: xqc_http_headers_s::count"]
-        [::core::mem::offset_of!(xqc_http_headers_s, count) - 8usize];
-    ["Offset of field: xqc_http_headers_s::capacity"]
-        [::core::mem::offset_of!(xqc_http_headers_s, capacity) - 16usize];
-    ["Offset of field: xqc_http_headers_s::total_len"]
-        [::core::mem::offset_of!(xqc_http_headers_s, total_len) - 24usize];
-};
-pub type xqc_http_headers_t = xqc_http_headers_s;
-#[doc = " @brief request statistics structure"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_request_stats_s {
-    pub send_body_size: usize,
-    pub recv_body_size: usize,
-    #[doc = " plaintext header size"]
-    pub send_header_size: usize,
-    #[doc = " plaintext header size"]
-    pub recv_header_size: usize,
-    #[doc = " compressed header size"]
-    pub send_hdr_compressed: usize,
-    #[doc = " compressed header size"]
-    pub recv_hdr_compressed: usize,
-    #[doc = " QUIC layer error code, 0 for no error"]
-    pub stream_err: ::core::ffi::c_int,
-    #[doc = " time of h3 stream being blocked"]
-    pub blocked_time: xqc_usec_t,
-    #[doc = " time of h3 stream being unblocked"]
-    pub unblocked_time: xqc_usec_t,
-    #[doc = " time of receiving transport fin"]
-    pub stream_fin_time: xqc_usec_t,
-    #[doc = " time of creating request"]
-    pub h3r_begin_time: xqc_usec_t,
-    #[doc = " time of request fin"]
-    pub h3r_end_time: xqc_usec_t,
-    #[doc = " time of receiving HEADERS frame"]
-    pub h3r_header_begin_time: xqc_usec_t,
-    #[doc = " time of finishing processing HEADERS frame"]
-    pub h3r_header_end_time: xqc_usec_t,
-    #[doc = " time of receiving DATA frame"]
-    pub h3r_body_begin_time: xqc_usec_t,
-    pub h3r_header_send_time: xqc_usec_t,
-    pub h3r_body_send_time: xqc_usec_t,
-    pub stream_fin_send_time: xqc_usec_t,
-    pub stream_fin_ack_time: xqc_usec_t,
-    pub stream_close_msg: *const ::core::ffi::c_char,
-    #[doc = " @brief 请求级别MP状态\n 0: 该请求所在连接当前仅有一条可用路径\n 1: 该请求所在连接当前有多条可用路径，该请求同时在 Available 和 Standby 路径传输\n 2: 该请求所在连接当前有多条可用路径，但该请求仅在  Standby  路径传输\n 3: 该请求所在连接当前有多条可用路径，但该请求仅在 Available 路径传输"]
-    pub mp_state: ::core::ffi::c_int,
-    pub mp_default_path_send_weight: f32,
-    pub mp_default_path_recv_weight: f32,
-    pub mp_standby_path_send_weight: f32,
-    pub mp_standby_path_recv_weight: f32,
-    pub rate_limit: u64,
-    #[doc = " @brief 0RTT state\n 0: no 0RTT\n 1: 0RTT accept\n 2: 0RTT reject"]
-    pub early_data_state: u8,
-    pub stream_info: [::core::ffi::c_char; 128usize],
-    pub extern_stream_info: [::core::ffi::c_char; 128usize],
-    pub stream_fst_fin_snd_time: xqc_usec_t,
-    #[doc = " @brief how long the request was blocked by congestion control (ms)"]
-    pub cwnd_blocked_ms: xqc_msec_t,
-    #[doc = " @brief the number of packet has been retransmitted"]
-    pub retrans_cnt: u32,
-    pub stream_fst_pkt_snd_time: xqc_usec_t,
-    pub stream_fst_pkt_rcv_time: xqc_usec_t,
-    pub sent_pkt_cnt: u32,
-    pub max_pto_backoff: u8,
-    #[doc = " @brief the number of lost/delayed packets recovered by fec module;"]
-    pub fec_recov_cnt: u32,
-    pub fst_rpr_time: xqc_usec_t,
-    pub last_rpr_time: xqc_usec_t,
-    pub is_fec_protected: u8,
-    pub block_size_mode: u8,
-    pub fec_blk_lack_num: xqc_int_t,
-    pub fec_blk_lack_time: xqc_usec_t,
-    pub fec_req_delay_time: xqc_usec_t,
-    pub recv_time_with_fec: xqc_usec_t,
-    pub final_packet_time: xqc_usec_t,
-    pub stream_close_delay: xqc_usec_t,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_request_stats_s"][::core::mem::size_of::<xqc_request_stats_s>() - 576usize];
-    ["Alignment of xqc_request_stats_s"][::core::mem::align_of::<xqc_request_stats_s>() - 8usize];
-    ["Offset of field: xqc_request_stats_s::send_body_size"]
-        [::core::mem::offset_of!(xqc_request_stats_s, send_body_size) - 0usize];
-    ["Offset of field: xqc_request_stats_s::recv_body_size"]
-        [::core::mem::offset_of!(xqc_request_stats_s, recv_body_size) - 8usize];
-    ["Offset of field: xqc_request_stats_s::send_header_size"]
-        [::core::mem::offset_of!(xqc_request_stats_s, send_header_size) - 16usize];
-    ["Offset of field: xqc_request_stats_s::recv_header_size"]
-        [::core::mem::offset_of!(xqc_request_stats_s, recv_header_size) - 24usize];
-    ["Offset of field: xqc_request_stats_s::send_hdr_compressed"]
-        [::core::mem::offset_of!(xqc_request_stats_s, send_hdr_compressed) - 32usize];
-    ["Offset of field: xqc_request_stats_s::recv_hdr_compressed"]
-        [::core::mem::offset_of!(xqc_request_stats_s, recv_hdr_compressed) - 40usize];
-    ["Offset of field: xqc_request_stats_s::stream_err"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_err) - 48usize];
-    ["Offset of field: xqc_request_stats_s::blocked_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, blocked_time) - 56usize];
-    ["Offset of field: xqc_request_stats_s::unblocked_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, unblocked_time) - 64usize];
-    ["Offset of field: xqc_request_stats_s::stream_fin_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_fin_time) - 72usize];
-    ["Offset of field: xqc_request_stats_s::h3r_begin_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, h3r_begin_time) - 80usize];
-    ["Offset of field: xqc_request_stats_s::h3r_end_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, h3r_end_time) - 88usize];
-    ["Offset of field: xqc_request_stats_s::h3r_header_begin_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, h3r_header_begin_time) - 96usize];
-    ["Offset of field: xqc_request_stats_s::h3r_header_end_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, h3r_header_end_time) - 104usize];
-    ["Offset of field: xqc_request_stats_s::h3r_body_begin_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, h3r_body_begin_time) - 112usize];
-    ["Offset of field: xqc_request_stats_s::h3r_header_send_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, h3r_header_send_time) - 120usize];
-    ["Offset of field: xqc_request_stats_s::h3r_body_send_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, h3r_body_send_time) - 128usize];
-    ["Offset of field: xqc_request_stats_s::stream_fin_send_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_fin_send_time) - 136usize];
-    ["Offset of field: xqc_request_stats_s::stream_fin_ack_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_fin_ack_time) - 144usize];
-    ["Offset of field: xqc_request_stats_s::stream_close_msg"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_close_msg) - 152usize];
-    ["Offset of field: xqc_request_stats_s::mp_state"]
-        [::core::mem::offset_of!(xqc_request_stats_s, mp_state) - 160usize];
-    ["Offset of field: xqc_request_stats_s::mp_default_path_send_weight"]
-        [::core::mem::offset_of!(xqc_request_stats_s, mp_default_path_send_weight) - 164usize];
-    ["Offset of field: xqc_request_stats_s::mp_default_path_recv_weight"]
-        [::core::mem::offset_of!(xqc_request_stats_s, mp_default_path_recv_weight) - 168usize];
-    ["Offset of field: xqc_request_stats_s::mp_standby_path_send_weight"]
-        [::core::mem::offset_of!(xqc_request_stats_s, mp_standby_path_send_weight) - 172usize];
-    ["Offset of field: xqc_request_stats_s::mp_standby_path_recv_weight"]
-        [::core::mem::offset_of!(xqc_request_stats_s, mp_standby_path_recv_weight) - 176usize];
-    ["Offset of field: xqc_request_stats_s::rate_limit"]
-        [::core::mem::offset_of!(xqc_request_stats_s, rate_limit) - 184usize];
-    ["Offset of field: xqc_request_stats_s::early_data_state"]
-        [::core::mem::offset_of!(xqc_request_stats_s, early_data_state) - 192usize];
-    ["Offset of field: xqc_request_stats_s::stream_info"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_info) - 193usize];
-    ["Offset of field: xqc_request_stats_s::extern_stream_info"]
-        [::core::mem::offset_of!(xqc_request_stats_s, extern_stream_info) - 321usize];
-    ["Offset of field: xqc_request_stats_s::stream_fst_fin_snd_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_fst_fin_snd_time) - 456usize];
-    ["Offset of field: xqc_request_stats_s::cwnd_blocked_ms"]
-        [::core::mem::offset_of!(xqc_request_stats_s, cwnd_blocked_ms) - 464usize];
-    ["Offset of field: xqc_request_stats_s::retrans_cnt"]
-        [::core::mem::offset_of!(xqc_request_stats_s, retrans_cnt) - 472usize];
-    ["Offset of field: xqc_request_stats_s::stream_fst_pkt_snd_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_fst_pkt_snd_time) - 480usize];
-    ["Offset of field: xqc_request_stats_s::stream_fst_pkt_rcv_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_fst_pkt_rcv_time) - 488usize];
-    ["Offset of field: xqc_request_stats_s::sent_pkt_cnt"]
-        [::core::mem::offset_of!(xqc_request_stats_s, sent_pkt_cnt) - 496usize];
-    ["Offset of field: xqc_request_stats_s::max_pto_backoff"]
-        [::core::mem::offset_of!(xqc_request_stats_s, max_pto_backoff) - 500usize];
-    ["Offset of field: xqc_request_stats_s::fec_recov_cnt"]
-        [::core::mem::offset_of!(xqc_request_stats_s, fec_recov_cnt) - 504usize];
-    ["Offset of field: xqc_request_stats_s::fst_rpr_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, fst_rpr_time) - 512usize];
-    ["Offset of field: xqc_request_stats_s::last_rpr_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, last_rpr_time) - 520usize];
-    ["Offset of field: xqc_request_stats_s::is_fec_protected"]
-        [::core::mem::offset_of!(xqc_request_stats_s, is_fec_protected) - 528usize];
-    ["Offset of field: xqc_request_stats_s::block_size_mode"]
-        [::core::mem::offset_of!(xqc_request_stats_s, block_size_mode) - 529usize];
-    ["Offset of field: xqc_request_stats_s::fec_blk_lack_num"]
-        [::core::mem::offset_of!(xqc_request_stats_s, fec_blk_lack_num) - 532usize];
-    ["Offset of field: xqc_request_stats_s::fec_blk_lack_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, fec_blk_lack_time) - 536usize];
-    ["Offset of field: xqc_request_stats_s::fec_req_delay_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, fec_req_delay_time) - 544usize];
-    ["Offset of field: xqc_request_stats_s::recv_time_with_fec"]
-        [::core::mem::offset_of!(xqc_request_stats_s, recv_time_with_fec) - 552usize];
-    ["Offset of field: xqc_request_stats_s::final_packet_time"]
-        [::core::mem::offset_of!(xqc_request_stats_s, final_packet_time) - 560usize];
-    ["Offset of field: xqc_request_stats_s::stream_close_delay"]
-        [::core::mem::offset_of!(xqc_request_stats_s, stream_close_delay) - 568usize];
-};
-#[doc = " @brief request statistics structure"]
-pub type xqc_request_stats_t = xqc_request_stats_s;
-#[doc = " @brief bytestream statistics\n"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_h3_ext_bytestream_stats_s {
-    pub bytes_sent: usize,
-    pub bytes_rcvd: usize,
-    pub stream_err: ::core::ffi::c_int,
-    pub stream_close_msg: *const ::core::ffi::c_char,
-    pub create_time: xqc_usec_t,
-    pub fin_rcvd_time: xqc_usec_t,
-    pub fin_read_time: xqc_usec_t,
-    pub fin_sent_time: xqc_usec_t,
-    pub fin_acked_time: xqc_usec_t,
-    pub first_byte_sent_time: xqc_usec_t,
-    pub first_byte_rcvd_time: xqc_usec_t,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_h3_ext_bytestream_stats_s"]
-        [::core::mem::size_of::<xqc_h3_ext_bytestream_stats_s>() - 88usize];
-    ["Alignment of xqc_h3_ext_bytestream_stats_s"]
-        [::core::mem::align_of::<xqc_h3_ext_bytestream_stats_s>() - 8usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::bytes_sent"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, bytes_sent) - 0usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::bytes_rcvd"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, bytes_rcvd) - 8usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::stream_err"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, stream_err) - 16usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::stream_close_msg"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, stream_close_msg) - 24usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::create_time"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, create_time) - 32usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::fin_rcvd_time"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, fin_rcvd_time) - 40usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::fin_read_time"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, fin_read_time) - 48usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::fin_sent_time"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, fin_sent_time) - 56usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::fin_acked_time"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, fin_acked_time) - 64usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::first_byte_sent_time"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, first_byte_sent_time) - 72usize];
-    ["Offset of field: xqc_h3_ext_bytestream_stats_s::first_byte_rcvd_time"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_stats_s, first_byte_rcvd_time) - 80usize];
-};
-#[doc = " @brief bytestream statistics\n"]
-pub type xqc_h3_ext_bytestream_stats_t = xqc_h3_ext_bytestream_stats_s;
-#[doc = " @brief connection settings for http3"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_h3_conn_settings_s {
-    #[doc = " MAX_FIELD_SECTION_SIZE of http3"]
-    pub max_field_section_size: u64,
-    #[doc = " MAX_PUSH_STREAMS"]
-    pub max_pushes: u64,
-    #[doc = " ENC_MAX_DYNAMIC_TABLE_CAPACITY"]
-    pub qpack_enc_max_table_capacity: u64,
-    #[doc = " DEC_MAX_DYNAMIC_TABLE_CAPACITY"]
-    pub qpack_dec_max_table_capacity: u64,
-    #[doc = " MAX_BLOCKED_STREAMS"]
-    pub qpack_blocked_streams: u64,
-    #[doc = " RFC 9220: SETTINGS_ENABLE_CONNECT_PROTOCOL (0x08). 1 = enable Extended CONNECT"]
-    pub enable_connect_protocol: u64,
-    #[doc = " RFC 9297: SETTINGS_H3_DATAGRAM (0x33). 1 = enable HTTP Datagrams"]
-    pub h3_datagram: u64,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_h3_conn_settings_s"][::core::mem::size_of::<xqc_h3_conn_settings_s>() - 56usize];
-    ["Alignment of xqc_h3_conn_settings_s"]
-        [::core::mem::align_of::<xqc_h3_conn_settings_s>() - 8usize];
-    ["Offset of field: xqc_h3_conn_settings_s::max_field_section_size"]
-        [::core::mem::offset_of!(xqc_h3_conn_settings_s, max_field_section_size) - 0usize];
-    ["Offset of field: xqc_h3_conn_settings_s::max_pushes"]
-        [::core::mem::offset_of!(xqc_h3_conn_settings_s, max_pushes) - 8usize];
-    ["Offset of field: xqc_h3_conn_settings_s::qpack_enc_max_table_capacity"]
-        [::core::mem::offset_of!(xqc_h3_conn_settings_s, qpack_enc_max_table_capacity) - 16usize];
-    ["Offset of field: xqc_h3_conn_settings_s::qpack_dec_max_table_capacity"]
-        [::core::mem::offset_of!(xqc_h3_conn_settings_s, qpack_dec_max_table_capacity) - 24usize];
-    ["Offset of field: xqc_h3_conn_settings_s::qpack_blocked_streams"]
-        [::core::mem::offset_of!(xqc_h3_conn_settings_s, qpack_blocked_streams) - 32usize];
-    ["Offset of field: xqc_h3_conn_settings_s::enable_connect_protocol"]
-        [::core::mem::offset_of!(xqc_h3_conn_settings_s, enable_connect_protocol) - 40usize];
-    ["Offset of field: xqc_h3_conn_settings_s::h3_datagram"]
-        [::core::mem::offset_of!(xqc_h3_conn_settings_s, h3_datagram) - 48usize];
-};
-#[doc = " @brief callback for h3 bytestream read\n @param h3_ext_bs bytestream\n @param data data to be read. NOTE, this could be a NULL pointer, please ONLY read it if data_len > 0.\n @param data_len length of data to be read\n @param fin the bytestream is finished\n @param bs_user_data bytestream user data\n @param data_recv_time time spent for receiving data"]
-pub type xqc_h3_ext_bytestream_read_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        h3_ext_bs: *mut xqc_h3_ext_bytestream_t,
-        data: *const ::core::ffi::c_void,
-        data_len: usize,
-        fin: u8,
-        bs_user_data: *mut ::core::ffi::c_void,
-        data_recv_time: u64,
-    ) -> ::core::ffi::c_int,
->;
-#[doc = " @brief callbacks for extended h3 bytestream"]
-pub type xqc_h3_ext_bytestream_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        h3_ext_bs: *mut xqc_h3_ext_bytestream_t,
-        bs_user_data: *mut ::core::ffi::c_void,
-    ) -> ::core::ffi::c_int,
->;
-#[doc = " @brief the callback API to notify the application that there is a datagram to be read\n\n @param conn the connection handle\n @param user_data the user_data set by xqc_h3_ext_datagram_set_user_data\n @param data the data delivered by this callback\n @param data_len the length of the delivered data\n @param data_recv_time time spent for receiving data"]
-pub type xqc_h3_ext_datagram_read_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        conn: *mut xqc_h3_conn_t,
-        data: *const ::core::ffi::c_void,
-        data_len: usize,
-        user_data: *mut ::core::ffi::c_void,
-        data_recv_time: u64,
-    ),
->;
-#[doc = " @brief the callback API to notify the application that datagrams can be sent\n\n @param conn the connection handle\n @param user_data the user_data set by xqc_h3_ext_datagram_set_user_data"]
-pub type xqc_h3_ext_datagram_write_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(conn: *mut xqc_h3_conn_t, user_data: *mut ::core::ffi::c_void),
->;
-#[doc = " @brief the callback API to notify the application that a datagram is declared lost.\n However, the datagram could also be acknowledged later, as the underlying\n loss detection is not fully accurate. Applications should handle this type of\n spurious loss. The return value is used to ask the QUIC stack to retransmit the lost\n datagram packet.\n\n @param conn the connection handle\n @param user_data the user_data set by xqc_h3_ext_datagram_set_user_data\n @param dgram_id the id of the lost datagram\n @return 0, do not retransmit;\n         XQC_DGRAM_RETX_ASKED_BY_APP, retransmit;\n         others, ignored by the QUIC stack."]
-pub type xqc_h3_ext_datagram_lost_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        conn: *mut xqc_h3_conn_t,
-        dgram_id: u64,
-        user_data: *mut ::core::ffi::c_void,
-    ) -> ::core::ffi::c_int,
->;
-#[doc = " @brief the callback API to notify the application that a datagram is acked\n\n @param conn the connection handle\n @param user_data the user_data set by xqc_h3_ext_datagram_set_user_data\n @param dgram_id the id of the acked datagram"]
-pub type xqc_h3_ext_datagram_acked_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(
-        conn: *mut xqc_h3_conn_t,
-        dgram_id: u64,
-        user_data: *mut ::core::ffi::c_void,
-    ),
->;
-#[doc = " @brief the callback to notify application the MSS of QUIC datagrams. Note,\n        the MSS of QUIC datagrams will never shrink. If the MSS is zero, it\n        means this connection does not support sending QUIC datagrams.\n\n @param conn the connection handle\n @param user_data the dgram_data set by xqc_h3_ext_datagram_set_user_data\n @param mss the MSS of QUIC datagrams"]
-pub type xqc_h3_ext_datagram_mss_updated_notify_pt = ::core::option::Option<
-    unsafe extern "C" fn(conn: *mut xqc_h3_conn_t, mss: usize, user_data: *mut ::core::ffi::c_void),
->;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_h3_ext_dgram_callbacks_s {
-    #[doc = " the return value is ignored by XQUIC stack"]
-    pub dgram_read_notify: xqc_h3_ext_datagram_read_notify_pt,
-    #[doc = " the return value is ignored by XQUIC stack"]
-    pub dgram_write_notify: xqc_h3_ext_datagram_write_notify_pt,
-    #[doc = " the return value is ignored by XQUIC stack"]
-    pub dgram_acked_notify: xqc_h3_ext_datagram_acked_notify_pt,
-    #[doc = " the return value is ignored by XQUIC stack"]
-    pub dgram_lost_notify: xqc_h3_ext_datagram_lost_notify_pt,
-    pub dgram_mss_updated_notify: xqc_h3_ext_datagram_mss_updated_notify_pt,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_h3_ext_dgram_callbacks_s"]
-        [::core::mem::size_of::<xqc_h3_ext_dgram_callbacks_s>() - 40usize];
-    ["Alignment of xqc_h3_ext_dgram_callbacks_s"]
-        [::core::mem::align_of::<xqc_h3_ext_dgram_callbacks_s>() - 8usize];
-    ["Offset of field: xqc_h3_ext_dgram_callbacks_s::dgram_read_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_dgram_callbacks_s, dgram_read_notify) - 0usize];
-    ["Offset of field: xqc_h3_ext_dgram_callbacks_s::dgram_write_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_dgram_callbacks_s, dgram_write_notify) - 8usize];
-    ["Offset of field: xqc_h3_ext_dgram_callbacks_s::dgram_acked_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_dgram_callbacks_s, dgram_acked_notify) - 16usize];
-    ["Offset of field: xqc_h3_ext_dgram_callbacks_s::dgram_lost_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_dgram_callbacks_s, dgram_lost_notify) - 24usize];
-    ["Offset of field: xqc_h3_ext_dgram_callbacks_s::dgram_mss_updated_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_dgram_callbacks_s, dgram_mss_updated_notify) - 32usize];
-};
-pub type xqc_h3_ext_dgram_callbacks_t = xqc_h3_ext_dgram_callbacks_s;
-#[doc = " @brief http3 connection callbacks for application layer"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_h3_conn_callbacks_s {
-    #[doc = " http3 connection creation callback, REQUIRED for server, OPTIONAL for client"]
-    pub h3_conn_create_notify: xqc_h3_conn_notify_pt,
-    #[doc = " http3 connection close callback"]
-    pub h3_conn_close_notify: xqc_h3_conn_notify_pt,
-    #[doc = " handshake finished callback. which will be triggered when HANDSHAKE_DONE is received"]
-    pub h3_conn_handshake_finished: xqc_h3_handshake_finished_pt,
-    #[doc = " ping callback. which will be triggered when ping is acked"]
-    pub h3_conn_ping_acked: xqc_h3_conn_ping_ack_notify_pt,
-    pub h3_conn_init_settings: xqc_h3_conn_init_settings_pt,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_h3_conn_callbacks_s"]
-        [::core::mem::size_of::<xqc_h3_conn_callbacks_s>() - 40usize];
-    ["Alignment of xqc_h3_conn_callbacks_s"]
-        [::core::mem::align_of::<xqc_h3_conn_callbacks_s>() - 8usize];
-    ["Offset of field: xqc_h3_conn_callbacks_s::h3_conn_create_notify"]
-        [::core::mem::offset_of!(xqc_h3_conn_callbacks_s, h3_conn_create_notify) - 0usize];
-    ["Offset of field: xqc_h3_conn_callbacks_s::h3_conn_close_notify"]
-        [::core::mem::offset_of!(xqc_h3_conn_callbacks_s, h3_conn_close_notify) - 8usize];
-    ["Offset of field: xqc_h3_conn_callbacks_s::h3_conn_handshake_finished"]
-        [::core::mem::offset_of!(xqc_h3_conn_callbacks_s, h3_conn_handshake_finished) - 16usize];
-    ["Offset of field: xqc_h3_conn_callbacks_s::h3_conn_ping_acked"]
-        [::core::mem::offset_of!(xqc_h3_conn_callbacks_s, h3_conn_ping_acked) - 24usize];
-    ["Offset of field: xqc_h3_conn_callbacks_s::h3_conn_init_settings"]
-        [::core::mem::offset_of!(xqc_h3_conn_callbacks_s, h3_conn_init_settings) - 32usize];
-};
-#[doc = " @brief http3 request callbacks for application layer"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_h3_request_callbacks_s {
-    #[doc = " request creation notify. it will be triggered after a request was created, and is required\nfor server, optional for client"]
-    pub h3_request_create_notify: xqc_h3_request_notify_pt,
-    #[doc = " request close notify. which will be triggered after a request was closed"]
-    pub h3_request_close_notify: xqc_h3_request_notify_pt,
-    #[doc = " request read notify callback. which will be triggered after received http headers or body"]
-    pub h3_request_read_notify: xqc_h3_request_read_notify_pt,
-    #[doc = " request write notify callback. when triggered, users can continue to send headers or body"]
-    pub h3_request_write_notify: xqc_h3_request_notify_pt,
-    #[doc = " request closing notify callback, will be triggered when request is closing"]
-    pub h3_request_closing_notify: xqc_h3_request_closing_notify_pt,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_h3_request_callbacks_s"]
-        [::core::mem::size_of::<xqc_h3_request_callbacks_s>() - 40usize];
-    ["Alignment of xqc_h3_request_callbacks_s"]
-        [::core::mem::align_of::<xqc_h3_request_callbacks_s>() - 8usize];
-    ["Offset of field: xqc_h3_request_callbacks_s::h3_request_create_notify"]
-        [::core::mem::offset_of!(xqc_h3_request_callbacks_s, h3_request_create_notify) - 0usize];
-    ["Offset of field: xqc_h3_request_callbacks_s::h3_request_close_notify"]
-        [::core::mem::offset_of!(xqc_h3_request_callbacks_s, h3_request_close_notify) - 8usize];
-    ["Offset of field: xqc_h3_request_callbacks_s::h3_request_read_notify"]
-        [::core::mem::offset_of!(xqc_h3_request_callbacks_s, h3_request_read_notify) - 16usize];
-    ["Offset of field: xqc_h3_request_callbacks_s::h3_request_write_notify"]
-        [::core::mem::offset_of!(xqc_h3_request_callbacks_s, h3_request_write_notify) - 24usize];
-    ["Offset of field: xqc_h3_request_callbacks_s::h3_request_closing_notify"]
-        [::core::mem::offset_of!(xqc_h3_request_callbacks_s, h3_request_closing_notify) - 32usize];
-};
-#[doc = " @brief http3 request callbacks for application layer"]
-pub type xqc_h3_request_callbacks_t = xqc_h3_request_callbacks_s;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_h3_ext_bytestream_callbacks_s {
-    #[doc = " the return value is ignored by XQUIC stack"]
-    pub bs_create_notify: xqc_h3_ext_bytestream_notify_pt,
-    #[doc = " the return value is ignored by XQUIC stack"]
-    pub bs_close_notify: xqc_h3_ext_bytestream_notify_pt,
-    #[doc = " negative return values will cause the connection to be closed"]
-    pub bs_read_notify: xqc_h3_ext_bytestream_read_notify_pt,
-    #[doc = " negative return values will cause the connection to be closed"]
-    pub bs_write_notify: xqc_h3_ext_bytestream_notify_pt,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_h3_ext_bytestream_callbacks_s"]
-        [::core::mem::size_of::<xqc_h3_ext_bytestream_callbacks_s>() - 32usize];
-    ["Alignment of xqc_h3_ext_bytestream_callbacks_s"]
-        [::core::mem::align_of::<xqc_h3_ext_bytestream_callbacks_s>() - 8usize];
-    ["Offset of field: xqc_h3_ext_bytestream_callbacks_s::bs_create_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_callbacks_s, bs_create_notify) - 0usize];
-    ["Offset of field: xqc_h3_ext_bytestream_callbacks_s::bs_close_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_callbacks_s, bs_close_notify) - 8usize];
-    ["Offset of field: xqc_h3_ext_bytestream_callbacks_s::bs_read_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_callbacks_s, bs_read_notify) - 16usize];
-    ["Offset of field: xqc_h3_ext_bytestream_callbacks_s::bs_write_notify"]
-        [::core::mem::offset_of!(xqc_h3_ext_bytestream_callbacks_s, bs_write_notify) - 24usize];
-};
-pub type xqc_h3_ext_bytestream_callbacks_t = xqc_h3_ext_bytestream_callbacks_s;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct xqc_h3_callbacks_s {
-    #[doc = " http3 connection callbacks"]
-    pub h3c_cbs: xqc_h3_conn_callbacks_t,
-    #[doc = " http3 request callbacks"]
-    pub h3r_cbs: xqc_h3_request_callbacks_t,
-    #[doc = " datagram callbacks"]
-    pub h3_ext_dgram_cbs: xqc_h3_ext_dgram_callbacks_t,
-    #[doc = " bytestream callbacks"]
-    pub h3_ext_bs_cbs: xqc_h3_ext_bytestream_callbacks_t,
-}
-#[allow(clippy::unnecessary_operation, clippy::identity_op)]
-const _: () = {
-    ["Size of xqc_h3_callbacks_s"][::core::mem::size_of::<xqc_h3_callbacks_s>() - 152usize];
-    ["Alignment of xqc_h3_callbacks_s"][::core::mem::align_of::<xqc_h3_callbacks_s>() - 8usize];
-    ["Offset of field: xqc_h3_callbacks_s::h3c_cbs"]
-        [::core::mem::offset_of!(xqc_h3_callbacks_s, h3c_cbs) - 0usize];
-    ["Offset of field: xqc_h3_callbacks_s::h3r_cbs"]
-        [::core::mem::offset_of!(xqc_h3_callbacks_s, h3r_cbs) - 40usize];
-    ["Offset of field: xqc_h3_callbacks_s::h3_ext_dgram_cbs"]
-        [::core::mem::offset_of!(xqc_h3_callbacks_s, h3_ext_dgram_cbs) - 80usize];
-    ["Offset of field: xqc_h3_callbacks_s::h3_ext_bs_cbs"]
-        [::core::mem::offset_of!(xqc_h3_callbacks_s, h3_ext_bs_cbs) - 120usize];
-};
-pub type xqc_h3_callbacks_t = xqc_h3_callbacks_s;
-unsafe extern "C" {
-    #[doc = " @brief init h3 context into xqc_engine_t, this MUST BE called before create any http3 connection\n\n @param engine the engine handler created by xqc_engine_create\n @return xqc_int_t XQC_OK for success, others for failure"]
-    pub fn xqc_h3_ctx_init(engine: *mut xqc_engine_t, h3_cbs: *mut xqc_h3_callbacks_t)
-    -> xqc_int_t;
-}
-unsafe extern "C" {
-    pub fn xqc_h3_ctx_destroy(engine: *mut xqc_engine_t) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief set max h3 max dynamic table capacity. It MUST only be called after\n        xqc_h3_ctx_init.\n\n @param engine the engine handler created by xqc_engine_create\n @param value capacity of dynamic table, 0 for disable dynamic table"]
-    pub fn xqc_h3_engine_set_max_dtable_capacity(engine: *mut xqc_engine_t, capacity: usize);
-}
-unsafe extern "C" {
-    #[doc = " @brief @deprecated use xqc_h3_engine_set_max_dtable_capacity instead.\n        It MUST only be called after xqc_h3_ctx_init.\n\n @param engine the engine handler created by xqc_engine_create\n @param value 0:disable dynamic table"]
-    pub fn xqc_h3_engine_set_dec_max_dtable_capacity(engine: *mut xqc_engine_t, value: usize);
-}
-unsafe extern "C" {
-    #[doc = " @brief @deprecated use xqc_h3_engine_set_max_dtable_capacity instead.\n        It MUST only be called after xqc_h3_ctx_init.\n\n @param engine the engine handler created by xqc_engine_create\n @param value 0:disable dynamic table"]
-    pub fn xqc_h3_engine_set_enc_max_dtable_capacity(engine: *mut xqc_engine_t, value: usize);
-}
-unsafe extern "C" {
-    #[doc = " @brief set max h3 field section size.\n        It MUST only be called after xqc_h3_ctx_init.\n\n @param engine the engine handler created by xqc_engine_create\n @param size size of field section size"]
-    pub fn xqc_h3_engine_set_max_field_section_size(engine: *mut xqc_engine_t, size: usize);
-}
-unsafe extern "C" {
-    #[doc = " @brief set the limit for qpack blocked streams.\n        It MUST only be called after xqc_h3_ctx_init.\n\n @param engine\n @param value\n @return XQC_EXPORT_PUBLIC_API"]
-    pub fn xqc_h3_engine_set_qpack_blocked_streams(engine: *mut xqc_engine_t, value: usize);
-}
-unsafe extern "C" {
-    #[doc = " User can set h3 settings when h3_conn_create_notify callbacks"]
-    pub fn xqc_h3_engine_set_local_settings(
-        engine: *mut xqc_engine_t,
-        h3_conn_settings: *const xqc_h3_conn_settings_t,
-    );
-}
-unsafe extern "C" {
-    #[doc = " @brief create and http3 connection\n\n @param engine return from xqc_engine_create\n @param conn_settings Include all the connection settings, which should be customized according to the actual needs, and will be defaultly set to internal_default_conn_settings if not specified.\n @param token token receive from server, xqc_save_token_pt callback\n @param token_len length of token\n @param server_host server domain\n @param no_crypto_flag 1:without crypto\n @param conn_ssl_config For handshake\n @param peer_addr address of peer\n @param peer_addrlen length of peer_addr\n @param user_data returned in connection callback functions\n @return cid of the connection; user should copy cid to your own memory, in case of cid destroyed\n in xquic library"]
-    pub fn xqc_h3_connect(
-        engine: *mut xqc_engine_t,
-        conn_settings: *const xqc_conn_settings_t,
-        token: *const ::core::ffi::c_uchar,
-        token_len: ::core::ffi::c_uint,
-        server_host: *const ::core::ffi::c_char,
-        no_crypto_flag: ::core::ffi::c_int,
-        conn_ssl_config: *const xqc_conn_ssl_config_t,
-        peer_addr: *const sockaddr,
-        peer_addrlen: socklen_t,
-        user_data: *mut ::core::ffi::c_void,
-    ) -> *const xqc_cid_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief manually close a http3 connection\n\n @param engine engine handler created by xqc_engine_create\n @param cid connection id of http3 connection\n @return XQC_OK for success, others for failure"]
-    pub fn xqc_h3_conn_close(engine: *mut xqc_engine_t, cid: *const xqc_cid_t) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief get QUIC connection handler\n\n @param h3c http3 connection handler\n @return quic_connection on which h3_conn rely"]
-    pub fn xqc_h3_conn_get_xqc_conn(h3c: *mut xqc_h3_conn_t) -> *mut xqc_connection_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief get http3 protocol error number\n\n @param h3c handler of http3 connection\n @return error number of http3 connection, HTTP_NO_ERROR(0x100) For no-error"]
-    pub fn xqc_h3_conn_get_errno(h3c: *mut xqc_h3_conn_t) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief get ssl handler of http3 connection\n\n @param h3c handler of http3 connection\n @return ssl handler of http3 connection"]
-    pub fn xqc_h3_conn_get_ssl(h3c: *mut xqc_h3_conn_t) -> *mut ::core::ffi::c_void;
-}
-unsafe extern "C" {
-    #[doc = " @brief set user_data for http3 connection, user_data could be the application layer context of\n http3 connection\n\n @param h3c handler of http3 connection\n @param user_data should set user_data when h3_conn_create_notify callbacks, which will be\n returned as parameter of http3 connection callback functions"]
-    pub fn xqc_h3_conn_set_user_data(h3c: *mut xqc_h3_conn_t, user_data: *mut ::core::ffi::c_void);
-}
-unsafe extern "C" {
-    #[doc = " @brief get user_data for http3 connection, user_data could be the application layer context of\n http3 connection\n\n @param h3c handler of http3 connection\n @return user_data"]
-    pub fn xqc_h3_conn_get_user_data(h3_conn: *mut xqc_h3_conn_t) -> *mut ::core::ffi::c_void;
-}
-unsafe extern "C" {
-    #[doc = " @brief get peer address information, server should call this when h3_conn_create_notify triggers\n\n @param h3c handler of http3 connection\n @param addr [out] output address of peer\n @param addr_cap capacity of addr\n @param peer_addr_len [out] output length of addr\n @return XQC_OK for success, others for failure"]
-    pub fn xqc_h3_conn_get_peer_addr(
-        h3c: *mut xqc_h3_conn_t,
-        addr: *mut sockaddr,
-        addr_cap: socklen_t,
-        peer_addr_len: *mut socklen_t,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief get local address information, server should call this when h3_conn_create_notify triggers\n\n @param h3c handler of http3 connection\n @param addr [out] output address of peer\n @param addr_cap capacity of addr\n @param peer_addr_len [out] output length of addr\n @return XQC_OK for success, others for failure"]
-    pub fn xqc_h3_conn_get_local_addr(
-        h3c: *mut xqc_h3_conn_t,
-        addr: *mut sockaddr,
-        addr_cap: socklen_t,
-        local_addr_len: *mut socklen_t,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief Send PING to peer, if ack received, h3_conn_ping_acked will callback with user_data\n\n @param engine handler of engine\n @param cid connection id of http3 connection, which is generated by xqc_h3_connect\n @param ping_user_data\n @return XQC_OK for success, < 0 for error"]
-    pub fn xqc_h3_conn_send_ping(
-        engine: *mut xqc_engine_t,
-        cid: *const xqc_cid_t,
-        ping_user_data: *mut ::core::ffi::c_void,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief check if h3 connection is ready to send 0rtt data\n @param h3c h3 connection handler\n @return XQC_TRUE for can send 0rtt, XQC_FALSE for can not"]
-    pub fn xqc_h3_conn_is_ready_to_send_early_data(h3c: *mut xqc_h3_conn_t) -> xqc_bool_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief set the dynamic table capacity of an existing h3 connection\n @param h3c h3 connection handler\n @param capacity capacity of dynamic table, 0 for disable dynamic table\n @return XQC_OK for success, others for failure"]
-    pub fn xqc_h3_conn_set_qpack_dtable_cap(h3c: *mut xqc_h3_conn_t, capacity: usize) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief create a http3 request\n @param engine handler created by xqc_engine_create\n @param cid connection id of http3 connection\n @param user_data For request\n @param settings stream settings\n @return handler of http3 request"]
-    pub fn xqc_h3_request_create(
-        engine: *mut xqc_engine_t,
-        cid: *const xqc_cid_t,
-        settings: *mut xqc_stream_settings_t,
-        user_data: *mut ::core::ffi::c_void,
-    ) -> *mut xqc_h3_request_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief get statistics of a http3 request user can get it before request destroyed\n\n @param h3_request handler of http3 request\n @return statistics information of request"]
-    pub fn xqc_h3_request_get_stats(h3_request: *mut xqc_h3_request_t) -> xqc_request_stats_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief write important information into str\n @return the number of characters printed"]
-    pub fn xqc_h3_request_stats_print(
-        h3_request: *mut xqc_h3_request_t,
-        str_: *mut ::core::ffi::c_char,
-        size: usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief set user_data of a http3 request, which will be used as parameter of request\n callback functions. server should set user_data when h3_request_create_notify triggers\n\n @param h3_request handler of http3 request\n @param user_data user data of request callback functions"]
-    pub fn xqc_h3_request_set_user_data(
-        h3_request: *mut xqc_h3_request_t,
-        user_data: *mut ::core::ffi::c_void,
-    );
-}
-unsafe extern "C" {
-    #[doc = " @brief close request, send QUIC RESET_STREAM frame to peer. h3_request_close_notify will\n triggered when request is finally destroyed\n\n @param h3_request handler of http3 request\n @return XQC_OK for success, others for error"]
-    pub fn xqc_h3_request_close(h3_request: *mut xqc_h3_request_t) -> xqc_int_t;
-}
-unsafe extern "C" {
-    pub fn xqc_h3_request_update_settings(
-        h3_request: *mut xqc_h3_request_t,
-        settings: *mut xqc_stream_settings_t,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief send http headers to peer\n\n @param h3_request handler of http3 request\n @param headers http headers\n @param fin request finish flag, 1 for finish. if set here, it means request has no body\n @return > 0 for Bytes sent，-XQC_EAGAIN try next time, < 0 for error, 0 for request finished"]
-    pub fn xqc_h3_request_send_headers(
-        h3_request: *mut xqc_h3_request_t,
-        headers: *mut xqc_http_headers_t,
-        fin: u8,
-    ) -> isize;
-}
-unsafe extern "C" {
-    #[doc = " @brief send http body to peer\n\n @param h3_request handler of http3 request\n @param data content of body\n @param data_size length of body\n @param fin request finish flag, 1 for finish.\n @return > 0 for Bytes sent，-XQC_EAGAIN try next time, < 0 for error, 0 for request finished"]
-    pub fn xqc_h3_request_send_body(
-        h3_request: *mut xqc_h3_request_t,
-        data: *mut ::core::ffi::c_uchar,
-        data_size: usize,
-        fin: u8,
-    ) -> isize;
-}
-unsafe extern "C" {
-    #[doc = " @brief finish request. if fin is not sent yet, and application has nothing to send anymore, call\n this function to send a QUIC STREAM frame with only fin\n\n @return > 0 for Bytes sent，-XQC_EAGAIN try next time, < 0 for error, 0 for request finished"]
-    pub fn xqc_h3_request_finish(h3_request: *mut xqc_h3_request_t) -> isize;
-}
-unsafe extern "C" {
-    #[doc = " @brief receive headers of a request\n\n @param h3_request handler of http3 request\n @param fin request finish flag, 1 for finish. if not 0, it means request has no body\n @return request headers. user should copy headers to your own memory，NULL for error"]
-    pub fn xqc_h3_request_recv_headers(
-        h3_request: *mut xqc_h3_request_t,
-        fin: *mut u8,
-    ) -> *mut xqc_http_headers_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief receive body of a request\n\n @param h3_request handler of http3 request\n @param fin request finish flag, 1 for finish\n @return Bytes read，-XQC_EAGAIN try next time, <0 for error"]
-    pub fn xqc_h3_request_recv_body(
-        h3_request: *mut xqc_h3_request_t,
-        recv_buf: *mut ::core::ffi::c_uchar,
-        recv_buf_size: usize,
-        fin: *mut u8,
-    ) -> isize;
-}
-unsafe extern "C" {
-    #[doc = " @brief get connection's user_data by request\n\n @param h3_request handler of http3 request\n @return user_data set by user"]
-    pub fn xqc_h3_get_conn_user_data_by_request(
-        h3_request: *mut xqc_h3_request_t,
-    ) -> *mut ::core::ffi::c_void;
-}
-unsafe extern "C" {
-    #[doc = " @brief Get QUIC stream ID by request\n\n @param h3_request handler of http3 request\n @return QUIC stream id"]
-    pub fn xqc_h3_stream_id(h3_request: *mut xqc_h3_request_t) -> xqc_stream_id_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief RFC 9218 HTTP Priority"]
-    pub fn xqc_h3_priority_init(prio: *mut xqc_h3_priority_t);
-}
-unsafe extern "C" {
-    pub fn xqc_write_http_priority(
-        prio: *mut xqc_h3_priority_t,
-        dst: *mut u8,
-        dstcap: usize,
-    ) -> usize;
-}
-unsafe extern "C" {
-    pub fn xqc_parse_http_priority(
-        dst: *mut xqc_h3_priority_t,
-        str_: *const u8,
-        str_len: usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    pub fn xqc_h3_request_set_priority(
-        h3r: *mut xqc_h3_request_t,
-        prio: *mut xqc_h3_priority_t,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief create a bytestream based on extended H3\n @param engine handler created by xqc_engine_create\n @param cid connection id of http3 connection\n @param user_data For bytestream\n @return handler of bytestream"]
-    pub fn xqc_h3_ext_bytestream_create(
-        engine: *mut xqc_engine_t,
-        cid: *const xqc_cid_t,
-        user_data: *mut ::core::ffi::c_void,
-    ) -> *mut xqc_h3_ext_bytestream_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief close bytestream, send QUIC RESET_STREAM frame to peer. h3_ext_bytestream_close_notify will\n triggered when bytestream is finally destroyed\n\n @param xqc_h3_ext_bytestream_t handler of bytestream\n @return XQC_OK for success, others for error"]
-    pub fn xqc_h3_ext_bytestream_close(h3_ext_bs: *mut xqc_h3_ext_bytestream_t) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief finish bytestream. if fin is not sent yet, and application has nothing to send anymore, call\n this function to send a QUIC STREAM frame with only fin\n\n @return > 0 for Bytes sent，-XQC_EAGAIN try next time, < 0 for error, 0 for bytestream finished"]
-    pub fn xqc_h3_ext_bytestream_finish(h3_ext_bs: *mut xqc_h3_ext_bytestream_t) -> isize;
-}
-unsafe extern "C" {
-    #[doc = " @brief set user_data of a bytestream, which will be used as the parameter of the bytestream\n callback functions. server should set user_data when h3_ext_bytestream_create_notify triggers\n\n @param xqc_h3_ext_bytestream_t handler of the bytestream\n @param user_data user data of the bytestream callback functions"]
-    pub fn xqc_h3_ext_bytestream_set_user_data(
-        h3_ext_bs: *mut xqc_h3_ext_bytestream_t,
-        user_data: *mut ::core::ffi::c_void,
-    );
-}
-unsafe extern "C" {
-    #[doc = " @brief get the user data associcated with the bytestream object\n\n @param xqc_h3_ext_bytestream_t handler of the bytestream\n @param user_data user data of the bytestream callback functions\n @return the pointer of user data"]
-    pub fn xqc_h3_ext_bytestream_get_user_data(
-        h3_ext_bs: *mut xqc_h3_ext_bytestream_t,
-    ) -> *mut ::core::ffi::c_void;
-}
-unsafe extern "C" {
-    #[doc = " @brief get statistics of a bytestream\n\n @param xqc_h3_ext_bytestream_t handler of the bytestream\n @return statistics information of the bytestream"]
-    pub fn xqc_h3_ext_bytestream_get_stats(
-        h3_ext_bs: *mut xqc_h3_ext_bytestream_t,
-    ) -> xqc_h3_ext_bytestream_stats_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief send data\n\n @param xqc_h3_ext_bytestream_t handler of the bytestream\n @param data content\n @param data_size data length\n @param fin request finish flag, 1 for finish.\n @param qos level (must be the values defined in xqc_data_qos_level_t)\n @return > 0 for bytes sent，-XQC_EAGAIN try next time, < 0 for error, 0 for bytestream finished"]
-    pub fn xqc_h3_ext_bytestream_send(
-        h3_ext_bs: *mut xqc_h3_ext_bytestream_t,
-        data: *mut ::core::ffi::c_uchar,
-        data_size: usize,
-        fin: u8,
-        qos_level: xqc_data_qos_level_t,
-    ) -> isize;
-}
-unsafe extern "C" {
-    #[doc = " @brief Get QUIC stream ID by a bytestream\n\n @param xqc_h3_ext_bytestream_t handler of a bytestream\n @return QUIC stream id"]
-    pub fn xqc_h3_ext_bytestream_id(h3_ext_bs: *mut xqc_h3_ext_bytestream_t) -> xqc_stream_id_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief get the h3 connection associated with a bytestream\n\n @param xqc_h3_ext_bytestream_t handler of a bytestream\n @return an h3 connection"]
-    pub fn xqc_h3_ext_bytestream_get_h3_conn(
-        h3_ext_bs: *mut xqc_h3_ext_bytestream_t,
-    ) -> *mut xqc_h3_conn_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief the API to get the max length of the data that can be sent\n        via a single call of xqc_datagram_send\n\n @param conn the connection handle\n @return 0 = the peer does not support datagram, >0 = the max length"]
-    pub fn xqc_h3_ext_datagram_get_mss(conn: *mut xqc_h3_conn_t) -> usize;
-}
-unsafe extern "C" {
-    #[doc = " Server should set datagram user_data when datagram callbacks\n @dgram_data: the user_data of all datagram callbacks"]
-    pub fn xqc_h3_ext_datagram_set_user_data(
-        conn: *mut xqc_h3_conn_t,
-        user_data: *mut ::core::ffi::c_void,
-    );
-}
-unsafe extern "C" {
-    #[doc = " @return the user_data of all datagram callbacks"]
-    pub fn xqc_h3_ext_datagram_get_user_data(conn: *mut xqc_h3_conn_t) -> *mut ::core::ffi::c_void;
-}
-unsafe extern "C" {
-    #[doc = " @brief the API to send a datagram over the h3 connection\n\n @param conn the connection handle\n @param data the data to be sent\n @param data_len the length of the data\n @param *dgram_id the pointer to return the id the datagram\n @param qos level (must be the values defined in xqc_data_qos_level_t)\n @return <0 = error (-XQC_EAGAIN, -XQC_CLOSING, -XQC_DGRAM_NOT_SUPPORTED, -XQC_DGRAM_TOO_LARGE, ...),\n         0 success"]
-    pub fn xqc_h3_ext_datagram_send(
-        conn: *mut xqc_h3_conn_t,
-        data: *mut ::core::ffi::c_void,
-        data_len: usize,
-        dgram_id: *mut u64,
-        qos_level: xqc_data_qos_level_t,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief the API to send a datagram over the h3 connection\n\n @param conn the connection handle\n @param iov multiple data buffers need to be sent\n @param *dgram_id the pointer to return the list of dgram_id\n @param iov_size the size of iov list\n @param *sent_cnt the number of successfully sent datagrams\n @param *sent_bytes the total bytes of successfully sent datagrams\n @param qos level (must be the values defined in xqc_data_qos_level_t)\n @return <0 = error (-XQC_EAGAIN, -XQC_CLOSING, -XQC_DGRAM_NOT_SUPPORTED, -XQC_DGRAM_TOO_LARGE, ...),\n         0 success"]
-    pub fn xqc_h3_ext_datagram_send_multiple(
-        conn: *mut xqc_h3_conn_t,
-        iov: *mut iovec,
-        dgram_id_list: *mut u64,
-        iov_size: usize,
-        sent_cnt: *mut usize,
-        sent_bytes: *mut usize,
-        qos_level: xqc_data_qos_level_t,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " @brief send a datagram pinned to a specific path (multipath QUIC)\n\n Same as xqc_h3_ext_datagram_send but the datagram packet is pinned to the\n given path_id, bypassing the multipath scheduler.\n Use XQC_INITIAL_PATH_ID (0) for the initial path."]
-    pub fn xqc_h3_ext_datagram_send_on_path(
-        conn: *mut xqc_h3_conn_t,
-        data: *mut ::core::ffi::c_void,
-        data_len: usize,
-        dgram_id: *mut u64,
-        qos_level: xqc_data_qos_level_t,
-        path_id: u64,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Frame a UDP/IP payload into an HTTP Datagram buffer (RFC 9297).\n Prepends [Quarter-Stream-ID : varint][Context-ID=0 : varint]."]
-    pub fn xqc_h3_ext_masque_frame_udp(
-        out: *mut u8,
-        outlen: usize,
-        written: *mut usize,
-        stream_id: u64,
-        payload: *const u8,
-        paylen: usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Unframe an HTTP Datagram (RFC 9297).\n Returns a pointer to the payload within the input buffer."]
-    pub fn xqc_h3_ext_masque_unframe_udp(
-        buf: *const u8,
-        buflen: usize,
-        quarter_stream_id: *mut u64,
-        context_id: *mut u64,
-        payload: *mut *const u8,
-        payload_len: *mut usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Calculate the maximum payload size for a single HTTP Datagram."]
-    pub fn xqc_h3_ext_masque_udp_mss(dgram_mss: usize, stream_id: u64) -> usize;
-}
-unsafe extern "C" {
-    #[doc = " Encode a capsule: [Type : varint][Length : varint][Payload] (RFC 9297)."]
-    pub fn xqc_h3_ext_capsule_encode(
-        out: *mut u8,
-        outlen: usize,
-        written: *mut usize,
-        type_: u64,
-        payload: *const u8,
-        paylen: usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Decode a capsule header and return a pointer to the payload (RFC 9297)."]
-    pub fn xqc_h3_ext_capsule_decode(
-        buf: *const u8,
-        buflen: usize,
-        type_: *mut u64,
-        payload: *mut *const u8,
-        payload_len: *mut usize,
-        bytes_consumed: *mut usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Parse a single entry from an ADDRESS_ASSIGN capsule payload (RFC 9484).\n Call in a loop, advancing by bytes_consumed each iteration, to handle\n capsules containing multiple assigned addresses."]
-    pub fn xqc_h3_ext_connectip_parse_address_assign(
-        payload: *const u8,
-        paylen: usize,
-        request_id: *mut u64,
-        ip_version: *mut u8,
-        ip_addr: *mut u8,
-        ip_addr_len: *mut usize,
-        prefix_len: *mut u8,
-        bytes_consumed: *mut usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Build an ADDRESS_REQUEST capsule payload (RFC 9484)."]
-    pub fn xqc_h3_ext_connectip_build_address_request(
-        buf: *mut u8,
-        buflen: usize,
-        written: *mut usize,
-        request_id: u64,
-        ip_version: u8,
-        ip_addr: *const u8,
-        prefix_len: u8,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Parse a single ROUTE_ADVERTISEMENT entry (RFC 9484).\n Call in a loop, advancing by bytes_consumed each iteration."]
-    pub fn xqc_h3_ext_connectip_parse_route_advertisement(
-        payload: *const u8,
-        paylen: usize,
-        ip_version: *mut u8,
-        start_ip: *mut u8,
-        end_ip: *mut u8,
-        ip_addr_len: *mut usize,
-        ip_protocol: *mut u8,
-        bytes_consumed: *mut usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Validate an IP packet extracted from an HTTP Datagram (RFC 9484 Section 4.6).\n Checks IP version field (must be 4 or 6) and minimum header length.\n Returns XQC_OK if valid, -XQC_EPARAM if invalid."]
-    pub fn xqc_h3_ext_masque_validate_ip_packet(
-        payload: *const u8,
-        payload_len: usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Validate a full ROUTE_ADVERTISEMENT capsule payload (RFC 9484 §4.7.3).\n Verifies ordering and non-overlapping ranges."]
-    pub fn xqc_h3_ext_connectip_validate_route_advertisement(
-        payload: *const u8,
-        paylen: usize,
-    ) -> xqc_int_t;
-}
-unsafe extern "C" {
-    #[doc = " Check that IPv6 tunnel MTU meets the RFC 9484 §7.2 minimum of 1280 bytes."]
-    pub fn xqc_h3_ext_masque_check_ipv6_mtu(tunnel_mtu: usize) -> xqc_int_t;
-}
diff --git a/crates/xquic-sys/wrapper.h b/crates/xquic-sys/wrapper.h
index 38587e69..d14b1a02 100644
--- a/crates/xquic-sys/wrapper.h
+++ b/crates/xquic-sys/wrapper.h
@@ -1,4 +1,3 @@
 #include <xquic/xquic.h>
-#include <xquic/xqc_http3.h>
 #include <xquic/xqc_errno.h>
 #include <xquic/xquic_typedef.h>