diff --git a/quic/api/QuicPacketScheduler.cpp b/quic/api/QuicPacketScheduler.cpp
index a97679bb9..01c8f6a76 100644
--- a/quic/api/QuicPacketScheduler.cpp
+++ b/quic/api/QuicPacketScheduler.cpp
@@ -510,9 +510,9 @@ CloningScheduler::CloningScheduler(
 
 bool CloningScheduler::hasData() const {
   return frameScheduler_.hasData() ||
-      (!conn_.outstandingPackets.empty() &&
-       conn_.outstandingPackets.size() !=
-           conn_.outstandingHandshakePacketsCount);
+      (!conn_.outstandings.packets.empty() &&
+       conn_.outstandings.packets.size() !=
+           conn_.outstandings.handshakePacketsCount);
 }
 
 SchedulingResult CloningScheduler::scheduleFramesForPacket(
@@ -534,8 +534,8 @@ SchedulingResult CloningScheduler::scheduleFramesForPacket(
   std::move(builder).releaseOutputBuffer();
   // Look for an outstanding packet that's no larger than the writableBytes
   // This is a loop, but it builds at most one packet.
-  for (auto iter = conn_.outstandingPackets.rbegin();
-       iter != conn_.outstandingPackets.rend();
+  for (auto iter = conn_.outstandings.packets.rbegin();
+       iter != conn_.outstandings.packets.rend();
        ++iter) {
     auto opPnSpace = iter->packet.header.getPacketNumberSpace();
     if (opPnSpace != PacketNumberSpace::AppData) {
@@ -573,7 +573,7 @@ SchedulingResult CloningScheduler::scheduleFramesForPacket(
     // If the packet is already a clone that has been processed, we don't clone
     // it again.
     if (iter->associatedEvent &&
-        conn_.outstandingPacketEvents.count(*iter->associatedEvent) == 0) {
+        conn_.outstandings.packetEvents.count(*iter->associatedEvent) == 0) {
       continue;
     }
     // I think this only fail if udpSendPacketLen somehow shrinks in the middle
diff --git a/quic/api/QuicTransportBase.cpp b/quic/api/QuicTransportBase.cpp
index 5865e03af..6687b90bb 100644
--- a/quic/api/QuicTransportBase.cpp
+++ b/quic/api/QuicTransportBase.cpp
@@ -412,8 +412,8 @@ void QuicTransportBase::closeImpl(
   connCallback_ = nullptr;
 
   // Don't need outstanding packets.
-  conn_->outstandingPackets.clear();
-  conn_->outstandingHandshakePacketsCount = 0;
+  conn_->outstandings.packets.clear();
+  conn_->outstandings.handshakePacketsCount = 0;
 
   // We don't need no congestion control.
   conn_->congestionController = nullptr;
@@ -2333,7 +2333,7 @@ void QuicTransportBase::cancelAllAppCallbacks(
 
 void QuicTransportBase::writeSocketData() {
   if (socket_) {
-    auto packetsBefore = conn_->outstandingPackets.size();
+    auto packetsBefore = conn_->outstandings.packets.size();
     writeData();
     if (closeState_ != CloseState::CLOSED) {
       if (conn_->pendingEvents.closeTransport == true) {
@@ -2342,7 +2342,7 @@ void QuicTransportBase::writeSocketData() {
             TransportErrorCode::PROTOCOL_VIOLATION);
       }
       setLossDetectionAlarm(*conn_, *this);
-      auto packetsAfter = conn_->outstandingPackets.size();
+      auto packetsAfter = conn_->outstandings.packets.size();
       bool packetWritten = (packetsAfter > packetsBefore);
       if (conn_->loopDetectorCallback && packetWritten) {
         conn_->writeDebugState.currentEmptyLoopCount = 0;
diff --git a/quic/api/QuicTransportFunctions.cpp b/quic/api/QuicTransportFunctions.cpp
index 24c75810b..85c424e46 100644
--- a/quic/api/QuicTransportFunctions.cpp
+++ b/quic/api/QuicTransportFunctions.cpp
@@ -621,14 +621,14 @@ void updateConnection(
   }
   auto packetIt =
       std::find_if(
-          conn.outstandingPackets.rbegin(),
-          conn.outstandingPackets.rend(),
+          conn.outstandings.packets.rbegin(),
+          conn.outstandings.packets.rend(),
           [packetNum](const auto& packetWithTime) {
             return packetWithTime.packet.header.getPacketSequenceNum() <
                 packetNum;
           })
           .base();
-  auto& pkt = *conn.outstandingPackets.emplace(
+  auto& pkt = *conn.outstandings.packets.emplace(
       packetIt,
       std::move(packet),
       std::move(sentTime),
@@ -647,7 +647,7 @@ void updateConnection(
         conn.lossState.totalBytesAckedAtLastAck);
   }
   if (packetEvent) {
-    DCHECK(conn.outstandingPacketEvents.count(*packetEvent));
+    DCHECK(conn.outstandings.packetEvents.count(*packetEvent));
     DCHECK(!isHandshake);
     pkt.associatedEvent = std::move(packetEvent);
     conn.lossState.totalBytesCloned += encodedSize;
@@ -675,19 +675,19 @@ void updateConnection(
     conn.pathValidationLimiter->onPacketSent(pkt.encodedSize);
   }
   if (pkt.isHandshake) {
-    ++conn.outstandingHandshakePacketsCount;
+    ++conn.outstandings.handshakePacketsCount;
     conn.lossState.lastHandshakePacketSentTime = pkt.time;
   }
   conn.lossState.lastRetransmittablePacketSentTime = pkt.time;
   if (pkt.associatedEvent) {
     CHECK_EQ(packetNumberSpace, PacketNumberSpace::AppData);
-    ++conn.outstandingClonedPacketsCount;
+    ++conn.outstandings.clonedPacketsCount;
     ++conn.lossState.timeoutBasedRtxCount;
   }
 
-  auto opCount = conn.outstandingPackets.size();
-  DCHECK_GE(opCount, conn.outstandingHandshakePacketsCount);
-  DCHECK_GE(opCount, conn.outstandingClonedPacketsCount);
+  auto opCount = conn.outstandings.packets.size();
+  DCHECK_GE(opCount, conn.outstandings.handshakePacketsCount);
+  DCHECK_GE(opCount, conn.outstandings.clonedPacketsCount);
 }
 
 uint64_t congestionControlWritableBytes(const QuicConnectionStateBase& conn) {
@@ -1353,7 +1353,7 @@ void implicitAckCryptoStream(
   AckBlocks ackBlocks;
   ReadAckFrame implicitAck;
   implicitAck.ackDelay = 0ms;
-  for (const auto& op : conn.outstandingPackets) {
+  for (const auto& op : conn.outstandings.packets) {
     if (op.packet.header.getPacketNumberSpace() == packetNumSpace) {
       ackBlocks.insert(op.packet.header.getPacketSequenceNum());
     }
diff --git a/quic/api/test/QuicPacketSchedulerTest.cpp b/quic/api/test/QuicPacketSchedulerTest.cpp
index 3b06df72c..8219f2427 100644
--- a/quic/api/test/QuicPacketSchedulerTest.cpp
+++ b/quic/api/test/QuicPacketSchedulerTest.cpp
@@ -37,8 +37,8 @@ PacketNum addInitialOutstandingPacket(QuicConnectionStateBase& conn) {
       nextPacketNum,
       QuicVersion::QUIC_DRAFT);
   RegularQuicWritePacket packet(std::move(header));
-  conn.outstandingPackets.emplace_back(packet, Clock::now(), 0, true, 0);
-  conn.outstandingHandshakePacketsCount++;
+  conn.outstandings.packets.emplace_back(packet, Clock::now(), 0, true, 0);
+  conn.outstandings.handshakePacketsCount++;
   increaseNextPacketNum(conn, PacketNumberSpace::Handshake);
   return nextPacketNum;
 }
@@ -55,8 +55,8 @@ PacketNum addHandshakeOutstandingPacket(QuicConnectionStateBase& conn) {
       nextPacketNum,
       QuicVersion::QUIC_DRAFT);
   RegularQuicWritePacket packet(std::move(header));
-  conn.outstandingPackets.emplace_back(packet, Clock::now(), 0, true, 0);
-  conn.outstandingHandshakePacketsCount++;
+  conn.outstandings.packets.emplace_back(packet, Clock::now(), 0, true, 0);
+  conn.outstandings.handshakePacketsCount++;
   increaseNextPacketNum(conn, PacketNumberSpace::Handshake);
   return nextPacketNum;
 }
@@ -68,7 +68,7 @@ PacketNum addOutstandingPacket(QuicConnectionStateBase& conn) {
       conn.clientConnectionId.value_or(quic::test::getTestConnectionId()),
       nextPacketNum);
   RegularQuicWritePacket packet(std::move(header));
-  conn.outstandingPackets.emplace_back(packet, Clock::now(), 0, false, 0);
+  conn.outstandings.packets.emplace_back(packet, Clock::now(), 0, false, 0);
   increaseNextPacketNum(conn, PacketNumberSpace::AppData);
   return nextPacketNum;
 }
@@ -436,7 +436,7 @@ TEST_F(QuicPacketSchedulerTest, CloningSchedulerTest) {
   EXPECT_FALSE(cloningScheduler.hasData());
   auto packetNum = addOutstandingPacket(conn);
   // There needs to have retransmittable frame for the rebuilder to work
-  conn.outstandingPackets.back().packet.frames.push_back(
+  conn.outstandings.packets.back().packet.frames.push_back(
       MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
   EXPECT_TRUE(cloningScheduler.hasData());
 
@@ -461,15 +461,15 @@ TEST_F(QuicPacketSchedulerTest, DoNotCloneProcessedClonedPacket) {
   FrameScheduler noopScheduler("frame");
   CloningScheduler cloningScheduler(noopScheduler, conn, "CopyCat", 0);
   // Add two outstanding packets, but then mark the second one processed by
-  // adding a PacketEvent that's missing from the outstandingPacketEvents set
+  // adding a PacketEvent that's missing from the outstandings.packetEvents set
   PacketNum expected = addOutstandingPacket(conn);
   // There needs to have retransmittable frame for the rebuilder to work
-  conn.outstandingPackets.back().packet.frames.push_back(
+  conn.outstandings.packets.back().packet.frames.push_back(
       MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
   addOutstandingPacket(conn);
-  conn.outstandingPackets.back().associatedEvent = 1;
+  conn.outstandings.packets.back().associatedEvent = 1;
   // There needs to have retransmittable frame for the rebuilder to work
-  conn.outstandingPackets.back().packet.frames.push_back(
+  conn.outstandings.packets.back().packet.frames.push_back(
       MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
 
   ShortHeader header(
@@ -511,10 +511,10 @@ TEST_F(QuicPacketSchedulerTest, DoNotCloneHandshake) {
   // Add two outstanding packets, with second one being handshake
   auto expected = addOutstandingPacket(conn);
   // There needs to have retransmittable frame for the rebuilder to work
-  conn.outstandingPackets.back().packet.frames.push_back(
+  conn.outstandings.packets.back().packet.frames.push_back(
       MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
   addHandshakeOutstandingPacket(conn);
-  conn.outstandingPackets.back().packet.frames.push_back(
+  conn.outstandings.packets.back().packet.frames.push_back(
       MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
 
   ShortHeader header(
@@ -587,9 +587,9 @@ TEST_F(QuicPacketSchedulerTest, CloneWillGenerateNewWindowUpdate) {
   FrameScheduler noopScheduler("frame");
   CloningScheduler cloningScheduler(noopScheduler, conn, "GiantsShoulder", 0);
   auto expectedPacketEvent = addOutstandingPacket(conn);
-  ASSERT_EQ(1, conn.outstandingPackets.size());
-  conn.outstandingPackets.back().packet.frames.push_back(MaxDataFrame(1000));
-  conn.outstandingPackets.back().packet.frames.push_back(
+  ASSERT_EQ(1, conn.outstandings.packets.size());
+  conn.outstandings.packets.back().packet.frames.push_back(MaxDataFrame(1000));
+  conn.outstandings.packets.back().packet.frames.push_back(
       MaxStreamDataFrame(stream->id, 1000));
   conn.flowControlState.advertisedMaxOffset = 1000;
   stream->flowControlState.advertisedMaxOffset = 1000;
@@ -674,7 +674,7 @@ TEST_F(QuicPacketSchedulerTest, CloningSchedulerWithInplaceBuilder) {
   CloningScheduler cloningScheduler(noopScheduler, conn, "93MillionMiles", 0);
   auto packetNum = addOutstandingPacket(conn);
   // There needs to have retransmittable frame for the rebuilder to work
-  conn.outstandingPackets.back().packet.frames.push_back(
+  conn.outstandings.packets.back().packet.frames.push_back(
       MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
   EXPECT_TRUE(cloningScheduler.hasData());
 
@@ -1227,10 +1227,10 @@ TEST_F(
   CloningScheduler cloningScheduler(noopScheduler, conn, "Little Hurry", 0);
   addOutstandingPacket(conn);
   // There needs to have retransmittable frame for the rebuilder to work
-  conn.outstandingPackets.back().packet.frames.push_back(
+  conn.outstandings.packets.back().packet.frames.push_back(
       MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
   // Lie about the encodedSize to let the Cloner skip it:
-  conn.outstandingPackets.back().encodedSize = kDefaultUDPSendPacketLen * 2;
+  conn.outstandings.packets.back().encodedSize = kDefaultUDPSendPacketLen * 2;
   EXPECT_TRUE(cloningScheduler.hasData());
 
   ASSERT_FALSE(noopScheduler.hasData());
@@ -1270,7 +1270,7 @@ TEST_F(
   CloningScheduler cloningScheduler(noopScheduler, conn, "HotPot", 0);
   addOutstandingPacket(conn);
   // Not adding frame to this outstanding packet so that rebuild will fail:
-  ASSERT_TRUE(conn.outstandingPackets.back().packet.frames.empty());
+  ASSERT_TRUE(conn.outstandings.packets.back().packet.frames.empty());
   EXPECT_TRUE(cloningScheduler.hasData());
 
   ASSERT_FALSE(noopScheduler.hasData());
diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp
index f7812ad96..3f470caec 100644
--- a/quic/api/test/QuicTransportBaseTest.cpp
+++ b/quic/api/test/QuicTransportBaseTest.cpp
@@ -1189,9 +1189,9 @@ TEST_F(QuicTransportImplTest, CancelAllDeliveryCallbacksMap) {
 }
 
 TEST_F(QuicTransportImplTest, CloseTransportCleansupOutstandingCounters) {
-  transport->transportConn->outstandingHandshakePacketsCount = 200;
+  transport->transportConn->outstandings.handshakePacketsCount = 200;
   transport->closeNow(folly::none);
-  EXPECT_EQ(0, transport->transportConn->outstandingHandshakePacketsCount);
+  EXPECT_EQ(0, transport->transportConn->outstandings.handshakePacketsCount);
 }
 
 TEST_F(QuicTransportImplTest, DeliveryCallbackUnsetAll) {
diff --git a/quic/api/test/QuicTransportFunctionsTest.cpp b/quic/api/test/QuicTransportFunctionsTest.cpp
index df5af5c69..10fd27eca 100644
--- a/quic/api/test/QuicTransportFunctionsTest.cpp
+++ b/quic/api/test/QuicTransportFunctionsTest.cpp
@@ -227,7 +227,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {
   EXPECT_EQ(
       conn->ackStates.appDataAckState.nextPacketNum,
       currentNextAppDataPacketNum);
-  EXPECT_TRUE(conn->outstandingPackets.back().isAppLimited);
+  EXPECT_TRUE(conn->outstandings.packets.back().isAppLimited);
 
   EXPECT_EQ(stream1->retransmissionBuffer.size(), 1);
   auto& rt1 = *stream1->retransmissionBuffer.at(0);
@@ -284,7 +284,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {
   EXPECT_EQ(
       conn->ackStates.appDataAckState.nextPacketNum,
       currentNextAppDataPacketNum);
-  EXPECT_FALSE(conn->outstandingPackets.back().isAppLimited);
+  EXPECT_FALSE(conn->outstandings.packets.back().isAppLimited);
 
   EXPECT_EQ(stream1->currentWriteOffset, 13);
   EXPECT_EQ(stream1->currentWriteOffset, 13);
@@ -399,15 +399,15 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPacketSorting) {
   EXPECT_EQ(event2->packetType, toString(LongHeader::Types::Initial));
   EXPECT_EQ(event3->packetType, toString(LongHeader::Types::ZeroRtt));
 
-  EXPECT_EQ(3, conn->outstandingPackets.size());
-  auto& firstHeader = conn->outstandingPackets.front().packet.header;
+  EXPECT_EQ(3, conn->outstandings.packets.size());
+  auto& firstHeader = conn->outstandings.packets.front().packet.header;
   auto firstPacketNum = firstHeader.getPacketSequenceNum();
   EXPECT_EQ(0, firstPacketNum);
   EXPECT_EQ(1, event1->packetNum);
 
   EXPECT_EQ(PacketNumberSpace::Initial, firstHeader.getPacketNumberSpace());
 
-  auto& lastHeader = conn->outstandingPackets.back().packet.header;
+  auto& lastHeader = conn->outstandings.packets.back().packet.header;
 
   auto lastPacketNum = lastHeader.getPacketSequenceNum();
 
@@ -539,7 +539,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPureAckCounter) {
   conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
   auto stream = conn->streamManager->createNextBidirectionalStream().value();
   writeDataToQuicStream(*stream, nullptr, true);
-  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
+  EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
 
   auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
   auto packetEncodedSize =
@@ -629,8 +629,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
   initialStream->writeBuffer.append(data->clone());
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
+  EXPECT_EQ(1, conn->outstandings.packets.size());
   EXPECT_EQ(1, initialStream->retransmissionBuffer.size());
 
   packet = buildEmptyPacket(*conn, PacketNumberSpace::Initial);
@@ -642,8 +642,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
   initialStream->writeBuffer.append(data->clone());
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_EQ(2, conn->outstandingHandshakePacketsCount);
-  EXPECT_EQ(2, conn->outstandingPackets.size());
+  EXPECT_EQ(2, conn->outstandings.handshakePacketsCount);
+  EXPECT_EQ(2, conn->outstandings.packets.size());
   EXPECT_EQ(3, initialStream->retransmissionBuffer.size());
   EXPECT_TRUE(initialStream->writeBuffer.empty());
   EXPECT_TRUE(initialStream->lossBuffer.empty());
@@ -653,8 +653,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
       initialStream->retransmissionBuffer.find(0)->second->data.move();
   initialStream->retransmissionBuffer.erase(0);
   initialStream->lossBuffer.emplace_back(std::move(firstBuf), 0, false);
-  conn->outstandingPackets.pop_front();
-  conn->outstandingHandshakePacketsCount--;
+  conn->outstandings.packets.pop_front();
+  conn->outstandings.handshakePacketsCount--;
 
   auto handshakeStream =
       getCryptoStream(*conn->cryptoState, EncryptionLevel::Handshake);
@@ -666,8 +666,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
   handshakeStream->writeBuffer.append(data->clone());
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_EQ(2, conn->outstandingHandshakePacketsCount);
-  EXPECT_EQ(2, conn->outstandingPackets.size());
+  EXPECT_EQ(2, conn->outstandings.handshakePacketsCount);
+  EXPECT_EQ(2, conn->outstandings.packets.size());
   EXPECT_EQ(1, handshakeStream->retransmissionBuffer.size());
 
   packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
@@ -676,8 +676,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
   handshakeStream->writeBuffer.append(data->clone());
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_EQ(3, conn->outstandingHandshakePacketsCount);
-  EXPECT_EQ(3, conn->outstandingPackets.size());
+  EXPECT_EQ(3, conn->outstandings.handshakePacketsCount);
+  EXPECT_EQ(3, conn->outstandings.packets.size());
   EXPECT_EQ(2, handshakeStream->retransmissionBuffer.size());
   EXPECT_TRUE(handshakeStream->writeBuffer.empty());
   EXPECT_TRUE(handshakeStream->lossBuffer.empty());
@@ -686,24 +686,24 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
   firstBuf = handshakeStream->retransmissionBuffer.find(0)->second->data.move();
   handshakeStream->retransmissionBuffer.erase(0);
   handshakeStream->lossBuffer.emplace_back(std::move(firstBuf), 0, false);
-  auto& op = conn->outstandingPackets.front();
+  auto& op = conn->outstandings.packets.front();
   ASSERT_EQ(
       op.packet.header.getPacketNumberSpace(), PacketNumberSpace::Handshake);
   auto frame = op.packet.frames[0].asWriteCryptoFrame();
   EXPECT_EQ(frame->offset, 0);
-  conn->outstandingPackets.pop_front();
-  conn->outstandingHandshakePacketsCount--;
+  conn->outstandings.packets.pop_front();
+  conn->outstandings.handshakePacketsCount--;
 
   implicitAckCryptoStream(*conn, EncryptionLevel::Initial);
-  EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
+  EXPECT_EQ(1, conn->outstandings.packets.size());
   EXPECT_TRUE(initialStream->retransmissionBuffer.empty());
   EXPECT_TRUE(initialStream->writeBuffer.empty());
   EXPECT_TRUE(initialStream->lossBuffer.empty());
 
   implicitAckCryptoStream(*conn, EncryptionLevel::Handshake);
-  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
-  EXPECT_TRUE(conn->outstandingPackets.empty());
+  EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
+  EXPECT_TRUE(conn->outstandings.packets.empty());
   EXPECT_TRUE(handshakeStream->retransmissionBuffer.empty());
   EXPECT_TRUE(handshakeStream->writeBuffer.empty());
   EXPECT_TRUE(handshakeStream->lossBuffer.empty());
@@ -714,7 +714,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
   conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
   auto stream = conn->streamManager->createNextBidirectionalStream().value();
   writeDataToQuicStream(*stream, nullptr, true);
-  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
+  EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
 
   auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
   auto packetEncodedSize =
@@ -724,7 +724,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
   packet.packet.frames.push_back(WriteCryptoFrame(0, 0));
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
+  EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
 
   auto nonHandshake = buildEmptyPacket(*conn, PacketNumberSpace::AppData);
   packetEncodedSize =
@@ -771,7 +771,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
       EXPECT_EQ(gotFrame->offset, 0);
       EXPECT_EQ(gotFrame->len, 0);
       EXPECT_TRUE(gotFrame->fin);
-      EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
+      EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
     }
   }
 }
@@ -781,7 +781,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
   conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
   auto stream = conn->streamManager->createNextBidirectionalStream().value();
   writeDataToQuicStream(*stream, nullptr, true);
-  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
+  EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
 
   // Packet with CryptoFrame in AppData pn space
   auto packet = buildEmptyPacket(*conn, PacketNumberSpace::AppData, true);
@@ -793,8 +793,8 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
 
-  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
+  EXPECT_EQ(1, conn->outstandings.packets.size());
 
   auto nonHandshake = buildEmptyPacket(*conn, PacketNumberSpace::AppData);
   packetEncodedSize =
@@ -843,8 +843,8 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
     }
   }
 
-  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
-  EXPECT_EQ(2, conn->outstandingPackets.size());
+  EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
+  EXPECT_EQ(2, conn->outstandings.packets.size());
 }
 
 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {
@@ -866,7 +866,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {
   EXPECT_CALL(*rawPacer, onPacketSent()).Times(0);
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_EQ(0, conn->outstandingPackets.size());
+  EXPECT_EQ(0, conn->outstandings.packets.size());
   EXPECT_EQ(0, conn->lossState.totalBytesAcked);
   std::shared_ptr<quic::FileQLogger> qLogger =
       std::dynamic_pointer_cast<quic::FileQLogger>(conn->qLogger);
@@ -961,7 +961,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithCloneResult) {
   conn->pendingEvents.connWindowUpdate = true;
   writePacket.frames.push_back(std::move(maxDataFrame));
   PacketEvent event = 1;
-  conn->outstandingPacketEvents.insert(event);
+  conn->outstandings.packetEvents.insert(event);
   auto futureMoment = thisMoment + 50ms;
   MockClock::mockNow = [=]() { return futureMoment; };
   EXPECT_CALL(*rawCongestionController, onPacketSent(_)).Times(1);
@@ -1308,7 +1308,7 @@ TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketWithNoBytesForHeader) {
       getVersion(*conn),
       conn->transportSettings.writeConnectionDataPacketsLimit);
   // No header space left. Should send nothing.
-  EXPECT_TRUE(conn->outstandingPackets.empty());
+  EXPECT_TRUE(conn->outstandings.packets.empty());
 }
 
 TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketRetxBufferSorted) {
@@ -1428,14 +1428,14 @@ TEST_F(QuicTransportFunctionsTest, WriteBlockedFrameWhenBlocked) {
 
   EXPECT_GT(conn->ackStates.appDataAckState.nextPacketNum, originalNextSeq);
   auto blocked = *getFirstFrameInOutstandingPackets(
-                      conn->outstandingPackets,
+                      conn->outstandings.packets,
                       QuicWriteFrame::Type::StreamDataBlockedFrame_E)
                       .asStreamDataBlockedFrame();
   EXPECT_EQ(blocked.streamId, stream1->id);
 
   // Since everything is blocked, we shouldn't write a blocked again, so we
   // won't have any new packets to write if we trigger a write.
-  auto previousPackets = conn->outstandingPackets.size();
+  auto previousPackets = conn->outstandings.packets.size();
   EXPECT_CALL(*transportInfoCb_, onWrite(_)).Times(0);
   writeQuicDataToSocket(
       *rawSocket,
@@ -1446,7 +1446,7 @@ TEST_F(QuicTransportFunctionsTest, WriteBlockedFrameWhenBlocked) {
       *headerCipher,
       getVersion(*conn),
       conn->transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(previousPackets, conn->outstandingPackets.size());
+  EXPECT_EQ(previousPackets, conn->outstandings.packets.size());
 }
 
 TEST_F(QuicTransportFunctionsTest, WriteProbingNewData) {
@@ -1478,9 +1478,9 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingNewData) {
   writeProbingDataToSocketForTest(
       *rawSocket, *conn, 1, *aead, *headerCipher, getVersion(*conn));
   EXPECT_LT(currentPacketSeqNum, conn->ackStates.appDataAckState.nextPacketNum);
-  EXPECT_FALSE(conn->outstandingPackets.empty());
+  EXPECT_FALSE(conn->outstandings.packets.empty());
   EXPECT_EQ(
-      conn->outstandingPackets.back().packet.header.getPacketSequenceNum(),
+      conn->outstandings.packets.back().packet.header.getPacketSequenceNum(),
       currentPacketSeqNum + 1);
   EXPECT_TRUE(conn->pendingEvents.setLossDetectionAlarm);
   EXPECT_GT(stream1->currentWriteOffset, currentStreamWriteOffset);
@@ -1566,7 +1566,7 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingCryptoData) {
   writeCryptoDataProbesToSocketForTest(
       *rawSocket, conn, 1, *aead, *headerCipher, getVersion(conn));
   EXPECT_LT(currentPacketSeqNum, conn.ackStates.initialAckState.nextPacketNum);
-  EXPECT_FALSE(conn.outstandingPackets.empty());
+  EXPECT_FALSE(conn.outstandings.packets.empty());
   EXPECT_TRUE(conn.pendingEvents.setLossDetectionAlarm);
   EXPECT_GT(cryptoStream->currentWriteOffset, currentStreamWriteOffset);
   EXPECT_FALSE(cryptoStream->retransmissionBuffer.empty());
@@ -1599,14 +1599,17 @@ TEST_F(QuicTransportFunctionsTest, ProbingFallbackToPing) {
           *aead,
           *headerCipher,
           getVersion(*conn)));
-  EXPECT_EQ(1, conn->outstandingPackets.size());
-  EXPECT_EQ(1, conn->outstandingPackets[0].packet.frames.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
+  EXPECT_EQ(1, conn->outstandings.packets[0].packet.frames.size());
   EXPECT_EQ(
       QuicWriteFrame::Type::QuicSimpleFrame_E,
-      conn->outstandingPackets[0].packet.frames[0].type());
+      conn->outstandings.packets[0].packet.frames[0].type());
   EXPECT_EQ(
       QuicSimpleFrame::Type::PingFrame_E,
-      conn->outstandingPackets[0].packet.frames[0].asQuicSimpleFrame()->type());
+      conn->outstandings.packets[0]
+          .packet.frames[0]
+          .asQuicSimpleFrame()
+          ->type());
 }
 
 TEST_F(QuicTransportFunctionsTest, TestCryptoWritingIsHandshakeInOutstanding) {
@@ -1631,7 +1634,7 @@ TEST_F(QuicTransportFunctionsTest, TestCryptoWritingIsHandshakeInOutstanding) {
           *conn->initialHeaderCipher,
           getVersion(*conn),
           conn->transportSettings.writeConnectionDataPacketsLimit));
-  ASSERT_EQ(1, conn->outstandingPackets.size());
+  ASSERT_EQ(1, conn->outstandings.packets.size());
   EXPECT_TRUE(getFirstOutstandingPacket(*conn, PacketNumberSpace::Initial)
                   ->isHandshake);
 }
@@ -1677,7 +1680,7 @@ TEST_F(QuicTransportFunctionsTest, WritePureAckWhenNoWritableBytes) {
           getVersion(*conn),
           conn->transportSettings.writeConnectionDataPacketsLimit),
       0);
-  EXPECT_EQ(0, conn->outstandingPackets.size());
+  EXPECT_EQ(0, conn->outstandings.packets.size());
 }
 
 TEST_F(QuicTransportFunctionsTest, ShouldWriteDataTest) {
@@ -1926,16 +1929,16 @@ TEST_F(QuicTransportFunctionsTest, HasAppDataToWrite) {
 
 TEST_F(QuicTransportFunctionsTest, UpdateConnectionCloneCounter) {
   auto conn = createConn();
-  ASSERT_EQ(0, conn->outstandingClonedPacketsCount);
+  ASSERT_EQ(0, conn->outstandings.clonedPacketsCount);
   auto packet = buildEmptyPacket(*conn, PacketNumberSpace::AppData);
   auto connWindowUpdate =
       MaxDataFrame(conn->flowControlState.advertisedMaxOffset);
   conn->pendingEvents.connWindowUpdate = true;
   packet.packet.frames.emplace_back(connWindowUpdate);
   PacketEvent packetEvent = 100;
-  conn->outstandingPacketEvents.insert(packetEvent);
+  conn->outstandings.packetEvents.insert(packetEvent);
   updateConnection(*conn, packetEvent, packet.packet, TimePoint(), 123);
-  EXPECT_EQ(1, conn->outstandingClonedPacketsCount);
+  EXPECT_EQ(1, conn->outstandings.clonedPacketsCount);
 }
 
 TEST_F(QuicTransportFunctionsTest, ClearBlockedFromPendingEvents) {
@@ -1948,8 +1951,8 @@ TEST_F(QuicTransportFunctionsTest, ClearBlockedFromPendingEvents) {
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
   EXPECT_FALSE(conn->streamManager->hasBlocked());
-  EXPECT_FALSE(conn->outstandingPackets.empty());
-  EXPECT_EQ(0, conn->outstandingClonedPacketsCount);
+  EXPECT_FALSE(conn->outstandings.packets.empty());
+  EXPECT_EQ(0, conn->outstandings.clonedPacketsCount);
 }
 
 TEST_F(QuicTransportFunctionsTest, ClonedBlocked) {
@@ -1959,12 +1962,12 @@ TEST_F(QuicTransportFunctionsTest, ClonedBlocked) {
   auto stream = conn->streamManager->createNextBidirectionalStream().value();
   StreamDataBlockedFrame blockedFrame(stream->id, 1000);
   packet.packet.frames.emplace_back(blockedFrame);
-  conn->outstandingPacketEvents.insert(packetEvent);
+  conn->outstandings.packetEvents.insert(packetEvent);
   // This shall not crash
   updateConnection(
       *conn, packetEvent, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_FALSE(conn->outstandingPackets.empty());
-  EXPECT_EQ(1, conn->outstandingClonedPacketsCount);
+  EXPECT_FALSE(conn->outstandings.packets.empty());
+  EXPECT_EQ(1, conn->outstandings.clonedPacketsCount);
 }
 
 TEST_F(QuicTransportFunctionsTest, TwoConnWindowUpdateWillCrash) {
@@ -1995,7 +1998,7 @@ TEST_F(QuicTransportFunctionsTest, WriteStreamFrameIsNotPureAck) {
   packet.packet.frames.push_back(std::move(writeStreamFrame));
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_FALSE(conn->outstandingPackets.empty());
+  EXPECT_FALSE(conn->outstandings.packets.empty());
 }
 
 TEST_F(QuicTransportFunctionsTest, ClearRstFromPendingEvents) {
@@ -2009,8 +2012,8 @@ TEST_F(QuicTransportFunctionsTest, ClearRstFromPendingEvents) {
   updateConnection(
       *conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
   EXPECT_TRUE(conn->pendingEvents.resets.empty());
-  EXPECT_FALSE(conn->outstandingPackets.empty());
-  EXPECT_EQ(0, conn->outstandingClonedPacketsCount);
+  EXPECT_FALSE(conn->outstandings.packets.empty());
+  EXPECT_EQ(0, conn->outstandings.clonedPacketsCount);
 }
 
 TEST_F(QuicTransportFunctionsTest, ClonedRst) {
@@ -2021,12 +2024,12 @@ TEST_F(QuicTransportFunctionsTest, ClonedRst) {
   RstStreamFrame rstStreamFrame(
       stream->id, GenericApplicationErrorCode::UNKNOWN, 0);
   packet.packet.frames.emplace_back(std::move(rstStreamFrame));
-  conn->outstandingPacketEvents.insert(packetEvent);
+  conn->outstandings.packetEvents.insert(packetEvent);
   // This shall not crash
   updateConnection(
       *conn, packetEvent, packet.packet, TimePoint(), getEncodedSize(packet));
-  EXPECT_FALSE(conn->outstandingPackets.empty());
-  EXPECT_EQ(1, conn->outstandingClonedPacketsCount);
+  EXPECT_FALSE(conn->outstandings.packets.empty());
+  EXPECT_EQ(1, conn->outstandings.clonedPacketsCount);
 }
 
 TEST_F(QuicTransportFunctionsTest, TotalBytesSentUpdate) {
@@ -2046,7 +2049,7 @@ TEST_F(QuicTransportFunctionsTest, TimeoutBasedRetxCountUpdate) {
       stream->id, GenericApplicationErrorCode::UNKNOWN, 0);
   packet.packet.frames.push_back(rstStreamFrame);
   PacketEvent packetEvent = 100;
-  conn->outstandingPacketEvents.insert(packetEvent);
+  conn->outstandings.packetEvents.insert(packetEvent);
   updateConnection(*conn, packetEvent, packet.packet, TimePoint(), 500);
   EXPECT_EQ(247, conn->lossState.timeoutBasedRtxCount);
 }
@@ -2214,11 +2217,11 @@ TEST_F(QuicTransportFunctionsTest, ProbeWriteNewFunctionalFrames) {
       *headerCipher,
       getVersion(*conn),
       1 /* limit to 1 packet */);
-  EXPECT_EQ(2, conn->outstandingPackets.size());
-  EXPECT_EQ(1, conn->outstandingPackets[1].packet.frames.size());
+  EXPECT_EQ(2, conn->outstandings.packets.size());
+  EXPECT_EQ(1, conn->outstandings.packets[1].packet.frames.size());
   EXPECT_EQ(
       QuicWriteFrame::Type::MaxDataFrame_E,
-      conn->outstandingPackets[1].packet.frames[0].type());
+      conn->outstandings.packets[1].packet.frames[0].type());
 }
 
 TEST_F(QuicTransportFunctionsTest, WriteWithInplaceBuilder) {
@@ -2375,13 +2378,13 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingWithInplaceBuilder) {
       conn->transportSettings.writeConnectionDataPacketsLimit + 1);
   ASSERT_EQ(0, bufPtr->length());
   ASSERT_EQ(0, bufPtr->headroom());
-  EXPECT_GE(conn->outstandingPackets.size(), 5);
+  EXPECT_GE(conn->outstandings.packets.size(), 5);
   // Make sure there no more new data to write:
   StreamFrameScheduler streamScheduler(*conn);
   ASSERT_FALSE(streamScheduler.hasPendingData());
 
   // The last packet may not be a full packet
-  auto lastPacketSize = conn->outstandingPackets.back().encodedSize;
+  auto lastPacketSize = conn->outstandings.packets.back().encodedSize;
   size_t expectedOutstandingPacketsCount = 5;
   if (lastPacketSize < conn->udpSendPacketLen) {
     expectedOutstandingPacketsCount++;
@@ -2404,7 +2407,7 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingWithInplaceBuilder) {
       *headerCipher,
       getVersion(*conn));
   EXPECT_EQ(
-      conn->outstandingPackets.size(), expectedOutstandingPacketsCount + 1);
+      conn->outstandings.packets.size(), expectedOutstandingPacketsCount + 1);
   EXPECT_EQ(0, bufPtr->length());
   EXPECT_EQ(0, bufPtr->headroom());
 
@@ -2442,14 +2445,15 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingWithInplaceBuilder) {
   EXPECT_EQ(0, bufPtr->length());
   EXPECT_EQ(0, bufPtr->headroom());
   EXPECT_EQ(
-      conn->outstandingPackets.size(), expectedOutstandingPacketsCount + 3);
+      conn->outstandings.packets.size(), expectedOutstandingPacketsCount + 3);
 
   // Clear out all the small packets:
-  while (conn->outstandingPackets.back().encodedSize < conn->udpSendPacketLen) {
-    conn->outstandingPackets.pop_back();
+  while (conn->outstandings.packets.back().encodedSize <
+         conn->udpSendPacketLen) {
+    conn->outstandings.packets.pop_back();
   }
-  ASSERT_FALSE(conn->outstandingPackets.empty());
-  auto currentOutstandingPackets = conn->outstandingPackets.size();
+  ASSERT_FALSE(conn->outstandings.packets.empty());
+  auto currentOutstandingPackets = conn->outstandings.packets.size();
 
   // Clone 2 full size packets
   EXPECT_CALL(mockSock, writeGSO(_, _, _))
@@ -2469,7 +2473,7 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingWithInplaceBuilder) {
       *aead,
       *headerCipher,
       getVersion(*conn));
-  EXPECT_EQ(conn->outstandingPackets.size(), currentOutstandingPackets + 2);
+  EXPECT_EQ(conn->outstandings.packets.size(), currentOutstandingPackets + 2);
   EXPECT_EQ(0, bufPtr->length());
   EXPECT_EQ(0, bufPtr->headroom());
 }
diff --git a/quic/api/test/QuicTransportTest.cpp b/quic/api/test/QuicTransportTest.cpp
index b0e7c7944..b2685bd6e 100644
--- a/quic/api/test/QuicTransportTest.cpp
+++ b/quic/api/test/QuicTransportTest.cpp
@@ -243,7 +243,7 @@ size_t bufLength(
 }
 
 void dropPackets(QuicServerConnectionState& conn) {
-  for (const auto& packet : conn.outstandingPackets) {
+  for (const auto& packet : conn.outstandings.packets) {
     for (const auto& frame : packet.packet.frames) {
       const WriteStreamFrame* streamFrame = frame.asWriteStreamFrame();
       if (!streamFrame) {
@@ -272,7 +272,7 @@ void dropPackets(QuicServerConnectionState& conn) {
       }
     }
   }
-  conn.outstandingPackets.clear();
+  conn.outstandings.packets.clear();
 }
 
 // Helper function to verify the data of buffer is written to outstanding
@@ -288,7 +288,7 @@ void verifyCorrectness(
   size_t totalLen = 0;
   bool finSet = false;
   std::vector<uint64_t> offsets;
-  for (const auto& packet : conn.outstandingPackets) {
+  for (const auto& packet : conn.outstandings.packets) {
     for (const auto& frame : packet.packet.frames) {
       auto streamFrame = frame.asWriteStreamFrame();
       if (!streamFrame) {
@@ -413,7 +413,7 @@ TEST_F(QuicTransportTest, NotAppLimitedWithNoWritableBytes) {
   conn.congestionController = std::move(mockCongestionController);
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
       .WillRepeatedly(Invoke([&]() {
-        if (conn.outstandingPackets.empty()) {
+        if (conn.outstandings.packets.empty()) {
           return 5000;
         }
         return 0;
@@ -512,7 +512,7 @@ TEST_F(QuicTransportTest, WriteLarge) {
   transport_->writeChain(stream, buf->clone(), false, false);
   loopForWrites();
   auto& conn = transport_->getConnectionState();
-  EXPECT_EQ(NumFullPackets + 1, conn.outstandingPackets.size());
+  EXPECT_EQ(NumFullPackets + 1, conn.outstandings.packets.size());
   verifyCorrectness(conn, 0, stream, *buf);
 
   // Test retransmission
@@ -529,7 +529,7 @@ TEST_F(QuicTransportTest, WriteLarge) {
       *headerCipher_,
       transport_->getVersion(),
       conn.transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(NumFullPackets + 1, conn.outstandingPackets.size());
+  EXPECT_EQ(NumFullPackets + 1, conn.outstandings.packets.size());
   verifyCorrectness(conn, 0, stream, *buf);
   EXPECT_EQ(WriteDataReason::NO_WRITE, shouldWriteData(conn));
 }
@@ -545,7 +545,7 @@ TEST_F(QuicTransportTest, WriteMultipleTimes) {
       conn.streamManager->findStream(stream)->currentWriteOffset;
   verifyCorrectness(conn, 0, stream, *buf);
 
-  conn.outstandingPackets.clear();
+  conn.outstandings.packets.clear();
   conn.streamManager->findStream(stream)->retransmissionBuffer.clear();
   buf = buildRandomInputData(50);
   EXPECT_CALL(*socket_, write(_, _)).WillOnce(Invoke(bufLength));
@@ -610,7 +610,7 @@ TEST_F(QuicTransportTest, WriteFlowControl) {
   transport_->writeChain(streamId, buf->clone(), false, false);
 
   loopForWrites();
-  EXPECT_EQ(conn.outstandingPackets.size(), 1);
+  EXPECT_EQ(conn.outstandings.packets.size(), 1);
   auto& packet =
       getFirstOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
   bool blockedFound = false;
@@ -623,7 +623,7 @@ TEST_F(QuicTransportTest, WriteFlowControl) {
     blockedFound = true;
   }
   EXPECT_TRUE(blockedFound);
-  conn.outstandingPackets.clear();
+  conn.outstandings.packets.clear();
 
   // Stream flow control
   auto buf1 = buf->clone();
@@ -793,7 +793,7 @@ TEST_F(QuicTransportTest, WriteImmediateAcks) {
       *headerCipher_,
       transport_->getVersion(),
       conn.transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_TRUE(conn.outstandingPackets.empty());
+  EXPECT_TRUE(conn.outstandings.packets.empty());
   EXPECT_EQ(conn.ackStates.appDataAckState.largestAckScheduled, end);
   EXPECT_FALSE(conn.ackStates.appDataAckState.needsToSendAckImmediately);
   EXPECT_EQ(0, conn.ackStates.appDataAckState.numNonRxPacketsRecvd);
@@ -833,7 +833,7 @@ TEST_F(QuicTransportTest, WritePendingAckIfHavingData) {
   // We should write acks if there is data pending
   transport_->writeChain(streamId, buf->clone(), true, false);
   loopForWrites();
-  EXPECT_EQ(conn.outstandingPackets.size(), 1);
+  EXPECT_EQ(conn.outstandings.packets.size(), 1);
   auto& packet =
       getFirstOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
   EXPECT_GE(packet.frames.size(), 2);
@@ -865,7 +865,7 @@ TEST_F(QuicTransportTest, RstStream) {
   EXPECT_CALL(*socket_, write(_, _)).WillOnce(Invoke(bufLength));
   transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
   loopForWrites();
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -901,7 +901,7 @@ TEST_F(QuicTransportTest, StopSending) {
   EXPECT_CALL(*socket_, write(_, _)).WillOnce(Invoke(bufLength));
   transport_->stopSending(streamId, GenericApplicationErrorCode::UNKNOWN);
   loopForWrites();
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -943,7 +943,7 @@ TEST_F(QuicTransportTest, SendPathChallenge) {
   EXPECT_EQ(conn.outstandingPathValidation, pathChallenge);
   EXPECT_TRUE(transport_->getPathValidationTimeout().isScheduled());
 
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -984,7 +984,7 @@ TEST_F(QuicTransportTest, PathValidationTimeoutExpired) {
   EXPECT_EQ(conn.outstandingPathValidation, pathChallenge);
   EXPECT_TRUE(transport_->getPathValidationTimeout().isScheduled());
 
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
 
   transport_->getPathValidationTimeout().cancelTimeout();
   transport_->getPathValidationTimeout().timeoutExpired();
@@ -1012,7 +1012,7 @@ TEST_F(QuicTransportTest, SendPathValidationWhileThereIsOutstandingOne) {
   EXPECT_EQ(conn.outstandingPathValidation, pathChallenge);
   EXPECT_TRUE(transport_->getPathValidationTimeout().isScheduled());
 
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
 
   PathChallengeFrame pathChallenge2(456);
   transport_->getPathValidationTimeout().cancelTimeout();
@@ -1029,14 +1029,14 @@ TEST_F(QuicTransportTest, SendPathValidationWhileThereIsOutstandingOne) {
   EXPECT_EQ(conn.outstandingPathValidation, pathChallenge2);
   EXPECT_TRUE(transport_->getPathValidationTimeout().isScheduled());
 
-  EXPECT_EQ(2, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(2, transport_->getConnectionState().outstandings.packets.size());
 }
 
 TEST_F(QuicTransportTest, ClonePathChallenge) {
   auto& conn = transport_->getConnectionState();
   // knock every handshake outstanding packets out
-  conn.outstandingHandshakePacketsCount = 0;
-  conn.outstandingPackets.clear();
+  conn.outstandings.handshakePacketsCount = 0;
+  conn.outstandings.packets.clear();
   for (auto& t : conn.lossState.lossTimes) {
     t.reset();
   }
@@ -1048,20 +1048,20 @@ TEST_F(QuicTransportTest, ClonePathChallenge) {
   transport_->updateWriteLooper(true);
   loopForWrites();
 
-  EXPECT_EQ(conn.outstandingPackets.size(), 1);
+  EXPECT_EQ(conn.outstandings.packets.size(), 1);
   auto numPathChallengePackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::PathChallengeFrame_E>());
   EXPECT_EQ(numPathChallengePackets, 1);
 
   // Force a timeout with no data so that it clones the packet
   transport_->lossTimeout().timeoutExpired();
   // On PTO, endpoint sends 2 probing packets, thus 1+2=3
-  EXPECT_EQ(conn.outstandingPackets.size(), 3);
+  EXPECT_EQ(conn.outstandings.packets.size(), 3);
   numPathChallengePackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::PathChallengeFrame_E>());
 
   EXPECT_EQ(numPathChallengePackets, 3);
@@ -1070,8 +1070,8 @@ TEST_F(QuicTransportTest, ClonePathChallenge) {
 TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) {
   auto& conn = transport_->getConnectionState();
   // knock every handshake outstanding packets out
-  conn.outstandingHandshakePacketsCount = 0;
-  conn.outstandingPackets.clear();
+  conn.outstandings.handshakePacketsCount = 0;
+  conn.outstandings.packets.clear();
   for (auto& t : conn.lossState.lossTimes) {
     t.reset();
   }
@@ -1084,8 +1084,8 @@ TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) {
   loopForWrites();
 
   auto numPathChallengePackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::PathChallengeFrame_E>());
   EXPECT_EQ(numPathChallengePackets, 1);
 
@@ -1097,8 +1097,8 @@ TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) {
   // Force a timeout with no data so that it clones the packet
   transport_->lossTimeout().timeoutExpired();
   numPathChallengePackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::PathChallengeFrame_E>());
   EXPECT_EQ(numPathChallengePackets, 1);
 }
@@ -1113,7 +1113,7 @@ TEST_F(QuicTransportTest, ResendPathChallengeOnLoss) {
   transport_->updateWriteLooper(true);
   loopForWrites();
 
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1134,7 +1134,7 @@ TEST_F(QuicTransportTest, DoNotResendLostPathChallengeIfNotOutstanding) {
   transport_->updateWriteLooper(true);
   loopForWrites();
 
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1160,7 +1160,7 @@ TEST_F(QuicTransportTest, SendPathResponse) {
   loopForWrites();
   EXPECT_EQ(conn.pendingEvents.frames.size(), 0);
 
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
   bool foundPathResponse = false;
@@ -1184,7 +1184,7 @@ TEST_F(QuicTransportTest, CloneAfterRecvReset) {
   auto streamId = transport_->createBidirectionalStream().value();
   transport_->writeChain(streamId, IOBuf::create(0), true, false);
   loopForWrites();
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   auto stream = conn.streamManager->getStream(streamId);
   EXPECT_EQ(1, stream->retransmissionBuffer.size());
   EXPECT_EQ(0, stream->retransmissionBuffer.at(0)->data.chainLength());
@@ -1201,10 +1201,10 @@ TEST_F(QuicTransportTest, CloneAfterRecvReset) {
   // the future, thus the EXPECT were written with LT and LE. But it will clone
   // for sure and we shouldn't crash.
   transport_->lossTimeout().timeoutExpired();
-  EXPECT_LT(1, conn.outstandingPackets.size());
+  EXPECT_LT(1, conn.outstandings.packets.size());
   size_t cloneCounter = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       [](const auto& packet) { return packet.associatedEvent.hasValue(); });
   EXPECT_LE(1, cloneCounter);
 }
@@ -1212,8 +1212,8 @@ TEST_F(QuicTransportTest, CloneAfterRecvReset) {
 TEST_F(QuicTransportTest, ClonePathResponse) {
   auto& conn = transport_->getConnectionState();
   // knock every handshake outstanding packets out
-  conn.outstandingHandshakePacketsCount = 0;
-  conn.outstandingPackets.clear();
+  conn.outstandings.handshakePacketsCount = 0;
+  conn.outstandings.packets.clear();
   for (auto& t : conn.lossState.lossTimes) {
     t.reset();
   }
@@ -1227,16 +1227,16 @@ TEST_F(QuicTransportTest, ClonePathResponse) {
   EXPECT_EQ(conn.pendingEvents.frames.size(), 0);
 
   auto numPathResponsePackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::PathResponseFrame_E>());
   EXPECT_EQ(numPathResponsePackets, 1);
 
   // Force a timeout with no data so that it clones the packet
   transport_->lossTimeout().timeoutExpired();
   numPathResponsePackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::PathResponseFrame_E>());
   EXPECT_EQ(numPathResponsePackets, 1);
 }
@@ -1252,7 +1252,7 @@ TEST_F(QuicTransportTest, DoNotResendPathResponseOnLoss) {
   loopForWrites();
   EXPECT_EQ(conn.pendingEvents.frames.size(), 0);
 
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
 
@@ -1270,7 +1270,7 @@ TEST_F(QuicTransportTest, SendNewConnectionIdFrame) {
   loopForWrites();
 
   EXPECT_TRUE(conn.pendingEvents.frames.empty());
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1295,8 +1295,8 @@ TEST_F(QuicTransportTest, SendNewConnectionIdFrame) {
 TEST_F(QuicTransportTest, CloneNewConnectionIdFrame) {
   auto& conn = transport_->getConnectionState();
   // knock every handshake outstanding packets out
-  conn.outstandingHandshakePacketsCount = 0;
-  conn.outstandingPackets.clear();
+  conn.outstandings.handshakePacketsCount = 0;
+  conn.outstandings.packets.clear();
   for (auto& t : conn.lossState.lossTimes) {
     t.reset();
   }
@@ -1307,20 +1307,20 @@ TEST_F(QuicTransportTest, CloneNewConnectionIdFrame) {
   transport_->updateWriteLooper(true);
   loopForWrites();
 
-  EXPECT_EQ(conn.outstandingPackets.size(), 1);
+  EXPECT_EQ(conn.outstandings.packets.size(), 1);
   auto numNewConnIdPackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::NewConnectionIdFrame_E>());
   EXPECT_EQ(numNewConnIdPackets, 1);
 
   // Force a timeout with no data so that it clones the packet
   transport_->lossTimeout().timeoutExpired();
   // On PTO, endpoint sends 2 probing packets, thus 1+2=3
-  EXPECT_EQ(conn.outstandingPackets.size(), 3);
+  EXPECT_EQ(conn.outstandings.packets.size(), 3);
   numNewConnIdPackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::NewConnectionIdFrame_E>());
   EXPECT_EQ(numNewConnIdPackets, 3);
 }
@@ -1356,7 +1356,7 @@ TEST_F(QuicTransportTest, BusyWriteLoopDetection) {
   EXPECT_EQ(WriteDataReason::STREAM, conn.writeDebugState.writeDataReason);
   EXPECT_CALL(*socket_, write(_, _)).WillOnce(Return(1000));
   loopForWrites();
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   EXPECT_EQ(0, conn.writeDebugState.currentEmptyLoopCount);
 
   // Queue a window update for a stream doesn't exist
@@ -1371,7 +1371,7 @@ TEST_F(QuicTransportTest, BusyWriteLoopDetection) {
       onSuspiciousWriteLoops(1, WriteDataReason::STREAM_WINDOW_UPDATE, _, _))
       .Times(1);
   loopForWrites();
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   EXPECT_EQ(1, conn.writeDebugState.currentEmptyLoopCount);
 
   transport_->close(folly::none);
@@ -1386,7 +1386,7 @@ TEST_F(QuicTransportTest, ResendNewConnectionIdOnLoss) {
   transport_->updateWriteLooper(true);
   loopForWrites();
 
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1410,7 +1410,7 @@ TEST_F(QuicTransportTest, SendRetireConnectionIdFrame) {
   loopForWrites();
 
   EXPECT_TRUE(conn.pendingEvents.frames.empty());
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1435,8 +1435,8 @@ TEST_F(QuicTransportTest, SendRetireConnectionIdFrame) {
 TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) {
   auto& conn = transport_->getConnectionState();
   // knock every handshake outstanding packets out
-  conn.outstandingHandshakePacketsCount = 0;
-  conn.outstandingPackets.clear();
+  conn.outstandings.handshakePacketsCount = 0;
+  conn.outstandings.packets.clear();
   for (auto& t : conn.lossState.lossTimes) {
     t.reset();
   }
@@ -1446,10 +1446,10 @@ TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) {
   transport_->updateWriteLooper(true);
   loopForWrites();
 
-  EXPECT_EQ(conn.outstandingPackets.size(), 1);
+  EXPECT_EQ(conn.outstandings.packets.size(), 1);
   auto numRetireConnIdPackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<
           QuicSimpleFrame::Type::RetireConnectionIdFrame_E>());
   EXPECT_EQ(numRetireConnIdPackets, 1);
@@ -1457,10 +1457,10 @@ TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) {
   // Force a timeout with no data so that it clones the packet
   transport_->lossTimeout().timeoutExpired();
   // On PTO, endpoint sends 2 probing packets, thus 1+2=3
-  EXPECT_EQ(conn.outstandingPackets.size(), 3);
+  EXPECT_EQ(conn.outstandings.packets.size(), 3);
   numRetireConnIdPackets = std::count_if(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       findFrameInPacketFunc<
           QuicSimpleFrame::Type::RetireConnectionIdFrame_E>());
   EXPECT_EQ(numRetireConnIdPackets, 3);
@@ -1474,7 +1474,7 @@ TEST_F(QuicTransportTest, ResendRetireConnectionIdOnLoss) {
   transport_->updateWriteLooper(true);
   loopForWrites();
 
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1534,7 +1534,7 @@ TEST_F(QuicTransportTest, RstWrittenStream) {
   transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
   loopForWrites();
   // 2 packets are outstanding: one for Stream frame one for RstStream frame:
-  EXPECT_EQ(2, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(2, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1568,7 +1568,7 @@ TEST_F(QuicTransportTest, RstStreamUDPWriteFailNonFatal) {
   transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
   loopForWrites();
 
-  EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
+  EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(
           transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1605,7 +1605,7 @@ TEST_F(QuicTransportTest, RstStreamUDPWriteFailFatal) {
       .WillRepeatedly(SetErrnoAndReturn(EBADF, -1));
   transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
   loopForWrites();
-  EXPECT_TRUE(transport_->getConnectionState().outstandingPackets.empty());
+  EXPECT_TRUE(transport_->getConnectionState().outstandings.packets.empty());
 
   // Streams should be empty now since the connection will be closed.
   EXPECT_EQ(transport_->getConnectionState().streamManager->streamCount(), 0);
@@ -1640,7 +1640,7 @@ TEST_F(QuicTransportTest, WriteAfterSendRst) {
 
   // only 2 packets are outstanding: one for Stream frame one for RstStream
   // frame. The 2nd writeChain won't write anything.
-  EXPECT_EQ(2, conn.outstandingPackets.size());
+  EXPECT_EQ(2, conn.outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
   EXPECT_GE(packet.frames.size(), 1);
@@ -1720,7 +1720,7 @@ TEST_F(QuicTransportTest, WriteWindowUpdate) {
       transport_->getVersion(),
       conn.transportSettings.writeConnectionDataPacketsLimit);
   EXPECT_EQ(1, res); // Write one packet out
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   auto packet =
       getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
   EXPECT_GE(packet.frames.size(), 1);
@@ -1737,7 +1737,7 @@ TEST_F(QuicTransportTest, WriteWindowUpdate) {
   EXPECT_TRUE(connWindowFound);
 
   EXPECT_EQ(conn.flowControlState.advertisedMaxOffset, 100);
-  conn.outstandingPackets.clear();
+  conn.outstandings.packets.clear();
 
   auto stream = transport_->createBidirectionalStream().value();
   auto streamState = conn.streamManager->getStream(stream);
@@ -1756,7 +1756,7 @@ TEST_F(QuicTransportTest, WriteWindowUpdate) {
       transport_->getVersion(),
       conn.transportSettings.writeConnectionDataPacketsLimit);
   EXPECT_EQ(1, res); // Write one packet out
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   auto packet1 =
       getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
   const MaxStreamDataFrame* streamWindowUpdate =
@@ -2353,14 +2353,14 @@ TEST_F(QuicTransportTest, WriteStreamFromMiddleOfMap) {
       *headerCipher_,
       transport_->getVersion(),
       conn.transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   auto& packet = *getFirstOutstandingPacket(conn, PacketNumberSpace::AppData);
   EXPECT_EQ(1, packet.packet.frames.size());
   auto& frame = packet.packet.frames.front();
   const WriteStreamFrame* streamFrame = frame.asWriteStreamFrame();
   EXPECT_TRUE(streamFrame);
   EXPECT_EQ(streamFrame->streamId, s1);
-  conn.outstandingPackets.clear();
+  conn.outstandings.packets.clear();
 
   // Start from stream2 instead of stream1
   conn.schedulingState.nextScheduledStream = s2;
@@ -2376,14 +2376,14 @@ TEST_F(QuicTransportTest, WriteStreamFromMiddleOfMap) {
       *headerCipher_,
       transport_->getVersion(),
       conn.transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   auto& packet2 = *getFirstOutstandingPacket(conn, PacketNumberSpace::AppData);
   EXPECT_EQ(1, packet2.packet.frames.size());
   auto& frame2 = packet2.packet.frames.front();
   const WriteStreamFrame* streamFrame2 = frame2.asWriteStreamFrame();
   EXPECT_TRUE(streamFrame2);
   EXPECT_EQ(streamFrame2->streamId, s2);
-  conn.outstandingPackets.clear();
+  conn.outstandings.packets.clear();
 
   // Test wrap around
   conn.schedulingState.nextScheduledStream = s2;
@@ -2398,7 +2398,7 @@ TEST_F(QuicTransportTest, WriteStreamFromMiddleOfMap) {
       *headerCipher_,
       transport_->getVersion(),
       conn.transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
   auto& packet3 = *getFirstOutstandingPacket(conn, PacketNumberSpace::AppData);
   EXPECT_EQ(2, packet3.packet.frames.size());
   auto& frame3 = packet3.packet.frames.front();
@@ -2424,7 +2424,7 @@ TEST_F(QuicTransportTest, NoStream) {
       *headerCipher_,
       transport_->getVersion(),
       conn.transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_TRUE(conn.outstandingPackets.empty());
+  EXPECT_TRUE(conn.outstandings.packets.empty());
 }
 
 TEST_F(QuicTransportTest, CancelAckTimeout) {
diff --git a/quic/codec/QuicPacketRebuilder.cpp b/quic/codec/QuicPacketRebuilder.cpp
index 97b81ba00..33c3f5fa1 100644
--- a/quic/codec/QuicPacketRebuilder.cpp
+++ b/quic/codec/QuicPacketRebuilder.cpp
@@ -25,16 +25,16 @@ uint64_t PacketRebuilder::getHeaderBytes() const {
 
 PacketEvent PacketRebuilder::cloneOutstandingPacket(OutstandingPacket& packet) {
   // Either the packet has never been cloned before, or it's associatedEvent is
-  // still in the outstandingPacketEvents set.
+  // still in the outstandings.packetEvents set.
   DCHECK(
       !packet.associatedEvent ||
-      conn_.outstandingPacketEvents.count(*packet.associatedEvent));
+      conn_.outstandings.packetEvents.count(*packet.associatedEvent));
   if (!packet.associatedEvent) {
     auto packetNum = packet.packet.header.getPacketSequenceNum();
-    DCHECK(!conn_.outstandingPacketEvents.count(packetNum));
+    DCHECK(!conn_.outstandings.packetEvents.count(packetNum));
     packet.associatedEvent = packetNum;
-    conn_.outstandingPacketEvents.insert(packetNum);
-    ++conn_.outstandingClonedPacketsCount;
+    conn_.outstandings.packetEvents.insert(packetNum);
+    ++conn_.outstandings.clonedPacketsCount;
   }
   return *packet.associatedEvent;
 }
diff --git a/quic/codec/QuicPacketRebuilder.h b/quic/codec/QuicPacketRebuilder.h
index e92008429..5d86953f3 100644
--- a/quic/codec/QuicPacketRebuilder.h
+++ b/quic/codec/QuicPacketRebuilder.h
@@ -38,7 +38,7 @@ class PacketRebuilder {
   /**
    * A helper function that takes a OutstandingPacket that's not processed, and
    * return its associatedEvent. If this packet has never been cloned, then
-   * create the associatedEvent and add it into outstandingPacketEvents first.
+   * create the associatedEvent and add it into outstandings.packetEvents first.
    */
   PacketEvent cloneOutstandingPacket(OutstandingPacket& packet);
 
diff --git a/quic/codec/test/QuicPacketRebuilderTest.cpp b/quic/codec/test/QuicPacketRebuilderTest.cpp
index 4363dafb8..48f99dea0 100644
--- a/quic/codec/test/QuicPacketRebuilderTest.cpp
+++ b/quic/codec/test/QuicPacketRebuilderTest.cpp
@@ -448,7 +448,7 @@ TEST_F(QuicPacketRebuilderTest, CloneCounter) {
   PacketRebuilder rebuilder(regularBuilder2, conn);
   rebuilder.rebuildFromPacket(outstandingPacket);
   EXPECT_TRUE(outstandingPacket.associatedEvent.has_value());
-  EXPECT_EQ(1, conn.outstandingClonedPacketsCount);
+  EXPECT_EQ(1, conn.outstandings.clonedPacketsCount);
 }
 
 TEST_F(QuicPacketRebuilderTest, LastStreamFrameSkipLen) {
diff --git a/quic/common/test/TestUtils.cpp b/quic/common/test/TestUtils.cpp
index 871503038..87bbe8e06 100644
--- a/quic/common/test/TestUtils.cpp
+++ b/quic/common/test/TestUtils.cpp
@@ -45,7 +45,7 @@ const RegularQuicWritePacket& writeQuicPacket(
       version,
       conn.transportSettings.writeConnectionDataPacketsLimit);
   CHECK(
-      conn.outstandingPackets.rend() !=
+      conn.outstandings.packets.rend() !=
       getLastOutstandingPacket(conn, PacketNumberSpace::AppData));
   return getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
 }
@@ -69,7 +69,7 @@ PacketNum rstStreamAndSendPacket(
       version,
       conn.transportSettings.writeConnectionDataPacketsLimit);
 
-  for (const auto& packet : conn.outstandingPackets) {
+  for (const auto& packet : conn.outstandings.packets) {
     for (const auto& frame : packet.packet.frames) {
       auto rstFrame = frame.asRstStreamFrame();
       if (!rstFrame) {
diff --git a/quic/common/test/TestUtils.h b/quic/common/test/TestUtils.h
index d3946abc4..8cd8d37dd 100644
--- a/quic/common/test/TestUtils.h
+++ b/quic/common/test/TestUtils.h
@@ -202,7 +202,7 @@ OutstandingPacket* findOutstandingPacket(
     }
     return nullptr;
   };
-  return helper(conn.outstandingPackets);
+  return helper(conn.outstandings.packets);
 }
 
 // Helper function to generate a buffer containing random data of given length
diff --git a/quic/congestion_control/Bandwidth.h b/quic/congestion_control/Bandwidth.h
index 3ebce14df..26f45f821 100644
--- a/quic/congestion_control/Bandwidth.h
+++ b/quic/congestion_control/Bandwidth.h
@@ -27,14 +27,12 @@ struct Bandwidth {
   UnitType unitType{UnitType::BYTES};
 
   explicit Bandwidth()
-      : units(0),
-        interval(std::chrono::microseconds::zero()) {}
+      : units(0), interval(std::chrono::microseconds::zero()) {}
 
   explicit Bandwidth(
       uint64_t unitsDelievered,
       std::chrono::microseconds deliveryInterval)
-      : units(unitsDelievered),
-        interval(deliveryInterval) {}
+      : units(unitsDelievered), interval(deliveryInterval) {}
 
   explicit Bandwidth(
       uint64_t unitsDelievered,
diff --git a/quic/congestion_control/CongestionControlFunctions.cpp b/quic/congestion_control/CongestionControlFunctions.cpp
index b8ecf5f83..0db52df52 100644
--- a/quic/congestion_control/CongestionControlFunctions.cpp
+++ b/quic/congestion_control/CongestionControlFunctions.cpp
@@ -50,8 +50,8 @@ PacingRate calculatePacingRate(
       conn.transportSettings.pacingTimerTickInterval,
       rtt * burstPerInterval / cwndInPackets);
   return PacingRate::Builder()
-        .setInterval(interval)
-        .setBurstSize(burstPerInterval)
-        .build();
+      .setInterval(interval)
+      .setBurstSize(burstPerInterval)
+      .build();
 }
 } // namespace quic
diff --git a/quic/congestion_control/test/BbrTest.cpp b/quic/congestion_control/test/BbrTest.cpp
index e44ac05c5..f9635a64f 100644
--- a/quic/congestion_control/test/BbrTest.cpp
+++ b/quic/congestion_control/test/BbrTest.cpp
@@ -548,7 +548,7 @@ TEST_F(BbrTest, BytesCounting) {
 
   PacketNum packetNum = 0;
   auto packet = makeTestingWritePacket(packetNum, 1200, 1200);
-  conn.outstandingPackets.push_back(packet);
+  conn.outstandings.packets.push_back(packet);
   ReadAckFrame ackFrame;
   ackFrame.largestAcked = packetNum;
   ackFrame.ackBlocks.emplace_back(packetNum, packetNum);
diff --git a/quic/congestion_control/test/CongestionControlFunctionsTest.cpp b/quic/congestion_control/test/CongestionControlFunctionsTest.cpp
index d708519d0..73d6d154e 100644
--- a/quic/congestion_control/test/CongestionControlFunctionsTest.cpp
+++ b/quic/congestion_control/test/CongestionControlFunctionsTest.cpp
@@ -72,6 +72,5 @@ TEST_F(CongestionControlFunctionsTest, RttSmallerThanInterval) {
       conn.transportSettings.writeConnectionDataPacketsLimit, result.burstSize);
 }
 
-
 } // namespace test
 } // namespace quic
diff --git a/quic/fizz/client/test/QuicClientTransportTest.cpp b/quic/fizz/client/test/QuicClientTransportTest.cpp
index 85ee7f624..3ce5db0c7 100644
--- a/quic/fizz/client/test/QuicClientTransportTest.cpp
+++ b/quic/fizz/client/test/QuicClientTransportTest.cpp
@@ -3474,7 +3474,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithStreamPending) {
   client->writeChain(streamId, expected->clone(), true, false);
   loopForWrites();
   // ack all the packets
-  ASSERT_FALSE(client->getConn().outstandingPackets.empty());
+  ASSERT_FALSE(client->getConn().outstandings.packets.empty());
 
   AckBlocks acks;
   auto start = getFirstOutstandingPacket(
@@ -3549,7 +3549,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithNoStreamPending) {
   loopForWrites();
 
   // ack all the packets
-  ASSERT_FALSE(client->getConn().outstandingPackets.empty());
+  ASSERT_FALSE(client->getConn().outstandings.packets.empty());
 
   AckBlocks acks;
   auto start = getFirstOutstandingPacket(
@@ -3961,7 +3961,7 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimerNotResetOnWritingOldData) {
 TEST_F(QuicClientTransportAfterStartTest, IdleTimerResetNoOutstandingPackets) {
   // This will clear out all the outstanding packets
   AckBlocks sentPackets;
-  for (auto& packet : client->getNonConstConn().outstandingPackets) {
+  for (auto& packet : client->getNonConstConn().outstandings.packets) {
     auto packetNum = packet.packet.header.getPacketSequenceNum();
     sentPackets.insert(packetNum);
   }
@@ -3974,9 +3974,9 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimerResetNoOutstandingPackets) {
 
   // Clear out all the outstanding packets to simulate quiescent state.
   client->getNonConstConn().receivedNewPacketBeforeWrite = false;
-  client->getNonConstConn().outstandingPackets.clear();
-  client->getNonConstConn().outstandingHandshakePacketsCount = 0;
-  client->getNonConstConn().outstandingClonedPacketsCount = 0;
+  client->getNonConstConn().outstandings.packets.clear();
+  client->getNonConstConn().outstandings.handshakePacketsCount = 0;
+  client->getNonConstConn().outstandings.clonedPacketsCount = 0;
   client->idleTimeout().cancelTimeout();
   auto streamId = client->createBidirectionalStream().value();
   auto expected = folly::IOBuf::copyBuffer("hello");
@@ -4723,7 +4723,7 @@ TEST_F(QuicClientTransportAfterStartTest, ResetClearsPendingLoss) {
   };
   client->writeChain(streamId, IOBuf::copyBuffer("hello"), true, false);
   loopForWrites();
-  ASSERT_FALSE(client->getConn().outstandingPackets.empty());
+  ASSERT_FALSE(client->getConn().outstandings.packets.empty());
 
   RegularQuicWritePacket* forceLossPacket =
       CHECK_NOTNULL(findPacketWithStream(client->getNonConstConn(), streamId));
@@ -4748,7 +4748,7 @@ TEST_F(QuicClientTransportAfterStartTest, LossAfterResetStream) {
   };
   client->writeChain(streamId, IOBuf::copyBuffer("hello"), true, false);
   loopForWrites();
-  ASSERT_FALSE(client->getConn().outstandingPackets.empty());
+  ASSERT_FALSE(client->getConn().outstandings.packets.empty());
 
   client->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
 
@@ -5367,7 +5367,7 @@ class QuicZeroRttClientTest : public QuicClientTransportAfterStartTestBase {
   }
 
   bool zeroRttPacketsOutstanding() {
-    for (auto& packet : client->getNonConstConn().outstandingPackets) {
+    for (auto& packet : client->getNonConstConn().outstandings.packets) {
       bool isZeroRtt =
           packet.packet.header.getProtectionType() == ProtectionType::ZeroRtt;
       if (isZeroRtt) {
diff --git a/quic/loss/QuicLossFunctions.cpp b/quic/loss/QuicLossFunctions.cpp
index 4efffd5db..dcfbf7835 100644
--- a/quic/loss/QuicLossFunctions.cpp
+++ b/quic/loss/QuicLossFunctions.cpp
@@ -38,7 +38,7 @@ void onPTOAlarm(QuicConnectionStateBase& conn) {
       conn,
       conn.lossState.largestSent.value_or(0),
       conn.lossState.ptoCount,
-      (uint64_t)conn.outstandingPackets.size());
+      (uint64_t)conn.outstandings.packets.size());
   QUIC_STATS(conn.statsCallback, onPTO);
   conn.lossState.ptoCount++;
   conn.lossState.totalPTOCount++;
@@ -46,7 +46,7 @@ void onPTOAlarm(QuicConnectionStateBase& conn) {
     conn.qLogger->addLossAlarm(
         conn.lossState.largestSent.value_or(0),
         conn.lossState.ptoCount,
-        (uint64_t)conn.outstandingPackets.size(),
+        (uint64_t)conn.outstandings.packets.size(),
         kPtoAlarm);
   }
   if (conn.lossState.ptoCount == conn.transportSettings.maxNumPTOs) {
diff --git a/quic/loss/QuicLossFunctions.h b/quic/loss/QuicLossFunctions.h
index b39d4be3e..a01644423 100644
--- a/quic/loss/QuicLossFunctions.h
+++ b/quic/loss/QuicLossFunctions.h
@@ -77,7 +77,7 @@ calculateAlarmDuration(const QuicConnectionStateBase& conn) {
       alarmDuration = 0us;
     }
     alarmMethod = LossState::AlarmMethod::EarlyRetransmitOrReordering;
-  } else if (conn.outstandingHandshakePacketsCount > 0) {
+  } else if (conn.outstandings.handshakePacketsCount > 0) {
     if (conn.lossState.srtt == 0us) {
       alarmDuration = conn.transportSettings.initialRtt * 2;
     } else {
@@ -106,7 +106,7 @@ calculateAlarmDuration(const QuicConnectionStateBase& conn) {
             lastSentPacketTime + alarmDuration - now);
   } else {
     auto lastSentPacketNum =
-        conn.outstandingPackets.back().packet.header.getPacketSequenceNum();
+        conn.outstandings.packets.back().packet.header.getPacketSequenceNum();
     VLOG(10) << __func__ << " alarm already due method=" << *alarmMethod
              << " lastSentPacketNum=" << lastSentPacketNum
              << " lastSentPacketTime="
@@ -138,7 +138,7 @@ void setLossDetectionAlarm(QuicConnectionStateBase& conn, Timeout& timeout) {
    */
   bool hasDataToWrite = hasAckDataToWrite(conn) ||
       (hasNonAckDataToWrite(conn) != WriteDataReason::NO_WRITE);
-  auto totalPacketsOutstanding = conn.outstandingPackets.size();
+  auto totalPacketsOutstanding = conn.outstandings.packets.size();
   /*
    * We have this condition to disambiguate the case where we have.
    * (1) All outstanding packets that are clones that are processed and there
@@ -151,11 +151,11 @@ void setLossDetectionAlarm(QuicConnectionStateBase& conn, Timeout& timeout) {
    * write them since we could be blocked by cwnd. So we must set the loss timer
    * so that we can write this data with the slack packet space for the clones.
    */
-  if (!hasDataToWrite && conn.outstandingPacketEvents.empty() &&
-      totalPacketsOutstanding == conn.outstandingClonedPacketsCount) {
+  if (!hasDataToWrite && conn.outstandings.packetEvents.empty() &&
+      totalPacketsOutstanding == conn.outstandings.clonedPacketsCount) {
     VLOG(10) << __func__ << " unset alarm pure ack or processed packets only"
              << " outstanding=" << totalPacketsOutstanding
-             << " handshakePackets=" << conn.outstandingHandshakePacketsCount
+             << " handshakePackets=" << conn.outstandings.handshakePacketsCount
              << " " << conn;
     conn.pendingEvents.setLossDetectionAlarm = false;
     timeout.cancelLossTimeout();
@@ -165,8 +165,8 @@ void setLossDetectionAlarm(QuicConnectionStateBase& conn, Timeout& timeout) {
     VLOG_IF(10, !timeout.isLossTimeoutScheduled())
         << __func__ << " alarm not scheduled"
         << " outstanding=" << totalPacketsOutstanding
-        << " handshakePackets=" << conn.outstandingHandshakePacketsCount << " "
-        << nodeToString(conn.nodeType) << " " << conn;
+        << " handshakePackets=" << conn.outstandings.handshakePacketsCount
+        << " " << nodeToString(conn.nodeType) << " " << conn;
     return;
   }
   timeout.cancelLossTimeout();
@@ -176,7 +176,7 @@ void setLossDetectionAlarm(QuicConnectionStateBase& conn, Timeout& timeout) {
            << " alarm=" << alarmDuration.first.count() << "ms"
            << " method=" << conn.lossState.currentAlarmMethod
            << " outstanding=" << totalPacketsOutstanding
-           << " handshakePackets=" << conn.outstandingHandshakePacketsCount
+           << " handshakePackets=" << conn.outstandings.handshakePacketsCount
            << " " << nodeToString(conn.nodeType) << " " << conn;
   timeout.scheduleLossTimeout(alarmDuration.first);
   conn.pendingEvents.setLossDetectionAlarm = false;
@@ -198,7 +198,7 @@ folly::Optional<CongestionController::LossEvent> detectLossPackets(
       std::max(conn.lossState.srtt, conn.lossState.lrtt) *
       conn.transportSettings.timeReorderingThreshDividend /
       conn.transportSettings.timeReorderingThreshDivisor;
-  VLOG(10) << __func__ << " outstanding=" << conn.outstandingPackets.size()
+  VLOG(10) << __func__ << " outstanding=" << conn.outstandings.packets.size()
            << " largestAcked=" << largestAcked.value_or(0)
            << " delayUntilLost=" << delayUntilLost.count() << "us"
            << " " << conn;
@@ -206,7 +206,7 @@ folly::Optional<CongestionController::LossEvent> detectLossPackets(
   // Note that time based loss detection is also within the same PNSpace.
   auto iter = getFirstOutstandingPacket(conn, pnSpace);
   bool shouldSetTimer = false;
-  while (iter != conn.outstandingPackets.end()) {
+  while (iter != conn.outstandings.packets.end()) {
     auto& pkt = *iter;
     auto currentPacketNum = pkt.packet.header.getPacketSequenceNum();
     if (!largestAcked.has_value() || currentPacketNum >= *largestAcked) {
@@ -228,40 +228,40 @@ folly::Optional<CongestionController::LossEvent> detectLossPackets(
     }
     lossEvent.addLostPacket(pkt);
     if (pkt.associatedEvent) {
-      DCHECK_GT(conn.outstandingClonedPacketsCount, 0);
-      --conn.outstandingClonedPacketsCount;
+      DCHECK_GT(conn.outstandings.clonedPacketsCount, 0);
+      --conn.outstandings.clonedPacketsCount;
     }
     // Invoke LossVisitor if the packet doesn't have a associated PacketEvent;
-    // or if the PacketEvent is present in conn.outstandingPacketEvents.
+    // or if the PacketEvent is present in conn.outstandings.packetEvents.
     bool processed = pkt.associatedEvent &&
-        !conn.outstandingPacketEvents.count(*pkt.associatedEvent);
+        !conn.outstandings.packetEvents.count(*pkt.associatedEvent);
     lossVisitor(conn, pkt.packet, processed, currentPacketNum);
-    // Remove the PacketEvent from the outstandingPacketEvents set
+    // Remove the PacketEvent from the outstandings.packetEvents set
     if (pkt.associatedEvent) {
-      conn.outstandingPacketEvents.erase(*pkt.associatedEvent);
+      conn.outstandings.packetEvents.erase(*pkt.associatedEvent);
     }
     if (pkt.isHandshake) {
-      DCHECK(conn.outstandingHandshakePacketsCount);
-      --conn.outstandingHandshakePacketsCount;
+      DCHECK(conn.outstandings.handshakePacketsCount);
+      --conn.outstandings.handshakePacketsCount;
     }
     VLOG(10) << __func__ << " lost packetNum=" << currentPacketNum
              << " handshake=" << pkt.isHandshake << " " << conn;
-    iter = conn.outstandingPackets.erase(iter);
+    iter = conn.outstandings.packets.erase(iter);
   }
 
   auto earliest = getFirstOutstandingPacket(conn, pnSpace);
-  for (; earliest != conn.outstandingPackets.end();
+  for (; earliest != conn.outstandings.packets.end();
        earliest = getNextOutstandingPacket(conn, pnSpace, earliest + 1)) {
     if (!earliest->associatedEvent ||
-        conn.outstandingPacketEvents.count(*earliest->associatedEvent)) {
+        conn.outstandings.packetEvents.count(*earliest->associatedEvent)) {
       break;
     }
   }
-  if (shouldSetTimer && earliest != conn.outstandingPackets.end()) {
+  if (shouldSetTimer && earliest != conn.outstandings.packets.end()) {
     // We are eligible to set a loss timer and there are a few packets which
     // are unacked, so we can set the early retransmit timer for them.
     VLOG(10) << __func__ << " early retransmit timer outstanding="
-             << conn.outstandingPackets.empty() << " delayUntilLost"
+             << conn.outstandings.packets.empty() << " delayUntilLost"
              << delayUntilLost.count() << "us"
              << " " << conn;
     getLossTime(conn, pnSpace) = delayUntilLost + earliest->time;
@@ -308,18 +308,18 @@ void onHandshakeAlarm(
       conn,
       conn.lossState.largestSent.value_or(0),
       conn.lossState.handshakeAlarmCount,
-      (uint64_t)conn.outstandingHandshakePacketsCount,
-      (uint64_t)conn.outstandingPackets.size());
+      (uint64_t)conn.outstandings.handshakePacketsCount,
+      (uint64_t)conn.outstandings.packets.size());
   if (conn.qLogger) {
     conn.qLogger->addLossAlarm(
         conn.lossState.largestSent.value_or(0),
         conn.lossState.handshakeAlarmCount,
-        (uint64_t)conn.outstandingPackets.size(),
+        (uint64_t)conn.outstandings.packets.size(),
         kHandshakeAlarm);
   }
   CongestionController::LossEvent lossEvent(ClockType::now());
-  auto iter = conn.outstandingPackets.begin();
-  while (iter != conn.outstandingPackets.end()) {
+  auto iter = conn.outstandings.packets.begin();
+  while (iter != conn.outstandings.packets.end()) {
     // the word "handshake" in our code base is unfortunately overloaded.
     if (iter->isHandshake) {
       auto& packet = *iter;
@@ -329,11 +329,11 @@ void onHandshakeAlarm(
                << " packetNumSpace=" << currentPacketNumSpace << " " << conn;
       lossEvent.addLostPacket(std::move(packet));
       lossVisitor(conn, packet.packet, false, currentPacketNum);
-      DCHECK(conn.outstandingHandshakePacketsCount);
-      --conn.outstandingHandshakePacketsCount;
+      DCHECK(conn.outstandings.handshakePacketsCount);
+      --conn.outstandings.handshakePacketsCount;
       ++conn.lossState.timeoutBasedRtxCount;
       ++conn.lossState.rtxCount;
-      iter = conn.outstandingPackets.erase(iter);
+      iter = conn.outstandings.packets.erase(iter);
     } else {
       iter++;
     }
@@ -356,7 +356,7 @@ void onLossDetectionAlarm(
     QuicConnectionStateBase& conn,
     const LossVisitor& lossVisitor) {
   auto now = ClockType::now();
-  if (conn.outstandingPackets.empty()) {
+  if (conn.outstandings.packets.empty()) {
     VLOG(10) << "Transmission alarm fired with no outstanding packets " << conn;
     return;
   }
@@ -385,11 +385,11 @@ void onLossDetectionAlarm(
   } else {
     onPTOAlarm(conn);
   }
-  conn.pendingEvents.setLossDetectionAlarm = !conn.outstandingPackets.empty();
+  conn.pendingEvents.setLossDetectionAlarm = !conn.outstandings.packets.empty();
   VLOG(10) << __func__ << " setLossDetectionAlarm="
            << conn.pendingEvents.setLossDetectionAlarm
-           << " outstanding=" << conn.outstandingPackets.size()
-           << " handshakePackets=" << conn.outstandingHandshakePacketsCount
+           << " outstanding=" << conn.outstandings.packets.size()
+           << " handshakePackets=" << conn.outstandings.handshakePacketsCount
            << " " << conn;
 }
 
@@ -426,13 +426,13 @@ folly::Optional<CongestionController::LossEvent> handleAckForLoss(
       lossVisitor,
       ack.ackTime,
       pnSpace);
-  conn.pendingEvents.setLossDetectionAlarm = !conn.outstandingPackets.empty();
+  conn.pendingEvents.setLossDetectionAlarm = !conn.outstandings.packets.empty();
   VLOG(10) << __func__
            << " largestAckedInPacket=" << ack.largestAckedPacket.value_or(0)
            << " setLossDetectionAlarm="
            << conn.pendingEvents.setLossDetectionAlarm
-           << " outstanding=" << conn.outstandingPackets.size()
-           << " handshakePackets=" << conn.outstandingHandshakePacketsCount
+           << " outstanding=" << conn.outstandings.packets.size()
+           << " handshakePackets=" << conn.outstandings.handshakePacketsCount
            << " " << conn;
   return lossEvent;
 }
@@ -446,7 +446,7 @@ void markZeroRttPacketsLost(
     const LossVisitor& lossVisitor) {
   CongestionController::LossEvent lossEvent(ClockType::now());
   auto iter = getFirstOutstandingPacket(conn, PacketNumberSpace::AppData);
-  while (iter != conn.outstandingPackets.end()) {
+  while (iter != conn.outstandings.packets.end()) {
     DCHECK_EQ(
         iter->packet.header.getPacketNumberSpace(), PacketNumberSpace::AppData);
     auto isZeroRttPacket =
@@ -456,16 +456,16 @@ void markZeroRttPacketsLost(
       DCHECK(!pkt.isHandshake);
       auto currentPacketNum = pkt.packet.header.getPacketSequenceNum();
       bool processed = pkt.associatedEvent &&
-          !conn.outstandingPacketEvents.count(*pkt.associatedEvent);
+          !conn.outstandings.packetEvents.count(*pkt.associatedEvent);
       lossVisitor(conn, pkt.packet, processed, currentPacketNum);
-      // Remove the PacketEvent from the outstandingPacketEvents set
+      // Remove the PacketEvent from the outstandings.packetEvents set
       if (pkt.associatedEvent) {
-        conn.outstandingPacketEvents.erase(*pkt.associatedEvent);
-        DCHECK_GT(conn.outstandingClonedPacketsCount, 0);
-        --conn.outstandingClonedPacketsCount;
+        conn.outstandings.packetEvents.erase(*pkt.associatedEvent);
+        DCHECK_GT(conn.outstandings.clonedPacketsCount, 0);
+        --conn.outstandings.clonedPacketsCount;
       }
       lossEvent.addLostPacket(pkt);
-      iter = conn.outstandingPackets.erase(iter);
+      iter = conn.outstandings.packets.erase(iter);
       iter = getNextOutstandingPacket(conn, PacketNumberSpace::AppData, iter);
     } else {
       iter =
diff --git a/quic/loss/test/QuicLossFunctionsTest.cpp b/quic/loss/test/QuicLossFunctionsTest.cpp
index dcd810efd..f9a09b0a6 100644
--- a/quic/loss/test/QuicLossFunctionsTest.cpp
+++ b/quic/loss/test/QuicLossFunctionsTest.cpp
@@ -187,7 +187,7 @@ PacketNum QuicLossFunctionsTest::sendPacket(
       packet.packet, time, encodedSize, isHandshake, encodedSize);
   outstandingPacket.associatedEvent = associatedEvent;
   if (isHandshake) {
-    conn.outstandingHandshakePacketsCount++;
+    conn.outstandings.handshakePacketsCount++;
     conn.lossState.lastHandshakePacketSentTime = time;
   }
   conn.lossState.lastRetransmittablePacketSentTime = time;
@@ -195,24 +195,24 @@ PacketNum QuicLossFunctionsTest::sendPacket(
     conn.congestionController->onPacketSent(outstandingPacket);
   }
   if (associatedEvent) {
-    conn.outstandingClonedPacketsCount++;
+    conn.outstandings.clonedPacketsCount++;
     // Simulates what the real writer does.
     auto it = std::find_if(
-        conn.outstandingPackets.begin(),
-        conn.outstandingPackets.end(),
+        conn.outstandings.packets.begin(),
+        conn.outstandings.packets.end(),
         [&associatedEvent](const auto& packet) {
           auto packetNum = packet.packet.header.getPacketSequenceNum();
           return packetNum == *associatedEvent;
         });
-    if (it != conn.outstandingPackets.end()) {
+    if (it != conn.outstandings.packets.end()) {
       if (!it->associatedEvent) {
-        conn.outstandingPacketEvents.emplace(*associatedEvent);
-        conn.outstandingClonedPacketsCount++;
+        conn.outstandings.packetEvents.emplace(*associatedEvent);
+        conn.outstandings.clonedPacketsCount++;
         it->associatedEvent = *associatedEvent;
       }
     }
   }
-  conn.outstandingPackets.emplace_back(std::move(outstandingPacket));
+  conn.outstandings.packets.emplace_back(std::move(outstandingPacket));
   conn.lossState.largestSent = getNextPacketNum(conn, packetNumberSpace);
   increaseNextPacketNum(conn, packetNumberSpace);
   conn.pendingEvents.setLossDetectionAlarm = true;
@@ -275,8 +275,8 @@ TEST_F(QuicLossFunctionsTest, TestOnLossDetectionAlarm) {
   onLossDetectionAlarm<decltype(testingLossMarkFunc(lostPacket)), MockClock>(
       *conn, testingLossMarkFunc(lostPacket));
   EXPECT_EQ(conn->lossState.ptoCount, 2);
-  // PTO doesn't take anything out of outstandingPackets
-  EXPECT_FALSE(conn->outstandingPackets.empty());
+  // PTO doesn't take anything out of outstandings.packets
+  EXPECT_FALSE(conn->outstandings.packets.empty());
   EXPECT_TRUE(conn->pendingEvents.setLossDetectionAlarm);
   // PTO shouldn't mark loss
   EXPECT_TRUE(lostPacket.empty());
@@ -290,16 +290,16 @@ TEST_F(QuicLossFunctionsTest, TestOnPTOSkipProcessed) {
   EXPECT_CALL(*rawCongestionController, onPacketSent(_))
       .WillRepeatedly(Return());
   // By adding an associatedEvent that doesn't exist in the
-  // outstandingPacketEvents, they are all processed and will skip lossVisitor
+  // outstandings.packetEvents, they are all processed and will skip lossVisitor
   for (auto i = 0; i < 10; i++) {
     sendPacket(*conn, TimePoint(), i, PacketType::OneRtt);
   }
-  EXPECT_EQ(10, conn->outstandingPackets.size());
+  EXPECT_EQ(10, conn->outstandings.packets.size());
   std::vector<PacketNum> lostPackets;
   EXPECT_CALL(*rawCongestionController, onRemoveBytesFromInflight(_)).Times(0);
   EXPECT_CALL(*transportInfoCb_, onPTO());
   onPTOAlarm(*conn);
-  EXPECT_EQ(10, conn->outstandingPackets.size());
+  EXPECT_EQ(10, conn->outstandings.packets.size());
   EXPECT_TRUE(lostPackets.empty());
 }
 
@@ -335,7 +335,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLoss) {
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
 
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
   auto& packet =
       getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
   auto packetNum = packet.header.getPacketSequenceNum();
@@ -371,7 +371,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossMerge) {
       *headerCipher,
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
 
   auto buf2 = buildRandomInputData(20);
   writeDataToQuicStream(*stream1, buf2->clone(), false);
@@ -384,7 +384,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossMerge) {
       *headerCipher,
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(2, conn->outstandingPackets.size());
+  EXPECT_EQ(2, conn->outstandings.packets.size());
 
   auto& packet1 =
       getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
@@ -427,7 +427,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossNoMerge) {
       *headerCipher,
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
 
   auto buf2 = buildRandomInputData(20);
   writeDataToQuicStream(*stream1, buf2->clone(), false);
@@ -440,7 +440,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossNoMerge) {
       *headerCipher,
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(2, conn->outstandingPackets.size());
+  EXPECT_EQ(2, conn->outstandings.packets.size());
 
   auto buf3 = buildRandomInputData(20);
   writeDataToQuicStream(*stream1, buf3->clone(), false);
@@ -453,7 +453,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossNoMerge) {
       *headerCipher,
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
-  EXPECT_EQ(3, conn->outstandingPackets.size());
+  EXPECT_EQ(3, conn->outstandings.packets.size());
 
   auto& packet1 =
       getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
@@ -508,8 +508,8 @@ TEST_F(QuicLossFunctionsTest, RetxBufferSortedAfterLoss) {
       *stream,
       *buf3);
   EXPECT_EQ(3, stream->retransmissionBuffer.size());
-  EXPECT_EQ(3, conn->outstandingPackets.size());
-  auto packet = conn->outstandingPackets[folly::Random::rand32() % 3];
+  EXPECT_EQ(3, conn->outstandings.packets.size());
+  auto packet = conn->outstandings.packets[folly::Random::rand32() % 3];
   markPacketLoss(
       *conn, packet.packet, false, packet.packet.header.getPacketSequenceNum());
   EXPECT_EQ(2, stream->retransmissionBuffer.size());
@@ -539,9 +539,9 @@ TEST_F(QuicLossFunctionsTest, TestMarkCryptoLostAfterCancelRetransmission) {
       *headerCipher,
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
-  ASSERT_EQ(conn->outstandingPackets.size(), 1);
+  ASSERT_EQ(conn->outstandings.packets.size(), 1);
   EXPECT_GT(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0);
-  auto& packet = conn->outstandingPackets.front().packet;
+  auto& packet = conn->outstandings.packets.front().packet;
   auto packetNum = packet.header.getPacketSequenceNum();
   cancelHandshakeCryptoStreamRetransmissions(*conn->cryptoState);
   markPacketLoss(*conn, packet, false, packetNum);
@@ -573,9 +573,9 @@ TEST_F(QuicLossFunctionsTest, TestMarkCryptoLostCancel) {
       *headerCipher,
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
-  ASSERT_EQ(conn->outstandingPackets.size(), 1);
+  ASSERT_EQ(conn->outstandings.packets.size(), 1);
   EXPECT_GT(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0);
-  auto& packet = conn->outstandingPackets.front().packet;
+  auto& packet = conn->outstandings.packets.front().packet;
   auto packetNum = packet.header.getPacketSequenceNum();
   markPacketLoss(*conn, packet, false, packetNum);
   EXPECT_EQ(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0);
@@ -627,7 +627,7 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) {
   for (int i = 0; i < 6; ++i) {
     sendPacket(*conn, Clock::now(), folly::none, PacketType::Handshake);
   }
-  EXPECT_EQ(6, conn->outstandingHandshakePacketsCount);
+  EXPECT_EQ(6, conn->outstandings.handshakePacketsCount);
   // Assume some packets are already acked
   for (auto iter =
            getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake) + 2;
@@ -635,12 +635,12 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) {
        getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake) + 5;
        iter++) {
     if (iter->isHandshake) {
-      conn->outstandingHandshakePacketsCount--;
+      conn->outstandings.handshakePacketsCount--;
     }
   }
   auto firstHandshakeOpIter =
       getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake);
-  conn->outstandingPackets.erase(
+  conn->outstandings.packets.erase(
       firstHandshakeOpIter + 2, firstHandshakeOpIter + 5);
   // Ack for packet 9 arrives
   auto lossEvent = detectLossPackets<decltype(testingLossMarkFunc)>(
@@ -657,12 +657,12 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) {
   EXPECT_EQ(lostPacket.back(), 2);
 
   // Packet 6 is the only thing remaining inflight, it is a handshake pkt
-  EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
+  EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
 
   // Packet 6 should remain in packet as the delta is less than threshold
-  EXPECT_EQ(conn->outstandingPackets.size(), 1);
+  EXPECT_EQ(conn->outstandings.packets.size(), 1);
   auto packetNum =
-      conn->outstandingPackets.front().packet.header.getPacketSequenceNum();
+      conn->outstandings.packets.front().packet.header.getPacketSequenceNum();
   EXPECT_EQ(packetNum, 6);
 }
 
@@ -681,7 +681,7 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) {
       conn->version.value());
   RegularQuicWritePacket outstandingRegularPacket(std::move(longHeader));
   auto now = Clock::now();
-  conn->outstandingPackets.emplace_back(
+  conn->outstandings.packets.emplace_back(
       OutstandingPacket(outstandingRegularPacket, now, 0, false, 0));
 
   bool testLossMarkFuncCalled = false;
@@ -697,7 +697,7 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) {
       *conn, testLossMarkFunc, ackEvent, PacketNumberSpace::Handshake);
 
   EXPECT_EQ(0, conn->lossState.ptoCount);
-  EXPECT_TRUE(conn->outstandingPackets.empty());
+  EXPECT_TRUE(conn->outstandings.packets.empty());
   EXPECT_FALSE(conn->pendingEvents.setLossDetectionAlarm);
   EXPECT_TRUE(testLossMarkFuncCalled);
 }
@@ -736,10 +736,10 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckedPacket) {
 
   EXPECT_EQ(0, conn->lossState.ptoCount);
   EXPECT_EQ(0, conn->lossState.handshakeAlarmCount);
-  EXPECT_TRUE(conn->outstandingPackets.empty());
+  EXPECT_TRUE(conn->outstandings.packets.empty());
   EXPECT_FALSE(conn->pendingEvents.setLossDetectionAlarm);
   EXPECT_FALSE(testLossMarkFuncCalled);
-  ASSERT_TRUE(conn->outstandingPackets.empty());
+  ASSERT_TRUE(conn->outstandings.packets.empty());
 
   setLossDetectionAlarm<decltype(timeout), MockClock>(*conn, timeout);
   EXPECT_FALSE(conn->pendingEvents.setLossDetectionAlarm);
@@ -765,7 +765,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkRstLoss) {
       *conn->version,
       conn->transportSettings.writeConnectionDataPacketsLimit);
 
-  EXPECT_EQ(conn->outstandingPackets.size(), 1);
+  EXPECT_EQ(conn->outstandings.packets.size(), 1);
   EXPECT_TRUE(conn->pendingEvents.resets.empty());
   auto& packet =
       getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
@@ -857,7 +857,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkWindowUpdateLoss) {
       conn->transportSettings.writeConnectionDataPacketsLimit);
   EXPECT_FALSE(conn->streamManager->hasWindowUpdates());
 
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
   auto& packet =
       getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
 
@@ -883,7 +883,7 @@ TEST_F(QuicLossFunctionsTest, TestTimeReordering) {
   // Some packets are already acked
   conn->lossState.srtt = 400ms;
   conn->lossState.lrtt = 350ms;
-  conn->outstandingPackets.erase(
+  conn->outstandings.packets.erase(
       getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData) + 2,
       getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData) + 5);
   auto lossEvent = detectLossPackets<decltype(testingLossMarkFunc(lostPacket))>(
@@ -900,7 +900,7 @@ TEST_F(QuicLossFunctionsTest, TestTimeReordering) {
   EXPECT_EQ(lostPacket.back(), 2);
 
   // Packet 6, 7 should remain in outstanding packet list
-  EXPECT_EQ(2, conn->outstandingPackets.size());
+  EXPECT_EQ(2, conn->outstandings.packets.size());
   auto packetNum = getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
                        ->packet.header.getPacketSequenceNum();
   EXPECT_EQ(packetNum, 6);
@@ -945,14 +945,14 @@ TEST_F(QuicLossFunctionsTest, LossTimePreemptsCryptoTimer) {
 
   // Second packet gets acked:
   getAckState(*conn, PacketNumberSpace::Handshake).largestAckedByPeer = second;
-  conn->outstandingPackets.pop_back();
+  conn->outstandings.packets.pop_back();
   MockClock::mockNow = [=]() { return sendTime + expectedDelayUntilLost + 5s; };
   onLossDetectionAlarm<decltype(testingLossMarkFunc(lostPackets)), MockClock>(
       *conn, testingLossMarkFunc(lostPackets));
   EXPECT_EQ(1, lostPackets.size());
   EXPECT_FALSE(
       conn->lossState.lossTimes[PacketNumberSpace::Handshake].has_value());
-  EXPECT_TRUE(conn->outstandingPackets.empty());
+  EXPECT_TRUE(conn->outstandings.packets.empty());
 }
 
 TEST_F(QuicLossFunctionsTest, PTONoLongerMarksPacketsToBeRetransmitted) {
@@ -1006,8 +1006,8 @@ TEST_F(
         expectedLargestLostNum, i % 2 ? sentPacketNum : expectedLargestLostNum);
   }
   uint64_t expectedLostBytes = std::accumulate(
-      conn->outstandingPackets.begin(),
-      conn->outstandingPackets.end(),
+      conn->outstandings.packets.begin(),
+      conn->outstandings.packets.end(),
       0,
       [](uint64_t num, const OutstandingPacket& packet) {
         return packet.isHandshake ? num + packet.encodedSize : num;
@@ -1214,9 +1214,9 @@ TEST_F(QuicLossFunctionsTest, NoDoubleProcess) {
   for (size_t i = 0; i < 6; i++) {
     lastSent = sendPacket(*conn, Clock::now(), event, PacketType::OneRtt);
   }
-  EXPECT_EQ(6, conn->outstandingPackets.size());
-  // Add the PacketEvent to the outstandingPacketEvents set
-  conn->outstandingPacketEvents.insert(event);
+  EXPECT_EQ(6, conn->outstandings.packets.size());
+  // Add the PacketEvent to the outstandings.packetEvents set
+  conn->outstandings.packetEvents.insert(event);
 
   // Ack the last sent packet. Despite two losses, lossVisitor only visit one
   // packet
@@ -1227,7 +1227,7 @@ TEST_F(QuicLossFunctionsTest, NoDoubleProcess) {
       TimePoint(100ms),
       PacketNumberSpace::AppData);
   EXPECT_EQ(1, lossVisitorCount);
-  EXPECT_EQ(4, conn->outstandingPackets.size());
+  EXPECT_EQ(4, conn->outstandings.packets.size());
 }
 
 TEST_F(QuicLossFunctionsTest, DetectPacketLossClonedPacketsCounter) {
@@ -1246,14 +1246,14 @@ TEST_F(QuicLossFunctionsTest, DetectPacketLossClonedPacketsCounter) {
       noopLossMarker,
       Clock::now(),
       PacketNumberSpace::AppData);
-  EXPECT_EQ(0, conn->outstandingClonedPacketsCount);
+  EXPECT_EQ(0, conn->outstandings.clonedPacketsCount);
 }
 
 TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) {
   MockAsyncUDPSocket socket(&evb);
   auto conn = createConn();
-  ASSERT_TRUE(conn->outstandingPackets.empty());
-  ASSERT_TRUE(conn->outstandingPacketEvents.empty());
+  ASSERT_TRUE(conn->outstandings.packets.empty());
+  ASSERT_TRUE(conn->outstandings.packetEvents.empty());
   auto stream1Id =
       conn->streamManager->createNextBidirectionalStream().value()->id;
   auto buf = folly::IOBuf::copyBuffer("I wrestled by the sea.");
@@ -1276,8 +1276,8 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) {
       true);
   EXPECT_FALSE(conn->streamManager->pendingWindowUpdate(stream2->id));
   EXPECT_FALSE(conn->pendingEvents.connWindowUpdate);
-  ASSERT_EQ(1, conn->outstandingPackets.size());
-  ASSERT_TRUE(conn->outstandingPacketEvents.empty());
+  ASSERT_EQ(1, conn->outstandings.packets.size());
+  ASSERT_TRUE(conn->outstandings.packetEvents.empty());
   uint32_t streamDataCounter = 0, streamWindowUpdateCounter = 0,
            connWindowUpdateCounter = 0;
   for (const auto& frame :
@@ -1358,7 +1358,7 @@ TEST_F(QuicLossFunctionsTest, TotalLossCount) {
     largestSent =
         sendPacket(*conn, Clock::now(), folly::none, PacketType::OneRtt);
   }
-  EXPECT_EQ(10, conn->outstandingPackets.size());
+  EXPECT_EQ(10, conn->outstandings.packets.size());
   uint32_t lostPackets = 0;
   auto countingLossVisitor = [&](auto& /* conn */,
                                  auto& /* packet */,
@@ -1387,13 +1387,13 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejected) {
   EXPECT_CALL(*rawCongestionController, onPacketSent(_))
       .WillRepeatedly(Return());
   // By adding an associatedEvent that doesn't exist in the
-  // outstandingPacketEvents, they are all processed and will skip lossVisitor
+  // outstandings.packetEvents, they are all processed and will skip lossVisitor
   for (auto i = 0; i < 2; i++) {
     sendPacket(*conn, TimePoint(), folly::none, PacketType::OneRtt);
     sendPacket(*conn, TimePoint(), folly::none, PacketType::ZeroRtt);
   }
-  EXPECT_FALSE(conn->outstandingPackets.empty());
-  EXPECT_EQ(4, conn->outstandingPackets.size());
+  EXPECT_FALSE(conn->outstandings.packets.empty());
+  EXPECT_EQ(4, conn->outstandings.packets.size());
   std::vector<std::pair<PacketNum, bool>> lostPackets;
   // onRemoveBytesFromInflight should still happen
   EXPECT_CALL(*rawCongestionController, onRemoveBytesFromInflight(_)).Times(1);
@@ -1401,13 +1401,13 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejected) {
       *conn, [&lostPackets](auto&, auto&, bool processed, PacketNum packetNum) {
         lostPackets.emplace_back(packetNum, processed);
       });
-  EXPECT_EQ(2, conn->outstandingPackets.size());
+  EXPECT_EQ(2, conn->outstandings.packets.size());
   EXPECT_EQ(lostPackets.size(), 2);
   for (auto lostPacket : lostPackets) {
     EXPECT_FALSE(lostPacket.second);
   }
-  for (size_t i = 0; i < conn->outstandingPackets.size(); ++i) {
-    auto longHeader = conn->outstandingPackets[i].packet.header.asLong();
+  for (size_t i = 0; i < conn->outstandings.packets.size(); ++i) {
+    auto longHeader = conn->outstandings.packets[i].packet.header.asLong();
     EXPECT_FALSE(
         longHeader &&
         longHeader->getProtectionType() == ProtectionType::ZeroRtt);
@@ -1423,7 +1423,7 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejectedWithClones) {
   EXPECT_CALL(*rawCongestionController, onPacketSent(_))
       .WillRepeatedly(Return());
   // By adding an associatedEvent that doesn't exist in the
-  // outstandingPacketEvents, they are all processed and will skip lossVisitor
+  // outstandings.packetEvents, they are all processed and will skip lossVisitor
   std::set<PacketNum> zeroRttPackets;
   folly::Optional<PacketNum> lastPacket;
   for (auto i = 0; i < 2; i++) {
@@ -1438,9 +1438,9 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejectedWithClones) {
         sendPacket(*conn, TimePoint(), zeroRttPacketNum, PacketType::OneRtt);
   }
 
-  EXPECT_EQ(6, conn->outstandingPackets.size());
-  ASSERT_EQ(conn->outstandingClonedPacketsCount, 6);
-  ASSERT_EQ(conn->outstandingPacketEvents.size(), 2);
+  EXPECT_EQ(6, conn->outstandings.packets.size());
+  ASSERT_EQ(conn->outstandings.clonedPacketsCount, 6);
+  ASSERT_EQ(conn->outstandings.packetEvents.size(), 2);
 
   std::vector<std::pair<PacketNum, bool>> lostPackets;
   // onRemoveBytesFromInflight should still happen
@@ -1449,17 +1449,17 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejectedWithClones) {
       *conn, [&lostPackets](auto&, auto&, bool processed, PacketNum packetNum) {
         lostPackets.emplace_back(packetNum, processed);
       });
-  ASSERT_EQ(conn->outstandingPacketEvents.size(), 0);
-  EXPECT_EQ(3, conn->outstandingPackets.size());
+  ASSERT_EQ(conn->outstandings.packetEvents.size(), 0);
+  EXPECT_EQ(3, conn->outstandings.packets.size());
   EXPECT_EQ(lostPackets.size(), 3);
-  ASSERT_EQ(conn->outstandingClonedPacketsCount, 3);
+  ASSERT_EQ(conn->outstandings.clonedPacketsCount, 3);
   size_t numProcessed = 0;
   for (auto lostPacket : lostPackets) {
     numProcessed += lostPacket.second;
   }
   EXPECT_EQ(numProcessed, 1);
-  for (size_t i = 0; i < conn->outstandingPackets.size(); ++i) {
-    auto longHeader = conn->outstandingPackets[i].packet.header.asLong();
+  for (size_t i = 0; i < conn->outstandings.packets.size(); ++i) {
+    auto longHeader = conn->outstandings.packets[i].packet.header.asLong();
     EXPECT_FALSE(
         longHeader &&
         longHeader->getProtectionType() == ProtectionType::ZeroRtt);
@@ -1509,12 +1509,12 @@ TEST_P(QuicLossFunctionsTest, CappedShiftNoCrash) {
   conn->lossState.handshakeAlarmCount =
       std::numeric_limits<decltype(conn->lossState.handshakeAlarmCount)>::max();
   sendPacket(*conn, Clock::now(), folly::none, PacketType::Handshake);
-  ASSERT_GT(conn->outstandingHandshakePacketsCount, 0);
+  ASSERT_GT(conn->outstandings.handshakePacketsCount, 0);
   calculateAlarmDuration(*conn);
 
   conn->lossState.handshakeAlarmCount = 0;
-  conn->outstandingHandshakePacketsCount = 0;
-  conn->outstandingPackets.clear();
+  conn->outstandings.handshakePacketsCount = 0;
+  conn->outstandings.packets.clear();
   conn->lossState.ptoCount =
       std::numeric_limits<decltype(conn->lossState.ptoCount)>::max();
   sendPacket(*conn, Clock::now(), folly::none, PacketType::OneRtt);
diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp
index 9eeb8b5d9..69ba38bf3 100644
--- a/quic/server/test/QuicServerTransportTest.cpp
+++ b/quic/server/test/QuicServerTransportTest.cpp
@@ -506,7 +506,7 @@ class QuicServerTransportTest : public Test {
     // Issue (kMinNumAvailableConnIds - 1) more connection ids on handshake
     // complete
     auto numNewConnIdFrames = 0;
-    for (const auto& packet : server->getConn().outstandingPackets) {
+    for (const auto& packet : server->getConn().outstandings.packets) {
       for (const auto& frame : packet.packet.frames) {
         switch (frame.type()) {
           case QuicWriteFrame::Type::QuicSimpleFrame_E: {
@@ -813,9 +813,9 @@ TEST_F(QuicServerTransportTest, IdleTimerNotResetOnDuplicatePacket) {
 TEST_F(QuicServerTransportTest, IdleTimerNotResetWhenDataOutstanding) {
   // Clear the receivedNewPacketBeforeWrite flag, since we may reveice from
   // client during the SetUp of the test case.
-  server->getNonConstConn().outstandingPackets.clear();
+  server->getNonConstConn().outstandings.packets.clear();
   server->getNonConstConn().receivedNewPacketBeforeWrite = false;
-  server->getNonConstConn().outstandingPackets.clear();
+  server->getNonConstConn().outstandings.packets.clear();
   StreamId streamId = server->createBidirectionalStream().value();
 
   server->idleTimeout().cancelTimeout();
@@ -1175,8 +1175,8 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
   auto data = IOBuf::copyBuffer("Aloha");
 
   // Remove any packets that might have been queued.
-  server->getNonConstConn().outstandingPackets.clear();
-  server->getNonConstConn().outstandingHandshakePacketsCount = 0;
+  server->getNonConstConn().outstandings.packets.clear();
+  server->getNonConstConn().outstandings.handshakePacketsCount = 0;
   server->writeChain(streamId, data->clone(), false, false);
   loopForWrites();
   server->writeChain(streamId, data->clone(), false, false);
@@ -1184,10 +1184,10 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
   loopForWrites();
 
   auto stream = server->getNonConstConn().streamManager->getStream(streamId);
-  ASSERT_FALSE(server->getConn().outstandingPackets.empty());
+  ASSERT_FALSE(server->getConn().outstandings.packets.empty());
   ASSERT_FALSE(stream->retransmissionBuffer.empty());
   // We need more than one packet for this test.
-  ASSERT_FALSE(server->getConn().outstandingPackets.empty());
+  ASSERT_FALSE(server->getConn().outstandings.packets.empty());
 
   PacketNum packetNum1 =
       getFirstOutstandingPacket(
@@ -1200,9 +1200,9 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
           ->packet.header.getPacketSequenceNum();
 
   uint32_t buffersInPacket1 = 0;
-  for (size_t i = 0; i < server->getNonConstConn().outstandingPackets.size();
+  for (size_t i = 0; i < server->getNonConstConn().outstandings.packets.size();
        ++i) {
-    auto& packet = server->getNonConstConn().outstandingPackets[i];
+    auto& packet = server->getNonConstConn().outstandings.packets[i];
     if (packet.packet.header.getPacketNumberSpace() !=
         PacketNumberSpace::AppData) {
       continue;
@@ -1265,7 +1265,7 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
   auto empty = IOBuf::create(0);
   server->writeChain(streamId, std::move(empty), true, false);
   loopForWrites();
-  ASSERT_FALSE(server->getConn().outstandingPackets.empty());
+  ASSERT_FALSE(server->getConn().outstandings.packets.empty());
 
   PacketNum finPacketNum =
       getFirstOutstandingPacket(
@@ -1778,8 +1778,8 @@ TEST_F(QuicServerTransportTest, TestCloneStopSending) {
   server->getNonConstConn().qLogger = qLogger;
   server->getNonConstConn().streamManager->getStream(streamId);
   // knock every handshake outstanding packets out
-  server->getNonConstConn().outstandingHandshakePacketsCount = 0;
-  server->getNonConstConn().outstandingPackets.clear();
+  server->getNonConstConn().outstandings.handshakePacketsCount = 0;
+  server->getNonConstConn().outstandings.packets.clear();
   for (auto& t : server->getNonConstConn().lossState.lossTimes) {
     t.reset();
   }
@@ -1788,17 +1788,18 @@ TEST_F(QuicServerTransportTest, TestCloneStopSending) {
   loopForWrites();
   // Find the outstanding StopSending.
   auto packetItr = std::find_if(
-      server->getNonConstConn().outstandingPackets.begin(),
-      server->getNonConstConn().outstandingPackets.end(),
+      server->getNonConstConn().outstandings.packets.begin(),
+      server->getNonConstConn().outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::StopSendingFrame_E>());
 
-  ASSERT_TRUE(packetItr != server->getNonConstConn().outstandingPackets.end());
+  ASSERT_TRUE(
+      packetItr != server->getNonConstConn().outstandings.packets.end());
   // Force a timeout with no data so that it clones the packet
   server->lossTimeout().timeoutExpired();
   loopForWrites();
   auto numStopSendingPackets = std::count_if(
-      server->getNonConstConn().outstandingPackets.begin(),
-      server->getNonConstConn().outstandingPackets.end(),
+      server->getNonConstConn().outstandings.packets.begin(),
+      server->getNonConstConn().outstandings.packets.end(),
       findFrameInPacketFunc<QuicSimpleFrame::Type::StopSendingFrame_E>());
 
   EXPECT_GT(numStopSendingPackets, 1);
@@ -3696,7 +3697,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestSendHandshakeDone) {
   setupClientReadCodec();
   recvClientHello(true, QuicVersion::QUIC_DRAFT);
   recvClientFinished(true, nullptr, QuicVersion::QUIC_DRAFT);
-  auto& packets = server->getConn().outstandingPackets;
+  auto& packets = server->getConn().outstandings.packets;
   ASSERT_FALSE(packets.empty());
   int numHandshakeDone = 0;
   for (auto& p : packets) {
diff --git a/quic/state/AckHandlers.cpp b/quic/state/AckHandlers.cpp
index f113eca6b..06e98a43b 100644
--- a/quic/state/AckHandlers.cpp
+++ b/quic/state/AckHandlers.cpp
@@ -23,7 +23,7 @@ namespace quic {
  * order of packet number. For each ack block, we try to find a continuous range
  * of outstanding packets in the connection's outstanding packets list that is
  * acked by the current ack block. The search is in the reverse order of the
- * outstandingPackets given that the list is sorted in the ascending order of
+ * outstandings.packets given that the list is sorted in the ascending order of
  * packet number. For each outstanding packet that is acked by current ack
  * frame, ack and loss visitors are invoked on the sent frames. The outstanding
  * packets may contain packets from all three packet number spaces. But ack is
@@ -54,22 +54,22 @@ void processAckFrame(
       lastAckedPacketSentTime;
   auto ackBlockIt = frame.ackBlocks.cbegin();
   while (ackBlockIt != frame.ackBlocks.cend() &&
-         currentPacketIt != conn.outstandingPackets.rend()) {
+         currentPacketIt != conn.outstandings.packets.rend()) {
     // In reverse order, find the first outstanding packet that has a packet
     // number LE the endPacket of the current ack range.
     auto rPacketIt = std::lower_bound(
         currentPacketIt,
-        conn.outstandingPackets.rend(),
+        conn.outstandings.packets.rend(),
         ackBlockIt->endPacket,
         [&](const auto& packetWithTime, const auto& val) {
           return packetWithTime.packet.header.getPacketSequenceNum() > val;
         });
-    if (rPacketIt == conn.outstandingPackets.rend()) {
+    if (rPacketIt == conn.outstandings.packets.rend()) {
       // This means that all the packets are greater than the end packet.
       // Since we iterate the ACK blocks in reverse order of end packets, our
       // work here is done.
       VLOG(10) << __func__ << " less than all outstanding packets outstanding="
-               << conn.outstandingPackets.size() << " range=["
+               << conn.outstandings.packets.size() << " range=["
                << ackBlockIt->startPacket << ", " << ackBlockIt->endPacket
                << "]"
                << " " << conn;
@@ -80,7 +80,7 @@ void processAckFrame(
     // TODO: only process ACKs from packets which are sent from a greater than
     // or equal to crypto protection level.
     auto eraseEnd = rPacketIt;
-    while (rPacketIt != conn.outstandingPackets.rend()) {
+    while (rPacketIt != conn.outstandings.packets.rend()) {
       auto currentPacketNum = rPacketIt->packet.header.getPacketSequenceNum();
       auto currentPacketNumberSpace =
           rPacketIt->packet.header.getPacketNumberSpace();
@@ -91,8 +91,8 @@ void processAckFrame(
         // this ack block. So the code erases the current iterator range and
         // move the iterator to be the next search point.
         if (rPacketIt != eraseEnd) {
-          auto nextElem =
-              conn.outstandingPackets.erase(rPacketIt.base(), eraseEnd.base());
+          auto nextElem = conn.outstandings.packets.erase(
+              rPacketIt.base(), eraseEnd.base());
           rPacketIt = std::reverse_iterator<decltype(nextElem)>(nextElem) + 1;
           eraseEnd = rPacketIt;
         } else {
@@ -123,15 +123,15 @@ void processAckFrame(
         updateRtt(conn, rttSample, frame.ackDelay);
       }
       // Only invoke AckVisitor if the packet doesn't have an associated
-      // PacketEvent; or the PacketEvent is in conn.outstandingPacketEvents
+      // PacketEvent; or the PacketEvent is in conn.outstandings.packetEvents
       if (!rPacketIt->associatedEvent ||
-          conn.outstandingPacketEvents.count(*rPacketIt->associatedEvent)) {
+          conn.outstandings.packetEvents.count(*rPacketIt->associatedEvent)) {
         for (auto& packetFrame : rPacketIt->packet.frames) {
           ackVisitor(*rPacketIt, packetFrame, frame);
         }
-        // Remove this PacketEvent from the outstandingPacketEvents set
+        // Remove this PacketEvent from the outstandings.packetEvents set
         if (rPacketIt->associatedEvent) {
-          conn.outstandingPacketEvents.erase(*rPacketIt->associatedEvent);
+          conn.outstandings.packetEvents.erase(*rPacketIt->associatedEvent);
         }
       }
       if (!ack.largestAckedPacket ||
@@ -167,7 +167,7 @@ void processAckFrame(
     // the next search point.
     if (rPacketIt != eraseEnd) {
       auto nextElem =
-          conn.outstandingPackets.erase(rPacketIt.base(), eraseEnd.base());
+          conn.outstandings.packets.erase(rPacketIt.base(), eraseEnd.base());
       currentPacketIt = std::reverse_iterator<decltype(nextElem)>(nextElem);
     } else {
       currentPacketIt = rPacketIt;
@@ -177,14 +177,15 @@ void processAckFrame(
   if (lastAckedPacketSentTime) {
     conn.lossState.lastAckedPacketSentTime = *lastAckedPacketSentTime;
   }
-  DCHECK_GE(conn.outstandingHandshakePacketsCount, handshakePacketAcked);
-  conn.outstandingHandshakePacketsCount -= handshakePacketAcked;
-  DCHECK_GE(conn.outstandingClonedPacketsCount, clonedPacketsAcked);
-  conn.outstandingClonedPacketsCount -= clonedPacketsAcked;
-  auto updatedOustandingPacketsCount = conn.outstandingPackets.size();
+  DCHECK_GE(conn.outstandings.handshakePacketsCount, handshakePacketAcked);
+  conn.outstandings.handshakePacketsCount -= handshakePacketAcked;
+  DCHECK_GE(conn.outstandings.clonedPacketsCount, clonedPacketsAcked);
+  conn.outstandings.clonedPacketsCount -= clonedPacketsAcked;
+  auto updatedOustandingPacketsCount = conn.outstandings.packets.size();
   DCHECK_GE(
-      updatedOustandingPacketsCount, conn.outstandingHandshakePacketsCount);
-  DCHECK_GE(updatedOustandingPacketsCount, conn.outstandingClonedPacketsCount);
+      updatedOustandingPacketsCount, conn.outstandings.handshakePacketsCount);
+  DCHECK_GE(
+      updatedOustandingPacketsCount, conn.outstandings.clonedPacketsCount);
   auto lossEvent = handleAckForLoss(conn, lossVisitor, ack, pnSpace);
   if (conn.congestionController &&
       (ack.largestAckedPacket.has_value() || lossEvent)) {
diff --git a/quic/state/QuicPacingFunctions.cpp b/quic/state/QuicPacingFunctions.cpp
index 5e9ae1ac5..e8ccef840 100644
--- a/quic/state/QuicPacingFunctions.cpp
+++ b/quic/state/QuicPacingFunctions.cpp
@@ -18,4 +18,4 @@ void updatePacingOnClose(QuicConnectionStateBase& conn) {
   conn.canBePaced = false;
 }
 
-}
+} // namespace quic
diff --git a/quic/state/QuicPacingFunctions.h b/quic/state/QuicPacingFunctions.h
index 2bc43f02e..c7829cf28 100644
--- a/quic/state/QuicPacingFunctions.h
+++ b/quic/state/QuicPacingFunctions.h
@@ -16,4 +16,4 @@ void updatePacingOnKeyEstablished(QuicConnectionStateBase& conn);
 
 void updatePacingOnClose(QuicConnectionStateBase& conn);
 
-}
+} // namespace quic
diff --git a/quic/state/QuicStateFunctions.cpp b/quic/state/QuicStateFunctions.cpp
index 2c3f5daa4..7802150b7 100644
--- a/quic/state/QuicStateFunctions.cpp
+++ b/quic/state/QuicStateFunctions.cpp
@@ -19,7 +19,7 @@ getPreviousOutstandingPacket(
     quic::PacketNumberSpace packetNumberSpace,
     std::deque<quic::OutstandingPacket>::reverse_iterator from) {
   return std::find_if(
-      from, conn.outstandingPackets.rend(), [=](const auto& op) {
+      from, conn.outstandings.packets.rend(), [=](const auto& op) {
         return packetNumberSpace == op.packet.header.getPacketNumberSpace();
       });
 }
@@ -212,23 +212,24 @@ std::deque<OutstandingPacket>::iterator getFirstOutstandingPacket(
     QuicConnectionStateBase& conn,
     PacketNumberSpace packetNumberSpace) {
   return getNextOutstandingPacket(
-      conn, packetNumberSpace, conn.outstandingPackets.begin());
+      conn, packetNumberSpace, conn.outstandings.packets.begin());
 }
 
 std::deque<OutstandingPacket>::reverse_iterator getLastOutstandingPacket(
     QuicConnectionStateBase& conn,
     PacketNumberSpace packetNumberSpace) {
   return getPreviousOutstandingPacket(
-      conn, packetNumberSpace, conn.outstandingPackets.rbegin());
+      conn, packetNumberSpace, conn.outstandings.packets.rbegin());
 }
 
 std::deque<OutstandingPacket>::iterator getNextOutstandingPacket(
     QuicConnectionStateBase& conn,
     PacketNumberSpace packetNumberSpace,
     std::deque<OutstandingPacket>::iterator from) {
-  return std::find_if(from, conn.outstandingPackets.end(), [=](const auto& op) {
-    return packetNumberSpace == op.packet.header.getPacketNumberSpace();
-  });
+  return std::find_if(
+      from, conn.outstandings.packets.end(), [=](const auto& op) {
+        return packetNumberSpace == op.packet.header.getPacketNumberSpace();
+      });
 }
 
 bool hasReceivedPacketsAtLastCloseSent(
diff --git a/quic/state/StateData.h b/quic/state/StateData.h
index ab2d08dd3..f1ed6d1b1 100644
--- a/quic/state/StateData.h
+++ b/quic/state/StateData.h
@@ -179,6 +179,23 @@ struct OutstandingPacket {
         totalBytesSent(totalBytesSentIn) {}
 };
 
+struct OutstandingsInfo {
+  // Sent packets which have not been acked. These are sorted by PacketNum.
+  std::deque<OutstandingPacket> packets;
+
+  // All PacketEvents of this connection. If a OutstandingPacket doesn't have an
+  // associatedEvent or if it's not in this set, there is no need to process its
+  // frames upon ack or loss.
+  // TODO: Enforce only AppTraffic packets to be clonable
+  folly::F14FastSet<PacketEvent> packetEvents;
+
+  // Number of handshake packets outstanding.
+  uint64_t handshakePacketsCount{0};
+
+  // Number of packets are clones or cloned.
+  uint64_t clonedPacketsCount{0};
+};
+
 struct Pacer {
   virtual ~Pacer() = default;
 
@@ -352,9 +369,9 @@ struct CongestionController {
    * Take bytes out of flight without mutating other states of the controller
    * TODO(yangchi): I'm not sure how long I'd like to keep this API. This is a
    * temporary workaround the fact that there are packets we will need to take
-   * out of outstandingPackets but not considered loss for congestion control
-   * perspective. In long term, we shouldn't take them out of
-   * outstandingPackets, then we don't have to do this.
+   * out of outstandings.packets but not considered loss for congestion
+   * control perspective. In long term, we shouldn't take them out of
+   * outstandings.packets, then we don't have to do this.
    */
   virtual void onRemoveBytesFromInflight(uint64_t) = 0;
   virtual void onPacketSent(const OutstandingPacket& packet) = 0;
@@ -535,22 +552,9 @@ struct QuicConnectionStateBase : public folly::DelayedDestruction {
 
   std::unique_ptr<PendingPathRateLimiter> pathValidationLimiter;
 
-  // TODO: We really really should wrap outstandingPackets, all its associated
-  // counters and the outstandingPacketEvents into one class.
-  // Sent packets which have not been acked. These are sorted by PacketNum.
-  std::deque<OutstandingPacket> outstandingPackets;
-
-  // All PacketEvents of this connection. If a OutstandingPacket doesn't have an
-  // associatedEvent or if it's not in this set, there is no need to process its
-  // frames upon ack or loss.
-  // TODO: Enforce only AppTraffic packets to be clonable
-  folly::F14FastSet<PacketEvent> outstandingPacketEvents;
-
-  // Number of handshake packets outstanding.
-  uint64_t outstandingHandshakePacketsCount{0};
-
-  // Number of packets are clones or cloned.
-  uint64_t outstandingClonedPacketsCount{0};
+  // Outstanding packets, packet events, and associated counters wrapped in one
+  // class
+  OutstandingsInfo outstandings;
 
   // The read codec to decrypt and decode packets.
   std::unique_ptr<QuicReadCodec> readCodec;
diff --git a/quic/state/stream/StreamStateFunctions.h b/quic/state/stream/StreamStateFunctions.h
index b6c8d4715..da2e4973e 100644
--- a/quic/state/stream/StreamStateFunctions.h
+++ b/quic/state/stream/StreamStateFunctions.h
@@ -19,4 +19,4 @@ void resetQuicStream(QuicStreamState& stream, ApplicationErrorCode error);
 void onResetQuicStream(QuicStreamState& stream, RstStreamFrame&& frame);
 
 bool isAllDataReceived(const QuicStreamState& stream);
-}
+} // namespace quic
diff --git a/quic/state/stream/test/StreamStateMachineTest.cpp b/quic/state/stream/test/StreamStateMachineTest.cpp
index f3ec70371..4d7d574e3 100644
--- a/quic/state/stream/test/StreamStateMachineTest.cpp
+++ b/quic/state/stream/test/StreamStateMachineTest.cpp
@@ -161,7 +161,7 @@ TEST_F(QuicOpenStateTest, AckStream) {
       true);
 
   EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
 
   auto& streamFrame =
       *getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
@@ -211,10 +211,10 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) {
       false);
 
   EXPECT_EQ(stream->retransmissionBuffer.size(), 3);
-  EXPECT_EQ(3, conn->outstandingPackets.size());
+  EXPECT_EQ(3, conn->outstandings.packets.size());
 
   auto& streamFrame3 =
-      *conn->outstandingPackets[2].packet.frames[0].asWriteStreamFrame();
+      *conn->outstandings.packets[2].packet.frames[0].asWriteStreamFrame();
 
   sendAckSMHandler(*stream, streamFrame3);
   ASSERT_EQ(stream->sendState, StreamSendState::Open_E);
@@ -222,7 +222,7 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) {
   ASSERT_EQ(stream->ackedIntervals.front().end, 21);
 
   auto& streamFrame2 =
-      *conn->outstandingPackets[1].packet.frames[0].asWriteStreamFrame();
+      *conn->outstandings.packets[1].packet.frames[0].asWriteStreamFrame();
 
   sendAckSMHandler(*stream, streamFrame2);
   ASSERT_EQ(stream->sendState, StreamSendState::Open_E);
@@ -230,7 +230,7 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) {
   ASSERT_EQ(stream->ackedIntervals.front().end, 21);
 
   auto& streamFrame1 =
-      *conn->outstandingPackets[0].packet.frames[0].asWriteStreamFrame();
+      *conn->outstandings.packets[0].packet.frames[0].asWriteStreamFrame();
 
   sendAckSMHandler(*stream, streamFrame1);
   ASSERT_EQ(stream->sendState, StreamSendState::Open_E);
@@ -275,9 +275,9 @@ TEST_F(QuicOpenStateTest, RetxBufferSortedAfterAck) {
       false);
 
   EXPECT_EQ(3, stream->retransmissionBuffer.size());
-  EXPECT_EQ(3, conn->outstandingPackets.size());
-  auto packet = conn->outstandingPackets[folly::Random::rand32() % 3];
-  auto streamFrame = *conn->outstandingPackets[std::rand() % 3]
+  EXPECT_EQ(3, conn->outstandings.packets.size());
+  auto packet = conn->outstandings.packets[folly::Random::rand32() % 3];
+  auto streamFrame = *conn->outstandings.packets[std::rand() % 3]
                           .packet.frames.front()
                           .asWriteStreamFrame();
   sendAckSMHandler(*stream, streamFrame);
@@ -305,7 +305,7 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkip) {
       true);
 
   EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
 
   auto& streamFrame =
       *getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
@@ -349,7 +349,7 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkipHalfBuf) {
       true);
 
   EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
 
   auto& streamFrame =
       *getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
@@ -400,7 +400,7 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkipOneAndAHalfBuf) {
       true);
 
   EXPECT_EQ(stream->retransmissionBuffer.size(), 2);
-  EXPECT_EQ(2, conn->outstandingPackets.size());
+  EXPECT_EQ(2, conn->outstandings.packets.size());
 
   auto streamFrameIt =
       getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData);
@@ -545,7 +545,7 @@ TEST_F(QuicHalfClosedRemoteStateTest, AckStream) {
       true);
 
   EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
 
   auto& streamFrame =
       *getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
@@ -583,7 +583,7 @@ TEST_F(QuicHalfClosedRemoteStateTest, AckStreamAfterSkip) {
       true);
 
   EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
-  EXPECT_EQ(1, conn->outstandingPackets.size());
+  EXPECT_EQ(1, conn->outstandings.packets.size());
 
   auto& streamFrame =
       *getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
diff --git a/quic/state/test/AckHandlersTest.cpp b/quic/state/test/AckHandlersTest.cpp
index 1c5e16b48..fd15d699d 100644
--- a/quic/state/test/AckHandlersTest.cpp
+++ b/quic/state/test/AckHandlersTest.cpp
@@ -50,7 +50,7 @@ TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocks) {
         createNewPacket(packetNum, GetParam());
     WriteStreamFrame frame(currentStreamId++, 0, 0, true);
     regularPacket.frames.emplace_back(std::move(frame));
-    conn.outstandingPackets.emplace_back(OutstandingPacket(
+    conn.outstandings.packets.emplace_back(OutstandingPacket(
         std::move(regularPacket), sentTime, 1, false, packetNum));
   }
   ReadAckFrame ackFrame;
@@ -94,13 +94,13 @@ TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocks) {
     start--;
   }
   // only unacked packets should be remaining
-  EXPECT_EQ(conn.outstandingPackets.size(), 5);
+  EXPECT_EQ(conn.outstandings.packets.size(), 5);
   PacketNum lostPackt = 10;
   for (auto& pkt : lostPackets) {
     EXPECT_EQ(pkt, lostPackt++);
   }
   PacketNum packetNum = 16;
-  for (auto& packet : conn.outstandingPackets) {
+  for (auto& packet : conn.outstandings.packets) {
     auto currentPacketNum = packet.packet.header.getPacketSequenceNum();
     EXPECT_EQ(currentPacketNum, packetNum);
     packetNum++;
@@ -121,7 +121,7 @@ TEST_P(AckHandlersTest, TestAckBlocksWithGaps) {
     auto regularPacket = createNewPacket(packetNum, GetParam());
     WriteStreamFrame frame(currentStreamId++, 0, 0, true);
     regularPacket.frames.emplace_back(std::move(frame));
-    conn.outstandingPackets.emplace_back(OutstandingPacket(
+    conn.outstandings.packets.emplace_back(OutstandingPacket(
         std::move(regularPacket), Clock::now(), 1, false, packetNum));
   }
 
@@ -185,8 +185,8 @@ TEST_P(AckHandlersTest, TestAckBlocksWithGaps) {
 
   std::vector<PacketNum> actualPacketNumbers;
   std::transform(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       std::back_insert_iterator<decltype(actualPacketNumbers)>(
           actualPacketNumbers),
       [](const auto& packet) {
@@ -222,7 +222,7 @@ TEST_P(AckHandlersTest, TestNonSequentialPacketNumbers) {
     auto regularPacket = createNewPacket(packetNum, GetParam());
     WriteStreamFrame frame(current++, 0, 0, true);
     regularPacket.frames.emplace_back(std::move(frame));
-    conn.outstandingPackets.emplace_back(OutstandingPacket(
+    conn.outstandings.packets.emplace_back(OutstandingPacket(
         std::move(regularPacket), Clock::now(), 1, false, packetNum));
   }
 
@@ -231,7 +231,7 @@ TEST_P(AckHandlersTest, TestNonSequentialPacketNumbers) {
     WriteStreamFrame frame(current, 0, 0, true);
     current += 3;
     regularPacket.frames.emplace_back(std::move(frame));
-    conn.outstandingPackets.emplace_back(OutstandingPacket(
+    conn.outstandings.packets.emplace_back(OutstandingPacket(
         std::move(regularPacket), Clock::now(), 1, false, packetNum));
   }
 
@@ -286,8 +286,8 @@ TEST_P(AckHandlersTest, TestNonSequentialPacketNumbers) {
 
   std::vector<PacketNum> actualPacketNumbers;
   std::transform(
-      conn.outstandingPackets.begin(),
-      conn.outstandingPackets.end(),
+      conn.outstandings.packets.begin(),
+      conn.outstandings.packets.end(),
       std::back_insert_iterator<decltype(actualPacketNumbers)>(
           actualPacketNumbers),
       [](const auto& packet) {
@@ -311,7 +311,7 @@ TEST_P(AckHandlersTest, AckVisitorForAckTest) {
   conn.ackStates.appDataAckState.acks.insert(900, 1000);
   conn.ackStates.appDataAckState.acks.insert(500, 700);
   firstPacket.frames.emplace_back(std::move(firstAckFrame));
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       OutstandingPacket(std::move(firstPacket), Clock::now(), 0, false, 0));
 
   auto secondPacket = createNewPacket(101 /* packetNum */, GetParam());
@@ -321,7 +321,7 @@ TEST_P(AckHandlersTest, AckVisitorForAckTest) {
   conn.ackStates.appDataAckState.acks.insert(1100, 2000);
   conn.ackStates.appDataAckState.acks.insert(1002, 1090);
   secondPacket.frames.emplace_back(std::move(secondAckFrame));
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       OutstandingPacket(std::move(secondPacket), Clock::now(), 0, false, 0));
 
   ReadAckFrame firstReceivedAck;
@@ -385,7 +385,7 @@ TEST_P(AckHandlersTest, NoNewAckedPacket) {
   conn.lossState.ptoCount = 1;
   PacketNum packetAfterRtoNum = 10;
   auto packetAfterRto = createNewPacket(packetAfterRtoNum, GetParam());
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       OutstandingPacket(std::move(packetAfterRto), Clock::now(), 0, false, 0));
 
   ReadAckFrame ackFrame;
@@ -429,12 +429,12 @@ TEST_P(AckHandlersTest, AckPacketNumDoesNotExist) {
 
   PacketNum packetNum1 = 9;
   auto regularPacket1 = createNewPacket(packetNum1, GetParam());
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       std::move(regularPacket1), Clock::now(), 0, false, 0);
 
   PacketNum packetNum2 = 10;
   auto regularPacket2 = createNewPacket(packetNum2, GetParam());
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       std::move(regularPacket2), Clock::now(), 0, false, 0);
 
   // Ack a packet one higher than the packet so that we don't trigger reordering
@@ -450,7 +450,7 @@ TEST_P(AckHandlersTest, AckPacketNumDoesNotExist) {
       [](const auto&, const auto&, const auto&) {},
       [](auto&, auto&, bool, PacketNum) {},
       Clock::now());
-  EXPECT_EQ(1, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.packets.size());
 }
 
 TEST_P(AckHandlersTest, TestHandshakeCounterUpdate) {
@@ -461,13 +461,13 @@ TEST_P(AckHandlersTest, TestHandshakeCounterUpdate) {
     WriteStreamFrame frame(
         stream, 100 * packetNum + 0, 100 * packetNum + 100, false);
     regularPacket.frames.emplace_back(std::move(frame));
-    conn.outstandingPackets.emplace_back(
+    conn.outstandings.packets.emplace_back(
         std::move(regularPacket),
         Clock::now(),
         0,
         packetNum % 2,
         packetNum / 2);
-    conn.outstandingHandshakePacketsCount += packetNum % 2;
+    conn.outstandings.handshakePacketsCount += packetNum % 2;
   }
 
   ReadAckFrame ackFrame;
@@ -484,8 +484,8 @@ TEST_P(AckHandlersTest, TestHandshakeCounterUpdate) {
       Clock::now());
   // When [3, 7] are acked, [0, 2] will also be marked loss, due to reordering
   // threshold
-  EXPECT_EQ(1, conn.outstandingHandshakePacketsCount);
-  EXPECT_EQ(2, conn.outstandingPackets.size());
+  EXPECT_EQ(1, conn.outstandings.handshakePacketsCount);
+  EXPECT_EQ(2, conn.outstandings.packets.size());
 }
 
 TEST_P(AckHandlersTest, PurgeAcks) {
@@ -524,7 +524,7 @@ TEST_P(AckHandlersTest, NoSkipAckVisitor) {
   // We need to at least have one frame to trigger ackVisitor
   WriteStreamFrame frame(0, 0, 0, true);
   regularPacket.frames.emplace_back(std::move(frame));
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       OutstandingPacket(std::move(regularPacket), Clock::now(), 1, false, 1));
   ReadAckFrame ackFrame;
   ackFrame.largestAcked = 0;
@@ -570,10 +570,10 @@ TEST_P(AckHandlersTest, SkipAckVisitor) {
   OutstandingPacket outstandingPacket(
       std::move(regularPacket), Clock::now(), 1, false, 1);
   // Give this outstandingPacket an associatedEvent that's not in
-  // outstandingPacketEvents
+  // outstandings.packetEvents
   outstandingPacket.associatedEvent = 0;
-  conn.outstandingPackets.push_back(std::move(outstandingPacket));
-  conn.outstandingClonedPacketsCount++;
+  conn.outstandings.packets.push_back(std::move(outstandingPacket));
+  conn.outstandings.clonedPacketsCount++;
 
   ReadAckFrame ackFrame;
   ackFrame.largestAcked = 0;
@@ -618,10 +618,10 @@ TEST_P(AckHandlersTest, NoDoubleProcess) {
   // The seconds packet has the same PacketEvent
   outstandingPacket2.associatedEvent = packetNum1;
 
-  conn.outstandingPackets.push_back(std::move(outstandingPacket1));
-  conn.outstandingPackets.push_back(std::move(outstandingPacket2));
-  conn.outstandingClonedPacketsCount += 2;
-  conn.outstandingPacketEvents.insert(packetNum1);
+  conn.outstandings.packets.push_back(std::move(outstandingPacket1));
+  conn.outstandings.packets.push_back(std::move(outstandingPacket2));
+  conn.outstandings.clonedPacketsCount += 2;
+  conn.outstandings.packetEvents.insert(packetNum1);
 
   // A counting ack visitor
   uint16_t ackVisitorCounter = 0;
@@ -682,10 +682,10 @@ TEST_P(AckHandlersTest, ClonedPacketsCounter) {
   OutstandingPacket outstandingPacket2(
       std::move(regularPacket2), Clock::now(), 1, false, 1);
 
-  conn.outstandingPackets.push_back(std::move(outstandingPacket1));
-  conn.outstandingPackets.push_back(std::move(outstandingPacket2));
-  conn.outstandingClonedPacketsCount = 1;
-  conn.outstandingPacketEvents.insert(packetNum1);
+  conn.outstandings.packets.push_back(std::move(outstandingPacket1));
+  conn.outstandings.packets.push_back(std::move(outstandingPacket2));
+  conn.outstandings.clonedPacketsCount = 1;
+  conn.outstandings.packetEvents.insert(packetNum1);
 
   ReadAckFrame ackFrame;
   ackFrame.largestAcked = packetNum2;
@@ -708,7 +708,7 @@ TEST_P(AckHandlersTest, ClonedPacketsCounter) {
           PacketNum) { /* no-op */ },
       Clock::now());
   EXPECT_EQ(2, ackVisitorCounter);
-  EXPECT_EQ(0, conn.outstandingClonedPacketsCount);
+  EXPECT_EQ(0, conn.outstandings.clonedPacketsCount);
 }
 
 TEST_P(AckHandlersTest, UpdateMaxAckDelay) {
@@ -718,7 +718,7 @@ TEST_P(AckHandlersTest, UpdateMaxAckDelay) {
   PacketNum packetNum = 0;
   auto regularPacket = createNewPacket(packetNum, GetParam());
   auto sentTime = Clock::now();
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       OutstandingPacket(std::move(regularPacket), sentTime, 1, false, 1));
 
   ReadAckFrame ackFrame;
@@ -775,8 +775,8 @@ TEST_P(AckHandlersTest, AckNotOutstandingButLoss) {
       1,
       false,
       1);
-  conn.outstandingPackets.push_back(std::move(outstandingPacket));
-  conn.outstandingClonedPacketsCount++;
+  conn.outstandings.packets.push_back(std::move(outstandingPacket));
+  conn.outstandings.clonedPacketsCount++;
 
   EXPECT_CALL(*mockQLogger, addPacketsLost(1, 1, 1));
 
@@ -813,7 +813,7 @@ TEST_P(AckHandlersTest, UpdatePendingAckStates) {
   PacketNum packetNum = 0;
   auto regularPacket = createNewPacket(packetNum, GetParam());
   auto sentTime = Clock::now() - 1500ms;
-  conn.outstandingPackets.emplace_back(OutstandingPacket(
+  conn.outstandings.packets.emplace_back(OutstandingPacket(
       std::move(regularPacket),
       sentTime,
       111,
@@ -862,7 +862,7 @@ TEST_P(AckHandlersTest, AckEventCreation) {
         false /* handshake */,
         packetNum);
     sentPacket.isAppLimited = (packetNum % 2);
-    conn.outstandingPackets.emplace_back(sentPacket);
+    conn.outstandings.packets.emplace_back(sentPacket);
     packetNum++;
   }
 
diff --git a/quic/state/test/QuicPacingFunctionsTest.cpp b/quic/state/test/QuicPacingFunctionsTest.cpp
index 7dc610a80..9c2df2d1a 100644
--- a/quic/state/test/QuicPacingFunctionsTest.cpp
+++ b/quic/state/test/QuicPacingFunctionsTest.cpp
@@ -31,5 +31,5 @@ TEST_F(QuicPacingFunctionsTest, OnClose) {
   EXPECT_FALSE(conn.canBePaced);
 }
 
-}
-}
+} // namespace test
+} // namespace quic
diff --git a/quic/state/test/QuicStateFunctionsTest.cpp b/quic/state/test/QuicStateFunctionsTest.cpp
index 243bd16f2..6f6219c11 100644
--- a/quic/state/test/QuicStateFunctionsTest.cpp
+++ b/quic/state/test/QuicStateFunctionsTest.cpp
@@ -533,27 +533,27 @@ TEST_F(QuicStateFunctionsTest, IsConnectionPaced) {
 
 TEST_F(QuicStateFunctionsTest, GetOutstandingPackets) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       makeTestLongPacket(LongHeader::Types::Initial),
       Clock::now(),
       135,
       false,
       0);
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       makeTestLongPacket(LongHeader::Types::Handshake),
       Clock::now(),
       1217,
       false,
       0);
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       makeTestShortPacket(), Clock::now(), 5556, false, 0);
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       makeTestLongPacket(LongHeader::Types::Initial),
       Clock::now(),
       56,
       false,
       0);
-  conn.outstandingPackets.emplace_back(
+  conn.outstandings.packets.emplace_back(
       makeTestShortPacket(), Clock::now(), 6665, false, 0);
   EXPECT_EQ(
       135,