AWS SDK

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/cell/h1.rs

@@ -1,1 +89,89 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! HTTP/1 connection records and exclusive request-sender ownership.
 //!
 //! Every installed connection remains in its connection-owning [`H1Records`]
 //! Every installed connection remains in its connection-owning [`H1CellState`]
 //! until logical close. While the record is live, its exclusive sender exists
 //! in exactly one place: inside an `Idle` record or in one external owner while
 //! the record is `Selected` or `Reserved`. Transitions move the sender; they
 //! the record is `Selected` or `ReservedForPeer`. Transitions move the sender; they
 //! never copy it. The residence records that ownership:
 //!
 //! ```text
 //! completed handshake -- install_selected --------------------> Selected
 //! test fixture ------- install_idle ---------------------------> Idle(sender)
 //! completed handshake -- insert_selected ---------------------> Selected
 //! test fixture ------- insert_idle ----------------------------> Idle(sender)
 //!
 //! Idle(sender) -- select_idle --------------------------------> Selected
 //! Idle(sender) -- take_idle_for_reuse ------------------------> Reserved
 //! Selected ---- reserve_for_reuse ----------------------------> Reserved
 //! Reserved ---- commit_return_to_waiter ----------------------> Selected
 //! Idle(sender) -- take_idle_candidate ----------------> ReservedForPeer
 //! Selected ---- reserve_for_peer ---------------------> ReservedForPeer
 //! ReservedForPeer -- commit_return_to_waiter -----------------> Selected
 //! Selected ---- return_idle ----------------------------------> Idle(sender)
 //! Reserved ---- return_idle ----------------------------------> Idle(sender)
 //! ReservedForPeer -- return_idle -----------------------------> Idle(sender)
 //!
 //! Idle(sender) ------------ begin_close ----------------------> Closing
 //! Selected / Reserved ---- begin_close / close_owned --------> Closing
 //! Closing -------- finish_close ------------------------------> removed
 //! Selected / ReservedForPeer -- begin_close / close_owned ---> Closing
 //! Closing -------- remove_closed -----------------------------> removed
 //! ```
 //!
 //! Outside the lock, ownership moves through values whose drop behavior is
 //! specific to the protocol phase:
 //!
 //! ```text
 //! H1Selection
 //!   |-- dropped ------------------------------> return to connection-owning cell
 //!   |-- retire_connection --------------------------------> logical close
 //!   `-- request accepted --> H1Exchange
 //!                              |-- incomplete or dropped --> logical close
 //!                              `-- offer_for_reuse --------> return to connection-owning cell
 //!
 //! cross-cell reuse --> ProvisionalH1
 //!                        |-- borrow ----------------------> H1Selection
 //!                        |-- reclaim ---------------------> logical close
 //!                        `-- rejected or dropped ---------> return to connection-owning cell
 //! ```
 //!
 //! [`H1Selection`], [`H1Exchange`], and [`ProvisionalH1`] are the
 //! sender-owning values outside the cell lock. Their drop behavior returns or
 //! retires the sender so a cancellation cannot leave a record with no terminal
 //! owner. They retain the owning cell weakly because a selected sender may
 //! temporarily be the ready result in that same cell; cell teardown makes the
 //! fallback close the connection directly.
-53
 use super::super::admission::reuse::{
     H1AvailabilitySnapshot, PreparedReuseInstall, ReuseCandidate, ReuseId, ReuseInstallResult,
 use super::super::admission::{
     AdmissionAction, H1Candidate, H1MatchId, H1SupplyStatus, OriginAdmission,
     PreparedH1Reservation, SupplyRevision,
 };
 use super::super::admission::{AdmissionAction, OriginAdmission};
 use super::super::connection::{CloseReason, ConnectionState};
 use super::{AcquisitionResult, OriginCell, ReuseInstall};
 use super::{AcquisitionOutcome, OriginCell};
 use crate::sync::{Arc, Weak};
 use aws_smithy_runtime_api::client::connection::ConnectionId;
 use std::collections::{HashMap, VecDeque};
 use std::fmt;
 use std::task::{Context, Poll};
 use std::time::SystemTime;
-66
 use aws_smithy_types::body::SdkBody;
-68
 /// Exclusive request handle for one Hyper HTTP/1 client connection.

↧ Expand context

 ///
 /// Hyper creates one `SendRequest<SdkBody>` handle when the client handshake
 /// completes. Pool code calls this handle the HTTP/1 sender. Moving it between
 /// residence guards transfers authority to send the next request; it does not
 /// move the socket or protocol driver. The test-only variant exercises those
 /// ownership transitions without running Hyper.
 pub(in crate::client::pool) enum H1Sender {
     /// Hyper's exclusive HTTP/1 request sender.
     Hyper(hyper::client::conn::http1::SendRequest<SdkBody>),
     /// Synthetic sender identity used only by ownership tests.
     #[cfg(test)]
     Test(u64),
-82
+}
-83
 impl H1Sender {
     /// Wraps a sender returned by a successful Hyper HTTP/1 handshake.
     pub(in crate::client::pool) fn from_hyper(
         sender: hyper::client::conn::http1::SendRequest<SdkBody>,
     ) -> Self {
         Self::Hyper(sender)

@@ -112,112 +1605,1675 @@

↥ Expand context

             Self::Test(_) => panic!("test HTTP/1 sender reached Hyper readiness"),
-113
+        }
-114
+    }
-115
     /// Creates a synthetic sender for state-machine tests.
     #[cfg(test)]
     pub(in crate::client::pool) fn test(id: u64) -> Self {
         Self::Test(id)
-120
+    }
-121
     /// Returns the synthetic sender identity.
     #[cfg(test)]
     pub(super) fn test_id(&self) -> u64 {
         match self {
             Self::Test(id) => *id,
             Self::Hyper(_) => panic!("Hyper sender used in a synthetic ownership test"),
-128
+        }
-129
+    }
-130
+}
-131

 impl fmt::Debug for H1Sender {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Hyper(_) => f.write_str("H1Sender::Hyper"),
             #[cfg(test)]
             Self::Test(id) => f.debug_tuple("H1Sender::Test").field(id).finish(),
-138
+        }
-139
+    }
-140
+}
-141
 /// Local reservation for one cross-cell reuse operation and its fairness debt.
 /// Local reservation for one peer match and its fairness debt.
 ///
 /// Reservation residence and fairness debt are separate because a completed
 /// transfer releases the reservation immediately, while the debt remains until
 /// later local service or the disappearance of compatible local demand.
 #[derive(Debug, Default)]
 pub(super) struct H1ReuseReservation {
     /// Residence of the current reuse reservation.
     state: H1ReuseReservationState,
 struct H1Reservation {
     /// State of the current peer reservation.
     state: H1ReservationState,
     /// Whether this cell's next usable HTTP/1 turn must remain local after the
     /// operation that earned it has completed.
     local_turn_owed: bool,
-154
+}
-155
 /// Authoritative residence of one cell-local reuse reservation.
 /// Authoritative state of one cell-local peer reservation.
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 enum H1ReuseReservationState {
     /// No reuse operation may intercept a sender return.
 enum H1ReservationState {
     /// No peer match may intercept a sender return.
     #[default]
     Available,
     /// The next reusable sender return is reserved for this reuse operation.
     Installed(ReuseId),
     /// A provisional sender is outside the connection-owning cell lock for this reuse operation.
     Resolving(ReuseId),
     /// The next reusable sender return is reserved for this match.
     Installed(H1MatchId),
     /// A provisional sender is outside the cell lock for this match.
     Resolving(H1MatchId),
-166
+}
-167
 impl H1ReuseReservation {
     /// Installs a reuse operation that will intercept a future reusable return.
     pub(super) fn install(&mut self, reuse_id: ReuseId) -> bool {
         if !matches!(self.state, H1ReuseReservationState::Available) {
 impl H1Reservation {
     /// Reserves a future reusable return for one retained match.
     fn reserve_waiting(&mut self, match_id: H1MatchId) -> bool {
         if !matches!(self.state, H1ReservationState::Available) {
             return false;
-173
+        }
         self.state = H1ReuseReservationState::Installed(reuse_id);
         self.state = H1ReservationState::Installed(match_id);
         true
-176
+    }
-177
     /// Installs a reuse operation that has already extracted an idle sender.
     pub(super) fn install_resolving(&mut self, reuse_id: ReuseId) -> bool {
         if !matches!(self.state, H1ReuseReservationState::Available) {
     /// Reserves a match that already owns an extracted idle sender.
     fn reserve_resolving(&mut self, match_id: H1MatchId) -> bool {
         if !matches!(self.state, H1ReservationState::Available) {
             return false;
-182
+        }
         self.state = H1ReuseReservationState::Resolving(reuse_id);
         self.state = H1ReservationState::Resolving(match_id);
         true
-185
+    }
-186
     /// Reserves the next reusable return for an installed reuse operation.
     pub(super) fn intercept_return(&mut self) -> Option<ReuseId> {
         let H1ReuseReservationState::Installed(reuse_id) = self.state else {
     /// Transfers a waiting match into resolution on sender return.
     fn take_return_match(&mut self) -> Option<H1MatchId> {
         let H1ReservationState::Installed(match_id) = self.state else {
             return None;
         };
         self.state = H1ReuseReservationState::Resolving(reuse_id);
         Some(reuse_id)
         self.state = H1ReservationState::Resolving(match_id);
         Some(match_id)
-194
+    }
-195
     /// Clears a matching reuse operation without earning a local fairness turn.
     pub(super) fn reject(&mut self, reuse_id: ReuseId) -> bool {
         if !self.names(reuse_id) {
     /// Releases a matching reservation without earning a local fairness turn.
     fn release(&mut self, match_id: H1MatchId) -> bool {
         if !self.names(match_id) {
             return false;
-200
+        }
         self.state = H1ReuseReservationState::Available;
         self.state = H1ReservationState::Available;
         true
-203
+    }
-204
     /// Completes an irreversible transfer and records any usable local turn.
     pub(super) fn complete_transfer(&mut self, reuse_id: ReuseId, local_h1_demand: bool) -> bool {
         if !matches!(self.state, H1ReuseReservationState::Resolving(current) if current == reuse_id)
--
+        {
     fn complete_transfer(&mut self, match_id: H1MatchId, local_h1_demand: bool) -> bool {
         if !matches!(self.state, H1ReservationState::Resolving(current) if current == match_id) {
             return false;
-209
+        }
         self.state = H1ReuseReservationState::Available;
         self.state = H1ReservationState::Available;
         self.local_turn_owed |= local_h1_demand;
         true
-213
+    }
-214
     /// Returns whether a usable local turn currently excludes a peer reuse operation.
     pub(super) fn blocks_peer_reuse(&self, local_h1_demand: bool) -> bool {
     /// Returns whether a usable local turn currently excludes a peer H1 match.
     fn blocks_peer_selection(&self, local_h1_demand: bool) -> bool {
         self.local_turn_owed && local_h1_demand
-218
+    }
-219
     /// Consumes an owed turn when local HTTP/1 service wins.
     pub(super) fn consume_local_turn(&mut self) -> bool {
     fn consume_local_turn(&mut self) -> bool {
         if !self.local_turn_owed {
             return false;
-224
+        }
         self.local_turn_owed = false;
         true
-227
+    }
-228
     /// Clears debt that can no longer be consumed by local demand.
     pub(super) fn clear_unused_turn(&mut self, local_h1_demand: bool) -> bool {
     fn clear_unused_turn(&mut self, local_h1_demand: bool) -> bool {
         if !self.local_turn_owed || local_h1_demand {
             return false;
-233
+        }
         self.local_turn_owed = false;
         true
-236
+    }
-237
     /// Returns whether another reuse reservation may be installed.
     pub(super) fn is_available(&self) -> bool {
         matches!(self.state, H1ReuseReservationState::Available)
     /// Returns whether another peer reservation may be installed.
     fn is_available(&self) -> bool {
         matches!(self.state, H1ReservationState::Available)
-241
+    }
-242
     /// Returns whether this reservation still names the given operation.
     pub(super) fn names(&self, reuse_id: ReuseId) -> bool {
     fn names(&self, match_id: H1MatchId) -> bool {
         matches!(
             self.state,
             H1ReuseReservationState::Installed(current) | H1ReuseReservationState::Resolving(current)
                 if current == reuse_id
             H1ReservationState::Installed(current) | H1ReservationState::Resolving(current)
                 if current == match_id
-249
+        )
-250
+    }
-251
     /// Checks relationships that are not already encoded by the state enum.
     pub(super) fn assert_consistent(&self, _supports_installed_reuse: bool) {
         #[cfg(debug_assertions)]
--
+        {
     #[cfg(any(debug_assertions, test))]
     fn assert_consistent(&self, supports_peer_reservation: bool) {
         if std::thread::panicking() {
             return;
-257
+        }
             if matches!(self.state, H1ReuseReservationState::Installed(_)) {
         if matches!(self.state, H1ReservationState::Installed(_)) {
             assert!(
                     _supports_installed_reuse,
                     "installed HTTP/1 reuse operation had no externally owned connection-owning cell record to settle it"
                 supports_peer_reservation,
                 "installed HTTP/1 peer reservation had no externally owned sender record to settle it"
             );
-263
+        }
-264
+    }
--
+    }
-265
     #[cfg(test)]
     pub(super) fn local_turn_owed(&self) -> bool {
     fn local_turn_owed(&self) -> bool {
         self.local_turn_owed
-269
+    }
-270
+}
-271
 /// Records owned by one cell and the order of reusable senders.
 /// Complete HTTP/1 sender and peer-reservation state under one cell lock.
 #[derive(Debug, Default)]
 pub(super) struct H1Records {
 pub(super) struct H1CellState {
     /// Every installed record that has not completed logical close.
     records: HashMap<ConnectionId, H1Record>,
     /// Reusable records in return order; selection takes the newest sender.
     idle: VecDeque<ConnectionId>,
     idle_order: VecDeque<ConnectionId>,
     /// Peer match that may intercept the next reusable sender return.
     peer_reservation: H1Reservation,
-281
+}
-282
 /// One cell-owned HTTP/1 connection record.
 #[derive(Debug)]
 struct H1Record {
     /// Shared logical and physical connection lifetime.
     connection: Arc<ConnectionState>,
     /// Location of the record's exclusive sender.
     residence: H1Residence,
     sender_state: H1SenderResidence,
-290
+}
-291
 /// Authoritative location of one exclusive HTTP/1 sender.
 #[derive(Debug)]
 enum H1Residence {
 enum H1SenderResidence {
     /// The sender is stored in this record and available for local selection.
     Idle {
         /// Exclusive sender available for the next local request.
         sender: H1Sender,
         /// Maintenance deadline, absent when idle expiry is disabled.
         deadline: Option<SystemTime>,
     },
     /// A request-side [`H1Selection`] or [`H1Exchange`] owns the sender.
     Selected,
     /// A [`ProvisionalH1`] owns the sender for cross-cell reuse.
     Reserved,
     ReservedForPeer,
     /// Logical close has started and no new selection or return may commit.
     Closing,
-308
+}
-309
 impl H1Records {
 impl H1CellState {
     /// Returns whether admission may install another peer reservation.
     pub(super) fn peer_reservation_available(&self) -> bool {
         self.peer_reservation.is_available()
-+
+    }
-+
     /// Returns whether fairness currently excludes peer selection.
     pub(super) fn blocks_peer_selection(&self, local_h1_demand: bool) -> bool {
         self.peer_reservation.blocks_peer_selection(local_h1_demand)
-+
+    }
-+
     /// Reserves a future sender return for one retained peer match.
     pub(super) fn reserve_waiting(&mut self, match_id: H1MatchId) -> bool {
         self.peer_reservation.reserve_waiting(match_id)
-+
+    }
-+
     /// Reserves a peer match that already owns an extracted sender.
     pub(super) fn reserve_resolving(&mut self, match_id: H1MatchId) -> bool {
         self.peer_reservation.reserve_resolving(match_id)
-+
+    }
-+
     /// Takes a waiting peer match when a reusable sender returns.
     pub(super) fn take_return_match(&mut self) -> Option<H1MatchId> {
         self.peer_reservation.take_return_match()
-+
+    }
-+
     /// Releases a peer reservation without recording a local turn.
     pub(super) fn release_peer_reservation(&mut self, match_id: H1MatchId) -> bool {
         self.peer_reservation.release(match_id)
-+
+    }
-+
     /// Returns whether the peer reservation still names `match_id`.
     pub(super) fn names_peer_reservation(&self, match_id: H1MatchId) -> bool {
         self.peer_reservation.names(match_id)
-+
+    }
-+
     /// Completes a transferred peer sender and records any local fairness turn.
     pub(super) fn complete_peer_transfer(
         &mut self,
         match_id: H1MatchId,
         local_h1_demand: bool,
     ) -> bool {
         self.peer_reservation
             .complete_transfer(match_id, local_h1_demand)
-+
+    }
-+
     /// Consumes an owed local turn after local HTTP/1 service wins.
     pub(super) fn consume_local_turn(&mut self) -> bool {
         self.peer_reservation.consume_local_turn()
-+
+    }
-+
     /// Clears fairness debt that no live local demand can consume.
     pub(super) fn clear_unused_turn(&mut self, local_h1_demand: bool) -> bool {
         self.peer_reservation.clear_unused_turn(local_h1_demand)
-+
+    }
-+
     /// Returns whether this cell owes its next usable sender to local demand.
     #[cfg(test)]
     pub(super) fn local_turn_owed(&self) -> bool {
         self.peer_reservation.local_turn_owed()
-+
+    }
-+
     /// Installs a fresh connection as selected by its launching acquisition.
     pub(super) fn install_selected(
     pub(super) fn insert_selected(
         &mut self,
         connection: Arc<ConnectionState>,
         sender: H1Sender,
     ) -> Result<OwnedH1, OwnedH1> {
         let owner = OwnedH1::new(connection, sender, false);
     ) -> Result<OwnedH1Sender, OwnedH1Sender> {
         let owner = OwnedH1Sender::new(connection, sender, false);
         if self.records.contains_key(&owner.id()) {
             return Err(owner);
-381
+        }
         self.records.insert(
             owner.id(),
             H1Record {
                 connection: owner.connection.clone(),
                 residence: H1Residence::Selected,
                 sender_state: H1SenderResidence::Selected,
             },
         );
         self.assert_consistent();
         Ok(owner)
-391
+    }
-392
     /// Installs a connection that completed without a live launching waiter.
     #[cfg(test)]
     pub(super) fn install_idle(
     pub(super) fn insert_idle(
         &mut self,
         connection: Arc<ConnectionState>,
         sender: H1Sender,
         deadline: Option<SystemTime>,
     ) -> Result<(), OwnedH1> {
         let owner = OwnedH1::new(connection, sender, true);
     ) -> Result<(), OwnedH1Sender> {
         let owner = OwnedH1Sender::new(connection, sender, true);
         if self.records.contains_key(&owner.id()) {
             return Err(owner);
-404
+        }
         let id = owner.id();
         let OwnedH1 {
         let OwnedH1Sender {
             connection, sender, ..
         } = owner;
         self.records.insert(
             id,
             H1Record {
                 connection,
                 residence: H1Residence::Idle { sender, deadline },
                 sender_state: H1SenderResidence::Idle { sender, deadline },
             },
         );
         self.idle.push_back(id);
         self.idle_order.push_back(id);
         self.assert_consistent();
         Ok(())
-419
+    }
-420
     /// Takes the most recently returned idle sender for one request.
     pub(super) fn select_idle(&mut self) -> Option<OwnedH1> {
         let id = self.idle.pop_back()?;
     pub(super) fn select_idle(&mut self) -> Option<OwnedH1Sender> {
         let id = self.idle_order.pop_back()?;
         let record = self
             .records
             .get_mut(&id)
             .expect("idle HTTP/1 record disappeared");
         if !matches!(record.residence, H1Residence::Idle { .. }) {
         if !matches!(record.sender_state, H1SenderResidence::Idle { .. }) {
             panic!("idle HTTP/1 order named a non-idle record");
-430
+        }
         let H1Residence::Idle { sender, .. } =
             std::mem::replace(&mut record.residence, H1Residence::Selected)
         let H1SenderResidence::Idle { sender, .. } =
             std::mem::replace(&mut record.sender_state, H1SenderResidence::Selected)
         else {
             unreachable!("HTTP/1 residence changed under the cell lock");
         };
         let owner = OwnedH1::new(record.connection.clone(), sender, true);
         let owner = OwnedH1Sender::new(record.connection.clone(), sender, true);
         self.assert_consistent();
         Some(owner)
-439
+    }
-440
     /// Extracts the newest idle sender into provisional return residence.
     ///
     /// A return reuse uses this path so rejection can follow the same ordinary
     /// A returning sender uses this path so rejection can follow the same ordinary
     /// return fallback as a sender intercepted after an active exchange.
     pub(super) fn take_idle_for_reuse(&mut self) -> Option<OwnedH1> {
         let id = self.idle.pop_back()?;
     pub(super) fn take_idle_candidate(&mut self) -> Option<OwnedH1Sender> {
         let id = self.idle_order.pop_back()?;
         let record = self
             .records
             .get_mut(&id)
             .expect("idle HTTP/1 record disappeared");
         let H1Residence::Idle { sender, .. } =
             std::mem::replace(&mut record.residence, H1Residence::Reserved)
         let H1SenderResidence::Idle { sender, .. } =
             std::mem::replace(&mut record.sender_state, H1SenderResidence::ReservedForPeer)
         else {
             panic!("idle HTTP/1 order named a non-idle record");
         };
         let owner = OwnedH1::new(record.connection.clone(), sender, true);
         let owner = OwnedH1Sender::new(record.connection.clone(), sender, true);
         self.assert_consistent();
         Some(owner)
-459
+    }
-460
     /// Returns whether a sender could satisfy a connection-owning cell reuse now or on return.
     /// Returns whether a sender could satisfy peer selection now or on return.
     pub(super) fn has_returnable(&self) -> bool {
         self.records.values().any(|record| {
             matches!(
                 record.residence,
                 H1Residence::Idle { .. } | H1Residence::Selected | H1Residence::Reserved
                 record.sender_state,
                 H1SenderResidence::Idle { .. }
                     | H1SenderResidence::Selected
                     | H1SenderResidence::ReservedForPeer
-469
+            )
         })
-471
+    }
-472
     /// Returns whether `owner` may still re-enter reusable return policy.
     pub(super) fn accepts_return(&self, owner: &OwnedH1) -> bool {
     pub(super) fn accepts_return(&self, owner: &OwnedH1Sender) -> bool {
         self.records.get(&owner.id()).is_some_and(|record| {
             matches!(
                 record.residence,
                 H1Residence::Selected | H1Residence::Reserved
                 record.sender_state,
                 H1SenderResidence::Selected | H1SenderResidence::ReservedForPeer
-479
+            )
         })
-481
+    }
-482
     /// Returns whether an installed reuse still has a cell-local reservation.
     /// Returns whether an installed peer reservation still has sender state.
     ///
     /// Logical close may move an externally owned sender to `Closing` before
     /// its return resolves the installed reuse, so reuse consistency is
     /// broader than current reuse eligibility.
     pub(super) fn supports_installed_reuse(&self) -> bool {
     /// its return resolves the installed match, so reservation consistency is
     /// broader than current peer selectability.
     #[cfg(any(debug_assertions, test))]
     fn supports_peer_reservation(&self) -> bool {
         self.records.values().any(|record| {
             matches!(
                 record.residence,
                 H1Residence::Selected | H1Residence::Reserved | H1Residence::Closing
                 record.sender_state,
                 H1SenderResidence::Selected
                     | H1SenderResidence::ReservedForPeer
                     | H1SenderResidence::Closing
-496
+            )
         })
-498
+    }
-499
     /// Reserves an external sender for cross-cell reuse.
     pub(super) fn reserve_for_reuse(&mut self, owner: &OwnedH1) -> bool {
     pub(super) fn reserve_for_peer(&mut self, owner: &OwnedH1Sender) -> bool {
         let Some(record) = self.records.get_mut(&owner.id()) else {
             return false;
         };
         match record.residence {
             H1Residence::Selected => {
                 record.residence = H1Residence::Reserved;
         match record.sender_state {
             H1SenderResidence::Selected => {
                 record.sender_state = H1SenderResidence::ReservedForPeer;
                 self.assert_consistent();
                 true
-510
+            }
             H1Residence::Reserved => true,
             H1Residence::Idle { .. } | H1Residence::Closing => false,
             H1SenderResidence::ReservedForPeer => true,
             H1SenderResidence::Idle { .. } | H1SenderResidence::Closing => false,
-513
+        }
-514
+    }
-515
     /// Restores a returned sender to idle storage.
     pub(super) fn return_idle(
         &mut self,
         owner: OwnedH1,
         owner: OwnedH1Sender,
         deadline: Option<SystemTime>,
     ) -> Result<(), OwnedH1> {
     ) -> Result<(), OwnedH1Sender> {
         let Some(record) = self.records.get_mut(&owner.id()) else {
             return Err(owner);
         };
         if !matches!(
             record.residence,
             H1Residence::Selected | H1Residence::Reserved
             record.sender_state,
             H1SenderResidence::Selected | H1SenderResidence::ReservedForPeer
         ) {
             return Err(owner);
-530
+        }
         let id = owner.id();
         let OwnedH1 { sender, .. } = owner;
         record.residence = H1Residence::Idle { sender, deadline };
         self.idle.push_back(id);
         let OwnedH1Sender { sender, .. } = owner;
         record.sender_state = H1SenderResidence::Idle { sender, deadline };
         self.idle_order.push_back(id);
         self.assert_consistent();
         Ok(())
-537
+    }
-538
     /// Commits a selected or returning sender to a waiting request.
     pub(super) fn commit_return_to_waiter(&mut self, owner: &OwnedH1) -> bool {
     pub(super) fn commit_return_to_waiter(&mut self, owner: &OwnedH1Sender) -> bool {
         let Some(record) = self.records.get_mut(&owner.id()) else {
             return false;
         };
         match record.residence {
             H1Residence::Selected => true,
             H1Residence::Reserved => {
                 record.residence = H1Residence::Selected;
         match record.sender_state {
             H1SenderResidence::Selected => true,
             H1SenderResidence::ReservedForPeer => {
                 record.sender_state = H1SenderResidence::Selected;
                 self.assert_consistent();
                 true
-550
+            }
             H1Residence::Idle { .. } | H1Residence::Closing => false,
             H1SenderResidence::Idle { .. } | H1SenderResidence::Closing => false,
-552
+        }
-553
+    }
-554
     /// Marks a selected or returning sender as closing.
     ///
     /// The caller still owns the sender and must complete logical close after
     /// releasing the cell lock.
     pub(super) fn close_owned(&mut self, owner: &OwnedH1) -> bool {
     pub(super) fn close_owned(&mut self, owner: &OwnedH1Sender) -> bool {
         let should_close = match self.records.get_mut(&owner.id()) {
             Some(record) => match record.residence {
                 H1Residence::Selected | H1Residence::Reserved => {
                     record.residence = H1Residence::Closing;
             Some(record) => match record.sender_state {
                 H1SenderResidence::Selected | H1SenderResidence::ReservedForPeer => {
                     record.sender_state = H1SenderResidence::Closing;
                     true
-565
+                }
                 H1Residence::Closing => false,
                 H1Residence::Idle { .. } => {
                 H1SenderResidence::Closing => false,
                 H1SenderResidence::Idle { .. } => {
                     panic!("externally owned HTTP/1 sender was recorded as idle")
-569
+                }
             },
             None => true,
         };
         self.assert_consistent();
         should_close
-575
+    }
-576
     /// Starts close for a record named without its external sender.
     ///
     /// Idle close extracts the sender. Selected and returning records stay
     /// represented as `Closing` until their external owner comes back.
     pub(super) fn begin_close(&mut self, id: ConnectionId) -> Option<CloseRecord> {
     pub(super) fn begin_close(&mut self, id: ConnectionId) -> Option<H1CloseTransition> {
         let record = self.records.get_mut(&id)?;
         let connection = record.connection.clone();
         let sender = match &record.residence {
             H1Residence::Idle { .. } => {
         let sender = match &record.sender_state {
             H1SenderResidence::Idle { .. } => {
                 let position = self
                     .idle
                     .idle_order
                     .iter()
                     .position(|candidate| *candidate == id)
                     .expect("idle HTTP/1 record was absent from idle order");
                 self.idle.remove(position);
                 let H1Residence::Idle { sender, .. } =
                     std::mem::replace(&mut record.residence, H1Residence::Closing)
                 self.idle_order.remove(position);
                 let H1SenderResidence::Idle { sender, .. } =
                     std::mem::replace(&mut record.sender_state, H1SenderResidence::Closing)
                 else {
                     unreachable!("HTTP/1 residence changed under the cell lock");
                 };
                 Some(sender)
-598
+            }
             H1Residence::Selected | H1Residence::Reserved => {
                 record.residence = H1Residence::Closing;
             H1SenderResidence::Selected | H1SenderResidence::ReservedForPeer => {
                 record.sender_state = H1SenderResidence::Closing;
                 None
-602
+            }
             H1Residence::Closing => return None,
             H1SenderResidence::Closing => return None,
         };
         self.assert_consistent();
         Some(CloseRecord { connection, sender })
         Some(H1CloseTransition { connection, sender })
-607
+    }
-608
     /// Removes a record after logical close and sender destruction complete.
     pub(super) fn finish_close(&mut self, id: ConnectionId) {
     pub(super) fn remove_closed(&mut self, id: ConnectionId) {
         let Some(record) = self.records.get(&id) else {
             return;
         };
         if !matches!(record.residence, H1Residence::Closing) {
         if !matches!(record.sender_state, H1SenderResidence::Closing) {
             return;
-616
+        }
         self.records.remove(&id);
         self.assert_consistent();
-619
+    }
-620
     /// Returns the installed record and idle counts.
     #[cfg(test)]
     pub(super) fn counts(&self) -> (usize, usize) {
         (self.records.len(), self.idle.len())
         (self.records.len(), self.idle_order.len())
-625
+    }
-626
     /// Returns the sole installed connection for focused dispatch tests.
     #[cfg(all(test, feature = "rt-tokio"))]
     pub(super) fn only_connection_for_test(&self) -> Arc<ConnectionState> {
         assert_eq!(
 ,
             self.records.len(),
             "expected exactly one installed HTTP/1 record"
         );
         self.records
             .values()
             .next()
             .expect("HTTP/1 record count changed under the cell lock")
             .connection
             .clone()
-641
+    }
-642
     /// Returns idle records whose configured deadline has elapsed.
     pub(super) fn expired_idle(&self, now: SystemTime) -> Vec<ConnectionId> {
         self.idle
         self.idle_order
             .iter()
             .copied()
             .filter(|id| {
                 matches!(
                     self.records.get(id).map(|record| &record.residence),
                     Some(H1Residence::Idle {
                     self.records.get(id).map(|record| &record.sender_state),
                     Some(H1SenderResidence::Idle {
                         deadline: Some(deadline),
                         ..
                     }) if *deadline <= now
-655
+                )
             })
             .collect()
-658
+    }
-659
     /// Returns the nearest configured deadline among reusable senders.
     pub(super) fn nearest_idle_deadline(&self) -> Option<SystemTime> {
         self.idle
         self.idle_order
             .iter()
             .filter_map(|id| {
                 match &self
                     .records
                     .get(id)
                     .expect("idle HTTP/1 record disappeared")
                     .residence
                     .sender_state
-670
+                {
                     H1Residence::Idle { deadline, .. } => *deadline,
                     H1SenderResidence::Idle { deadline, .. } => *deadline,
                     _ => unreachable!("idle HTTP/1 order named a non-idle record"),
-673
+                }
             })
             .min()
-676
+    }
-677
     /// Returns every installed record identity for pool-wide shutdown.
     pub(super) fn connection_ids(&self) -> Vec<ConnectionId> {
         self.records.keys().copied().collect()
-681
+    }
-682
     /// Checks that idle records and the idle order describe the same set.
     pub(super) fn assert_consistent(&self) {
         #[cfg(debug_assertions)]
         #[cfg(any(debug_assertions, test))]
-686
+        {
             if std::thread::panicking() {
                 return;
-689
+            }
             self.peer_reservation
                 .assert_consistent(self.supports_peer_reservation());
             let idle_records = self
                 .records
                 .values()
                 .filter(|record| matches!(record.residence, H1Residence::Idle { .. }))
                 .filter(|record| matches!(record.sender_state, H1SenderResidence::Idle { .. }))
                 .count();
             assert_eq!(
                 idle_records,
                 self.idle.len(),
                 self.idle_order.len(),
                 "HTTP/1 idle count did not match idle order"
             );
             let mut seen = HashMap::new();
             for id in &self.idle {
             for id in &self.idle_order {
                 assert!(
                     matches!(
                         self.records.get(id).map(|record| &record.residence),
                         Some(H1Residence::Idle { .. })
                         self.records.get(id).map(|record| &record.sender_state),
                         Some(H1SenderResidence::Idle { .. })
                     ),
                     "HTTP/1 idle order named a missing or non-idle record"
                 );
                 assert!(
                     seen.insert(*id, ()).is_none(),
                     "HTTP/1 idle order contained a duplicate record"
                 );
-715
+            }
-716
+        }
-717
+    }
-718
+}
-719
 /// Exclusive sender and connection state detached from a connection-owning cell record.
 #[derive(Debug)]
 pub(super) struct OwnedH1 {
 pub(super) struct OwnedH1Sender {
     /// Shared lifetime state for the physical connection.
     connection: Arc<ConnectionState>,
     /// The one Hyper HTTP/1 sender for the connection.
     sender: H1Sender,
     /// Whether this sender came from an already installed reusable record.
     reused: bool,
-729
+}
-730
 impl OwnedH1 {
 impl OwnedH1Sender {
     /// Creates detached sender ownership.
     fn new(connection: Arc<ConnectionState>, sender: H1Sender, reused: bool) -> Self {
         Self {
             connection,
             sender,
             reused,
-738
+        }
-739
+    }
-740
     /// Returns the installed connection identity.
     pub(super) fn id(&self) -> ConnectionId {
         self.connection.id()
-744
+    }
-745
     /// Returns whether this selection came from an existing reusable record.
     pub(super) fn is_reused(&self) -> bool {
         self.reused
-749
+    }
-750
     /// Marks the next request as reusing an already established connection.
     pub(super) fn mark_reused(&mut self) {
         self.reused = true;
-754
+    }
-755
     /// Returns the shared connection state.
     pub(super) fn connection(&self) -> &Arc<ConnectionState> {
         &self.connection
-759
+    }
-760
     /// Returns the exclusive sender.
     pub(super) fn sender_mut(&mut self) -> &mut H1Sender {
         &mut self.sender
-764
+    }
-765
     /// Returns the synthetic sender identity.
     #[cfg(test)]
     pub(super) fn test_sender_id(&self) -> u64 {
         self.sender.test_id()
-770
+    }
-771
+}
-772
 /// Returns an external sender to its connection-owning cell.
 ///
 /// A sender whose cell was torn down closes its connection directly.
 fn return_to_connection_cell(connection_cell: &Weak<OriginCell>, owner: OwnedH1) {
 fn return_to_connection_cell(connection_cell: &Weak<OriginCell>, owner: OwnedH1Sender) {
     if let Some(connection_cell) = connection_cell.upgrade() {
         OriginCell::return_h1_owner(&connection_cell, owner);
     } else {
         owner.connection().logical_close(CloseReason::PoolDropped);
         drop(owner);
-782
+    }
-783
+}
-784
 /// Retires an external sender through its connection-owning cell.
 ///
 /// A sender whose cell was torn down closes its connection directly.
 fn retire_at_connection_cell(
     connection_cell: &Weak<OriginCell>,
     owner: OwnedH1,
     owner: OwnedH1Sender,
     reason: CloseReason,
 ) {
     if let Some(connection_cell) = connection_cell.upgrade() {
         OriginCell::retire_h1_owner(&connection_cell, owner, reason);
     } else {
         owner.connection().logical_close(reason);
         drop(owner);
-798
+    }
-799
+}
-800
 /// State detached when close begins for a record named by identity.
 pub(super) struct CloseRecord {
 pub(super) struct H1CloseTransition {
     /// Connection whose logical lifetime close must end.
     pub(super) connection: Arc<ConnectionState>,
     /// Idle sender extracted for destruction, if close found one in the cell.
     pub(super) sender: Option<H1Sender>,
-807
+}
-808
 /// Exclusive sender checked out for readiness and one request dispatch.
 ///
 /// Local selection, successful establishment, or peer reuse creates this value
 /// while the installed record is `Selected`. The value alone may use the
 /// sender. Hyper accepting the request transfers ownership to [`H1Exchange`];
 /// explicit retirement closes the installed record. Dropping an undispatched
 /// selection returns the sender through ordinary connection-owning-cell policy.
 pub(in crate::client::pool) struct H1Selection {
     /// Non-retaining reference to the cell that owns the installed record.
     connection_cell: Weak<OriginCell>,
     /// Sender ownership until return, retirement, or response transfer.
     owner: Option<OwnedH1>,
     owner: Option<OwnedH1Sender>,
-821
+}
-822
 impl H1Selection {
     /// Creates a selected sender owned outside the connection-owning cell lock.
     pub(super) fn new(connection_cell: &Arc<OriginCell>, owner: OwnedH1) -> Self {
     pub(super) fn new(connection_cell: &Arc<OriginCell>, owner: OwnedH1Sender) -> Self {
         Self {
             connection_cell: Weak::from_arc(connection_cell),
             owner: Some(owner),
-829
+        }
-830
+    }
-831
     /// Returns this selection's physical connection identity.
     pub(in crate::client::pool) fn connection_id(&self) -> ConnectionId {
         self.owner
             .as_ref()
             .expect("HTTP/1 selection consumed more than once")
             .id()
-838
+    }
-839
     /// Returns whether this sender came from a reusable installed record.
     pub(in crate::client::pool) fn is_reused(&self) -> bool {
         self.owner
             .as_ref()
             .expect("HTTP/1 selection consumed more than once")
             .is_reused()
-846
+    }
-847
     /// Returns the selected connection state.
     pub(in crate::client::pool) fn connection(&self) -> &Arc<ConnectionState> {
         self.owner
             .as_ref()
             .expect("HTTP/1 selection consumed more than once")
             .connection()
-854
+    }
-855
     /// Returns the exclusive sender for readiness and dispatch.
     pub(in crate::client::pool) fn sender_mut(&mut self) -> &mut H1Sender {
         self.owner
             .as_mut()
             .expect("HTTP/1 selection consumed more than once")
             .sender_mut()
-862
+    }
-863
     /// Transfers the sender after Hyper accepts the request.
     ///
     /// The installed record remains `Selected`; [`H1Exchange`] now owns the
     /// sender until the response proves reuse or requires retirement.
     pub(in crate::client::pool) fn into_exchange(mut self) -> H1Exchange {
         H1Exchange {
             connection_cell: self.connection_cell.clone(),
             owner: self.owner.take(),
-872
+        }
-873
+    }
-874
     /// Returns non-retaining close authority for this selected generation.
     /// Returns non-retaining close authority for this selected connection.
     pub(in crate::client::pool) fn close_handle(&self) -> H1CloseHandle {
         let owner = self
             .owner
             .as_ref()
             .expect("HTTP/1 selection consumed more than once");
         H1CloseHandle {
             connection_cell: self.connection_cell.clone(),
             connection: Weak::from_arc(owner.connection()),
             id: owner.id(),
             connection_id: owner.id(),
-885
+        }
-886
+    }
-887
     /// Retires this selection instead of returning it for reuse.
     pub(in crate::client::pool) fn retire_connection(mut self, reason: CloseReason) {
         if let Some(owner) = self.owner.take() {
             retire_at_connection_cell(&self.connection_cell, owner, reason);
-892
+        }
-893
+    }
-894
     /// Returns the synthetic sender identity.
     #[cfg(test)]
     pub(super) fn test_sender_id(&self) -> u64 {
         self.owner
             .as_ref()
             .expect("HTTP/1 selection consumed more than once")
             .test_sender_id()
-902
+    }
-903
+}
-904
 impl fmt::Debug for H1Selection {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("H1Selection")
             .field(
                 "connection-owning cell",
                 &self
                     .connection_cell
                     .upgrade()
                     .map(|connection_cell| connection_cell.id().clone()),
-914
+            )
             .field("connection_id", &self.owner.as_ref().map(OwnedH1::id))
             .field("connection_id", &self.owner.as_ref().map(OwnedH1Sender::id))
             .finish()
-917
+    }
-918
+}
-919
 impl Drop for H1Selection {
     fn drop(&mut self) {
         if let Some(owner) = self.owner.take() {
             return_to_connection_cell(&self.connection_cell, owner);
-924
+        }
-925
+    }
-926
+}
-927
 /// Exclusive sender for a request Hyper accepted on this connection.
 ///
 /// The installed record remains `Selected` while response-body processing owns
 /// this value. After a complete response and successful Hyper readiness,
 /// [`H1Exchange::offer_for_reuse`] runs owning-cell return arbitration.
 /// Explicit retirement handles protocol failure or upgrade. Dropping the
 /// exchange means a reusable message boundary was not proven and closes the
 /// connection as an incomplete HTTP/1 exchange.
 pub(in crate::client::pool) struct H1Exchange {
     /// Non-retaining reference to the cell that owns the selected record.
     connection_cell: Weak<OriginCell>,
     /// Sender held until Hyper proves it may return.
     owner: Option<OwnedH1>,
     owner: Option<OwnedH1Sender>,
-941
+}
-942
 impl H1Exchange {
     /// Returns whether Hyper already permits another request.
     pub(in crate::client::pool) fn is_ready(&self) -> bool {
         self.owner
             .as_ref()
             .expect("HTTP/1 exchange consumed more than once")
             .sender
             .is_ready()
-951
+    }
-952
     /// Polls Hyper for proof that the sender can accept another request.
     pub(in crate::client::pool) fn poll_ready(
         &mut self,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), hyper::Error>> {
         self.owner
             .as_mut()
             .expect("HTTP/1 exchange consumed more than once")
             .sender_mut()
             .hyper_mut()
             .poll_ready(cx)
-964
+    }
-965
     /// Offers a proven-ready sender to owning-cell reuse policy.
     pub(in crate::client::pool) fn offer_for_reuse(mut self) {
         let mut owner = self
             .owner
             .take()
             .expect("HTTP/1 exchange consumed more than once");
         owner.mark_reused();
         return_to_connection_cell(&self.connection_cell, owner);
-974
+    }
-975
     /// Retires the sender instead of returning it to the connection-owning cell.
     pub(in crate::client::pool) fn retire_connection(mut self, reason: CloseReason) {
         if let Some(owner) = self.owner.take() {
             let upgrade = (reason == CloseReason::Upgraded).then(|| owner.connection().clone());
             retire_at_connection_cell(&self.connection_cell, owner, reason);
             if let Some(connection) = upgrade {
                 connection.refine_protocol_close_as_upgrade();
                 #[cfg(debug_assertions)]
                 #[cfg(any(debug_assertions, test))]
                 connection.debug_assert_close_reason(CloseReason::Upgraded);
-985
+            }
-986
+        }
-987
+    }
-988
+}
-989
 impl fmt::Debug for H1Exchange {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("H1Exchange")
             .field(
                 "connection-owning cell",
                 &self
                     .connection_cell
                     .upgrade()
                     .map(|connection_cell| connection_cell.id().clone()),
-999
+            )
             .field("connection_id", &self.owner.as_ref().map(OwnedH1::id))
             .field("connection_id", &self.owner.as_ref().map(OwnedH1Sender::id))
             .finish()
-1002
+    }
-1003
+}
-1004
 impl Drop for H1Exchange {
     fn drop(&mut self) {
         if let Some(owner) = self.owner.take() {
             retire_at_connection_cell(
                 &self.connection_cell,
                 owner,
                 CloseReason::IncompleteH1Exchange,
             );
-1013
+        }
-1014
+    }
-1015
+}
-1016
 /// Sender temporarily detached from a `Reserved` record for peer reuse.
 /// Sender temporarily detached from a `ReservedForPeer` record.
 ///
 /// Reuse arbitration creates this value before crossing from the
 /// Admission matching creates this value before crossing from the
 /// connection-owning cell to a requesting cell. A successful borrow converts
 /// it into [`H1Selection`]; reclaim closes the connection and releases its
 /// capacity. Rejection, cancellation, or `Drop` returns the sender through
 /// ordinary connection-owning-cell policy.
 pub(in crate::client::pool) struct ProvisionalH1 {
     /// Non-retaining connection-owning cell whose record remains in `Reserved`.
     /// Non-retaining owning cell whose record remains `ReservedForPeer`.
     connection_cell: Weak<OriginCell>,
     /// Sender reserved by the provisional action.
     owner: Option<OwnedH1>,
     owner: Option<OwnedH1Sender>,
-1029
+}
-1030
 impl ProvisionalH1 {
     /// Creates a provisional owner for a sender extracted by reuse arbitration.
     pub(super) fn new(connection_cell: &Arc<OriginCell>, owner: OwnedH1) -> Self {
     /// Creates a provisional owner for a sender extracted by admission matching.
     pub(super) fn new(connection_cell: &Arc<OriginCell>, owner: OwnedH1Sender) -> Self {
         Self {
             connection_cell: Weak::from_arc(connection_cell),
             owner: Some(owner),
-1037
+        }
-1038
+    }
-1039
     /// Returns the selected connection identity without consuming the sender.
     pub(in crate::client::pool) fn connection_id(&self) -> ConnectionId {
         self.owner
             .as_ref()
             .expect("provisional HTTP/1 sender consumed more than once")
             .id()
-1046
+    }
-1047
     /// Transfers the cell reference and sender into the next reuse transition.
     pub(super) fn into_parts(mut self) -> (Weak<OriginCell>, OwnedH1) {
     /// Transfers the cell reference and sender into the next match transition.
     pub(super) fn into_parts(mut self) -> (Weak<OriginCell>, OwnedH1Sender) {
         let owner = self
             .owner
             .take()
             .expect("provisional HTTP/1 sender consumed more than once");
         (self.connection_cell.clone(), owner)
-1055
+    }
-1056
     /// Restores provisional ownership when a reuse transition cannot commit.
     pub(super) fn from_parts(connection_cell: Weak<OriginCell>, owner: OwnedH1) -> Self {
     /// Restores provisional ownership when a match transition cannot commit.
     pub(super) fn from_parts(connection_cell: Weak<OriginCell>, owner: OwnedH1Sender) -> Self {
         Self {
             connection_cell,
             owner: Some(owner),
-1062
+        }
-1063
+    }
-1064
+}
-1065
 impl fmt::Debug for ProvisionalH1 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ProvisionalH1")
             .field(
                 "connection-owning cell",
                 &self
                     .connection_cell
                     .upgrade()
                     .map(|connection_cell| connection_cell.id().clone()),
-1075
+            )
             .field("connection_id", &self.owner.as_ref().map(OwnedH1::id))
             .field("connection_id", &self.owner.as_ref().map(OwnedH1Sender::id))
             .finish()
-1078
+    }
-1079
+}
-1080
 impl Drop for ProvisionalH1 {
     fn drop(&mut self) {
         if let Some(owner) = self.owner.take() {
             return_to_connection_cell(&self.connection_cell, owner);
-1085
+        }
-1086
+    }
-1087
+}
-1088
 /// Non-retaining authority to retire one installed H1 record.
 #[derive(Clone, Debug)]
 pub(in crate::client::pool) struct H1CloseHandle {
     /// Connection-owning cell used to remove dispatch eligibility before
     /// logical close.
     connection_cell: Weak<OriginCell>,
     /// Core fallback when the connection-owning cell no longer exists.
     connection: Weak<ConnectionState>,
     /// Generation identity rejected by stale close actions.
     id: ConnectionId,
     connection_id: ConnectionId,
-1099
+}
-1100
 impl H1CloseHandle {
     /// Creates a close handle for a newly installed H1 record.
     pub(in crate::client::pool) fn new(
         connection_cell: &Arc<OriginCell>,
         connection: &Arc<ConnectionState>,
     ) -> Self {
         Self {
             connection_cell: Weak::from_arc(connection_cell),
             connection: Weak::from_arc(connection),
             id: connection.id(),
             connection_id: connection.id(),
-1111
+        }
-1112
+    }
-1113
     /// Begins logical close and returns whether this signal won.
     pub(in crate::client::pool) fn close(&self, reason: CloseReason) -> bool {
         if let Some(connection_cell) = self.connection_cell.upgrade() {
             return OriginCell::close_h1(&connection_cell, self.id, reason);
             return OriginCell::close_h1(&connection_cell, self.connection_id, reason);
-1118
+        }
         self.connection
             .upgrade()
             .is_some_and(|connection| connection.logical_close(reason))
-1122
+    }
-1123
+}
-1124
 /// Driver-owned fallback that closes its H1 record on termination.
 #[derive(Debug)]
 pub(in crate::client::pool) struct H1DriverGuard {
     /// Non-retaining generation close authority.
     /// Non-retaining connection close authority.
     close: H1CloseHandle,
     /// Whether drop still represents owner-runtime shutdown.
     active: bool,
-1132
+}
-1133
 impl H1DriverGuard {
     /// Arms driver-lifecycle cleanup for an installed H1 record.
     pub(in crate::client::pool) fn new(close: H1CloseHandle) -> Self {
         Self {
             close,
             active: true,
-1140
+        }
-1141
+    }
-1142
     /// Records ordinary protocol-driver completion.
     pub(in crate::client::pool) fn protocol_closed(mut self) {
         self.active = false;
         self.close.close(CloseReason::ProtocolClosed);
-1147
+    }
-1148
+}
-1149
 impl Drop for H1DriverGuard {
     fn drop(&mut self) {
         if self.active {
             self.close.close(CloseReason::OwnerRuntimeShutdown);
-1154
+        }
-1155
+    }
-1156
+}
-1157
 impl OriginCell {
     /// Installs a fresh H1 record selected by its launching request.
     ///
     /// # Panics
     ///
     /// Panics if this cell already contains the connection identity.
     pub(in crate::client::pool) fn install_selected_h1(
     pub(in crate::client::pool) fn insert_selected_h1(
         cell: &Arc<Self>,
         connection: Arc<ConnectionState>,
         sender: H1Sender,
     ) -> H1Selection {
         let (installed, availability) = {
         let (installed, supply_update) = {
             let mut state = cell.state.lock();
             let installed = state.h1.install_selected(connection, sender);
             let installed = state.h1.insert_selected(connection, sender);
             state.assert_consistent();
             (installed, state.take_h1_availability_update())
             (installed, state.take_h1_supply_update())
         };
         cell.publish_h1_availability(availability);
         cell.submit_h1_supply_update(supply_update);
         match installed {
             Ok(owner) => H1Selection::new(cell, owner),
             Err(owner) => {
                 owner
                     .connection()
                     .logical_close(CloseReason::ProtocolClosed);
                 drop(owner);
                 panic!("duplicate HTTP/1 connection identity installed in one cell");
-1184
+            }
-1185
+        }
-1186
+    }
-1187
     /// Installs an H1 record whose launching acquisition already completed.
     ///
     /// # Panics
     ///
     /// Panics if this cell already contains the connection identity.
     #[cfg(test)]
     pub(in crate::client::pool) fn install_idle_h1(
     pub(in crate::client::pool) fn insert_idle_h1(
         cell: &Arc<Self>,
         connection: Arc<ConnectionState>,
         sender: H1Sender,
     ) {
         let deadline = cell.idle_deadline();
         let (installed, availability) = {
         let (installed, supply_update) = {
             let mut state = cell.state.lock();
             let installed = state.h1.install_idle(connection, sender, deadline);
             let installed = state.h1.insert_idle(connection, sender, deadline);
             state.assert_consistent();
             (installed, state.take_h1_availability_update())
             (installed, state.take_h1_supply_update())
         };
         cell.publish_h1_availability(availability);
         cell.submit_h1_supply_update(supply_update);
         if let Err(owner) = installed {
             owner
                 .connection()
                 .logical_close(CloseReason::ProtocolClosed);
             drop(owner);
             panic!("duplicate HTTP/1 connection identity installed in one cell");
-1213
+        }
         cell.notify_maintenance(deadline);
-1215
+    }
-1216
     /// Selects the newest reusable H1 sender without origin-wide coordination.
     pub(in crate::client::pool) fn select_h1(cell: &Arc<Self>) -> Option<H1Selection> {
         let (owner, availability) = {
         let (owner, supply_update) = {
             let mut state = cell.state.lock();
             let owner = state.h1.select_idle();
             if owner.is_some() {
                 state.reuse.consume_local_turn();
                 state.h1.consume_local_turn();
-1224
+            }
             state.assert_consistent();
             let availability = cell
             let supply_update = cell
                 .admission
                 .as_ref()
                 .and_then(|_| state.take_h1_availability_update());
             (owner, availability)
                 .and_then(|_| state.take_h1_supply_update());
             (owner, supply_update)
         };
         cell.publish_h1_availability(availability);
         cell.submit_h1_supply_update(supply_update);
         let owner = owner?;
         Some(H1Selection::new(cell, owner))
-1235
+    }
-1236
     /// Reserves this cell's selected connection for one peer reuse operation.
     pub(in crate::client::pool) fn install_h1_reuse(
     /// Commits one admission-selected supplier reservation at this cell.
     pub(in crate::client::pool) fn commit_h1_reservation(
         cell: &Arc<Self>,
         origin: Arc<OriginAdmission>,
         prepared: PreparedReuseInstall,
         admission: Arc<OriginAdmission>,
         prepared: PreparedH1Reservation,
     ) -> Option<AdmissionAction> {
         let decision = {
             let mut state = cell.state.lock();
             state.install_reuse(prepared.id)
             state.commit_h1_reservation(prepared.match_id)
         };
-1247
         let result = match decision {
             ReuseInstall::Installed => ReuseInstallResult::Installed,
             ReuseInstall::Candidate(owner) => {
         let decision = decision.map_candidate(|owner| {
             let provisional = ProvisionalH1::new(cell, owner);
                 ReuseInstallResult::Candidate(ReuseCandidate::new(
                     origin.clone(),
                     prepared.id,
             H1Candidate::new(
                 admission.clone(),
                 prepared.match_id,
                 cell.id.partition(),
                 provisional,
                 ))
--
+            }
             ReuseInstall::Rejected(availability) => ReuseInstallResult::Rejected(availability),
         };
         OriginAdmission::finish_h1_reuse_install(&origin, prepared.id, cell.id.partition(), result)
-+
+            )
         });
         OriginAdmission::settle_h1_reservation(
             &admission,
             prepared.match_id,
             cell.id.partition(),
             decision,
-+
+        )
-1263
+    }
-1264
     /// Clears an installed or resolving reservation after request cancellation.
     pub(in crate::client::pool) fn cancel_h1_reuse(
     pub(in crate::client::pool) fn cancel_h1_reservation(
         &self,
         reuse_id: ReuseId,
     ) -> H1AvailabilitySnapshot {
         self.state.lock().cancel_reuse(reuse_id)
         match_id: H1MatchId,
     ) -> SupplyRevision<H1SupplyStatus> {
         self.state.lock().cancel_h1_reservation(match_id)
-1271
+    }
-1272
     /// Returns a rejected provisional sender through ordinary connection-owning cell handling.
     pub(in crate::client::pool) fn reject_h1_reuse_candidate(
     pub(in crate::client::pool) fn reject_h1_match(
         cell: &Arc<Self>,
         reuse_id: ReuseId,
         match_id: H1MatchId,
         provisional: ProvisionalH1,
     ) -> H1AvailabilitySnapshot {
     ) -> SupplyRevision<H1SupplyStatus> {
-1279
+        {
             let mut state = cell.state.lock();
             state.reject_reuse_candidate(reuse_id);
             state.reject_h1_match(match_id);
-1282
+        }
         drop(provisional);
         let mut state = cell.state.lock();
         state.assert_consistent();
         state.report_h1_availability()
         state.current_h1_supply_revision()
-1287
+    }
-1288
     /// Revalidates a reuse operation and commits its provisional sender for dispatch.
     pub(in crate::client::pool) fn commit_h1_reuse(
     /// Revalidates one match and commits its provisional sender for dispatch.
     pub(in crate::client::pool) fn commit_h1_match(
         cell: &Arc<Self>,
         reuse_id: ReuseId,
         match_id: H1MatchId,
         provisional: ProvisionalH1,
     ) -> Result<H1Selection, ProvisionalH1> {
         let (connection_cell, owner) = provisional.into_parts();
         let committed = cell.state.lock().commit_reuse(reuse_id, &owner);
         let committed = cell.state.lock().commit_h1_match(match_id, &owner);
         if committed {
             Ok(H1Selection::new(cell, owner))
         } else {
             Err(ProvisionalH1::from_parts(connection_cell, owner))
-1301
+        }
-1302
+    }
-1303
     /// Closes a selected sender and records fairness only if close wins.
     pub(in crate::client::pool) fn reclaim_h1_reuse(
     pub(in crate::client::pool) fn reclaim_h1_candidate(
         cell: &Arc<Self>,
         reuse_id: ReuseId,
         match_id: H1MatchId,
         provisional: ProvisionalH1,
     ) -> Result<(H1AvailabilitySnapshot, bool), ProvisionalH1> {
     ) -> Result<(SupplyRevision<H1SupplyStatus>, bool), ProvisionalH1> {
         let (connection_cell, owner) = provisional.into_parts();
         if !cell.state.lock().reuse.names(reuse_id) {
         if !cell.state.lock().h1.names_peer_reservation(match_id) {
             return Err(ProvisionalH1::from_parts(connection_cell, owner));
-1313
+        }
-1314
         let close_won = Self::retire_h1_owner(cell, owner, CloseReason::Reclaimed);
         let availability = {
         let supply_update = {
             let mut state = cell.state.lock();
             let availability = state.finish_reuse(reuse_id, close_won);
             let revision = state.complete_h1_match(match_id, close_won);
             state.assert_consistent();
             availability
             revision
         };
         Ok((availability, close_won))
         Ok((supply_update, close_won))
-1323
+    }
-1324
     /// Completes local reuse state after a requesting cell accepts the sender.
     pub(in crate::client::pool) fn complete_h1_reuse(
     /// Completes local match state after a requesting cell accepts the sender.
     pub(in crate::client::pool) fn complete_h1_match(
         &self,
         reuse_id: ReuseId,
         match_id: H1MatchId,
         transferred: bool,
     ) -> H1AvailabilitySnapshot {
         self.state.lock().finish_reuse(reuse_id, transferred)
     ) -> SupplyRevision<H1SupplyStatus> {
         self.state.lock().complete_h1_match(match_id, transferred)
-1332
+    }
-1333
     /// Publishes this cell's HTTP/1 availability when the origin is bounded.
     pub(super) fn publish_h1_availability(&self, availability: Option<H1AvailabilitySnapshot>) {
         if let (Some(admission), Some(availability)) = (&self.admission, availability) {
             OriginAdmission::update_h1_availability(
     /// Submits this cell's changed HTTP/1 supply when the origin is bounded.
     pub(super) fn submit_h1_supply_update(&self, revision: Option<SupplyRevision<H1SupplyStatus>>) {
         if let (Some(admission), Some(revision)) = (&self.admission, revision) {
             OriginAdmission::apply_h1_supply_revision(
                 admission,
                 self.id.partition(),
                 self.eligibility_group.clone(),
                 availability,
                 revision,
             );
-1343
+        }
-1344
+    }
-1345
     /// Returns a reusable sender to the oldest compatible waiter or idle set.
     ///
     /// Demand publication, task wakeup, and any rejected-result fallback all
     /// run after the cell lock is released. `owner` remains outside the locked
     /// scope so sender or connection drop cannot run while the cell guard is
     /// live.
     fn return_h1_owner(cell: &Arc<Self>, owner: OwnedH1) {
     fn return_h1_owner(cell: &Arc<Self>, owner: OwnedH1Sender) {
         let connection_id = owner.id();
         let mut owner = Some(owner);
         let mut installation = None;
         let mut intercepted = None;
         let mut rejected_reuse = None;
         let mut rejected_match = None;
         let idle_deadline = cell.idle_deadline();
         let should_retire = {
             let mut state = cell.state.lock();
             let returnable = state
                 .h1
                 .accepts_return(owner.as_ref().expect("HTTP/1 owner disappeared"));
             if !returnable {
                 if let Some(reuse_id) = state.reuse.intercept_return() {
                     let snapshot = state.finish_reuse(reuse_id, false);
                     rejected_reuse = Some((reuse_id, snapshot));
                 if let Some(match_id) = state.h1.take_return_match() {
                     let revision = state.complete_h1_match(match_id, false);
                     rejected_match = Some((match_id, revision));
                 } else {
                     state.assert_consistent();
-1370
+                }
                 true
             } else if let Some(reuse_id) = state.reuse.intercept_return() {
             } else if let Some(match_id) = state.h1.take_return_match() {
                 if state
                     .h1
                     .reserve_for_reuse(owner.as_ref().expect("HTTP/1 owner disappeared"))
                     .reserve_for_peer(owner.as_ref().expect("HTTP/1 owner disappeared"))
-1376
+                {
                     state.assert_consistent();
                     intercepted = Some((
                         reuse_id,
                         match_id,
                         ProvisionalH1::new(cell, owner.take().expect("HTTP/1 owner disappeared")),
                     ));
                     false
                 } else {
                     let snapshot = state.finish_reuse(reuse_id, false);
                     rejected_reuse = Some((reuse_id, snapshot));
                     let revision = state.complete_h1_match(match_id, false);
                     rejected_match = Some((match_id, revision));
                     true
-1387
+                }
             } else if state.waiters.can_accept_h1()
             } else if state.acquisitions.has_h1_compatible_waiter()
                 && state
                     .h1
                     .commit_return_to_waiter(owner.as_ref().expect("HTTP/1 owner disappeared"))
-1392
+            {
                 state.reuse.consume_local_turn();
                 state.h1.consume_local_turn();
                 state.assert_consistent();
                 let mut returned = owner.take().expect("HTTP/1 owner disappeared");
                 returned.mark_reused();
                 installation = Some(state.waiters.install_returned_h1(
                     || AcquisitionResult::H1(H1Selection::new(cell, returned)),
                 let (waiter, mut install) = state.acquisitions.offer_returned_h1(
                     || AcquisitionOutcome::H1(H1Selection::new(cell, returned)),
                     &cell.eligibility_group,
                 ));
                 let install = installation
                     .as_mut()
                     .expect("HTTP/1 installation disappeared");
                 if let Some(waiter) = install.waiter {
                     state.h2.cancel_pending_waiter(waiter);
--
+                }
                 );
                 state.h2.cancel_pending_waiter(
                     waiter.expect("compatible HTTP/1 waiter disappeared during offer"),
                 );
                 install.demand_updates =
                     state.publishable_demand_updates(std::mem::take(&mut install.demand_updates));
                 installation = Some(install);
                 false
             } else {
                 let returned = state.h1.return_idle(
                     owner.take().expect("HTTP/1 owner disappeared"),
                     idle_deadline,
                 );
                 match returned {
                     Ok(()) => {
                         state.assert_consistent();
                         false
-1417
+                    }
                     Err(returned) => {
                         owner = Some(returned);
                         true
-1421
+                    }
-1422
+                }
-1423
+            }
         };
-1425
         if should_retire {
             if tracing::level_enabled!(tracing::Level::TRACE) {
                 trace_h1_return(cell, connection_id, H1ReturnTrace::Rejected);
-1429
+            }
             if let Some((reuse_id, snapshot)) = rejected_reuse {
             if let Some((match_id, revision)) = rejected_match {
                 let admission = cell
                     .admission
                     .as_ref()
                     .expect("an HTTP/1 reuse operation requires bounded admission");
                 OriginAdmission::reject_returned_h1_reuse(
                     .expect("an H1 match requires bounded admission");
                 OriginAdmission::reject_returned_h1_match(
                     admission,
                     reuse_id,
                     match_id,
                     cell.id.partition(),
                     snapshot,
                     revision,
                 );
-1441
+            }
             Self::retire_h1_owner(
                 cell,
                 owner.take().expect("retired HTTP/1 owner disappeared"),
                 CloseReason::ProtocolClosed,
             );
             return;
-1448
+        }
-1449
         if let Some((reuse_id, provisional)) = intercepted {
         if let Some((match_id, provisional)) = intercepted {
             if tracing::level_enabled!(tracing::Level::TRACE) {
                 trace_h1_return(cell, connection_id, H1ReturnTrace::ReuseIntercepted);
                 trace_h1_return(
                     cell,
                     connection_id,
                     H1ReturnTrace::PeerReservationIntercepted,
                 );
-1457
+            }
             let admission = cell
                 .admission
                 .as_ref()
                 .expect("an HTTP/1 reuse operation requires bounded admission");
             let candidate = ReuseCandidate::new(
                 .expect("an H1 match requires bounded admission");
             let candidate = H1Candidate::new(
                 admission.clone(),
                 reuse_id,
                 match_id,
                 cell.id.partition(),
                 provisional,
             );
             let action = OriginAdmission::resolve_h1_reuse(admission, reuse_id, candidate);
             OriginAdmission::drive(action);
             let action = OriginAdmission::resolve_h1_match(admission, match_id, candidate);
             OriginAdmission::run_action_chain(action);
             return;
-1471
+        }
-1472
         let Some(installation) = installation else {
             if tracing::level_enabled!(tracing::Level::TRACE) {
                 trace_h1_return(cell, connection_id, H1ReturnTrace::Idle);
-1476
+            }
             cell.notify_maintenance(idle_deadline);
             if cell.admission.is_some() {
                 let availability = cell.state.lock().take_h1_availability_update();
                 cell.publish_h1_availability(availability);
                 let revision = cell.state.lock().take_h1_supply_update();
                 cell.submit_h1_supply_update(revision);
-1481
+            }
             return;
         };
         if tracing::level_enabled!(tracing::Level::TRACE) {
             trace_h1_return(cell, connection_id, H1ReturnTrace::LocalDemand);
-1486
+        }
         if let Some(admission) = &cell.admission {
             for snapshot in installation.demand_updates.into_iter().flatten() {
                 OriginAdmission::publish_demand(admission, cell.id.partition(), snapshot);
                 OriginAdmission::submit_demand_snapshot(admission, cell.id.partition(), snapshot);
-1490
+            }
-1491
+        }
         drop(installation.returned_event);
         drop(installation.returned_step);
         if let Some(waker) = installation.waker {
             waker.wake();
-1495
+        }
         if cell.admission.is_some() {
             let availability = cell.state.lock().take_h1_availability_update();
             cell.publish_h1_availability(availability);
             let revision = cell.state.lock().take_h1_supply_update();
             cell.submit_h1_supply_update(revision);
-1499
+        }
-1500
+    }
-1501
     /// Retires an externally owned H1 sender and removes its connection-owning cell record.
     ///
     /// Returns whether this path won the connection's logical-close race.
     fn retire_h1_owner(cell: &Arc<Self>, owner: OwnedH1, reason: CloseReason) -> bool {
     fn retire_h1_owner(cell: &Arc<Self>, owner: OwnedH1Sender, reason: CloseReason) -> bool {
         let should_close = {
             let mut state = cell.state.lock();
             let should_close = state.h1.close_owned(&owner);
             state.assert_consistent();
             should_close
         };
-1512
         let id = owner.id();
         let won = should_close && owner.connection().logical_close(reason);
         drop(owner);
-1516
         let mut state = cell.state.lock();
         state.h1.finish_close(id);
         state.h1.remove_closed(id);
         state.assert_consistent();
         let availability = state.take_h1_availability_update();
         let revision = state.take_h1_supply_update();
         drop(state);
         cell.publish_h1_availability(availability);
         cell.submit_h1_supply_update(revision);
         won
-1524
+    }
-1525
     /// Begins close for an installed H1 record named without its sender.
     ///
     /// Returns whether this signal won the connection's logical-close race.
     pub(super) fn close_h1(cell: &Arc<Self>, id: ConnectionId, reason: CloseReason) -> bool {
         let Some((close, availability)) = ({
         let Some((close, supply_update)) = ({
             let mut state = cell.state.lock();
             let close = state.h1.begin_close(id);
             state.assert_consistent();
             close.map(|close| (close, state.take_h1_availability_update()))
             close.map(|close| (close, state.take_h1_supply_update()))
         }) else {
             return false;
         };
-1538
         cell.publish_h1_availability(availability);
         cell.submit_h1_supply_update(supply_update);
         let remove_record = close.sender.is_some();
         let won = close.connection.logical_close(reason);
         drop(close.sender);
         if remove_record {
             let mut state = cell.state.lock();
             state.h1.finish_close(id);
             state.h1.remove_closed(id);
             state.assert_consistent();
-1547
+        }
         won
-1549
+    }
-1550
     /// Returns H1 record counts for focused ownership tests.
     #[cfg(test)]
     pub(super) fn h1_counts(&self) -> (usize, usize) {
         self.state.lock().h1.counts()
-1555
+    }
-1556
     /// Returns the sole installed HTTP/1 connection for focused dispatch tests.
     #[cfg(all(test, feature = "rt-tokio"))]
     pub(in crate::client::pool) fn only_h1_connection_for_test(&self) -> Arc<ConnectionState> {
         self.state.lock().h1.only_connection_for_test()
-1561
+    }
-1562
+}
-1563
 /// Terminal outcome for one reusable HTTP/1 sender return.
 enum H1ReturnTrace {
     /// The owning cell no longer accepts the sender.
     Rejected,
     /// Origin admission reserved the sender for peer demand.
     ReuseIntercepted,
     PeerReservationIntercepted,
     /// No compatible demand exists, so the sender became idle.
     Idle,
     /// A waiter in the owning cell accepted the sender.
     LocalDemand,
-1574
+}
-1575
 /// Emits a committed HTTP/1 return outcome outside the cell lock.
 // Keep field formatting out of a return transition that can synchronously
 // enter admission and sender fallbacks.
 #[inline(never)]
 fn trace_h1_return(cell: &OriginCell, connection_id: ConnectionId, outcome: H1ReturnTrace) {
     match outcome {
         H1ReturnTrace::Rejected => tracing::trace!(
             connection_id = %connection_id,
             connection_partition = ?cell.id.partition(),
             origin_scheme = %cell.id.origin().scheme(),
             origin_host = cell.id.origin().host(),
             origin_port = ?cell.id.origin().port(),
             "HTTP/1 return was rejected by its connection-owning cell"
         ),
         H1ReturnTrace::ReuseIntercepted => tracing::trace!(
         H1ReturnTrace::PeerReservationIntercepted => tracing::trace!(
             connection_id = %connection_id,
             connection_partition = ?cell.id.partition(),
             origin_scheme = %cell.id.origin().scheme(),
             origin_host = cell.id.origin().host(),
             origin_port = ?cell.id.origin().port(),
             "HTTP/1 return was intercepted by a cross-cell reuse operation"
             "HTTP/1 return was intercepted by a peer reservation"
         ),
         H1ReturnTrace::Idle => tracing::trace!(
             connection_id = %connection_id,
             connection_partition = ?cell.id.partition(),
             origin_scheme = %cell.id.origin().scheme(),
             origin_host = cell.id.origin().host(),
             origin_port = ?cell.id.origin().port(),
             "HTTP/1 connection returned to idle storage"
         ),
         H1ReturnTrace::LocalDemand => tracing::trace!(
             connection_id = %connection_id,
             request_partition = ?cell.id.partition(),
             connection_partition = ?cell.id.partition(),
             origin_scheme = %cell.id.origin().scheme(),
             origin_host = cell.id.origin().host(),
             origin_port = ?cell.id.origin().port(),
             "HTTP/1 return satisfied local demand"
         ),
-1615
+    }
-1616
+}
-1617
 #[cfg(all(test, not(smithy_http_client_loom)))]
 mod tests {
     use super::*;
     use crate::client::pool::connection::ConnectionInfo;
     use crate::client::pool::PartitionId;
-1623
     #[test]
     fn closing_a_selected_record_rejects_its_later_return() {
         let info = ConnectionInfo::for_test(ConnectionId::new(1), PartitionId::from_index(1));
         let (connection, _physical) = ConnectionState::unbounded(info);
         let mut records = H1Records::default();
         let mut records = H1CellState::default();
         let owner = records
             .install_selected(connection, H1Sender::test(11))
             .insert_selected(connection, H1Sender::test(11))
             .expect("fresh HTTP/1 record was rejected");
-1632
         assert!(records.accepts_return(&owner));
         assert!(records.begin_close(owner.id()).is_some());
         assert!(!records.accepts_return(&owner));
-1636
         drop(owner);
         records.finish_close(ConnectionId::new(1));
         records.remove_closed(ConnectionId::new(1));
-1639
+    }
     #[test]
     fn reuse_reservation_distinguishes_install_resolution_and_completion() {
         let reuse_id = ReuseId::for_test(1);
         let mut slot = H1ReuseReservation::default();
--
         assert!(slot.install(reuse_id));
         assert!(!slot.install(ReuseId::for_test(2)));
         assert_eq!(Some(reuse_id), slot.intercept_return());
         assert!(slot.complete_transfer(reuse_id, true));
     fn peer_reservation_distinguishes_waiting_resolution_and_completion() {
         let match_id = H1MatchId::for_test(1);
         let mut slot = H1Reservation::default();
-+
         assert!(slot.reserve_waiting(match_id));
         assert!(!slot.reserve_waiting(H1MatchId::for_test(2)));
         assert_eq!(Some(match_id), slot.take_return_match());
         assert!(slot.complete_transfer(match_id, true));
         assert!(slot.local_turn_owed());
         assert!(slot.is_available());
-1651
+    }
-1652
     #[test]
     fn rejection_does_not_manufacture_a_fairness_turn() {
         let reuse_id = ReuseId::for_test(1);
         let mut slot = H1ReuseReservation::default();
         let match_id = H1MatchId::for_test(1);
         let mut slot = H1Reservation::default();
-1657
         assert!(slot.install_resolving(reuse_id));
         assert!(slot.reject(reuse_id));
         assert!(slot.reserve_resolving(match_id));
         assert!(slot.release(match_id));
         assert!(!slot.local_turn_owed());
-1661
+    }
-1662
     #[test]
     fn owed_turn_blocks_only_while_local_h1_demand_can_use_it() {
         let reuse_id = ReuseId::for_test(1);
         let mut slot = H1ReuseReservation::default();
         assert!(slot.install_resolving(reuse_id));
         assert!(slot.complete_transfer(reuse_id, true));
         let match_id = H1MatchId::for_test(1);
         let mut slot = H1Reservation::default();
         assert!(slot.reserve_resolving(match_id));
         assert!(slot.complete_transfer(match_id, true));
-1669
         assert!(slot.blocks_peer_reuse(true));
         assert!(!slot.blocks_peer_reuse(false));
         assert!(slot.blocks_peer_selection(true));
         assert!(!slot.blocks_peer_selection(false));
         assert!(slot.clear_unused_turn(false));
         assert!(!slot.blocks_peer_reuse(true));
         assert!(!slot.blocks_peer_selection(true));
-1674
+    }
-1675
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/cell/h2.rs

@@ -1,1 +110,131 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! HTTP/2 flight, generation, route, and request-lease ownership.
 //! HTTP/2 connection generations, routes, and request activation.
 //!
 //! One connection-owning cell stores the authoritative HTTP/2 generation.
 //! Other cells store only [`H2Route`] identities and revalidate them at the
 //! connection-owning cell before dispatch. A generation may stop accepting
 //! new requests while prospective and accepted requests still drain.
 //! HTTP/2 carries many concurrent request and response exchanges as streams on
 //! one connection. The pool calls one installed lifetime of that connection a
 //! generation. The cell that established the connection owns its generation,
 //! including the Hyper request handle, driver, transport, and capacity.
 //!
 //! [`H2Records`] is the invariant owner under the cell lock. It stores one
 //! post-ALPN flight, the accepting and draining generations, a local generation
 //! gate, and at most one peer route. A route carries only connection partition
 //! and generation identity. [`H2Activation`] is the unlocked value that carries
 //! a prospective lease and transient sender from selection to Hyper acceptance.
 //! A flight is the post-ALPN handshake work shared by concurrent requests
 //! waiting for that generation. A successful flight installs one accepting
 //! generation; failed or superseded flight work installs nothing.
 //!
 //! ```text
 //! requesting cell                        connection-owning cell
 //! peer route + local gate --identity---> exact accepting generation
 //!                                      |-- increment prospective count
 //!                                      `-- clone transient sender
 //!                                               |
 //!                                               `--> H2Activation
 //! ```
 //! An accepting generation may issue new request streams. A draining
 //! generation issues no new streams but remains recorded while selected or
 //! accepted requests still own it.
 //!
 //! A requesting cell may store an [`H2Route`] to a peer cell's generation.
 //! The route carries only cell and generation identity. [`H2Activation`]
 //! revalidates that identity under the connection-cell lock, reserves one
 //! prospective stream, and carries a transient sender clone to Hyper.
 //!
 //! Each Hyper-accepted request owns one claim with independent upload and
 //! response guards. The generation releases the request only after both sides
 //! finish, including drop, error, and bodyless completion paths. The detached
 //! request lifecycle lives in [`request`]; this module retains the cell-locked
 //! generation, route, and activation-gate state.
 //!
 //! [`H2CellState`] is the invariant owner under the cell lock. It stores one
 //! flight, accepting and draining generations, activation priority, and one
 //! peer route. A peer route references another cell's generation; it does not
 //! transfer connection ownership.
 //!
 //! ```text
 //! no flight -- post-ALPN owner task ----------------------> Flight
 //! Flight -- successful handshake and install ------------> Accepting
 //! Flight -- failure, stale completion, or task drop ------> no flight
 //! Accepting -- close with retained request leases --------> Draining
 //! Accepting -- close without retained request leases -----> removed
 //! Draining -- last prospective or accepted lease --------> removed
 //! Accepting -- close with retained request claims --------> Draining
 //! Accepting -- close without retained request claims -----> removed
 //! Draining -- last prospective or accepted claim --------> removed
 //! ```
 //!
 //! ```text
 //! no peer route -- publication ---------------------------> PeerRoute(generation)
 //! PeerRoute(A) -- replacement publication ---------------> PeerRoute(B)
 //! PeerRoute -- stale activation or local generation -----> no peer route
 //! requesting cell                        connection-owning cell
 //! peer route + local gate --identity---> exact accepting generation
 //!                                      |-- reserve one prospective stream
 //!                                      `-- clone transient sender
 //!                                               |
 //!                                               `--> H2Activation
 //! ```
 //!
 //! Generation installation makes the sender visible before the owner task
 //! submits the Hyper driver. An activation in that interval is accepted by
 //! Hyper's dispatch channel and remains pending until the driver is polled.
 //! submits the Hyper driver. An activation accepted in that interval remains
 //! pending in Hyper's dispatch channel until the driver is polled.
 //!
 //! Activation reserves a prospective lease before a sender clone leaves the
 //! cell lock. Hyper acceptance converts that reservation to one accepted
 //! lease. The accepted lease is released only after both request-send and
 //! response-receive endpoints terminate.
--
 use super::super::connection::{ConnectionInfo, ConnectionState, DispatchGuard};
 use super::super::partition::PartitionId;
 use super::waiters::{AcquisitionQueue, WaiterInstall};
 use super::{AcquisitionEvent, AcquisitionResult, CellState, OriginCell, WaiterId};
 use crate::sync::{Arc, Mutex, Weak};
 //! Activation reserves its prospective claim before the sender clone leaves
 //! the cell lock. Hyper acceptance converts that reservation to an accepted
 //! request claim with independent upload and response guards.
-+
 mod request;
-+
 pub(in crate::client::pool) use request::{
     H2Activation, H2DispatchParts, H2ResponseGuard, H2UploadGuard,
 };
 use request::{H2ActivationResources, H2ActivationTurnGuard};
-+
 use super::super::admission::{
     DemandId, DemandSnapshot, H2SupplyStatus, OriginAdmission, SupplyRevision,
 };
 use super::super::connection::{CloseReason, ConnectionState};
 use super::super::partition::{EligibilityGroup, PartitionId};
 use super::waiters::{AcquisitionQueue, WaiterResolution};
 use super::{AcquisitionOutcome, AcquisitionStep, CellState, OriginCell, WaiterId};
 use crate::sync::{Arc, Weak};
 use aws_smithy_runtime_api::client::connection::ConnectionId;
 use aws_smithy_types::body::SdkBody;
 use std::collections::{BTreeSet, HashMap};
 use std::time::SystemTime;
-82
 /// Identity of one post-ALPN HTTP/2 establishment flight.
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub(in crate::client::pool) struct H2FlightId(u64);
-86
 /// Identity of one installed HTTP/2 generation within a cell.
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub(in crate::client::pool) struct H2GenerationId(u64);
-90
 #[cfg(test)]
 impl H2GenerationId {
     /// Creates a generation identity for admission-index tests.
     pub(in crate::client::pool) fn for_test(value: u64) -> Self {
         Self(value)
-96
+    }
-97
+}
-98
 /// Cloneable Hyper request sender retained only by its owning generation.
 ///
 /// The test-only variant exercises generation and lease transitions without a
 /// The test-only variant exercises generation and claim transitions without a
 /// parallel fake generation implementation.
 #[derive(Clone)]
 pub(in crate::client::pool) enum H2Sender {
     /// Sender returned by a successful Hyper HTTP/2 handshake.
     Hyper(hyper::client::conn::http2::SendRequest<SdkBody>),
     /// Synthetic sender identity used by state-machine tests.
     #[cfg(test)]
     Test(u64),
-110
+}
-111

↧ Expand context

 impl H2Sender {
     /// Wraps a sender produced by a successful Hyper HTTP/2 handshake.
     pub(in crate::client::pool) fn from_hyper(
         inner: hyper::client::conn::http2::SendRequest<SdkBody>,
     ) -> Self {
         Self::Hyper(inner)
-118
+    }
-119
     /// Returns whether Hyper has observed connection closure.
     pub(in crate::client::pool) fn is_closed(&self) -> bool {
         match self {
             Self::Hyper(sender) => sender.is_closed(),
             #[cfg(test)]
             Self::Test(_) => false,
-126
+        }
-127
+    }
-128
     /// Returns mutable access to a transient sender clone for dispatch.
     ///
     /// # Panics

@@ -147,168 +3519,3038 @@

↥ Expand context

     connection_cell: Weak<OriginCell>,
-169
+}
-170
 /// Exact connection-owning generation named by one peer route.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub(super) struct H2RouteId {
     connection_partition: PartitionId,
     generation: H2GenerationId,
-176
+}
-177
 impl H2Route {
     /// Creates a route after its generation has been installed.
     pub(in crate::client::pool) fn new(
         connection_cell: &Arc<OriginCell>,
         generation: H2GenerationId,
     ) -> Self {
         Self {
             connection_cell: Weak::from_arc(connection_cell),
             id: H2RouteId {
                 connection_partition: connection_cell.id().partition(),

                 generation,
             },
-190
+        }
-191
+    }
-192
     /// Returns the exact connection-owning generation named by this route.
     fn id(&self) -> H2RouteId {
         self.id
-196
+    }
-197
     /// Returns the partition that owns the advertised generation.
     /// Returns the partition that owns the routed generation.
     pub(super) fn connection_partition(&self) -> PartitionId {
         self.id.connection_partition
-201
+    }
-202
     /// Returns the advertised generation identity.
     /// Returns the routed generation identity.
     #[cfg(any(debug_assertions, test))]
     pub(in crate::client::pool) fn generation(&self) -> H2GenerationId {
         self.id.generation
-207
+    }
-208
     /// Attempts to reserve a prospective request lease for one requesting partition.
     /// Attempts to reserve a prospective request claim for one requesting partition.
     pub(super) fn activate(&self, request_partition: PartitionId) -> Option<H2Activation> {
         let cell = self.connection_cell.upgrade()?;
         let mut activation = OriginCell::activate_h2(&cell, self.id.generation)?;
         activation.request_partition = request_partition;
         Some(activation)
         OriginCell::activate_h2(&cell, self.id.generation, request_partition)
-213
+    }
-214
+}
-215
 /// Cell-local ownership of one HTTP/2 flight and installed generations.
 /// Complete HTTP/2 acquisition state owned by one origin cell.
 ///
 /// At every completed transition:
 ///
 /// - at most one flight and one accepting generation exist;
 /// - the accepting identity names an `Accepting` record;
 /// - every other generation is `Draining`;
 /// - prospective and accepted request counts are checked and non-wrapping;
 /// - prospective and active request counts are checked and non-wrapping;
 /// - a draining record remains until both counts reach zero; and
 /// - each flight participant identity appears at most once.
 /// - each flight participant identity appears at most once;
 /// - the local activation gate names the accepting generation;
 /// - a peer route gate names the routed generation; and
 /// - at most one peer-route waiter is crossing the connection-cell lock.
 #[derive(Debug, Default)]
 pub(super) struct H2Records {
 pub(super) struct H2CellState {
     /// Post-ALPN convergence in progress for this cell.
     flight: Option<H2Flight>,
     /// Installed accepting and draining generations by exact identity.
     generations: HashMap<H2GenerationId, H2Generation>,
     /// Sole generation permitted to issue new activations.
     accepting: Option<H2GenerationId>,
     accepting_generation: Option<H2GenerationId>,
     /// Identity-only route to one peer cell's accepting generation.
     peer_route: Option<PeerH2Route>,
     /// Local activation order for the accepting generation.
     gate: GenerationGate,
     local_activation_gate: H2ActivationGate,
     /// Next cell-local flight identity.
     next_flight: u64,
     next_flight_id: u64,
     /// Next cell-local generation identity.
     next_generation: u64,
     next_generation_id: u64,
-245
+}
-246
 /// One post-ALPN flight and the waiters awaiting its result.
 #[derive(Debug)]
 struct H2Flight {
     /// Identity checked by the owner task at completion.
     id: H2FlightId,
     /// Waiters that receive the shared handshake result.
     participants: BTreeSet<WaiterId>,
-254
+}
-255
 /// One installed multiplexed connection generation.
 #[derive(Debug)]
 struct H2Generation {
     /// Establishment waiters transferred to this generation but not yet served.
     pending_waiters: BTreeSet<WaiterId>,
     /// Protocol-neutral connection and capacity owner.
     connection: Arc<ConnectionState>,
     /// Authoritative Hyper sender cloned only after generation validation.
     sender: H2Sender,
     /// Whether new activations may be issued.
     residence: H2Residence,
     state: H2GenerationState,
     /// Activations selected but not yet accepted by Hyper.
     prospective: usize,
     prospective_requests: usize,
     /// Whether Hyper has accepted a request on this generation.
     has_dispatched: bool,
     /// Accepted requests whose two lease endpoints have not both terminated.
     accepted: usize,
     has_accepted_request: bool,
     /// Requests accepted by Hyper whose upload and response sides have not both finished.
     active_requests: usize,
     /// Expiration deadline while the generation remains accepting.
     idle_deadline: Option<SystemTime>,
-275
+}
-276
 /// Whether an installed generation may accept new requests.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum H2Residence {
     /// New requests may reserve prospective leases.
 enum H2GenerationState {
     /// New requests may reserve prospective claims.
     Accepting,
     /// No new requests are admitted; retained leases may finish.
     /// No new requests are admitted; retained claims may finish.
     Draining,
-284
+}
-285
 /// Peer route visibility and requesting-cell activation order.
 #[derive(Debug)]
 struct PeerH2Route {
     /// Exact connection-cell generation visible to this requesting cell.
     route: H2Route,
     /// Local waiter priority for uses of this route.
     gate: GenerationGate,
     activation_gate: H2ActivationGate,
     /// Waiter whose route activation is crossing the connection-cell lock.
     crossing: Option<WaiterId>,
     crossing_waiter: Option<WaiterId>,
-295
+}
-296
 /// Local priority state for one accepting generation.
 #[derive(Debug, Default)]
 enum GenerationGate {
 enum H2ActivationGate {
     /// No accepting generation is visible.
     #[default]
     Closed,
     /// Waiters committed through `cutoff` precede later arrivals.
     Prioritizing {
         /// Exact generation governed by this gate.
         generation: H2GenerationId,
         /// Newest waiter committed before generation visibility.
         cutoff: WaiterId,
         /// Prioritized waiter whose activation has not accepted or cancelled.
         activating: Option<WaiterId>,
         active_turn: Option<WaiterId>,
     },
     /// The publication cutoff drained; queued work still precedes direct arrivals.
     /// The peer-route cutoff drained; queued work still precedes direct arrivals.
     Open { generation: H2GenerationId },
-314
+}
-315
 /// One activation opportunity returned by a generation gate.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum GateTurn {
 enum H2ActivationTurn {
     /// The gate cannot issue another activation.
     Unavailable,
     /// Any oldest compatible acquisition may activate.
     Open,
     /// Only an acquisition at or before this waiter may activate.
     Through(WaiterId),
-325
+}
-326
 impl GenerationGate {
 impl H2ActivationGate {
     /// Creates a gate over every waiter committed through `cutoff`.
     fn for_generation(generation: H2GenerationId, cutoff: Option<WaiterId>) -> Self {
         match cutoff {
             Some(cutoff) => Self::Prioritizing {
                 generation,
                 cutoff,
                 activating: None,
                 active_turn: None,
             },
             None => Self::Open { generation },
-337
+        }
-338
+    }
-339
     fn generation(&self) -> Option<H2GenerationId> {
         match self {
             Self::Closed => None,
             Self::Prioritizing { generation, .. } | Self::Open { generation } => Some(*generation),
-344
+        }
-345
+    }
-346
     /// Returns the next activation opportunity and opens a drained priority gate.
     fn next_turn(&mut self, has_prioritized: bool) -> GateTurn {
     fn take_next_turn(&mut self, has_prioritized: bool) -> H2ActivationTurn {
         match self {
             Self::Closed => GateTurn::Unavailable,
             Self::Closed => H2ActivationTurn::Unavailable,
             Self::Prioritizing {
                 cutoff,
                 activating,
                 active_turn,
                 generation,
             } => {
                 if activating.is_some() {
                     return GateTurn::Unavailable;
                 if active_turn.is_some() {
                     return H2ActivationTurn::Unavailable;
-358
+                }
                 if !has_prioritized {
                     let generation = *generation;
                     *self = Self::Open { generation };
                     GateTurn::Open
                     H2ActivationTurn::Open
                 } else {
                     GateTurn::Through(*cutoff)
                     H2ActivationTurn::Through(*cutoff)
-365
+                }
-366
+            }
             Self::Open { .. } => GateTurn::Open,
             Self::Open { .. } => H2ActivationTurn::Open,
-368
+        }
-369
+    }
-370
     /// Records a prioritized activation until it accepts or cancels.
     fn begin_gate_activation(&mut self, waiter: WaiterId) -> bool {
         let activating = match self {
     fn reserve_turn(&mut self, waiter: WaiterId) -> bool {
         let active_turn = match self {
             Self::Closed => {
                 unreachable!("started an HTTP/2 activation while its gate was closed")
-376
+            }
             Self::Prioritizing { activating, .. } => activating,
             Self::Prioritizing { active_turn, .. } => active_turn,
             Self::Open { .. } => return false,
         };
         assert!(
             activating.replace(waiter).is_none(),
             active_turn.replace(waiter).is_none(),
             "HTTP/2 generation gate admitted two activation opportunities"
         );
         true
-385
+    }
-386
     /// Discharges one exact activation opportunity.
     fn finish_gate_activation(&mut self, generation: H2GenerationId, waiter: WaiterId) -> bool {
     fn release_turn(&mut self, generation: H2GenerationId, waiter: WaiterId) -> bool {
         if self.generation() != Some(generation) {
             return false;
-391
+        }
         let activating = match self {
         let active_turn = match self {
             Self::Closed => return false,
             Self::Prioritizing { activating, .. } => activating,
             Self::Prioritizing { active_turn, .. } => active_turn,
             Self::Open { .. } => return false,
         };
         if *activating != Some(waiter) {
         if *active_turn != Some(waiter) {
             return false;
-399
+        }
         *activating = None;
         *active_turn = None;
         true
-402
+    }
-403
     fn priority_cutoff(&self) -> Option<WaiterId> {
         match self {
             Self::Prioritizing { cutoff, .. } => Some(*cutoff),
             Self::Closed | Self::Open { .. } => None,
-408
+        }
-409
+    }
-410
     fn activating(&self) -> Option<WaiterId> {
     fn active_turn(&self) -> Option<WaiterId> {
         match self {
             Self::Prioritizing { activating, .. } => *activating,
             Self::Prioritizing { active_turn, .. } => *active_turn,
             Self::Closed | Self::Open { .. } => None,
-415
+        }
-416
+    }
-417
     fn is_open_for(&self, generation: H2GenerationId) -> bool {
         matches!(self, Self::Open { generation: current } if *current == generation)
-420
+    }
-421
+}
-422
 /// Result of atomically converging one post-ALPN attempt.
 #[derive(Debug)]
 pub(in crate::client::pool) enum H2FlightInstall {
 pub(in crate::client::pool) enum H2FlightDecision {
     /// An installed generation can serve this waiter.
     Accepting(H2GenerationId),
     UseGeneration(H2GenerationId),
     /// The waiter joined the current flight as a result participant.
     Joined,
     JoinedFlight,
     /// The caller owns the task that must drive this new flight.
     Driver(H2FlightId),
     RunFlight(H2FlightId),
     /// Another transition already installed or retired the waiter's result.
     WaiterCompleted,
     WaiterResolved,
-434
+}
-435
 /// Result of joining an accepting generation after ALPN selected HTTP/2.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(in crate::client::pool) enum H2GenerationJoin {
 pub(in crate::client::pool) enum H2GenerationJoinOutcome {
     /// The waiter was transferred to the named generation.
     Joined,
     /// The named generation stopped accepting before the transfer.
     GenerationChanged,
     /// Another transition already installed the waiter's result.
     WaiterCompleted,
     WaiterResolved,
-445
+}
-446
 impl H2Records {
     /// Installs or joins the one current flight after ALPN selected HTTP/2.
     pub(super) fn install_or_join_flight(&mut self, waiter: WaiterId) -> H2FlightInstall {
         if let Some(generation) = self.accepting {
             return H2FlightInstall::Accepting(generation);
 impl H2CellState {
     /// Uses an accepting generation, joins its flight, or starts a new flight.
     pub(super) fn converge_flight(&mut self, waiter: WaiterId) -> H2FlightDecision {
         if let Some(generation) = self.accepting_generation {
             return H2FlightDecision::UseGeneration(generation);
-452
+        }
         if let Some(flight) = &mut self.flight {
             assert!(
                 flight.participants.insert(waiter),
                 "HTTP/2 waiter joined one flight more than once"
             );
             self.assert_consistent();
             return H2FlightInstall::Joined;
             return H2FlightDecision::JoinedFlight;
-460
+        }
-461
         let id = self.take_flight_id();
         self.flight = Some(H2Flight {
             id,
             participants: BTreeSet::from([waiter]),
         });
         self.assert_consistent();
         H2FlightInstall::Driver(id)
         H2FlightDecision::RunFlight(id)
-469
+    }
-470
     /// Removes one cancelled waiter from its current flight, when present.
     pub(super) fn cancel_flight_participant(&mut self, waiter: WaiterId) {
         if let Some(flight) = &mut self.flight {
             flight.participants.remove(&waiter);
-475
+        }
         self.assert_consistent();
-477
+    }
-478
     /// Removes a waiter that no longer awaits an accepting generation.
     pub(super) fn cancel_pending_waiter(&mut self, waiter: WaiterId) {
         if let Some(generation) = self.accepting {
         if let Some(generation) = self.accepting_generation {
             self.generations
                 .get_mut(&generation)
                 .expect("accepting HTTP/2 generation disappeared")
                 .pending_waiters
                 .remove(&waiter);
-487
+        }
         self.assert_consistent();
-489
+    }
-490
     /// Installs the generation produced by the named flight.
     pub(in crate::client::pool) fn complete_flight(
         &mut self,
         flight: H2FlightId,
         connection: Arc<ConnectionState>,
         sender: H2Sender,
         idle_deadline: Option<SystemTime>,
     ) -> Result<H2GenerationId, (Arc<ConnectionState>, H2Sender)> {
         if self.flight.as_ref().map(|current| current.id) != Some(flight)
             || self.accepting.is_some()
             || self.accepting_generation.is_some()
-501
+        {
             return Err((connection, sender));
-503
+        }
         let flight = self
             .flight
             .take()
             .expect("validated HTTP/2 flight disappeared");
         let generation =
             self.install_generation(flight.participants, connection, sender, idle_deadline);
             self.open_generation(flight.participants, connection, sender, idle_deadline);
         self.assert_consistent();
         Ok(generation)
-512
+    }
-513
     /// Installs one accepting generation with its transferred waiters.
     fn install_generation(
     fn open_generation(
         &mut self,
         pending_waiters: BTreeSet<WaiterId>,
         connection: Arc<ConnectionState>,
         sender: H2Sender,
         idle_deadline: Option<SystemTime>,
     ) -> H2GenerationId {
         let generation = self.take_generation_id();
         let replaced = self.generations.insert(
             generation,
             H2Generation {
                 pending_waiters,
                 connection,
                 sender,
                 residence: H2Residence::Accepting,
                 prospective: 0,
                 has_dispatched: false,
                 accepted: 0,
                 state: H2GenerationState::Accepting,
                 prospective_requests: 0,
                 has_accepted_request: false,
                 active_requests: 0,
                 idle_deadline,
             },
         );
         assert!(replaced.is_none(), "HTTP/2 generation identity was reused");
         self.accepting = Some(generation);
         self.accepting_generation = Some(generation);
         self.peer_route = None;
         debug_assert!(matches!(self.gate, GenerationGate::Closed));
         self.gate = GenerationGate::Open { generation };
         debug_assert!(matches!(
             self.local_activation_gate,
             H2ActivationGate::Closed
         ));
         self.local_activation_gate = H2ActivationGate::Open { generation };
         generation
-545
+    }
-546
     /// Retires a failed or dropped flight and returns its participants.
     pub(super) fn fail_flight(&mut self, flight: H2FlightId) -> Option<Vec<WaiterId>> {
         if self.flight.as_ref().map(|current| current.id) != Some(flight) {
             return None;
-551
+        }
         let participants = self
             .flight
             .take()
             .expect("validated HTTP/2 flight disappeared")
             .participants
             .into_iter()
             .collect();
         self.assert_consistent();
         Some(participants)
-561
+    }
-562
     /// Closes the gate over waiters committed when a generation became visible.
     pub(super) fn prioritize_through(&mut self, cutoff: Option<WaiterId>) {
         let generation = self
             .accepting
             .accepting_generation
             .expect("HTTP/2 generation gate opened without an accepting generation");
         self.gate = GenerationGate::for_generation(generation, cutoff);
         self.local_activation_gate = H2ActivationGate::for_generation(generation, cutoff);
         self.assert_consistent();
-570
+    }
-571
     /// Extends priority to a post-ALPN waiter that found this generation.
     pub(super) fn prioritize_waiter(
         &mut self,
         generation: H2GenerationId,
         waiter: WaiterId,
     ) -> bool {
         if self.accepting != Some(generation) {
         if self.accepting_generation != Some(generation) {
             return false;
-580
+        }
         match &mut self.gate {
             GenerationGate::Closed => {
         match &mut self.local_activation_gate {
             H2ActivationGate::Closed => {
                 unreachable!("accepting HTTP/2 generation had no generation gate")
-584
+            }
             GenerationGate::Prioritizing { cutoff, .. } => {
             H2ActivationGate::Prioritizing { cutoff, .. } => {
                 *cutoff = (*cutoff).max(waiter);
-587
+            }
             GenerationGate::Open { .. } => {
                 self.gate = GenerationGate::Prioritizing {
             H2ActivationGate::Open { .. } => {
                 self.local_activation_gate = H2ActivationGate::Prioritizing {
                     generation,
                     cutoff: waiter,
                     activating: None,
                     active_turn: None,
                 };
-594
+            }
-595
+        }
         self.generations
             .get_mut(&generation)
             .expect("accepting HTTP/2 generation disappeared")
             .pending_waiters
             .insert(waiter);
         self.assert_consistent();
         true
-603
+    }
-604
     /// Returns the next queued activation opportunity.
     fn next_gate_turn(&mut self, has_prioritized: bool) -> GateTurn {
         self.gate.next_turn(has_prioritized)
     fn take_next_turn(&mut self, has_prioritized: bool) -> H2ActivationTurn {
         self.local_activation_gate.take_next_turn(has_prioritized)
-608
+    }
-609
     /// Records a prioritized activation and releases its transferred waiter.
     pub(super) fn begin_gate_activation(&mut self, waiter: WaiterId) -> bool {
         let gated = self.gate.begin_gate_activation(waiter);
         if let Some(generation) = self.accepting {
     pub(super) fn reserve_activation_turn(&mut self, waiter: WaiterId) -> bool {
         let gated = self.local_activation_gate.reserve_turn(waiter);
         if let Some(generation) = self.accepting_generation {
             self.generations
                 .get_mut(&generation)
                 .expect("accepting HTTP/2 generation disappeared")
                 .pending_waiters
                 .remove(&waiter);
-619
+        }
         self.assert_consistent();
         gated
-622
+    }
-623
     /// Discharges one accepted or cancelled activation opportunity.
     pub(super) fn finish_gate_activation(
     pub(super) fn release_activation_turn(
         &mut self,
         generation: H2GenerationId,
         waiter: WaiterId,
     ) -> bool {
         let finished = self.gate.finish_gate_activation(generation, waiter);
         let finished = self.local_activation_gate.release_turn(generation, waiter);
         self.assert_consistent();
         finished
-633
+    }
-634
     /// Returns whether a direct arrival may use the accepting generation.
     pub(super) fn direct_is_allowed(&self, queued: bool) -> bool {
         !queued && matches!(self.gate, GenerationGate::Open { .. })
         !queued && matches!(self.local_activation_gate, H2ActivationGate::Open { .. })
-638
+    }
-639
     /// Returns the publication cutoff while older waiters remain prioritized.
     /// Returns the peer-route cutoff while older waiters remain prioritized.
     fn priority_cutoff(&self) -> Option<WaiterId> {
         self.gate.priority_cutoff()
         self.local_activation_gate.priority_cutoff()
-643
+    }
-644
     /// Reserves one prospective lease against an accepting generation.
     fn activate(&mut self, generation: H2GenerationId) -> Option<H2ActivationParts> {
         if self.accepting != Some(generation) {
     /// Reserves one prospective claim against an accepting generation.
     fn activate(&mut self, generation: H2GenerationId) -> Option<H2ActivationResources> {
         if self.accepting_generation != Some(generation) {
             return None;
-649
+        }
         let record = self.generations.get_mut(&generation)?;
         if record.residence != H2Residence::Accepting {
         if record.state != H2GenerationState::Accepting {
             return None;
-653
+        }
         record.prospective = record
             .prospective
         record.prospective_requests = record
             .prospective_requests
             .checked_add(1)
             .expect("HTTP/2 prospective request count exhausted");
         let parts = H2ActivationParts {
         let resources = H2ActivationResources {
             sender: record.sender.clone(),
             reused: record.has_dispatched,
             reused: record.has_accepted_request,
             connection: record.connection.clone(),
         };
         self.assert_consistent();
         Some(parts)
         Some(resources)
-665
+    }
-666
     /// Converts one prospective reservation to an accepted request lease.
     /// Converts one prospective reservation to an accepted request claim.
     fn accept(&mut self, generation: H2GenerationId) -> bool {
         let Some(record) = self.generations.get_mut(&generation) else {
             return false;
         };
         if record.prospective == 0 {
         if record.prospective_requests == 0 {
             return false;
-674
+        }
         record.prospective -= 1;
         record.accepted = record
             .accepted
         record.prospective_requests -= 1;
         record.active_requests = record
             .active_requests
             .checked_add(1)
             .expect("HTTP/2 accepted request count exhausted");
         record.has_dispatched = true;
             .expect("HTTP/2 active request count exhausted");
         record.has_accepted_request = true;
         self.assert_consistent();
         true
-683
+    }
-684
     /// Cancels one prospective reservation and detaches an empty drain record.
     ///
     /// # Panics
     ///
     /// Panics if the activation's exact generation or prospective count is
     /// missing.
     #[must_use]
     fn cancel(&mut self, generation: H2GenerationId) -> Option<H2Generation> {
         let record = self
             .generations
             .get_mut(&generation)
             .expect("HTTP/2 activation generation disappeared before cancellation");
         assert!(
             record.prospective > 0,
             record.prospective_requests > 0,
             "HTTP/2 prospective request count underflowed"
         );
         record.prospective -= 1;
         record.prospective_requests -= 1;
         self.remove_finished_drain(generation)
-703
+    }
-704
     /// Releases one accepted request and detaches an empty drain record.
     ///
     /// # Panics
     ///
     /// Panics if the lease's exact generation or accepted count is missing.
     /// Panics if the claim's exact generation or active request count is missing.
     #[must_use]
     fn complete_request(&mut self, generation: H2GenerationId) -> Option<H2Generation> {
         let record = self
             .generations
             .get_mut(&generation)
             .expect("HTTP/2 request generation disappeared before lease completion");
             .expect("HTTP/2 request generation disappeared before claim release");
         assert!(
             record.accepted > 0,
             "HTTP/2 accepted request count underflowed"
             record.active_requests > 0,
             "HTTP/2 active request count underflowed"
         );
         record.accepted -= 1;
         record.active_requests -= 1;
         self.remove_finished_drain(generation)
-722
+    }
-723
     /// Moves one exact accepting generation to draining.
     /// Stops one exact generation from accepting new request streams.
     ///
     /// Selected and accepted streams retain the generation in `Draining`
     /// until their claims finish. A generation with no request work is removed
     /// immediately. Pending establishment participants are returned so they
     /// can acquire another connection.
     #[must_use]
     fn begin_close(&mut self, generation: H2GenerationId) -> Option<H2CloseTransition> {
         if self.accepting != Some(generation) {
         if self.accepting_generation != Some(generation) {
             return None;
-734
+        }
         let record = self.generations.get_mut(&generation)?;
         if record.residence != H2Residence::Accepting {
         if record.state != H2GenerationState::Accepting {
             return None;
-738
+        }
         record.residence = H2Residence::Draining;
         self.accepting = None;
         self.gate = GenerationGate::Closed;
         record.state = H2GenerationState::Draining;
         self.accepting_generation = None;
         self.local_activation_gate = H2ActivationGate::Closed;
         let pending_waiters = std::mem::take(&mut record.pending_waiters);
         let remove_record = record.prospective == 0 && record.accepted == 0;
         let remove_record = record.prospective_requests == 0 && record.active_requests == 0;
         let connection = record.connection.clone();
         let removed_generation = remove_record
             .then(|| self.generations.remove(&generation))
             .flatten();
         Some(H2CloseTransition {
             connection,
             pending_waiters,
             removed_generation,
         })
-753
+    }
-754
     /// Detaches an exact accepting generation only while it has no request work.
     #[must_use]
     fn begin_idle_reclaim(&mut self, generation: H2GenerationId) -> Option<H2CloseTransition> {
         self.is_idle(generation)
             .then(|| self.begin_close(generation))
             .flatten()
-761
+    }
-762
     /// Returns the accepting generation when one is locally reusable.
     pub(in crate::client::pool) fn accepting(&self) -> Option<H2GenerationId> {
         self.accepting
         self.accepting_generation
-766
+    }
-767
     /// Returns whether an exact generation remains accepting.
     pub(super) fn is_accepting(&self, generation: H2GenerationId) -> bool {
         self.accepting == Some(generation)
         self.accepting_generation == Some(generation)
-771
+    }
-772
     /// Returns the generation peers may discover after the local cutoff drains.
     pub(super) fn publishable_generation(&self) -> Option<H2GenerationId> {
         let generation = self.accepting?;
     pub(super) fn peer_routable_generation(&self) -> Option<H2GenerationId> {
         let generation = self.accepting_generation?;
         matches!(
             self.gate,
             GenerationGate::Open { generation: gate_generation } if gate_generation == generation
             self.local_activation_gate,
             H2ActivationGate::Open { generation: gate_generation }
                 if gate_generation == generation
-780
+        )
         .then_some(generation)
-782
+    }
-783
     /// Returns whether an exact publishable generation has no request work.
     pub(super) fn is_idle(&self, generation: H2GenerationId) -> bool {
         if self.publishable_generation() != Some(generation) {
         if self.peer_routable_generation() != Some(generation) {
             return false;
-788
+        }
         self.generations.get(&generation).is_some_and(|record| {
             record.pending_waiters.is_empty() && record.prospective == 0 && record.accepted == 0
             record.pending_waiters.is_empty()
                 && record.prospective_requests == 0
                 && record.active_requests == 0
         })
-794
+    }
-795
     /// Returns whether a local generation or peer route suppresses admission demand.
     pub(super) fn has_visible_h2(&self) -> bool {
         self.accepting.is_some() || self.peer_route.is_some()
         self.accepting_generation.is_some() || self.peer_route.is_some()
-799
+    }
-800
     /// Installs or refreshes one identity-only peer route.
     pub(super) fn install_peer_route(&mut self, route: H2Route, cutoff: Option<WaiterId>) {
         if self.accepting.is_some() {
     pub(super) fn attach_peer_route(&mut self, route: H2Route, cutoff: Option<WaiterId>) {
         if self.accepting_generation.is_some() {
             self.peer_route = None;
             self.assert_consistent();
             return;
-807
+        }
         let id = route.id();
         match &mut self.peer_route {
             Some(current) if current.route.id() == id => {
                 if let Some(cutoff) = cutoff {
                     match &mut current.gate {
                         GenerationGate::Closed => {
                     match &mut current.activation_gate {
                         H2ActivationGate::Closed => {
                             unreachable!("visible peer HTTP/2 route had a closed gate")
-815
+                        }
                         GenerationGate::Prioritizing {
                         H2ActivationGate::Prioritizing {
                             cutoff: current, ..
                         } => *current = (*current).max(cutoff),
                         GenerationGate::Open { generation } => {
                             current.gate = GenerationGate::Prioritizing {
                         H2ActivationGate::Open { generation } => {
                             current.activation_gate = H2ActivationGate::Prioritizing {
                                 generation: *generation,
                                 cutoff,
                                 activating: None,
                                 active_turn: None,
                             };
-825
+                        }
-826
+                    }
-827
+                }
-828
+            }
             _ => {
                 self.peer_route = Some(PeerH2Route {
                     gate: GenerationGate::for_generation(id.generation, cutoff),
                     activation_gate: H2ActivationGate::for_generation(id.generation, cutoff),
                     route,
                     crossing: None,
                     crossing_waiter: None,
                 });
-835
+            }
-836
+        }
         self.assert_consistent();
-838
+    }
-839
     /// Marks one requesting waiter as the route's current activation opportunity.
     fn prepare_peer_activation(
         &mut self,
         waiters: &AcquisitionQueue,
     ) -> Option<PreparedPeerActivation> {
         let peer = self.peer_route.as_mut()?;
         if peer.crossing.is_some() {
         if peer.crossing_waiter.is_some() {
             return None;
-848
+        }
         let has_prioritized = peer
             .gate
             .activation_gate
             .priority_cutoff()
             .is_some_and(|cutoff| waiters.has_h2_candidate_through(cutoff));
         let cutoff = match peer.gate.next_turn(has_prioritized) {
             GateTurn::Unavailable => return None,
             GateTurn::Open => None,
             GateTurn::Through(cutoff) => Some(cutoff),
             .is_some_and(|cutoff| waiters.has_h2_compatible_waiter_through(cutoff));
         let cutoff = match peer.activation_gate.take_next_turn(has_prioritized) {
             H2ActivationTurn::Unavailable => return None,
             H2ActivationTurn::Open => None,
             H2ActivationTurn::Through(cutoff) => Some(cutoff),
         };
         let waiter = waiters.oldest_h2_candidate()?;
         let waiter = waiters.oldest_h2_compatible_waiter()?;
         if cutoff.is_some_and(|cutoff| waiter > cutoff) {
             return None;
-861
+        }
         let gated = peer.gate.begin_gate_activation(waiter);
         peer.crossing = Some(waiter);
         let gated = peer.activation_gate.reserve_turn(waiter);
         peer.crossing_waiter = Some(waiter);
         Some(PreparedPeerActivation {
             route: peer.route.clone(),
             waiter,
             cutoff,
             gated,
         })
-870
+    }
-871
     /// Revalidates one peer activation after the connection-cell crossing.
     fn peer_activation_is_current(
         &self,
         prepared: &PreparedPeerActivation,
         waiters: &AcquisitionQueue,
     ) -> bool {
         self.peer_route.as_ref().is_some_and(|peer| {
             peer.route.id() == prepared.route.id()
                 && peer.crossing == Some(prepared.waiter)
                 && (!prepared.gated || peer.gate.activating() == Some(prepared.waiter))
                 && waiters.is_oldest_h2_candidate(prepared.waiter)
                 && peer.crossing_waiter == Some(prepared.waiter)
                 && (!prepared.gated || peer.activation_gate.active_turn() == Some(prepared.waiter))
                 && waiters.is_oldest_h2_compatible_waiter(prepared.waiter)
         })
-884
+    }
-885
     /// Ends one route crossing after its result is installed or rejected.
     fn finish_peer_crossing(&mut self, route: H2RouteId, waiter: WaiterId) -> bool {
     fn release_peer_crossing(&mut self, route: H2RouteId, waiter: WaiterId) -> bool {
         let Some(peer) = &mut self.peer_route else {
             return false;
         };
         if peer.route.id() != route || peer.crossing != Some(waiter) {
         if peer.route.id() != route || peer.crossing_waiter != Some(waiter) {
             return false;
-893
+        }
         peer.crossing = None;
         peer.crossing_waiter = None;
         self.assert_consistent();
         true
-897
+    }
-898
     /// Discharges one prioritized peer-route activation opportunity.
     fn finish_peer_gate(&mut self, route: H2RouteId, waiter: WaiterId) -> bool {
     fn release_peer_turn(&mut self, route: H2RouteId, waiter: WaiterId) -> bool {
         let Some(peer) = &mut self.peer_route else {
             return false;
         };
         if peer.route.id() != route {
             return false;
-906
+        }
         let finished = peer.gate.finish_gate_activation(route.generation, waiter);
         let finished = peer.activation_gate.release_turn(route.generation, waiter);
         self.assert_consistent();
         finished
-910
+    }
-911
     /// Clears a peer activation marker when its requesting waiter is cancelled.
     pub(super) fn cancel_peer_activation(&mut self, waiter: WaiterId) -> bool {
         let Some(route) = self.peer_route.as_ref().map(|peer| peer.route.id()) else {
             return false;
         };
         if self
             .peer_route
             .as_ref()
             .and_then(|peer| peer.gate.activating())
             .and_then(|peer| peer.activation_gate.active_turn())
             != Some(waiter)
-922
+        {
             return false;
-924
+        }
         self.finish_peer_gate(route, waiter)
         self.release_peer_turn(route, waiter)
-926
+    }
-927
     /// Returns an open peer route when no queued acquisition precedes it.
     fn open_peer_route(&self, queued: bool) -> Option<H2Route> {
         let peer = self.peer_route.as_ref()?;
         (!queued && peer.gate.is_open_for(peer.route.id().generation)).then(|| peer.route.clone())
         (!queued && peer.activation_gate.is_open_for(peer.route.id().generation))
             .then(|| peer.route.clone())
-933
+    }
-934
     /// Revalidates a direct peer route after its connection-cell crossing.
     fn direct_peer_route_is_current(&self, route: H2RouteId, queued: bool) -> bool {
         !queued
             && self.peer_route.as_ref().is_some_and(|peer| {
                 peer.route.id() == route && peer.gate.is_open_for(route.generation)
                 peer.route.id() == route && peer.activation_gate.is_open_for(route.generation)
             })
-941
+    }
-942
     /// Removes one stale exact peer route.
     fn clear_peer_route(&mut self, route: H2RouteId) -> bool {
     fn detach_peer_route(&mut self, route: H2RouteId) -> bool {
         if self.peer_route.as_ref().map(|peer| peer.route.id()) != Some(route) {
             return false;
-947
+        }
         self.peer_route = None;
         self.assert_consistent();
         true
-951
+    }
-952
     /// Returns all installed generation identities for shutdown.
     pub(super) fn generation_ids(&self) -> Vec<H2GenerationId> {
         self.generations.keys().copied().collect()
-956
+    }
-957
     /// Returns the accepting generation's idle deadline.
     pub(super) fn nearest_idle_deadline(&self) -> Option<SystemTime> {
         self.accepting
         self.accepting_generation
             .and_then(|generation| self.generations.get(&generation))
             .and_then(|record| record.idle_deadline)
-963
+    }
-964
     /// Returns an accepting generation whose idle deadline elapsed.
     pub(super) fn expired(&self, now: SystemTime) -> Option<H2GenerationId> {
         let generation = self.accepting?;
         let generation = self.accepting_generation?;
         let deadline = self.generations.get(&generation)?.idle_deadline?;
         (deadline <= now).then_some(generation)
-970
+    }
-971
     /// Replaces the accepting generation's idle deadline after dispatch.
     pub(super) fn reset_idle_deadline(
         &mut self,
         generation: H2GenerationId,
         deadline: Option<SystemTime>,
     ) -> bool {
         if self.accepting != Some(generation) {
         if self.accepting_generation != Some(generation) {
             return false;
-980
+        }
         let record = self
             .generations
             .get_mut(&generation)
             .expect("accepting HTTP/2 generation disappeared");
         record.idle_deadline = deadline;
         self.assert_consistent();
         true
-988
+    }
-989
     /// Detaches a draining generation after its last retained request ends.
     #[must_use]
     fn remove_finished_drain(&mut self, generation: H2GenerationId) -> Option<H2Generation> {
         let remove = self.generations.get(&generation).is_some_and(|record| {
             record.residence == H2Residence::Draining
                 && record.prospective == 0
                 && record.accepted == 0
             record.state == H2GenerationState::Draining
                 && record.prospective_requests == 0
                 && record.active_requests == 0
         });
         remove
             .then(|| self.generations.remove(&generation))
             .flatten()
-1001
+    }
-1002
     fn take_flight_id(&mut self) -> H2FlightId {
         let value = self.next_flight;
         self.next_flight = value
         let value = self.next_flight_id;
         self.next_flight_id = value
             .checked_add(1)
             .expect("HTTP/2 flight identity exhausted");
         H2FlightId(value)
-1009
+    }
-1010
     fn take_generation_id(&mut self) -> H2GenerationId {
         let value = self.next_generation;
         self.next_generation = value
         let value = self.next_generation_id;
         self.next_generation_id = value
             .checked_add(1)
             .expect("HTTP/2 generation identity exhausted");
         H2GenerationId(value)
-1017
+    }
-1018
     /// Checks flight, generation, residence, and request-count relationships.
     pub(super) fn assert_consistent(&self) {
         #[cfg(any(debug_assertions, test))]
-1022
+        {
             if std::thread::panicking() {
                 return;
-1025
+            }
             let accepting_records = self
                 .generations
                 .iter()
                 .filter(|(_, record)| record.residence == H2Residence::Accepting)
                 .filter(|(_, record)| record.state == H2GenerationState::Accepting)
                 .map(|(generation, _)| *generation)
                 .collect::<Vec<_>>();
             match self.accepting {
             match self.accepting_generation {
                 Some(generation) => assert_eq!(
                     vec![generation],
                     accepting_records,
                     "HTTP/2 accepting identity did not match generation residence"
                     "HTTP/2 accepting identity did not match generation state"
                 ),
                 None => assert!(
                     accepting_records.is_empty(),
                     "HTTP/2 accepting generation lacked an accepting identity"
                 ),
-1042
+            }
             assert_eq!(
                 self.accepting,
                 self.gate.generation(),
                 self.accepting_generation,
                 self.local_activation_gate.generation(),
                 "HTTP/2 generation gate did not name the accepting generation"
             );
             assert!(
                 self.flight.is_none() || self.accepting.is_none(),
                 self.flight.is_none() || self.accepting_generation.is_none(),
                 "HTTP/2 flight coexisted with an accepting generation"
             );
             if let Some(peer) = &self.peer_route {
                 assert!(
                     self.accepting.is_none(),
                     self.accepting_generation.is_none(),
                     "local accepting generation retained a peer route"
                 );
                 assert_eq!(
                     Some(peer.route.generation()),
                     peer.gate.generation(),
                     "peer route gate did not name the advertised generation"
                     peer.activation_gate.generation(),
                     "peer route gate did not name the routed generation"
                 );
-1062
+            }
-1063
             for record in self.generations.values() {
                 if record.residence == H2Residence::Draining {
                 if record.state == H2GenerationState::Draining {
                     assert!(
                         record.prospective > 0 || record.accepted > 0,
                         record.prospective_requests > 0 || record.active_requests > 0,
                         "empty HTTP/2 draining generation was retained"
                     );
                     assert!(
                         record.pending_waiters.is_empty(),
                         "draining HTTP/2 generation retained unserved waiters"
                     );
-1074
+                }
-1075
+            }
-1076
+        }
-1077
+    }
-1078
     /// Checks transferred waiter identities against the cell's acquisition state.
     /// Checks flight and generation waiters against the cell's acquisition state.
     #[cfg(any(debug_assertions, test))]
     pub(super) fn assert_pending_waiters(&self, waiters: &AcquisitionQueue) {
         if let Some(flight) = &self.flight {
             for waiter in &flight.participants {
                 assert!(
                     waiters.is_launching_h2_waiter(*waiter),
                     "HTTP/2 flight retained a waiter that was no longer launchable"
                 );
-+
+            }
-+
+        }
         for record in self.generations.values() {
             for waiter in &record.pending_waiters {
                 assert!(
                     waiters.is_launching_h2_candidate(*waiter),
                     waiters.is_launching_h2_waiter(*waiter),
                     "HTTP/2 generation retained a waiter that was no longer launchable"
                 );
-1096
+            }
-1097
+        }
-1098
+    }
-1099
+}
-1100
 /// One requesting-cell activation prepared before crossing to its connection cell.
 struct PreparedPeerActivation {
     /// Route validated in the requesting cell before the lock crossing.
     route: H2Route,
     /// Oldest waiter selected for this activation.
     waiter: WaiterId,
     /// Publication cutoff that this waiter must satisfy.
     /// Peer-route cutoff that this waiter must satisfy.
     cutoff: Option<WaiterId>,
     /// Whether acceptance or cancellation must discharge a priority turn.
     gated: bool,
-1111
+}
-1112
 /// State detached when an accepting generation begins draining.
 struct H2CloseTransition {
     /// Connection whose logical close follows cell unlock.
     connection: Arc<ConnectionState>,
     /// Unserved transferred waiters that must re-enter acquisition.
     pending_waiters: BTreeSet<WaiterId>,
     /// Removed record retained until the cell lock is released.
     removed_generation: Option<H2Generation>,
-1121
+}
-1122
 /// Sender and connection cloned while a prospective lease is state-owned.
 struct H2ActivationParts {
     /// Transient sender clone for one activation.
     sender: H2Sender,
     /// Whether the generation has accepted an earlier request.
     reused: bool,
     /// Connection retained through prospective dispatch.
     connection: Arc<ConnectionState>,
--
+}
--
 /// Values transferred together when an activation begins Hyper dispatch.
 pub(in crate::client::pool) struct H2DispatchParts {
     /// Transient sender clone for one dispatch attempt.
     pub(in crate::client::pool) sender: H2Sender,
     /// Request-send endpoint retained by the request body.
     pub(in crate::client::pool) send_endpoint: H2LeaseEndpoint,
     /// Response-receive endpoint retained by the response body.
     pub(in crate::client::pool) receive_endpoint: H2LeaseEndpoint,
--
+}
--
 /// Prospective request reservation against one exact generation.
 ///
 /// Dropping the activation before Hyper accepts the request cancels the
 /// prospective reservation. Acceptance creates endpoint guards and transfers
 /// dispatch accounting to the response lifecycle.
 pub(in crate::client::pool) struct H2Activation {
     /// Cell that owns the selected generation.
     cell: Arc<OriginCell>,
     /// Partition issuing this request.
     request_partition: PartitionId,
     /// Exact generation that owns the prospective count.
     generation: H2GenerationId,
     /// Transient sender transferred at most once into dispatch.
     sender: Option<H2Sender>,
     /// Whether the generation has accepted an earlier request.
     reused: bool,
     /// Connection retained until acceptance or cancellation.
     connection: Arc<ConnectionState>,
     /// Shared state for the request's send and receive endpoints.
     lease: Arc<H2LeaseCore>,
     /// Requesting-cell priority discharged only at acceptance or cancellation.
     gate: Option<H2GateToken>,
     /// Whether drop must cancel the prospective generation count.
     active: bool,
--
+}
--
 impl std::fmt::Debug for H2Activation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("H2Activation")
             .field("generation", &self.generation)
             .field("connection_id", &self.connection.id())
             .field("active", &self.active)
             .finish()
--
+    }
--
+}
--
 impl H2Activation {
     /// Builds an activation after the generation records its prospective lease.
     fn new(
         cell: Arc<OriginCell>,
         generation: H2GenerationId,
         parts: H2ActivationParts,
         gate: Option<H2GateToken>,
     ) -> Self {
         let request_partition = cell.id().partition();
         let lease = Arc::new(H2LeaseCore {
             cell: Weak::from_arc(&cell),
             generation,
             state: Mutex::new(H2LeaseState::Prospective {
                 send_complete: false,
                 receive_complete: false,
             }),
         });
         Self {
             cell,
             request_partition,
             generation,
             sender: Some(parts.sender),
             reused: parts.reused,
             connection: parts.connection,
             lease,
             gate,
             active: true,
--
+        }
--
+    }
--
     /// Returns the exact selected generation.
     #[cfg(test)]
     pub(in crate::client::pool) fn generation(&self) -> H2GenerationId {
         self.generation
--
+    }
--
     /// Returns whether Hyper previously accepted a request on this generation.
     pub(in crate::client::pool) fn is_reused(&self) -> bool {
         self.reused
--
+    }
--
     /// Returns the selected protocol-neutral connection.
     pub(in crate::client::pool) fn connection(&self) -> &Arc<ConnectionState> {
         &self.connection
--
+    }
--
     /// Transfers the sender and both lease endpoints into one dispatch attempt.
     ///
     /// # Panics
     ///
     /// Panics if dispatch parts were already taken.
     pub(in crate::client::pool) fn take_dispatch_parts(&mut self) -> H2DispatchParts {
         let sender = self
             .sender
             .take()
             .expect("HTTP/2 activation dispatch parts already taken");
         let trace = H2EndpointTrace::new(self);
         H2DispatchParts {
             sender,
             send_endpoint: H2LeaseEndpoint::new(
                 self.lease.clone(),
                 H2Endpoint::Send,
                 Some(trace.clone()),
             ),
             receive_endpoint: H2LeaseEndpoint::new(
                 self.lease.clone(),
                 H2Endpoint::Receive,
                 Some(trace),
             ),
--
+        }
--
+    }
--
     /// Retains a requesting-cell route opportunity until acceptance or cancellation.
     fn attach_peer_gate(
         &mut self,
         requesting_cell: &Arc<OriginCell>,
         route: H2RouteId,
         waiter: WaiterId,
     ) {
         debug_assert_eq!(
             self.request_partition,
             requesting_cell.id().partition(),
             "peer HTTP/2 activation changed requesting partition"
         );
         assert!(
             self.gate.is_none(),
             "HTTP/2 activation acquired two requesting-cell gates"
         );
         self.gate = Some(H2GateToken::peer(requesting_cell, route, waiter));
--
+    }
--
     /// Returns close authority for the connection-owning generation.
     pub(in crate::client::pool) fn close_handle(&self) -> H2CloseHandle {
         H2CloseHandle::new(&self.cell, self.generation)
--
+    }
--
     /// Converts the prospective reservation after Hyper accepts the request.
     ///
     /// # Panics
     ///
     /// Panics if dispatch parts were not transferred or the prospective
     /// reservation disappeared before acceptance.
     pub(in crate::client::pool) fn accept(mut self, dispatch: DispatchGuard) {
         assert!(
             self.sender.is_none(),
             "HTTP/2 activation accepted before dispatch parts were taken"
         );
         assert!(
             OriginCell::accept_h2_activation(&self.cell, self.generation),
             "prospective HTTP/2 activation disappeared before acceptance"
         );
         self.active = false;
         self.lease.accept(dispatch);
         if let Some(gate) = self.gate.take() {
             gate.finish();
--
+        }
         tracing::trace!(
             connection_id = %self.connection.id(),
             request_partition = ?self.request_partition,
             connection_partition = ?self.connection.owner_partition(),
             origin_scheme = %self.connection.info().origin().scheme(),
             origin_host = self.connection.info().origin().host(),
             origin_port = ?self.connection.info().origin().port(),
             h2_generation = ?self.generation,
             "HTTP/2 request accepted"
         );
--
+    }
--
+}
--
 impl Drop for H2Activation {
     fn drop(&mut self) {
         if self.active {
             OriginCell::cancel_h2_activation(&self.cell, self.generation);
             self.lease.cancel();
             if let Some(gate) = self.gate.take() {
                 gate.finish();
--
+            }
             tracing::trace!(
                 connection_id = %self.connection.id(),
                 request_partition = ?self.request_partition,
                 connection_partition = ?self.connection.owner_partition(),
                 origin_scheme = %self.connection.info().origin().scheme(),
                 origin_host = self.connection.info().origin().host(),
                 origin_port = ?self.connection.info().origin().port(),
                 h2_generation = ?self.generation,
                 "HTTP/2 activation cancelled before request acceptance"
             );
--
+        }
--
+    }
--
+}
--
 /// One activation opportunity retained until Hyper acceptance or cancellation.
 struct H2GateToken {
     /// Requesting cell whose gate owns this turn.
     cell: Weak<OriginCell>,
     /// Waiter that received the activation opportunity.
     waiter: WaiterId,
     /// Local-generation or peer-route gate identity.
     kind: H2GateKind,
--
+}
--
 /// Cell transition run when an activation accepts or cancels.
 enum H2GateKind {
     /// Gate attached to the connection cell's local generation.
     Local { generation: H2GenerationId },
     /// Gate attached to a requesting cell's peer route.
     Peer { route: H2RouteId },
--
+}
--
 impl H2GateToken {
     fn local(cell: &Arc<OriginCell>, generation: H2GenerationId, waiter: WaiterId) -> Self {
         Self {
             cell: Weak::from_arc(cell),
             waiter,
             kind: H2GateKind::Local { generation },
--
+        }
--
+    }
--
     fn peer(cell: &Arc<OriginCell>, route: H2RouteId, waiter: WaiterId) -> Self {
         Self {
             cell: Weak::from_arc(cell),
             waiter,
             kind: H2GateKind::Peer { route },
--
+        }
--
+    }
--
     fn finish(self) {
         if let Some(cell) = self.cell.upgrade() {
             match self.kind {
                 H2GateKind::Local { generation } => {
                     OriginCell::finish_h2_gate(&cell, generation, self.waiter)
--
+                }
                 H2GateKind::Peer { route } => {
                     OriginCell::finish_peer_h2_gate(&cell, route, self.waiter)
--
+                }
--
+            }
--
+        }
--
+    }
--
+}
--
 /// One terminal side of an accepted HTTP/2 request lease.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum H2Endpoint {
     /// Request-body upload lifetime.
     Send,
     /// Response future and response-body lifetime.
     Receive,
--
+}
--
 /// Shared request-lease phase and endpoint bits.
 enum H2LeaseState {
     /// Generation count reserved before Hyper accepts the request.
     Prospective {
         /// Whether upload ownership already terminated.
         send_complete: bool,
         /// Whether response ownership already terminated.
         receive_complete: bool,
     },
     /// Hyper accepted the request and connection dispatch is retained.
     Accepted {
         /// Whether upload ownership already terminated.
         send_complete: bool,
         /// Whether response ownership already terminated.
         receive_complete: bool,
         /// Accepted-dispatch accounting released with the second endpoint.
         dispatch: DispatchGuard,
     },
     /// Both endpoints terminated or prospective dispatch was cancelled.
     Complete,
--
+}
--
 /// Shared endpoint state for one prospective or accepted request.
 struct H2LeaseCore {
     /// Connection cell updated after both accepted endpoints terminate.
     cell: Weak<OriginCell>,
     /// Exact generation whose request count this lease owns.
     generation: H2GenerationId,
     /// Endpoint phase; never held while locking the cell or connection state.
     state: Mutex<H2LeaseState>,
--
+}
--
 impl H2LeaseCore {
     /// Converts prospective endpoint state to accepted state.
     fn accept(&self, dispatch: DispatchGuard) {
         let mut dispatch = Some(dispatch);
         let complete = {
             let mut state = self.state.lock();
             let (send_complete, receive_complete) = match &*state {
                 H2LeaseState::Prospective {
                     send_complete,
                     receive_complete,
                 } => (*send_complete, *receive_complete),
                 H2LeaseState::Accepted { .. } | H2LeaseState::Complete => {
                     drop(state);
                     panic!("HTTP/2 request lease accepted outside prospective state");
--
+                }
             };
             if send_complete && receive_complete {
                 *state = H2LeaseState::Complete;
                 true
             } else {
                 *state = H2LeaseState::Accepted {
                     send_complete,
                     receive_complete,
                     dispatch: dispatch
                         .take()
                         .expect("HTTP/2 dispatch guard disappeared before acceptance"),
                 };
                 false
--
+            }
         };
         drop(dispatch);
         if complete {
             self.complete_generation();
--
+        }
--
+    }
--
     /// Cancels endpoint state after the prospective reservation ends.
     fn cancel(&self) {
         let mut state = self.state.lock();
         if matches!(*state, H2LeaseState::Prospective { .. }) {
             *state = H2LeaseState::Complete;
--
+        }
--
+    }
--
     /// Marks one endpoint terminal and releases the accepted lease on the second.
     fn complete_endpoint(&self, endpoint: H2Endpoint) -> bool {
         let dispatch = {
             let mut state = self.state.lock();
             match &mut *state {
                 H2LeaseState::Prospective {
                     send_complete,
                     receive_complete,
                 } => {
                     match endpoint {
                         H2Endpoint::Send => *send_complete = true,
                         H2Endpoint::Receive => *receive_complete = true,
--
+                    }
                     None
--
+                }
                 H2LeaseState::Accepted {
                     send_complete,
                     receive_complete,
                     ..
                 } => {
                     match endpoint {
                         H2Endpoint::Send => *send_complete = true,
                         H2Endpoint::Receive => *receive_complete = true,
--
+                    }
                     if *send_complete && *receive_complete {
                         let previous = std::mem::replace(&mut *state, H2LeaseState::Complete);
                         let H2LeaseState::Accepted { dispatch, .. } = previous else {
                             unreachable!("completed HTTP/2 lease changed state under its lock");
                         };
                         Some(dispatch)
                     } else {
                         None
--
+                    }
--
+                }
                 H2LeaseState::Complete => None,
--
+            }
         };
         let request_complete = dispatch.is_some();
         if let Some(dispatch) = dispatch {
             // Dispatch completion takes the connection lifecycle lock. Keep it
             // outside the request-lease lock so endpoint completion cannot
             // nest pool synchronization.
             drop(dispatch);
             self.complete_generation();
--
+        }
         request_complete
--
+    }
--
     /// Releases the generation count after the lease lock is released.
     fn complete_generation(&self) {
         if let Some(cell) = self.cell.upgrade() {
             OriginCell::complete_h2_request(&cell, self.generation);
--
+        }
--
+    }
--
+}
--
 /// Structured identity retained by one request-lease endpoint.
 #[derive(Clone)]
 struct H2EndpointTrace {
     /// Partition that issued the request.
     request_partition: PartitionId,
     /// Stable connection identity and origin metadata.
     connection: Arc<ConnectionInfo>,
     /// Generation that owns the endpoint.
     generation: H2GenerationId,
--
+}
--
 impl H2EndpointTrace {
     fn new(activation: &H2Activation) -> Self {
         Self {
             request_partition: activation.request_partition,
             connection: activation.connection.info().clone(),
             generation: activation.generation,
--
+        }
--
+    }
--
+}
--
 /// Linear guard for one request-lease endpoint.
 pub(in crate::client::pool) struct H2LeaseEndpoint {
     /// Shared request-lease state.
     core: Arc<H2LeaseCore>,
     /// Send or receive side owned by this guard.
     endpoint: H2Endpoint,
     /// Structured fields emitted on terminal completion.
     trace: Option<H2EndpointTrace>,
     /// Whether drop must finish this endpoint.
     active: bool,
--
+}
--
 impl H2LeaseEndpoint {
     fn new(core: Arc<H2LeaseCore>, endpoint: H2Endpoint, trace: Option<H2EndpointTrace>) -> Self {
         Self {
             core,
             endpoint,
             trace,
             active: true,
--
+        }
--
+    }
--
     /// Creates a detached endpoint and observation handle for body tests.
     #[cfg(all(test, not(smithy_http_client_loom), feature = "rt-tokio"))]
     fn for_test(cell: &Arc<OriginCell>, endpoint: H2Endpoint) -> (Self, H2LeaseProbe) {
         let core = Arc::new(H2LeaseCore {
             cell: Weak::from_arc(cell),
             generation: H2GenerationId(0),
             state: Mutex::new(H2LeaseState::Prospective {
                 send_complete: false,
                 receive_complete: false,
             }),
         });
--
+        (
             Self::new(core.clone(), endpoint, None),
             H2LeaseProbe { core },
--
+        )
--
+    }
--
     /// Creates a detached send endpoint and observation handle for body tests.
     #[cfg(all(test, not(smithy_http_client_loom), feature = "rt-tokio"))]
     pub(in crate::client::pool) fn send_for_test(cell: &Arc<OriginCell>) -> (Self, H2LeaseProbe) {
         Self::for_test(cell, H2Endpoint::Send)
--
+    }
--
     /// Creates a detached receive endpoint and observation handle for body tests.
     #[cfg(all(test, not(smithy_http_client_loom), feature = "rt-tokio"))]
     pub(in crate::client::pool) fn receive_for_test(
         cell: &Arc<OriginCell>,
     ) -> (Self, H2LeaseProbe) {
         Self::for_test(cell, H2Endpoint::Receive)
--
+    }
--
     /// Completes this endpoint before dropping the guard.
     pub(in crate::client::pool) fn complete(mut self) {
         self.finish();
--
+    }
--
     fn finish(&mut self) {
         if self.active {
             self.active = false;
             let request_complete = self.core.complete_endpoint(self.endpoint);
             if let Some(trace) = self.trace.take() {
                 tracing::trace!(
                     connection_id = %trace.connection.id(),
                     request_partition = ?trace.request_partition,
                     connection_partition = ?trace.connection.owner_partition(),
                     origin_scheme = %trace.connection.origin().scheme(),
                     origin_host = trace.connection.origin().host(),
                     origin_port = ?trace.connection.origin().port(),
                     h2_generation = ?trace.generation,
                     endpoint = ?self.endpoint,
                     request_complete,
                     "HTTP/2 request endpoint completed"
                 );
--
+            }
--
+        }
--
+    }
--
+}
--
 impl Drop for H2LeaseEndpoint {
     fn drop(&mut self) {
         self.finish();
--
+    }
--
+}
--
 /// Test observation of a request-lease endpoint's production state.
 #[cfg(all(test, not(smithy_http_client_loom), feature = "rt-tokio"))]
 pub(in crate::client::pool) struct H2LeaseProbe {
     /// Production lease state observed by the test.
     core: Arc<H2LeaseCore>,
--
+}
--
 #[cfg(all(test, not(smithy_http_client_loom), feature = "rt-tokio"))]
 impl H2LeaseProbe {
     /// Returns whether the send endpoint reached its terminal transition.
     pub(in crate::client::pool) fn send_complete(&self) -> bool {
         matches!(
             &*self.core.state.lock(),
             H2LeaseState::Prospective {
                 send_complete: true,
                 ..
             } | H2LeaseState::Accepted {
                 send_complete: true,
                 ..
             } | H2LeaseState::Complete
--
+        )
--
+    }
--
     /// Returns whether the receive endpoint reached its terminal transition.
     pub(in crate::client::pool) fn receive_complete(&self) -> bool {
         matches!(
             &*self.core.state.lock(),
             H2LeaseState::Prospective {
                 receive_complete: true,
                 ..
             } | H2LeaseState::Accepted {
                 receive_complete: true,
                 ..
             } | H2LeaseState::Complete
--
+        )
--
+    }
--
+}
--
 impl OriginCell {
     /// Reserves a prospective request lease from one exact local generation.
     /// Reserves a prospective request claim from one exact local generation.
     pub(in crate::client::pool) fn activate_h2(
         cell: &Arc<Self>,
         generation: H2GenerationId,
         request_partition: PartitionId,
     ) -> Option<H2Activation> {
         let (parts, advertisement) = {
         let (parts, revision) = {
             let mut state = cell.state.lock();
             let parts = state.h2.activate(generation)?;
             state.assert_consistent();
             let advertisement = state.take_h2_advertisement_update();
             (parts, advertisement)
             let revision = state.take_h2_supply_update();
             (parts, revision)
         };
         Self::publish_h2_advertisement(cell, advertisement);
         Some(H2Activation::new(cell.clone(), generation, parts, None))
         Self::submit_h2_supply_update(cell, revision);
         Some(H2Activation::new(
             cell.clone(),
             generation,
             parts,
             request_partition,
             None,
         ))
-1145
+    }
-1146
     /// Converts a prospective activation to an accepted generation lease.
     /// Converts a prospective activation to an accepted request claim.
     fn accept_h2_activation(cell: &Arc<Self>, generation: H2GenerationId) -> bool {
         let deadline = cell.idle_deadline();
         let (accepted, reset_deadline) = {
             let mut state = cell.state.lock();
             let accepted = state.h2.accept(generation);
             let reset_deadline = accepted && state.h2.reset_idle_deadline(generation, deadline);
             state.assert_consistent();
             (accepted, reset_deadline)
         };
         if reset_deadline {
             cell.notify_maintenance(deadline);
-1159
+        }
         accepted
-1161
+    }
-1162
     /// Cancels one prospective activation after sender rejection or task drop.
     fn cancel_h2_activation(cell: &Arc<Self>, generation: H2GenerationId) {
         // Keep the detached generation outside the lock's unwind scope. Its
         // sender drop may wake Hyper's driver.
         let (removed, advertisement) = {
         let (removed, revision) = {
             let mut state = cell.state.lock();
             let removed = state.h2.cancel(generation);
             state.assert_consistent();
             let advertisement = state.take_h2_advertisement_update();
             (removed, advertisement)
             let revision = state.take_h2_supply_update();
             (removed, revision)
         };
         drop(removed);
         Self::publish_h2_advertisement(cell, advertisement);
         Self::service_h2_waiters(cell);
         Self::submit_h2_supply_update(cell, revision);
         Self::offer_local_h2(cell);
-1177
+    }
-1178
     /// Releases one accepted lease after its second endpoint terminates.
     fn complete_h2_request(cell: &Arc<Self>, generation: H2GenerationId) {
     /// Releases one accepted request after its upload and response sides finish.
     fn release_h2_request(cell: &Arc<Self>, generation: H2GenerationId) {
         // Keep the detached generation outside the lock's unwind scope. Its
         // sender drop may wake Hyper's driver.
         let (removed, advertisement) = {
         let (removed, revision) = {
             let mut state = cell.state.lock();
             let removed = state.h2.complete_request(generation);
             state.assert_consistent();
             let advertisement = state.take_h2_advertisement_update();
             (removed, advertisement)
             let revision = state.take_h2_supply_update();
             (removed, revision)
         };
         drop(removed);
         Self::publish_h2_advertisement(cell, advertisement);
         Self::submit_h2_supply_update(cell, revision);
-1192
+    }
-1193
     /// Offers one local activation while preserving the generation cutoff.
     fn service_h2_gate_locked(
     fn offer_local_h2_locked(
         cell: &Arc<Self>,
         state: &mut CellState,
         returned_event: &mut Option<AcquisitionEvent>,
     ) -> Option<WaiterInstall> {
         returned_step: &mut Option<AcquisitionStep>,
     ) -> Option<WaiterResolution> {
         let generation = state.h2.accepting()?;
         let has_prioritized = state
             .h2
             .priority_cutoff()
             .is_some_and(|cutoff| state.waiters.has_h2_candidate_through(cutoff));
         let cutoff = match state.h2.next_gate_turn(has_prioritized) {
             GateTurn::Unavailable => return None,
             GateTurn::Open => None,
             GateTurn::Through(cutoff) => Some(cutoff),
             .is_some_and(|cutoff| state.acquisitions.has_h2_compatible_waiter_through(cutoff));
         let cutoff = match state.h2.take_next_turn(has_prioritized) {
             H2ActivationTurn::Unavailable => return None,
             H2ActivationTurn::Open => None,
             H2ActivationTurn::Through(cutoff) => Some(cutoff),
         };
         state.waiters.oldest_h2_candidate()?;
         state.acquisitions.oldest_h2_compatible_waiter()?;
-1211
         let h2 = &mut state.h2;
         let waiters = &mut state.waiters;
         let mut install = waiters.install_h2(
         let acquisitions = &mut state.acquisitions;
         let (waiter, mut install) = acquisitions.offer_h2_activation(
             cutoff,
             |waiter| {
                 let parts = h2
                     .activate(generation)
                     .expect("accepting HTTP/2 generation could not create a gated activation");
                 let gated = h2.begin_gate_activation(waiter);
                 AcquisitionResult::H2(H2Activation::new(
                 let gated = h2.reserve_activation_turn(waiter);
                 AcquisitionOutcome::H2(H2Activation::new(
                     cell.clone(),
                     generation,
                     parts,
                     gated.then(|| H2GateToken::local(cell, generation, waiter)),
                     cell.id.partition(),
                     gated.then(|| H2ActivationTurnGuard::local(cell, generation, waiter)),
                 ))
             },
             &cell.eligibility_group,
         );
         *returned_event = install.returned_event.take();
         *returned_step = install.returned_step.take();
         install.demand_updates = state.publishable_demand_updates(install.demand_updates);
         state.assert_consistent();
         install.waiter.is_some().then_some(install)
         waiter.is_some().then_some(install)
-1235
+    }
-1236
     /// Runs publication, fallback, and wake work after the cell lock is released.
     fn finish_h2_install(cell: &Arc<Self>, install: Option<WaiterInstall>) {
         let Some(install) = install else {
     fn run_waiter_resolution(cell: &Arc<Self>, resolution: Option<WaiterResolution>) {
         let Some(resolution) = resolution else {
             return;
         };
         if let Some(admission) = &cell.admission {
             for snapshot in install.demand_updates.into_iter().flatten() {
                 super::super::admission::OriginAdmission::publish_demand(
                     admission,
                     cell.id.partition(),
                     snapshot,
                 );
             for snapshot in resolution.demand_updates.into_iter().flatten() {
                 OriginAdmission::submit_demand_snapshot(admission, cell.id.partition(), snapshot);
-1245
+            }
-1246
+        }
         drop(install.returned_event);
         if let Some(waker) = install.waker {
         drop(resolution.returned_step);
         if let Some(waker) = resolution.waker {
             waker.wake();
-1250
+        }
-1251
+    }
-1252
     /// Publishes one complete local-generation report after cell unlock.
     fn publish_h2_advertisement(
         cell: &Arc<Self>,
         snapshot: Option<super::super::admission::H2AdvertisementSnapshot>,
     ) {
         if let (Some(admission), Some(snapshot)) = (&cell.admission, snapshot) {
             super::super::admission::OriginAdmission::update_h2_advertisement(
     /// Submits one changed local-generation status after cell unlock.
     fn submit_h2_supply_update(cell: &Arc<Self>, revision: Option<SupplyRevision<H2SupplyStatus>>) {
         if let (Some(admission), Some(revision)) = (&cell.admission, revision) {
             OriginAdmission::apply_h2_supply_revision(
                 admission,
                 cell.id.partition(),
                 cell.eligibility_group.clone(),
                 snapshot,
                 revision,
             );
-1262
+        }
-1263
+    }
-1264
     /// Publishes the current local demand after its last H2 route disappears.
     fn publish_current_demand(
         cell: &Arc<Self>,
         snapshot: Option<super::super::admission::DemandSnapshot>,
     ) {
     fn publish_current_demand(cell: &Arc<Self>, snapshot: Option<DemandSnapshot>) {
         if let (Some(admission), Some(snapshot)) = (&cell.admission, snapshot) {
             super::super::admission::OriginAdmission::publish_demand(
                 admission,
                 cell.id.partition(),
                 snapshot,
             );
             OriginAdmission::submit_demand_snapshot(admission, cell.id.partition(), snapshot);
-1269
+        }
-1270
+    }
-1271
     /// Advances a generation gate after one activation accepts or cancels.
     fn finish_h2_gate(cell: &Arc<Self>, generation: H2GenerationId, waiter: WaiterId) {
         let mut returned_event = None;
         let (install, advertisement) = {
     fn release_local_h2_turn(cell: &Arc<Self>, generation: H2GenerationId, waiter: WaiterId) {
         let mut returned_step = None;
         let (install, revision) = {
             let mut state = cell.state.lock();
             if !state.h2.finish_gate_activation(generation, waiter) {
             if !state.h2.release_activation_turn(generation, waiter) {
                 return;
-1279
+            }
             let install = Self::service_h2_gate_locked(cell, &mut state, &mut returned_event);
             let install = Self::offer_local_h2_locked(cell, &mut state, &mut returned_step);
             state.assert_consistent();
             let advertisement = state.take_h2_advertisement_update();
             (install, advertisement)
             let revision = state.take_h2_supply_update();
             (install, revision)
         };
         drop(returned_event);
         Self::publish_h2_advertisement(cell, advertisement);
         Self::finish_h2_install(cell, install);
         drop(returned_step);
         Self::submit_h2_supply_update(cell, revision);
         Self::run_waiter_resolution(cell, install);
-1288
+    }
-1289
     /// Offers the accepting local generation to one queued acquisition.
     pub(in crate::client::pool) fn service_h2_waiters(cell: &Arc<Self>) {
         let mut returned_event = None;
         let (install, advertisement) = {
     pub(in crate::client::pool) fn offer_local_h2(cell: &Arc<Self>) {
         let mut returned_step = None;
         let (install, revision) = {
             let mut state = cell.state.lock();
             let install = Self::service_h2_gate_locked(cell, &mut state, &mut returned_event);
             let install = Self::offer_local_h2_locked(cell, &mut state, &mut returned_step);
             state.assert_consistent();
             let advertisement = state.take_h2_advertisement_update();
             (install, advertisement)
             let revision = state.take_h2_supply_update();
             (install, revision)
         };
         drop(returned_event);
         Self::publish_h2_advertisement(cell, advertisement);
         Self::finish_h2_install(cell, install);
         drop(returned_step);
         Self::submit_h2_supply_update(cell, revision);
         Self::run_waiter_resolution(cell, install);
-1303
+    }
-1304
     /// Returns whether one exact connection generation still accepts activations.
     pub(in crate::client::pool) fn h2_generation_is_accepting(
         cell: &Arc<Self>,
         generation: H2GenerationId,
     ) -> bool {
         cell.state.lock().h2.is_accepting(generation)
-1311
+    }
-1312
     /// Installs requesting-cell visibility for one peer generation publication.
     /// Attaches requesting-cell visibility for one peer generation route.
     ///
     /// The named local demand remains queued behind the route gate. Advancing
     /// its snapshot version makes admission acknowledgement authoritative
     /// without losing the demand if this exact route later becomes stale.
     pub(in crate::client::pool) fn install_h2_route(
     pub(in crate::client::pool) fn attach_h2_route(
         cell: &Arc<Self>,
         route: H2Route,
         group: &super::super::partition::EligibilityGroup,
         demand: super::super::admission::DemandId,
         group: &EligibilityGroup,
         demand: DemandId,
     ) -> bool {
         if &cell.eligibility_group != group || route.connection_partition() == cell.id.partition() {
             return false;
-1326
+        }
         let mut state = cell.state.lock();
         if !state.waiters.suppress_published_demand(demand) {
         if !state.acquisitions.supersede_demand_snapshot(demand) {
             return false;
-1330
+        }
         let cutoff = state.waiters.publication_cutoff();
         state.h2.install_peer_route(route, cutoff);
         let cutoff = state.acquisitions.route_cutoff();
         state.h2.attach_peer_route(route, cutoff);
         state.assert_consistent();
         true
-1335
+    }
-1336
     /// Activates queued requests through the currently visible peer route.
     ///
     /// Preparing the requesting-cell opportunity, activating the connection
     /// generation, and committing the result each use a separate lock scope.
     pub(in crate::client::pool) fn service_peer_h2_waiters(cell: &Arc<Self>) {
     pub(in crate::client::pool) fn offer_peer_h2(cell: &Arc<Self>) {
         loop {
             let prepared = {
                 let mut state = cell.state.lock();
                 let CellState { h2, waiters, .. } = &mut *state;
                 let prepared = h2.prepare_peer_activation(waiters);
                 let CellState {
                     h2, acquisitions, ..
                 } = &mut *state;
                 let prepared = h2.prepare_peer_activation(acquisitions);
                 state.assert_consistent();
                 prepared
             };
             let Some(prepared) = prepared else {
                 return;
             };
             let route_id = prepared.route.id();
             let Some(activation) = prepared.route.activate(cell.id.partition()) else {
                 let snapshot = {
                     let mut state = cell.state.lock();
                     if !state.h2.clear_peer_route(route_id) {
                     if !state.h2.detach_peer_route(route_id) {
                         return;
-1361
+                    }
                     let snapshot = state
                         .waiters
                         .acquisitions
                         .current_demand_snapshot(&cell.eligibility_group);
                     state.assert_consistent();
                     snapshot
                 };
                 if let (Some(admission), Some(snapshot)) = (&cell.admission, snapshot) {
                     super::super::admission::OriginAdmission::publish_demand(
                     OriginAdmission::submit_demand_snapshot(
                         admission,
                         cell.id.partition(),
                         snapshot,
                     );
-1374
+                }
                 return;
             };
-1377
             let mut activation = Some(activation);
             let mut returned_event = None;
             let mut returned_step = None;
             let install = {
                 let mut state = cell.state.lock();
                 let current = state
                     .h2
                     .peer_activation_is_current(&prepared, &state.waiters);
                     .peer_activation_is_current(&prepared, &state.acquisitions);
                 if !current {
                     state.h2.finish_peer_crossing(route_id, prepared.waiter);
                     state.h2.release_peer_crossing(route_id, prepared.waiter);
                     if prepared.gated {
                         state.h2.finish_peer_gate(route_id, prepared.waiter);
                         state.h2.release_peer_turn(route_id, prepared.waiter);
-1389
+                    }
                     state.assert_consistent();
                     None
                 } else {
                     if prepared.gated {
                         activation
                             .as_mut()
                             .expect("peer HTTP/2 activation disappeared")
                             .attach_peer_gate(cell, route_id, prepared.waiter);
                             .attach_peer_turn(cell, route_id, prepared.waiter);
-1398
+                    }
                     let mut install = state.waiters.install_h2(
                     let (waiter, mut install) = state.acquisitions.offer_h2_activation(
                         prepared.cutoff,
                         |_| {
                             AcquisitionResult::H2(
                             AcquisitionOutcome::H2(
                                 activation
                                     .take()
                                     .expect("peer HTTP/2 activation was installed twice"),
-1406
+                            )
                         },
                         &cell.eligibility_group,
                     );
                     returned_event = install.returned_event.take();
                     returned_step = install.returned_step.take();
                     install.demand_updates =
                         state.publishable_demand_updates(install.demand_updates);
                     state.h2.finish_peer_crossing(route_id, prepared.waiter);
                     if install.waiter.is_none() && prepared.gated {
                         state.h2.finish_peer_gate(route_id, prepared.waiter);
                     state.h2.release_peer_crossing(route_id, prepared.waiter);
                     if waiter.is_none() && prepared.gated {
                         state.h2.release_peer_turn(route_id, prepared.waiter);
-1416
+                    }
                     state.assert_consistent();
                     install.waiter.is_some().then_some(install)
                     waiter.is_some().then_some(install)
-1419
+                }
             };
             drop(activation);
             drop(returned_event);
             drop(returned_step);
             if install.is_some() {
                 Self::finish_h2_install(cell, install);
                 Self::run_waiter_resolution(cell, install);
                 return;
-1426
+            }
-1427
+        }
-1428
+    }
-1429
     /// Advances an exact peer-route gate after acceptance or cancellation.
     fn finish_peer_h2_gate(cell: &Arc<Self>, route: H2RouteId, waiter: WaiterId) {
     fn release_peer_h2_turn(cell: &Arc<Self>, route: H2RouteId, waiter: WaiterId) {
         let finished = {
             let mut state = cell.state.lock();
             let finished = state.h2.finish_peer_gate(route, waiter);
             let finished = state.h2.release_peer_turn(route, waiter);
             state.assert_consistent();
             finished
         };
         if finished {
             Self::service_peer_h2_waiters(cell);
             Self::offer_peer_h2(cell);
-1440
+        }
-1441
+    }
-1442
+}
-1443
 /// Generation-specific close authority that does not retain the cell.
 #[derive(Clone, Debug)]
 pub(in crate::client::pool) struct H2CloseHandle {
     /// Cell weak reference so driver lifetime does not retain the pool.
     cell: Weak<OriginCell>,
     /// Exact generation this handle may close.
     generation: H2GenerationId,
-1451
+}
-1452
 impl H2CloseHandle {
     /// Creates close authority for one installed generation.
     pub(in crate::client::pool) fn new(cell: &Arc<OriginCell>, generation: H2GenerationId) -> Self {
         Self {
             cell: Weak::from_arc(cell),
             generation,
-1459
+        }
-1460
+    }
-1461
     /// Begins drain when the cell still contains this generation.
     pub(in crate::client::pool) fn close(
         &self,
         reason: super::super::connection::CloseReason,
     ) -> bool {
     pub(in crate::client::pool) fn close(&self, reason: CloseReason) -> bool {
         self.cell
             .upgrade()
             .is_some_and(|cell| OriginCell::close_h2(&cell, self.generation, reason))
-1467
+    }
-1468
+}
-1469
 /// Closes an H2 generation if its owner-runtime driver ends or is dropped.
 pub(in crate::client::pool) struct H2DriverGuard {
     /// Exact-generation close authority.
     close: H2CloseHandle,
     /// Whether drop must report owner-runtime shutdown.
     active: bool,
-1476
+}
-1477
 impl H2DriverGuard {
     /// Arms generation cleanup before driver submission.
     pub(in crate::client::pool) fn new(close: H2CloseHandle) -> Self {
         Self {
             close,
             active: true,
-1484
+        }
-1485
+    }
-1486
     /// Records ordinary driver completion.
     pub(in crate::client::pool) fn protocol_closed(mut self) {
         self.active = false;
         self.close
             .close(super::super::connection::CloseReason::ProtocolClosed);
         self.close.close(CloseReason::ProtocolClosed);
-1491
+    }
-1492
+}
-1493
 impl Drop for H2DriverGuard {
     fn drop(&mut self) {
         if self.active {
             self.close
                 .close(super::super::connection::CloseReason::OwnerRuntimeShutdown);
             self.close.close(CloseReason::OwnerRuntimeShutdown);
-1498
+        }
-1499
+    }
-1500
+}
-1501
 impl OriginCell {
     /// Selects an accepting local generation before consulting a peer route.
     pub(in crate::client::pool) fn select_h2(cell: &Arc<Self>) -> Option<H2Activation> {
         let local = {
             let mut state = cell.state.lock();
             let queued = state.waiters.has_h2_candidate();
             let queued = state.acquisitions.has_h2_compatible_waiter();
             if state.h2.direct_is_allowed(queued) {
                 let generation = state.h2.accepting()?;
                 let parts = state.h2.activate(generation)?;
                 state.assert_consistent();
                 let advertisement = state.take_h2_advertisement_update();
                 Some((generation, parts, advertisement))
                 let revision = state.take_h2_supply_update();
                 Some((generation, parts, revision))
             } else {
                 None
-1516
+            }
         };
         if let Some((generation, parts, advertisement)) = local {
             Self::publish_h2_advertisement(cell, advertisement);
             return Some(H2Activation::new(cell.clone(), generation, parts, None));
         if let Some((generation, parts, revision)) = local {
             Self::submit_h2_supply_update(cell, revision);
             return Some(H2Activation::new(
                 cell.clone(),
                 generation,
                 parts,
                 cell.id.partition(),
                 None,
             ));
-1527
+        }
-1528
         let route = {
             let state = cell.state.lock();
             state.h2.open_peer_route(state.waiters.has_h2_candidate())?
             state
                 .h2
                 .open_peer_route(state.acquisitions.has_h2_compatible_waiter())?
         };
         let route_id = route.id();
         let Some(activation) = route.activate(cell.id.partition()) else {
             Self::clear_stale_peer_route(cell, route_id);
             Self::detach_stale_peer_route(cell, route_id);
             return None;
         };
         let current = {
             let state = cell.state.lock();
             state
                 .h2
                 .direct_peer_route_is_current(route_id, state.waiters.has_h2_candidate())
             state.h2.direct_peer_route_is_current(
                 route_id,
                 state.acquisitions.has_h2_compatible_waiter(),
-+
+            )
         };
         current.then_some(activation)
-1548
+    }
-1549
     /// Removes one exact stale route and republishes the requesting demand.
     fn clear_stale_peer_route(cell: &Arc<Self>, route: H2RouteId) {
     fn detach_stale_peer_route(cell: &Arc<Self>, route: H2RouteId) {
         let snapshot = {
             let mut state = cell.state.lock();
             if !state.h2.clear_peer_route(route) {
             if !state.h2.detach_peer_route(route) {
                 return;
-1556
+            }
             let snapshot = state
                 .waiters
                 .acquisitions
                 .current_demand_snapshot(&cell.eligibility_group);
             state.assert_consistent();
             snapshot
         };
         Self::publish_current_demand(cell, snapshot);
-1564
+    }
-1565
     /// Places a post-ALPN waiter behind an already accepting generation.
     pub(in crate::client::pool) fn join_h2_generation(
         cell: &Arc<Self>,
         waiter: WaiterId,
         generation: H2GenerationId,
     ) -> H2GenerationJoin {
         let mut returned_event = None;
         let (install, advertisement) = {
     ) -> H2GenerationJoinOutcome {
         let mut returned_step = None;
         let (install, revision) = {
             let mut state = cell.state.lock();
             if !state.waiters.is_launching_h2_candidate(waiter) {
                 return H2GenerationJoin::WaiterCompleted;
             if !state.acquisitions.is_launching_h2_waiter(waiter) {
                 return H2GenerationJoinOutcome::WaiterResolved;
-1577
+            }
             if !state.h2.prioritize_waiter(generation, waiter) {
                 return H2GenerationJoin::GenerationChanged;
                 return H2GenerationJoinOutcome::GenerationChanged;
-1580
+            }
             let install = Self::service_h2_gate_locked(cell, &mut state, &mut returned_event);
             let install = Self::offer_local_h2_locked(cell, &mut state, &mut returned_step);
             state.assert_consistent();
             let advertisement = state.take_h2_advertisement_update();
             (install, advertisement)
             let revision = state.take_h2_supply_update();
             (install, revision)
         };
         drop(returned_event);
         Self::publish_h2_advertisement(cell, advertisement);
         Self::finish_h2_install(cell, install);
         H2GenerationJoin::Joined
         drop(returned_step);
         Self::submit_h2_supply_update(cell, revision);
         Self::run_waiter_resolution(cell, install);
         H2GenerationJoinOutcome::Joined
-1590
+    }
-1591
     /// Atomically selects, joins, or installs the cell's post-ALPN flight.
     pub(in crate::client::pool) fn install_or_join_h2_flight(
         &self,
         waiter: WaiterId,
     ) -> H2FlightInstall {
     pub(in crate::client::pool) fn converge_h2_flight(&self, waiter: WaiterId) -> H2FlightDecision {
         let mut state = self.state.lock();
         if !state.waiters.is_launching_h2_candidate(waiter) {
             return H2FlightInstall::WaiterCompleted;
         if !state.acquisitions.is_launching_h2_waiter(waiter) {
             return H2FlightDecision::WaiterResolved;
-1597
+        }
         let result = state.h2.install_or_join_flight(waiter);
         let result = state.h2.converge_flight(waiter);
         state.assert_consistent();
         result
-1601
+    }
-1602
     /// Installs one successful flight as the accepting generation.
     pub(in crate::client::pool) fn complete_h2_flight(
         cell: &Arc<Self>,
         flight: H2FlightId,
         connection: Arc<ConnectionState>,
         sender: H2Sender,
         idle_deadline: Option<SystemTime>,
     ) -> Result<H2GenerationId, (Arc<ConnectionState>, H2Sender)> {
         let mut returned_event = None;
         let (completion, install, advertisement) = {
         let mut returned_step = None;
         let (completion, install, revision) = {
             let mut state = cell.state.lock();
             let completion = state
                 .h2
                 .complete_flight(flight, connection, sender, idle_deadline);
             let install = if completion.is_ok() {
                 let cutoff = state.waiters.publication_cutoff();
                 let cutoff = state.acquisitions.route_cutoff();
                 state.h2.prioritize_through(cutoff);
                 Self::service_h2_gate_locked(cell, &mut state, &mut returned_event)
                 Self::offer_local_h2_locked(cell, &mut state, &mut returned_step)
             } else {
                 None
             };
             state.assert_consistent();
             let advertisement = state.take_h2_advertisement_update();
             (completion, install, advertisement)
             let revision = state.take_h2_supply_update();
             (completion, install, revision)
         };
         drop(returned_event);
         Self::publish_h2_advertisement(cell, advertisement);
         Self::finish_h2_install(cell, install);
         drop(returned_step);
         Self::submit_h2_supply_update(cell, revision);
         Self::run_waiter_resolution(cell, install);
         if completion.is_ok() {
             cell.notify_maintenance(idle_deadline);
-1633
+        }
         completion
-1635
+    }
-1636
     /// Retires one failed flight and returns its retained participants.
     pub(in crate::client::pool) fn fail_h2_flight(
         &self,
         flight: H2FlightId,
     ) -> Option<Vec<WaiterId>> {
         let mut state = self.state.lock();
         let participants = state.h2.fail_flight(flight);
         state.assert_consistent();
         participants
-1646
+    }
-1647
     /// Returns the complete current advertisement for an unlocked crossing.
     pub(in crate::client::pool) fn report_h2_advertisement(
     /// Returns the complete current H2 supply revision for an unlocked crossing.
     pub(in crate::client::pool) fn current_h2_supply_revision(
         &self,
     ) -> super::super::admission::H2AdvertisementSnapshot {
     ) -> SupplyRevision<H2SupplyStatus> {
         let mut state = self.state.lock();
         let snapshot = state.report_h2_advertisement();
         let revision = state.current_h2_supply_revision();
         state.assert_consistent();
         snapshot
         revision
-1656
+    }
-1657
     /// Reclaims one exact idle generation and reports its resulting availability.
     pub(in crate::client::pool) fn reclaim_idle_h2(
         cell: &Arc<Self>,
         generation: H2GenerationId,
     ) -> (
         super::super::admission::H2AdvertisementSnapshot,
         Option<ConnectionId>,
     ) {
     ) -> (SupplyRevision<H2SupplyStatus>, Option<ConnectionId>) {
         // A zero-request generation may hold the last capacity-owning
         // connection reference. Keep it outside the cell-lock unwind scope.
         let detached;
         let (advertisement, demand) = {
         let (revision, demand) = {
             let mut state = cell.state.lock();
             detached = state.h2.begin_idle_reclaim(generation);
             let advertisement = state.report_h2_advertisement();
             let revision = state.current_h2_supply_revision();
             let demand = detached.as_ref().and_then(|_| {
                 state
                     .waiters
                     .acquisitions
                     .current_demand_snapshot(&cell.eligibility_group)
             });
             state.assert_consistent();
             (advertisement, demand)
             (revision, demand)
         };
         let Some(detached) = detached else {
             return (advertisement, None);
             return (revision, None);
         };
         let H2CloseTransition {
             connection,
             pending_waiters,
             removed_generation,
         } = detached;
         assert!(
             pending_waiters.is_empty(),
             "idle HTTP/2 reclaim detached pending generation waiters"
         );
         let connection_id = connection.id();
         drop(removed_generation);
         Self::publish_current_demand(cell, demand);
         let reclaimed = connection.logical_close(super::super::connection::CloseReason::Reclaimed);
         (advertisement, reclaimed.then_some(connection_id))
         let reclaimed = connection.logical_close(CloseReason::Reclaimed);
         (revision, reclaimed.then_some(connection_id))
-1695
+    }
-1696
     /// Moves one exact generation to draining and closes its connection.
     pub(super) fn close_h2(
         cell: &Arc<Self>,
         generation: H2GenerationId,
         reason: super::super::connection::CloseReason,
         reason: CloseReason,
     ) -> bool {
         // A zero-request generation may hold the last capacity-owning
         // connection reference. Keep it outside the cell-lock unwind scope.
         let detached;
         let (advertisement, demand) = {
         let (revision, demand) = {
             let mut state = cell.state.lock();
             detached = state.h2.begin_close(generation);
             let advertisement = detached
             let revision = detached
                 .as_ref()
                 .and_then(|_| state.take_h2_advertisement_update());
                 .and_then(|_| state.take_h2_supply_update());
             let demand = detached.as_ref().and_then(|_| {
                 state
                     .waiters
                     .acquisitions
                     .current_demand_snapshot(&cell.eligibility_group)
             });
             state.assert_consistent();
             (advertisement, demand)
             (revision, demand)
         };
         let Some(detached) = detached else {
             return false;
         };
         let H2CloseTransition {
             connection,
             pending_waiters,
             removed_generation,
         } = detached;
         drop(removed_generation);
         Self::publish_h2_advertisement(cell, advertisement);
         Self::submit_h2_supply_update(cell, revision);
         Self::publish_current_demand(cell, demand);
         for waiter in pending_waiters {
             cell.complete_establishment(waiter, AcquisitionResult::Reacquire);
             cell.complete_establishment(waiter, AcquisitionOutcome::RetryAcquisition);
-1733
+        }
         connection.logical_close(reason)
-1735
+    }
-1736
     /// Returns the exact accepting generation for publication.
     /// Returns the exact accepting generation for peer routing.
     #[cfg(test)]
     pub(in crate::client::pool) fn accepting_h2_generation(&self) -> Option<H2GenerationId> {
         self.state.lock().h2.accepting()
-1741
+    }
-1742
     /// Returns the prospective and accepted request counts for one generation.
     /// Returns the prospective and active request counts for one generation.
     #[cfg(test)]
     pub(in crate::client::pool) fn h2_request_counts(
         &self,
         generation: H2GenerationId,
     ) -> Option<(usize, usize)> {
         self.state
             .lock()
             .h2
             .generations
             .get(&generation)
             .map(|record| (record.prospective, record.accepted))
             .map(|record| (record.prospective_requests, record.active_requests))
-1755
+    }
-1756
     /// Installs an accepting generation without a Hyper handshake.
     #[cfg(test)]
     pub(in crate::client::pool) fn install_h2_for_test(
         cell: &Arc<Self>,
         connection: Arc<ConnectionState>,
         sender_id: u64,
         idle_deadline: Option<SystemTime>,
     ) -> H2GenerationId {
         let (generation, advertisement) = {
         let (generation, revision) = {
             let mut state = cell.state.lock();
             let generation = state.h2.install_generation(
             let generation = state.h2.open_generation(
                 BTreeSet::new(),
                 connection,
                 H2Sender::test(sender_id),
                 idle_deadline,
             );
             state.assert_consistent();
             let advertisement = state.take_h2_advertisement_update();
             (generation, advertisement)
             let revision = state.take_h2_supply_update();
             (generation, revision)
         };
         Self::publish_h2_advertisement(cell, advertisement);
         Self::submit_h2_supply_update(cell, revision);
         cell.notify_maintenance(idle_deadline);
         generation
-1780
+    }
-1781
+}
-1782
 #[cfg(all(test, not(smithy_http_client_loom)))]
 mod tests {
     use super::*;
     use crate::client::pool::admission::ProtocolRequirement;
     use crate::client::pool::connection::{CloseReason, ConnectionInfo};
     use crate::client::pool::origin::OriginKey;
     use crate::client::pool::partition::EligibilityGroup;
     use aws_smithy_runtime_api::client::connection::ConnectionId;
     use http_1x::uri::Scheme;
-1792
     fn cell() -> Arc<OriginCell> {
         Arc::new(OriginCell::new(
             PartitionId::from_index(1),
             OriginKey::from_parts(Scheme::HTTPS, "example.com", None).unwrap(),
             EligibilityGroup::Pool,
             None,
             None,
         ))
-1801
+    }
-1802
     fn bounded_cell(
         admission: &Arc<crate::client::pool::admission::OriginAdmission>,
         partition: usize,
     ) -> Arc<OriginCell> {
         crate::client::pool::admission::OriginAdmission::register_cell(
             admission,
             Arc::new(OriginCell::new(
                 PartitionId::from_index(partition),
                 OriginKey::from_parts(Scheme::HTTPS, "example.com", None).unwrap(),
                 EligibilityGroup::Pool,
                 Some(admission.clone()),
                 None,
             )),
-1816
+        )
-1817
+    }
-1818
     fn connection(
         id: u64,
     ) -> (
         Arc<ConnectionState>,
         super::super::super::connection::PhysicalConnectionGuard,
     ) {
         ConnectionState::unbounded(ConnectionInfo::for_test(
             ConnectionId::new(id),
             PartitionId::from_index(1),
         ))
-1829
+    }
-1830
     fn begin_waiter(cell: &Arc<OriginCell>) -> WaiterId {
         let waiter = OriginCell::register_waiter(cell, ProtocolRequirement::H2Required);
         let event = cell
             .take_ready_event(waiter)
             .expect("unbounded H2 waiter did not receive establishment authority");
         let super::super::AcquisitionEvent::Establish(permit) = event else {
         let super::super::AcquisitionStep::StartEstablishment(permit) = event else {
             panic!("new H2 waiter completed before establishment");
         };
         assert!(cell.start_establishment(waiter));
         drop(permit);
         waiter
-1842
+    }
-1843
     fn install_generation(
     fn open_test_generation(
         cell: &Arc<OriginCell>,
         connection_id: u64,
     ) -> (
         H2GenerationId,
         Arc<ConnectionState>,
         super::super::super::connection::PhysicalConnectionGuard,
     ) {
         let waiter = begin_waiter(cell);
         let H2FlightInstall::Driver(flight) = cell.install_or_join_h2_flight(waiter) else {
         let H2FlightDecision::RunFlight(flight) = cell.converge_h2_flight(waiter) else {
             panic!("fresh cell did not create an HTTP/2 flight");
         };
         let (connection, physical) = connection(connection_id);
         let generation = OriginCell::complete_h2_flight(
             cell,
             flight,
             connection.clone(),
             H2Sender::test(connection_id),
             None,
-1863
+        )
         .expect("fresh flight did not install");
         let event = cell
             .take_ready_event(waiter)
             .expect("flight completion did not satisfy its waiter");
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             activation,
         )) = event
         else {
             panic!("flight completion produced a non-H2 result");
         };
         drop(activation);
         (generation, connection, physical)
-1876
+    }
-1877
     fn generation_counts(cell: &OriginCell, generation: H2GenerationId) -> (usize, usize) {
         cell.h2_request_counts(generation)
             .expect("generation was not installed")
-1881
+    }
-1882
     #[test]
     fn flight_converges_participants_and_cancellation() {
         let mut records = H2Records::default();
         let mut records = H2CellState::default();
         let first = WaiterId(1);
         let second = WaiterId(2);
-1888
         let H2FlightInstall::Driver(flight) = records.install_or_join_flight(first) else {
         let H2FlightDecision::RunFlight(flight) = records.converge_flight(first) else {
             panic!("first participant did not become the flight driver");
         };
         assert!(matches!(
             records.install_or_join_flight(second),
             H2FlightInstall::Joined
             records.converge_flight(second),
             H2FlightDecision::JoinedFlight
         ));
         records.cancel_flight_participant(second);
         assert_eq!(Some(vec![first]), records.fail_flight(flight));
         assert!(records.flight.is_none());
-1899
+    }
-1900
     #[test]
     #[should_panic(expected = "HTTP/2 flight retained a waiter that was no longer launchable")]
     fn flight_participant_must_remain_launchable() {
         let cell = cell();
         let waiter = begin_waiter(&cell);
         assert!(matches!(
             cell.converge_h2_flight(waiter),
             H2FlightDecision::RunFlight(_)
         ));
-+
         let mut state = cell.state.lock();
         let cancellation = state
             .acquisitions
             .cancel_waiter(waiter, &cell.eligibility_group)
             .expect("launching waiter did not cancel");
         drop(cancellation);
         state.h2.assert_pending_waiters(&state.acquisitions);
-+
+    }
-+
     #[test]
     fn accepting_generation_prevents_a_second_flight() {
         let mut records = H2Records::default();
         let mut records = H2CellState::default();
         let (connection, _physical) = connection(1);
         let generation =
             records.install_generation(BTreeSet::new(), connection, H2Sender::test(1), None);
             records.open_generation(BTreeSet::new(), connection, H2Sender::test(1), None);
-1926
         assert!(matches!(
             records.install_or_join_flight(WaiterId(1)),
             H2FlightInstall::Accepting(current) if current == generation
             records.converge_flight(WaiterId(1)),
             H2FlightDecision::UseGeneration(current) if current == generation
         ));
         assert!(records.flight.is_none());
-1932
+    }
-1933
     #[test]
     fn flight_convergence_does_not_retain_a_cancelled_waiter() {
         let cell = cell();
         let waiter = begin_waiter(&cell);
-1938
         assert!(OriginCell::cancel_waiter(&cell, waiter));
         assert!(matches!(
             cell.install_or_join_h2_flight(waiter),
             H2FlightInstall::WaiterCompleted
             cell.converge_h2_flight(waiter),
             H2FlightDecision::WaiterResolved
         ));
         assert!(cell.state.lock().h2.flight.is_none());
         assert_eq!(0, cell.retained_waiters_for_test());
-1946
+    }
-1947
     #[test]
     fn generation_join_does_not_retain_a_waiter_already_served_by_the_gate() {
         let cell = cell();
         let first = begin_waiter(&cell);
         let second = begin_waiter(&cell);
         let H2FlightInstall::Driver(flight) = cell.install_or_join_h2_flight(first) else {
         let H2FlightDecision::RunFlight(flight) = cell.converge_h2_flight(first) else {
             panic!("first waiter did not become the flight driver");
         };
         assert!(matches!(
             cell.install_or_join_h2_flight(second),
             H2FlightInstall::Joined
             cell.converge_h2_flight(second),
             H2FlightDecision::JoinedFlight
         ));
-1960
         let (connection, _physical) = connection(1);
         let generation =
             OriginCell::complete_h2_flight(&cell, flight, connection, H2Sender::test(1), None)
                 .expect("flight did not install");
-1965
         assert_eq!(
             H2GenerationJoin::WaiterCompleted,
             H2GenerationJoinOutcome::WaiterResolved,
             OriginCell::join_h2_generation(&cell, first, generation)
         );
         assert!(OriginCell::close_h2(
             &cell,
             generation,
             CloseReason::PoolDropped,
         ));
         assert!(matches!(
             cell.install_or_join_h2_flight(first),
             H2FlightInstall::WaiterCompleted
             cell.converge_h2_flight(first),
             H2FlightDecision::WaiterResolved
         ));
         assert!(cell.state.lock().h2.flight.is_none());
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             activation,
         )) = cell
             .take_ready_event(first)
             .expect("generation gate did not serve the first waiter")
         else {
             panic!("first waiter received a non-H2 result");
         };
-1988
         drop(activation);
         assert!(matches!(
             cell.take_ready_event(second),
             Some(super::super::AcquisitionEvent::Complete(
                 super::super::AcquisitionResult::Reacquire
             Some(super::super::AcquisitionStep::Resolved(
                 super::super::AcquisitionOutcome::RetryAcquisition
             ))
         ));
         assert_eq!(0, cell.retained_waiters_for_test());
-1997
+    }
-1998
     #[test]
     fn generation_gate_services_committed_waiters_before_direct_arrivals() {
         let cell = cell();
         let first = begin_waiter(&cell);
         let second = begin_waiter(&cell);
         let H2FlightInstall::Driver(flight) = cell.install_or_join_h2_flight(first) else {
         let H2FlightDecision::RunFlight(flight) = cell.converge_h2_flight(first) else {
             panic!("first participant did not become the flight driver");
         };
         assert!(matches!(
             cell.install_or_join_h2_flight(second),
             H2FlightInstall::Joined
             cell.converge_h2_flight(second),
             H2FlightDecision::JoinedFlight
         ));
         let (connection, _physical) = connection(1);
         OriginCell::complete_h2_flight(&cell, flight, connection, H2Sender::test(1), None)
             .expect("flight did not install");
-2014
         assert!(
             OriginCell::select_h2(&cell).is_none(),
             "direct arrival bypassed committed waiters"
         );
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             first_activation,
         )) = cell
             .take_ready_event(first)
             .expect("first waiter was not served")
         else {
             panic!("first waiter received a non-H2 result");
         };
         drop(first_activation);
-2028
         assert!(
             OriginCell::select_h2(&cell).is_none(),
             "direct arrival bypassed the second committed waiter"
         );
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             second_activation,
         )) = cell
             .take_ready_event(second)
             .expect("second waiter was not served")
         else {
             panic!("second waiter received a non-H2 result");
         };
         drop(second_activation);
-2042
         assert!(
             OriginCell::select_h2(&cell).is_some(),
             "gate did not open after committed waiters drained"
         );
-2047
+    }
-2048
     #[test]
     fn cancelling_an_open_gate_activation_services_the_next_waiter() {
         use crate::client::pool::admission::OriginAdmission;
         use std::num::NonZeroUsize;
-2053
         let admission = OriginAdmission::for_test(NonZeroUsize::new(1).unwrap());
         let cell = OriginAdmission::register_cell(
             &admission,
             Arc::new(OriginCell::new(
                 PartitionId::from_index(1),
                 OriginKey::from_parts(Scheme::HTTPS, "example.com", None).unwrap(),
                 EligibilityGroup::Pool,
                 Some(admission.clone()),
                 None,
             )),
         );
         let (connection, _physical) = ConnectionState::bounded(
             ConnectionInfo::for_test(ConnectionId::new(1), cell.id().partition()),
             OriginAdmission::lease_for_test(&admission),
         );
         let generation = OriginCell::install_h2_for_test(&cell, connection, 1, None);
         cell.state.lock().h2.prioritize_through(Some(WaiterId(0)));
-2071
         let first = OriginCell::register_waiter(&cell, ProtocolRequirement::H2Required);
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             first_activation,
         )) = cell
             .take_ready_event(first)
             .expect("first waiter was not served")
         else {
             panic!("first waiter received a non-H2 result");
         };
         let second = OriginCell::register_waiter(&cell, ProtocolRequirement::H2Required);
         let third = OriginCell::register_waiter(&cell, ProtocolRequirement::H2Required);
         assert_eq!((1, 0), generation_counts(&cell, generation));
-2084
         drop(first_activation);
         assert_eq!((1, 0), generation_counts(&cell, generation));
         assert!(OriginCell::cancel_waiter(&cell, second));
         assert_eq!(
             (1, 0),
             generation_counts(&cell, generation),
             "cancelling an open-gate activation stranded its successor"
         );
-2093
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             third_activation,
         )) = cell
             .take_ready_event(third)
             .expect("successor was not served after cancellation")
         else {
             panic!("successor received a non-H2 result");
         };
         drop(third_activation);
         assert_eq!((0, 0), generation_counts(&cell, generation));
         assert!(OriginCell::close_h2(
             &cell,
             generation,
             CloseReason::PoolDropped,
         ));
-2109
+    }
-2110
     #[test]
     fn cancelling_an_unserved_flight_participant_prunes_the_generation() {
         let cell = cell();
         let first = begin_waiter(&cell);
         let second = begin_waiter(&cell);
         let H2FlightInstall::Driver(flight) = cell.install_or_join_h2_flight(first) else {
         let H2FlightDecision::RunFlight(flight) = cell.converge_h2_flight(first) else {
             panic!("first participant did not become the flight driver");
         };
         assert!(matches!(
             cell.install_or_join_h2_flight(second),
             H2FlightInstall::Joined
             cell.converge_h2_flight(second),
             H2FlightDecision::JoinedFlight
         ));
         let (connection, _physical) = connection(1);
         let generation =
             OriginCell::complete_h2_flight(&cell, flight, connection, H2Sender::test(1), None)
                 .expect("flight did not install");
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             first_activation,
         )) = cell
             .take_ready_event(first)
             .expect("first participant was not served")
         else {
             panic!("first participant received a non-H2 result");
         };
-2135
         assert!(OriginCell::cancel_waiter(&cell, second));
         assert!(OriginCell::close_h2(
             &cell,
             generation,
             CloseReason::PoolDropped,
         ));
         drop(first_activation);
         assert_eq!(0, cell.retained_waiters_for_test());
-2144
+    }
-2145
     #[test]
     fn returned_h1_prunes_a_transferred_h2_waiter() {
         let cell = cell();
         let first = begin_waiter(&cell);
         let second = OriginCell::register_waiter(&cell, ProtocolRequirement::H1Compatible);
         let super::super::AcquisitionEvent::Establish(permit) = cell
         let super::super::AcquisitionStep::StartEstablishment(permit) = cell
             .take_ready_event(second)
             .expect("second participant did not receive establishment authority")
         else {
             panic!("second participant completed before establishment");
         };
         assert!(cell.start_establishment(second));
         drop(permit);
-2159
         let H2FlightInstall::Driver(flight) = cell.install_or_join_h2_flight(first) else {
         let H2FlightDecision::RunFlight(flight) = cell.converge_h2_flight(first) else {
             panic!("first participant did not become the flight driver");
         };
         assert!(matches!(
             cell.install_or_join_h2_flight(second),
             H2FlightInstall::Joined
             cell.converge_h2_flight(second),
             H2FlightDecision::JoinedFlight
         ));
         let (h2_connection, _h2_physical) = connection(1);
         let generation =
             OriginCell::complete_h2_flight(&cell, flight, h2_connection, H2Sender::test(1), None)
                 .expect("flight did not install");
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             first_activation,
         )) = cell
             .take_ready_event(first)
             .expect("first participant was not served")
         else {
             panic!("first participant received a non-H2 result");
         };
-2179
         let (h1_connection, _h1_physical) = connection(2);
         let returning = OriginCell::install_selected_h1(
         let returning = OriginCell::insert_selected_h1(
             &cell,
             h1_connection,
             super::super::h1::H1Sender::test(2),
         );
         drop(returning);
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H1(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H1(
             selection,
         )) = cell
             .take_ready_event(second)
             .expect("returned HTTP/1 sender did not serve the compatible waiter")
         else {
             panic!("compatible waiter received a non-H1 result");
         };
         drop(selection);
-2196
         assert!(OriginCell::close_h2(
             &cell,
             generation,
             CloseReason::PoolDropped,
         ));
         drop(first_activation);
         assert_eq!(0, cell.retained_waiters_for_test());
-2204
+    }
-2205
     #[test]
     fn later_local_activation_does_not_hide_an_open_generation_from_peers() {
         let mut records = H2Records::default();
         let mut records = H2CellState::default();
         let committed = WaiterId(1);
         let later = WaiterId(2);
         let H2FlightInstall::Driver(flight) = records.install_or_join_flight(committed) else {
         let H2FlightDecision::RunFlight(flight) = records.converge_flight(committed) else {
             panic!("first participant did not become the flight driver");
         };
         let (connection, _physical) = connection(1);
         let generation = records
             .complete_flight(flight, connection, H2Sender::test(1), None)
             .expect("flight did not install");
         records.prioritize_through(Some(committed));
-2219
         assert_eq!(
             GateTurn::Through(committed),
             records.next_gate_turn(true),
             H2ActivationTurn::Through(committed),
             records.take_next_turn(true),
             "committed waiter did not retain initial priority"
         );
         records.begin_gate_activation(committed);
         assert_eq!(None, records.publishable_generation());
         assert!(records.finish_gate_activation(generation, committed));
         records.reserve_activation_turn(committed);
         assert_eq!(None, records.peer_routable_generation());
         assert!(records.release_activation_turn(generation, committed));
-2228
         assert_eq!(GateTurn::Open, records.next_gate_turn(false));
         records.begin_gate_activation(later);
         assert_eq!(H2ActivationTurn::Open, records.take_next_turn(false));
         records.reserve_activation_turn(later);
         assert_eq!(
             Some(generation),
             records.publishable_generation(),
             records.peer_routable_generation(),
             "a post-cutoff local activation hid the generation from peers"
         );
-2236
+    }
-2237
     #[test]
     fn generation_close_reacquires_unserved_flight_participant() {
         let cell = cell();
         let first = begin_waiter(&cell);
         let second = begin_waiter(&cell);
         let H2FlightInstall::Driver(flight) = cell.install_or_join_h2_flight(first) else {
         let H2FlightDecision::RunFlight(flight) = cell.converge_h2_flight(first) else {
             panic!("first participant did not become the flight driver");
         };
         assert!(matches!(
             cell.install_or_join_h2_flight(second),
             H2FlightInstall::Joined
             cell.converge_h2_flight(second),
             H2FlightDecision::JoinedFlight
         ));
         let (connection, _physical) = connection(1);
         let generation =
             OriginCell::complete_h2_flight(&cell, flight, connection, H2Sender::test(1), None)
                 .expect("flight did not install");
-2254
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             first_activation,
         )) = cell
             .take_ready_event(first)
             .expect("first participant was not served")
         else {
             panic!("first participant received a non-H2 result");
         };
         assert!(cell.take_ready_event(second).is_none());
-2264
         assert!(OriginCell::close_h2(
             &cell,
             generation,
             CloseReason::Poisoned
         ));
         assert!(matches!(
             cell.take_ready_event(second),
             Some(super::super::AcquisitionEvent::Complete(
                 super::super::AcquisitionResult::Reacquire
             Some(super::super::AcquisitionStep::Resolved(
                 super::super::AcquisitionOutcome::RetryAcquisition
             ))
         ));
         drop(first_activation);
         assert_eq!(0, cell.retained_waiters_for_test());
-2278
+    }
-2279
     #[test]
     fn bounded_generation_close_returns_capacity_and_reacquires_participant() {
         use crate::client::pool::admission::OriginAdmission;
         use std::num::NonZeroUsize;
-2284
         let admission = OriginAdmission::for_test(NonZeroUsize::new(2).unwrap());
         let cell = OriginAdmission::register_cell(
             &admission,
             Arc::new(OriginCell::new(
                 PartitionId::from_index(1),
                 OriginKey::from_parts(Scheme::HTTPS, "example.com", None).unwrap(),
                 EligibilityGroup::Pool,
                 Some(admission.clone()),
                 None,
             )),
         );
         let mut participants = Vec::new();
         for _ in 0..2 {
             let waiter = OriginCell::register_waiter(&cell, ProtocolRequirement::H2Required);
             let super::super::AcquisitionEvent::Establish(permit) = cell
             let super::super::AcquisitionStep::StartEstablishment(permit) = cell
                 .take_ready_event(waiter)
                 .expect("bounded participant did not receive capacity")
             else {
                 panic!("bounded participant completed before establishment");
             };
             assert!(cell.start_establishment(waiter));
             participants.push((waiter, permit));
-2307
+        }
         let (first, first_permit) = participants.remove(0);
         let (second, second_permit) = participants.remove(0);
         let H2FlightInstall::Driver(flight) = cell.install_or_join_h2_flight(first) else {
         let H2FlightDecision::RunFlight(flight) = cell.converge_h2_flight(first) else {
             panic!("first participant did not become the flight driver");
         };
         assert!(matches!(
             cell.install_or_join_h2_flight(second),
             H2FlightInstall::Joined
             cell.converge_h2_flight(second),
             H2FlightDecision::JoinedFlight
         ));
         drop(second_permit);
         let (connection, _physical) = ConnectionState::bounded(
             ConnectionInfo::for_test(ConnectionId::new(1), cell.id().partition()),
             first_permit
                 .into_lease()
                 .expect("bounded permit had no lease"),
         );
         let generation =
             OriginCell::complete_h2_flight(&cell, flight, connection, H2Sender::test(1), None)
                 .expect("bounded flight did not install");
         let super::super::AcquisitionEvent::Complete(super::super::AcquisitionResult::H2(
         let super::super::AcquisitionStep::Resolved(super::super::AcquisitionOutcome::H2(
             first_activation,
         )) = cell
             .take_ready_event(first)
             .expect("first participant was not served")
         else {
             panic!("first participant received a non-H2 result");
         };
-2335
         assert!(OriginCell::close_h2(
             &cell,
             generation,
             CloseReason::Poisoned
         ));
         assert!(matches!(
             cell.take_ready_event(second),
             Some(super::super::AcquisitionEvent::Complete(
                 super::super::AcquisitionResult::Reacquire
             Some(super::super::AcquisitionStep::Resolved(
                 super::super::AcquisitionOutcome::RetryAcquisition
             ))
         ));
         drop(first_activation);
         assert_eq!(2, admission.available_capacity_for_test());
         assert_eq!(0, cell.retained_waiters_for_test());
-2350
+    }
-2351
     #[test]
     fn generation_is_reused_only_after_hyper_acceptance() {
         let cell = cell();
         let (_generation, connection, _physical) = install_generation(&cell, 1);
         let (_generation, connection, _physical) = open_test_generation(&cell, 1);
-2356
         let mut activation =
             OriginCell::select_h2(&cell).expect("accepting generation was not selected");
         assert!(!activation.is_reused());
         let H2DispatchParts {
             sender: _sender,
             send_endpoint: send,
             receive_endpoint: receive,
             upload,
             response,
         } = activation.take_dispatch_parts();
         let dispatch = ConnectionState::try_commit_dispatch(&connection)
             .expect("open connection rejected dispatch");
         activation.accept(dispatch);
         drop(send);
         drop(receive);
         drop(upload);
         drop(response);
-2370
         let reused = OriginCell::select_h2(&cell).expect("accepted generation was not reusable");
         assert!(reused.is_reused());
         drop(reused);
-2374
+    }
-2375
     #[test]
     #[should_panic(expected = "HTTP/2 activation dispatch parts already taken")]
     fn activation_transfers_dispatch_parts_once() {
         let cell = cell();
         let (_generation, _connection, _physical) = install_generation(&cell, 1);
         let (_generation, _connection, _physical) = open_test_generation(&cell, 1);
         let mut activation =
             OriginCell::select_h2(&cell).expect("accepting generation was not selected");
-2383
         let _first = activation.take_dispatch_parts();
         let _second = activation.take_dispatch_parts();
-2386
+    }
-2387
     #[test]
     fn prospective_activation_cancellation_returns_its_generation_count() {
         let cell = cell();
         let (generation, _connection, _physical) = install_generation(&cell, 1);
         let (generation, _connection, _physical) = open_test_generation(&cell, 1);
-2392
         let activation =
             OriginCell::select_h2(&cell).expect("accepting generation was not selected");
         assert_eq!((1, 0), generation_counts(&cell, generation));
         drop(activation);
         assert_eq!((0, 0), generation_counts(&cell, generation));
-2398
+    }
-2399
     #[test]
     fn accepted_lease_waits_for_both_endpoints_in_either_order() {
         for send_first in [true, false] {
     fn accepted_claim_waits_for_both_sides_in_either_order() {
         for upload_first in [true, false] {
             let cell = cell();
             let (generation, connection, _physical) = install_generation(&cell, 1);
             let (generation, connection, _physical) = open_test_generation(&cell, 1);
             let mut activation =
                 OriginCell::select_h2(&cell).expect("accepting generation was not selected");
             let H2DispatchParts {
                 sender: _sender,
                 send_endpoint: send,
                 receive_endpoint: receive,
                 upload,
                 response,
             } = activation.take_dispatch_parts();
             let dispatch = ConnectionState::try_commit_dispatch(&connection)
                 .expect("open connection rejected dispatch");
             activation.accept(dispatch);
             assert_eq!((0, 1), generation_counts(&cell, generation));
             assert_eq!(1, connection.snapshot().in_flight);
             assert_eq!(1, connection.probe().in_flight);
-2417
             if send_first {
                 drop(send);
             if upload_first {
                 drop(upload);
                 assert_eq!((0, 1), generation_counts(&cell, generation));
                 receive.complete();
                 response.finish();
             } else {
                 receive.complete();
                 response.finish();
                 assert_eq!((0, 1), generation_counts(&cell, generation));
                 drop(send);
                 drop(upload);
-2426
+            }
-2427
             assert_eq!((0, 0), generation_counts(&cell, generation));
             assert_eq!(0, connection.snapshot().in_flight);
             assert_eq!(0, connection.probe().in_flight);
-2430
+        }
-2431
+    }
-2432
     #[test]
     fn stale_route_cannot_activate_a_replacement_or_retained_drain() {
         let cell = cell();
         let (first, _first_connection, _first_physical) = install_generation(&cell, 1);
         let (first, _first_connection, _first_physical) = open_test_generation(&cell, 1);
         let stale_route = H2Route::new(&cell, first);
         let retained = OriginCell::select_h2(&cell).expect("first generation was not selectable");
         assert!(OriginCell::close_h2(
             &cell,
             first,
             CloseReason::ProtocolClosed
         ));
-2444
         let (second, _second_connection, _second_physical) = install_generation(&cell, 2);
         let (second, _second_connection, _second_physical) = open_test_generation(&cell, 2);
         assert_ne!(first, second);
         assert!(
             stale_route.activate(PartitionId::from_index(2)).is_none(),
             "stale route activated a draining or replacement generation"
         );
         drop(retained);
-2452
+    }
-2453
     #[test]
     fn accepting_identity_rejects_a_retained_draining_generation() {
         let cell = cell();
         let (first, _first_connection, _first_physical) = install_generation(&cell, 1);
         let (first, _first_connection, _first_physical) = open_test_generation(&cell, 1);
         let retained = OriginCell::select_h2(&cell).expect("first generation was not selectable");
         assert!(OriginCell::close_h2(
             &cell,
             first,
             CloseReason::ProtocolClosed
         ));
         let (second, _second_connection, _second_physical) = install_generation(&cell, 2);
         let (second, _second_connection, _second_physical) = open_test_generation(&cell, 2);
-2465
         assert!(cell.state.lock().h2.is_accepting(second));
         assert!(!cell.state.lock().h2.is_accepting(first));
         drop(retained);
-2469
+    }
-2470
     #[test]
     fn activation_requires_the_exact_accepting_generation() {
         let cell = cell();
         let (first, _first_connection, _first_physical) = install_generation(&cell, 1);
         let (first, _first_connection, _first_physical) = open_test_generation(&cell, 1);
         let retained = OriginCell::select_h2(&cell).expect("first generation was not selectable");
         assert!(OriginCell::close_h2(
             &cell,
             first,
             CloseReason::ProtocolClosed
         ));
         let (second, _second_connection, _second_physical) = install_generation(&cell, 2);
         let (second, _second_connection, _second_physical) = open_test_generation(&cell, 2);
-2482
-2483
+        {
             let mut state = cell.state.lock();
             let first_record = state
                 .h2
                 .generations
                 .get_mut(&first)
                 .expect("retained generation disappeared");
             assert_eq!(H2Residence::Draining, first_record.residence);
             first_record.residence = H2Residence::Accepting;
             assert_eq!(H2GenerationState::Draining, first_record.state);
             first_record.state = H2GenerationState::Accepting;
             assert!(
                 state.h2.activate(first).is_none(),
                 "non-current generation accepted an activation"
             );
             state
                 .h2
                 .generations
                 .get_mut(&first)
                 .expect("retained generation disappeared")
                 .residence = H2Residence::Draining;
                 .state = H2GenerationState::Draining;
             state.assert_consistent();
-2503
+        }
-2504
         assert!(cell.state.lock().h2.is_accepting(second));
         drop(retained);
-2507
+    }
-2508
     #[test]
     fn activation_requires_accepting_residence() {
     fn activation_requires_accepting_generation_state() {
         let cell = cell();
         let (first, _first_connection, _first_physical) = install_generation(&cell, 1);
         let (first, _first_connection, _first_physical) = open_test_generation(&cell, 1);
         let retained = OriginCell::select_h2(&cell).expect("first generation was not selectable");
         assert!(OriginCell::close_h2(
             &cell,
             first,
             CloseReason::ProtocolClosed
         ));
         let (second, _second_connection, _second_physical) = install_generation(&cell, 2);
         let (second, _second_connection, _second_physical) = open_test_generation(&cell, 2);
-2520
-2521
+        {
             let mut state = cell.state.lock();
             assert_eq!(
                 H2Residence::Draining,
                 state.h2.generations[&first].residence
                 H2GenerationState::Draining,
                 state.h2.generations[&first].state
             );
             state.h2.accepting = Some(first);
             state.h2.accepting_generation = Some(first);
             assert!(
                 state.h2.activate(first).is_none(),
                 "draining generation accepted an activation"
             );
             state.h2.accepting = Some(second);
             state.h2.accepting_generation = Some(second);
             state.assert_consistent();
-2534
+        }
-2535
         drop(retained);
-2537
+    }
-2538
     #[test]
     fn local_generation_excludes_a_peer_route() {
         let local_cell = cell();
         let (generation, _connection, _physical) = install_generation(&local_cell, 1);
         let (generation, _connection, _physical) = open_test_generation(&local_cell, 1);
         let peer_cell = Arc::new(OriginCell::new(
             PartitionId::from_index(2),
             local_cell.id().origin().clone(),
             EligibilityGroup::Pool,
             None,
             None,
         ));
         let route = H2Route::new(&peer_cell, H2GenerationId::for_test(99));
-2551
         let mut state = local_cell.state.lock();
         state.h2.install_peer_route(route, None);
         state.h2.attach_peer_route(route, None);
         assert!(state.h2.peer_route.is_none());
         assert_eq!(Some(generation), state.h2.accepting());
-2556
+    }
-2557
     #[test]
     fn open_generation_allows_concurrent_prospective_activations() {
         let cell = cell();
         let (generation, _connection, _physical) = install_generation(&cell, 1);
         let (generation, _connection, _physical) = open_test_generation(&cell, 1);
-2562
         let first = OriginCell::select_h2(&cell).expect("first activation was not selected");
         let second =
             OriginCell::select_h2(&cell).expect("open generation serialized the second activation");
         assert_eq!((2, 0), generation_counts(&cell, generation));
         drop(first);
         drop(second);
         assert_eq!((0, 0), generation_counts(&cell, generation));
-2570
+    }
-2571
     #[test]
     fn consistency_checks_do_not_repanic_during_unwind() {
         use std::panic::{catch_unwind, AssertUnwindSafe};
-2575
         let cell = cell();
         let (generation, _connection, _physical) = install_generation(&cell, 1);
         let (generation, _connection, _physical) = open_test_generation(&cell, 1);
         let activation =
             OriginCell::select_h2(&cell).expect("accepting generation did not activate");
         let (corrupt_connection, corrupt_physical) = connection(2);
-2581
+        {
             let mut state = cell.state.lock();
             state.h2.generations.insert(
                 H2GenerationId(99),
                 H2Generation {
                     pending_waiters: BTreeSet::new(),
                     connection: corrupt_connection,
                     sender: H2Sender::test(2),
                     residence: H2Residence::Draining,
                     prospective: 0,
                     has_dispatched: false,
                     accepted: 0,
                     state: H2GenerationState::Draining,
                     prospective_requests: 0,
                     has_accepted_request: false,
                     active_requests: 0,
                     idle_deadline: None,
                 },
             );
-2596
+        }
-2597
         let result = catch_unwind(AssertUnwindSafe(move || {
             let _activation = activation;
             panic!("primary test panic");
         }));
         assert!(result.is_err(), "primary panic was not observed");
-2603
         let removed = {
             let mut state = cell.state.lock();
             state.h2.generations.remove(&H2GenerationId(99))
         };
         drop(removed);
         drop(corrupt_physical);
         assert!(OriginCell::close_h2(
             &cell,
             generation,
             CloseReason::PoolDropped,
         ));
-2615
+    }
-2616
     #[test]
     fn removed_generation_id_cannot_activate_or_close_the_current_generation() {
         let cell = cell();
         let (first, first_connection, _first_physical) = install_generation(&cell, 1);
         let (first, first_connection, _first_physical) = open_test_generation(&cell, 1);
         let stale = H2CloseHandle::new(&cell, first);
         assert!(stale.close(CloseReason::ProtocolClosed));
         assert_eq!(
             Some(CloseReason::ProtocolClosed),
             first_connection.snapshot().close_reason
             first_connection.probe().close_reason
         );
-2627
         let (second, second_connection, _second_physical) = install_generation(&cell, 2);
         let (second, second_connection, _second_physical) = open_test_generation(&cell, 2);
         assert_ne!(first, second);
         assert!(OriginCell::activate_h2(&cell, first).is_none());
         assert!(OriginCell::activate_h2(&cell, first, cell.id.partition()).is_none());
         assert!(!stale.close(CloseReason::Poisoned));
         assert_eq!(None, second_connection.snapshot().close_reason);
         assert_eq!(None, second_connection.probe().close_reason);
         assert_eq!(Some(second), cell.accepting_h2_generation());
-2634
+    }
-2635
     #[test]
     fn close_drops_detached_capacity_only_after_cell_unlock() {
         use crate::client::pool::admission::OriginAdmission;
         use std::num::NonZeroUsize;
         use std::panic::{catch_unwind, AssertUnwindSafe};
-2641
         let admission = OriginAdmission::for_test(NonZeroUsize::MIN);
         let cell = OriginAdmission::register_cell(
             &admission,
             Arc::new(OriginCell::new(
                 PartitionId::from_index(1),
                 OriginKey::from_parts(Scheme::HTTPS, "example.com", None).unwrap(),
                 EligibilityGroup::Pool,
                 Some(admission.clone()),
                 None,
             )),
         );
         let info = ConnectionInfo::for_test(ConnectionId::new(1), PartitionId::from_index(1));
         let (bounded_connection, physical) = ConnectionState::pending_open(info);
         bounded_connection
             .open(Some(OriginAdmission::lease_for_test(&admission)))
             .expect("bounded test connection did not open");
         let generation =
             OriginCell::install_h2_for_test(&cell, bounded_connection.clone(), 1, None);
         drop(bounded_connection);
         drop(physical);
-2662
         // Keep an unrelated empty drain so the close transition's final
         // consistency check panics after detaching the bounded connection.
         let (corrupt_connection, corrupt_physical) = connection(2);
-2666
+        {
             let mut state = cell.state.lock();
             state.h2.generations.insert(
                 H2GenerationId(99),
                 H2Generation {
                     pending_waiters: BTreeSet::new(),
                     connection: corrupt_connection,
                     sender: H2Sender::test(2),
                     residence: H2Residence::Draining,
                     prospective: 0,
                     has_dispatched: false,
                     accepted: 0,
                     state: H2GenerationState::Draining,
                     prospective_requests: 0,
                     has_accepted_request: false,
                     active_requests: 0,
                     idle_deadline: None,
                 },
             );
-2681
+        }
         drop(corrupt_physical);
-2683
         let result = catch_unwind(AssertUnwindSafe(|| {
             OriginCell::close_h2(&cell, generation, CloseReason::ProtocolClosed);
         }));
         assert!(
             result.is_err(),
             "corrupt H2 state did not reach its consistency assertion"
         );
-2691
         // This second lease exists only if unwinding dropped the connection
         // after the cell guard, allowing capacity to return through admission.
         drop(OriginAdmission::lease_for_test(&admission));
-2695
+    }
-2696
     #[test]
     fn close_retains_an_accepted_generation_until_both_endpoints_finish() {
     fn close_retains_an_accepted_generation_until_both_request_sides_finish() {
         let cell = cell();
         let (generation, connection, _physical) = install_generation(&cell, 1);
         let (generation, connection, _physical) = open_test_generation(&cell, 1);
         let mut activation =
             OriginCell::select_h2(&cell).expect("accepting generation was not selected");
         let H2DispatchParts {
             sender: _sender,
             send_endpoint: send,
             receive_endpoint: receive,
             upload,
             response,
         } = activation.take_dispatch_parts();
         let dispatch = ConnectionState::try_commit_dispatch(&connection)
             .expect("open connection rejected dispatch");
         activation.accept(dispatch);
-2711
         assert!(OriginCell::close_h2(
             &cell,
             generation,
             CloseReason::ProtocolClosed
         ));
         assert!(cell.state.lock().h2.generations.contains_key(&generation));
         drop(send);
         drop(upload);
         assert!(cell.state.lock().h2.generations.contains_key(&generation));
         drop(receive);
         drop(response);
         assert!(!cell.state.lock().h2.generations.contains_key(&generation));
         assert_eq!(0, connection.snapshot().in_flight);
         assert_eq!(0, connection.probe().in_flight);
-2723
+    }
-2724
     #[test]
     fn driver_task_drop_closes_its_exact_generation() {
         let cell = cell();
         let (generation, connection, _physical) = install_generation(&cell, 1);
         let (generation, connection, _physical) = open_test_generation(&cell, 1);
         let guard = H2DriverGuard::new(H2CloseHandle::new(&cell, generation));
-2730
         drop(guard);
-2732
         assert_eq!(
             Some(CloseReason::OwnerRuntimeShutdown),
             connection.snapshot().close_reason
             connection.probe().close_reason
         );
         assert_eq!(None, cell.accepting_h2_generation());
-2738
+    }
-2739
     #[test]
     fn local_selection_withdraws_idle_h2_from_reclaim() {
         use crate::client::pool::admission::OriginAdmission;
         use std::num::NonZeroUsize;
-2744
         let admission = OriginAdmission::for_test(NonZeroUsize::MIN);
         let connection_cell = bounded_cell(&admission, 1);
         let requesting_cell = bounded_cell(&admission, 2);
         let info = ConnectionInfo::for_test(ConnectionId::new(1), connection_cell.id().partition());
         let (connection, _physical) = ConnectionState::pending_open(info);
         connection
             .open(Some(OriginAdmission::lease_for_test(&admission)))
             .expect("bounded HTTP/2 connection did not open");
         let generation =
             OriginCell::install_h2_for_test(&connection_cell, connection.clone(), 1, None);
         let activation = OriginCell::select_h2(&connection_cell)
             .expect("local accepting generation did not activate");
-2757
         let (waiter, demand) =
             requesting_cell.register_waiter_without_publish(ProtocolRequirement::H1Required);
         let action = OriginAdmission::publish_action_without_driving(
         let action = OriginAdmission::submit_action_without_running(
             &admission,
             requesting_cell.id().partition(),
             demand,
         );
         assert!(
             action.is_none(),
             "busy local HTTP/2 generation remained eligible for reclaim"
         );
-2769
         assert!(OriginCell::cancel_waiter(&requesting_cell, waiter));
         drop(activation);
         assert_eq!(None, connection.snapshot().close_reason);
         assert_eq!(None, connection.probe().close_reason);
         assert!(OriginCell::close_h2(
             &connection_cell,
             generation,
             CloseReason::PoolDropped,
         ));
-2778
+    }
-2779
     #[test]
     fn h1_required_demand_preserves_h2_without_an_http1_guarantee() {
         use crate::client::pool::admission::OriginAdmission;
         use std::num::NonZeroUsize;
-2784
         let admission = OriginAdmission::for_test_with_h2_reclaim(NonZeroUsize::MIN, false);
         let connection_cell = bounded_cell(&admission, 1);
         let requesting_cell = bounded_cell(&admission, 2);
         let info = ConnectionInfo::for_test(ConnectionId::new(1), connection_cell.id().partition());
         let (connection, _physical) = ConnectionState::pending_open(info);
         connection
             .open(Some(OriginAdmission::lease_for_test(&admission)))
             .expect("bounded HTTP/2 connection did not open");
         let generation =
             OriginCell::install_h2_for_test(&connection_cell, connection.clone(), 1, None);
-2795
         let waiter = OriginCell::register_waiter(&requesting_cell, ProtocolRequirement::H1Required);
         assert!(
             requesting_cell.take_ready_event(waiter).is_none(),
             "H1-required demand reclaimed capacity without an HTTP/1 guarantee"
         );
         assert_eq!(None, connection.snapshot().close_reason);
         assert_eq!(None, connection.probe().close_reason);
         assert_eq!(Some(generation), connection_cell.accepting_h2_generation());
-2803
         assert!(OriginCell::close_h2(
             &connection_cell,
             generation,
             CloseReason::ProtocolClosed,
         ));
         let super::super::AcquisitionEvent::Establish(permit) = requesting_cell
         let super::super::AcquisitionStep::StartEstablishment(permit) = requesting_cell
             .take_ready_event(waiter)
             .expect("ordinary H2 close did not release capacity")
         else {
             panic!("released capacity produced a non-establishment result");
         };
         drop(permit);
         assert_eq!(1, admission.available_capacity_for_test());
-2817
+    }
-2818
     #[test]
     fn h1_required_demand_reclaims_idle_h2_capacity() {
         use crate::client::pool::admission::OriginAdmission;
         use std::num::NonZeroUsize;
-2823
         let admission = OriginAdmission::for_test(NonZeroUsize::MIN);
         let connection_cell = bounded_cell(&admission, 1);
         let requesting_cell = bounded_cell(&admission, 2);
         let info = ConnectionInfo::for_test(ConnectionId::new(1), connection_cell.id().partition());
         let (connection, _physical) = ConnectionState::pending_open(info);
         connection
             .open(Some(OriginAdmission::lease_for_test(&admission)))
             .expect("bounded HTTP/2 connection did not open");
         OriginCell::install_h2_for_test(&connection_cell, connection.clone(), 1, None);
-2833
         let waiter = OriginCell::register_waiter(&requesting_cell, ProtocolRequirement::H1Required);
         let super::super::AcquisitionEvent::Establish(permit) = requesting_cell
         let super::super::AcquisitionStep::StartEstablishment(permit) = requesting_cell
             .take_ready_event(waiter)
             .expect("idle HTTP/2 reclaim did not deliver capacity")
         else {
             panic!("idle HTTP/2 reclaim produced a non-capacity result");
         };
-2841
         assert_eq!(
             Some(CloseReason::Reclaimed),
             connection.snapshot().close_reason
             connection.probe().close_reason
         );
         assert_eq!(None, connection_cell.accepting_h2_generation());
         drop(permit);
         assert_eq!(1, admission.available_capacity_for_test());
-2849
+    }
-2850
     #[test]
     fn h1_required_demand_waits_for_active_h2_before_reclaim() {
         use crate::client::pool::admission::OriginAdmission;
         use std::num::NonZeroUsize;
-2855
         let admission = OriginAdmission::for_test(NonZeroUsize::MIN);
         let connection_cell = bounded_cell(&admission, 1);
         let requesting_cell = bounded_cell(&admission, 2);
         let info = ConnectionInfo::for_test(ConnectionId::new(1), connection_cell.id().partition());
         let (connection, _physical) = ConnectionState::pending_open(info);
         connection
             .open(Some(OriginAdmission::lease_for_test(&admission)))
             .expect("bounded HTTP/2 connection did not open");
         let generation =
             OriginCell::install_h2_for_test(&connection_cell, connection.clone(), 1, None);
         let activation = OriginCell::activate_h2(&connection_cell, generation)
         let activation = OriginCell::activate_h2(
             &connection_cell,
             generation,
             requesting_cell.id().partition(),
-+
+        )
         .expect("accepting HTTP/2 generation did not activate");
-2872
         let waiter = OriginCell::register_waiter(&requesting_cell, ProtocolRequirement::H1Required);
         assert!(
             requesting_cell.take_ready_event(waiter).is_none(),
             "active HTTP/2 generation was reclaimed"
         );
         assert_eq!(None, connection.snapshot().close_reason);
         assert_eq!(None, connection.probe().close_reason);
-2879
         drop(activation);
         let super::super::AcquisitionEvent::Establish(permit) = requesting_cell
         let super::super::AcquisitionStep::StartEstablishment(permit) = requesting_cell
             .take_ready_event(waiter)
             .expect("idle transition did not resume H1-required demand")
         else {
             panic!("idle HTTP/2 reclaim produced a non-capacity result");
         };
         assert_eq!(
             Some(CloseReason::Reclaimed),
             connection.snapshot().close_reason
             connection.probe().close_reason
         );
         drop(permit);
         assert_eq!(1, admission.available_capacity_for_test());
-2893
+    }
-2894
     #[test]
     fn pool_shutdown_closes_an_accepting_generation() {
         let cell = cell();
         let (_generation, connection, _physical) = install_generation(&cell, 1);
         let (_generation, connection, _physical) = open_test_generation(&cell, 1);
-2899
         OriginCell::close_all(&cell, CloseReason::PoolDropped);
-2901
         assert_eq!(
             Some(CloseReason::PoolDropped),
             connection.snapshot().close_reason
             connection.probe().close_reason
         );
         assert_eq!(None, cell.accepting_h2_generation());
-2907
+    }
-2908
+}
-2909
 #[cfg(all(test, smithy_http_client_loom))]
 mod loom_tests {
     use super::*;
     use crate::client::pool::connection::{CloseReason, ConnectionInfo};
     use crate::client::pool::origin::OriginKey;
     use crate::client::pool::partition::EligibilityGroup;
     use aws_smithy_runtime_api::client::connection::ConnectionId;
     use http_1x::uri::Scheme;
-2918
     fn cell() -> Arc<OriginCell> {
         Arc::new(OriginCell::new(
             PartitionId::from_index(1),
             OriginKey::from_parts(Scheme::HTTPS, "example.com", None).unwrap(),
             EligibilityGroup::Pool,
             None,
             None,
         ))
-2927
+    }
-2928
     fn install_generation(cell: &Arc<OriginCell>) -> (H2GenerationId, Arc<ConnectionState>) {
     fn open_test_generation(cell: &Arc<OriginCell>) -> (H2GenerationId, Arc<ConnectionState>) {
         let (connection, _physical) = ConnectionState::unbounded(ConnectionInfo::for_test(
             ConnectionId::new(1),
             PartitionId::from_index(1),
         ));
         let generation = OriginCell::install_h2_for_test(cell, connection.clone(), 1, None);
         (generation, connection)
-2936
+    }
-2937
     #[test]
     fn activation_linearizes_against_generation_close() {
         loom::model(|| {
             let cell = cell();
             let (generation, connection) = install_generation(&cell);
             let (generation, connection) = open_test_generation(&cell);
             let activating_cell = cell.clone();
             let activation =
                 loom::thread::spawn(move || OriginCell::activate_h2(&activating_cell, generation));
             let activation = loom::thread::spawn(move || {
                 OriginCell::activate_h2(
                     &activating_cell,
                     generation,
                     activating_cell.id().partition(),
-+
+                )
             });
             let closing_cell = cell.clone();
             let close = loom::thread::spawn(move || {
                 OriginCell::close_h2(&closing_cell, generation, CloseReason::Poisoned)
             });
-2955
             drop(activation.join().unwrap());
             assert!(close.join().unwrap());
             assert_eq!(
                 Some(CloseReason::Poisoned),
                 connection.snapshot().close_reason
             );
             assert_eq!(Some(CloseReason::Poisoned), connection.probe().close_reason);
             assert!(!cell.state.lock().h2.generations.contains_key(&generation));
         });
-2961
+    }
-2962
     #[test]
     fn concurrent_lease_endpoint_completion_releases_one_dispatch() {
     fn concurrent_request_side_completion_releases_one_dispatch() {
         loom::model(|| {
             let cell = cell();
             let (generation, connection) = install_generation(&cell);
             let mut activation =
                 OriginCell::activate_h2(&cell, generation).expect("generation did not activate");
             let (generation, connection) = open_test_generation(&cell);
             let mut activation = OriginCell::activate_h2(&cell, generation, cell.id().partition())
                 .expect("generation did not activate");
             let H2DispatchParts {
                 sender: _sender,
                 send_endpoint: send,
                 receive_endpoint: receive,
                 upload,
                 response,
             } = activation.take_dispatch_parts();
             let dispatch = ConnectionState::try_commit_dispatch(&connection)
                 .expect("open connection rejected dispatch");
             activation.accept(dispatch);
-2978
             let send = loom::thread::spawn(move || drop(send));
             let receive = loom::thread::spawn(move || drop(receive));
             send.join().unwrap();
             receive.join().unwrap();
             let upload = loom::thread::spawn(move || drop(upload));
             let response = loom::thread::spawn(move || drop(response));
             upload.join().unwrap();
             response.join().unwrap();
-2983
             assert_eq!(0, connection.snapshot().in_flight);
             assert_eq!(0, connection.probe().in_flight);
             let state = cell.state.lock();
             let record = state
                 .h2
                 .generations
                 .get(&generation)
                 .expect("accepting generation disappeared");
             assert_eq!(0, record.accepted);
             assert_eq!(0, record.active_requests);
         });
-2993
+    }
-2994
     #[test]
     fn generation_close_waits_for_both_lease_endpoints() {
     fn generation_close_waits_for_both_request_sides() {
         loom::model(|| {
             let cell = cell();
             let (connection, _physical) = ConnectionState::unbounded(ConnectionInfo::for_test(
                 ConnectionId::new(1),
                 PartitionId::from_index(1),
             ));
             let generation = OriginCell::install_h2_for_test(&cell, connection.clone(), 1, None);
             let mut activation =
                 OriginCell::activate_h2(&cell, generation).expect("generation did not activate");
             let mut activation = OriginCell::activate_h2(&cell, generation, cell.id().partition())
                 .expect("generation did not activate");
             let H2DispatchParts {
                 sender: _sender,
                 send_endpoint: send,
                 receive_endpoint: receive,
                 upload,
                 response,
             } = activation.take_dispatch_parts();
             let dispatch = ConnectionState::try_commit_dispatch(&connection)
                 .expect("open connection rejected dispatch");
             activation.accept(dispatch);
-3014
             let first_endpoint = loom::thread::spawn(move || drop(send));
             let first_side = loom::thread::spawn(move || drop(upload));
             let closing_cell = cell.clone();
             let close = loom::thread::spawn(move || {
                 OriginCell::close_h2(&closing_cell, generation, CloseReason::ProtocolClosed)
             });
             first_endpoint.join().unwrap();
             first_side.join().unwrap();
             assert!(close.join().unwrap());
-3022
             assert_eq!(1, connection.snapshot().in_flight);
             assert_eq!(1, connection.probe().in_flight);
             assert_eq!(
                 Some((0, 1)),
                 cell.h2_request_counts(generation),
                 "draining generation released before its second endpoint"
                 "draining generation released before its second request side"
             );
             drop(receive);
             assert_eq!(0, connection.snapshot().in_flight);
             drop(response);
             assert_eq!(0, connection.probe().in_flight);
             assert_eq!(
                 None,
                 cell.h2_request_counts(generation),
                 "finished draining generation remained installed"
             );
         });
-3037
+    }
-3038
+}

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/cell/h1.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/src/client/pool/cell/h2.rs