diff --git a/Package.swift b/Package.swift
index 1f2f0046f..c2e7e69a6 100644
--- a/Package.swift
+++ b/Package.swift
@@ -49,6 +49,7 @@ let package = Package(
                 .product(name: "Logging", package: "swift-log"),
                 .product(name: "Atomics", package: "swift-atomics"),
             ]
+            , swiftSettings: [.unsafeFlags(["-Xfrontend", "-strict-concurrency=complete"])]
         ),
         .testTarget(
             name: "AsyncHTTPClientTests",
diff --git a/Sources/AsyncHTTPClient/AsyncAwait/HTTPClientRequest.swift b/Sources/AsyncHTTPClient/AsyncAwait/HTTPClientRequest.swift
index 278be7f84..08863781f 100644
--- a/Sources/AsyncHTTPClient/AsyncAwait/HTTPClientRequest.swift
+++ b/Sources/AsyncHTTPClient/AsyncAwait/HTTPClientRequest.swift
@@ -102,13 +102,6 @@ extension HTTPClientRequest.Body {
     @preconcurrency
     public static func bytes<Bytes: RandomAccessCollection & Sendable>(
         _ bytes: Bytes
-    ) -> Self where Bytes.Element == UInt8 {
-        Self._bytes(bytes)
-    }
-
-    @inlinable
-    static func _bytes<Bytes: RandomAccessCollection>(
-        _ bytes: Bytes
     ) -> Self where Bytes.Element == UInt8 {
         self.init(.sequence(
             length: .known(bytes.count),
@@ -145,14 +138,6 @@ extension HTTPClientRequest.Body {
     public static func bytes<Bytes: Sequence & Sendable>(
         _ bytes: Bytes,
         length: Length
-    ) -> Self where Bytes.Element == UInt8 {
-        Self._bytes(bytes, length: length)
-    }
-
-    @inlinable
-    static func _bytes<Bytes: Sequence>(
-        _ bytes: Bytes,
-        length: Length
     ) -> Self where Bytes.Element == UInt8 {
         self.init(.sequence(
             length: length.storage,
@@ -185,14 +170,6 @@ extension HTTPClientRequest.Body {
     public static func bytes<Bytes: Collection & Sendable>(
         _ bytes: Bytes,
         length: Length
-    ) -> Self where Bytes.Element == UInt8 {
-        Self._bytes(bytes, length: length)
-    }
-
-    @inlinable
-    static func _bytes<Bytes: Collection>(
-        _ bytes: Bytes,
-        length: Length
     ) -> Self where Bytes.Element == UInt8 {
         self.init(.sequence(
             length: length.storage,
@@ -223,14 +200,6 @@ extension HTTPClientRequest.Body {
     public static func stream<SequenceOfBytes: AsyncSequence & Sendable>(
         _ sequenceOfBytes: SequenceOfBytes,
         length: Length
-    ) -> Self where SequenceOfBytes.Element == ByteBuffer {
-        Self._stream(sequenceOfBytes, length: length)
-    }
-
-    @inlinable
-    static func _stream<SequenceOfBytes: AsyncSequence>(
-        _ sequenceOfBytes: SequenceOfBytes,
-        length: Length
     ) -> Self where SequenceOfBytes.Element == ByteBuffer {
         let body = self.init(.asyncSequence(length: length.storage) {
             var iterator = sequenceOfBytes.makeAsyncIterator()
@@ -259,14 +228,6 @@ extension HTTPClientRequest.Body {
     public static func stream<Bytes: AsyncSequence & Sendable>(
         _ bytes: Bytes,
         length: Length
-    ) -> Self where Bytes.Element == UInt8 {
-        Self._stream(bytes, length: length)
-    }
-
-    @inlinable
-    static func _stream<Bytes: AsyncSequence>(
-        _ bytes: Bytes,
-        length: Length
     ) -> Self where Bytes.Element == UInt8 {
         let body = self.init(.asyncSequence(length: length.storage) {
             var iterator = bytes.makeAsyncIterator()
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/HTTP1ProxyConnectHandler.swift b/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/HTTP1ProxyConnectHandler.swift
index fbcd4f9c0..8b47a9ba4 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/HTTP1ProxyConnectHandler.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/HTTP1ProxyConnectHandler.swift
@@ -24,9 +24,9 @@ final class HTTP1ProxyConnectHandler: ChannelDuplexHandler, RemovableChannelHand
         // transitions to `.connectSent` or `.failed`
         case initialized
         // transitions to `.headReceived` or `.failed`
-        case connectSent(Scheduled<Void>)
+        case connectSent(ScheduledOnCurrentEventLoop<Void>)
         // transitions to `.completed` or `.failed`
-        case headReceived(Scheduled<Void>)
+        case headReceived(ScheduledOnCurrentEventLoop<Void>)
         // final error state
         case failed(Error)
         // final success state
@@ -40,8 +40,8 @@ final class HTTP1ProxyConnectHandler: ChannelDuplexHandler, RemovableChannelHand
     private let proxyAuthorization: HTTPClient.Authorization?
     private let deadline: NIODeadline
 
-    private var proxyEstablishedPromise: EventLoopPromise<Void>?
-    var proxyEstablishedFuture: EventLoopFuture<Void>? {
+    private var proxyEstablishedPromise: CurrentEventLoopPromise<Void>?
+    var proxyEstablishedFuture: CurrentEventLoopFuture<Void>? {
         return self.proxyEstablishedPromise?.futureResult
     }
 
@@ -81,7 +81,7 @@ final class HTTP1ProxyConnectHandler: ChannelDuplexHandler, RemovableChannelHand
     }
 
     func handlerAdded(context: ChannelHandlerContext) {
-        self.proxyEstablishedPromise = context.eventLoop.makePromise(of: Void.self)
+        self.proxyEstablishedPromise = context.currentEventLoop.makePromise(of: Void.self)
 
         self.sendConnect(context: context)
     }
@@ -135,7 +135,7 @@ final class HTTP1ProxyConnectHandler: ChannelDuplexHandler, RemovableChannelHand
             return
         }
 
-        let timeout = context.eventLoop.scheduleTask(deadline: self.deadline) {
+        let timeout = context.currentEventLoop.scheduleTask(deadline: self.deadline) {
             switch self.state {
             case .initialized:
                 preconditionFailure("How can we have a scheduled timeout, if the connection is not even up?")
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/SOCKSEventsHandler.swift b/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/SOCKSEventsHandler.swift
index 5a46f44a7..4b26822ee 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/SOCKSEventsHandler.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/SOCKSEventsHandler.swift
@@ -22,15 +22,15 @@ final class SOCKSEventsHandler: ChannelInboundHandler, RemovableChannelHandler {
         // transitions to channelActive or failed
         case initialized
         // transitions to socksEstablished or failed
-        case channelActive(Scheduled<Void>)
+        case channelActive(ScheduledOnCurrentEventLoop<Void>)
         // final success state
         case socksEstablished
         // final success state
         case failed(Error)
     }
 
-    private var socksEstablishedPromise: EventLoopPromise<Void>?
-    var socksEstablishedFuture: EventLoopFuture<Void>? {
+    private var socksEstablishedPromise: CurrentEventLoopPromise<Void>?
+    var socksEstablishedFuture: CurrentEventLoopFuture<Void>? {
         return self.socksEstablishedPromise?.futureResult
     }
 
@@ -42,7 +42,7 @@ final class SOCKSEventsHandler: ChannelInboundHandler, RemovableChannelHandler {
     }
 
     func handlerAdded(context: ChannelHandlerContext) {
-        self.socksEstablishedPromise = context.eventLoop.makePromise(of: Void.self)
+        self.socksEstablishedPromise = context.currentEventLoop.makePromise(of: Void.self)
 
         if context.channel.isActive {
             self.connectionStarted(context: context)
@@ -99,7 +99,7 @@ final class SOCKSEventsHandler: ChannelInboundHandler, RemovableChannelHandler {
             return
         }
 
-        let scheduled = context.eventLoop.scheduleTask(deadline: self.deadline) {
+        let scheduled = context.currentEventLoop.scheduleTask(deadline: self.deadline) {
             switch self.state {
             case .initialized, .channelActive:
                 // close the connection, if the handshake timed out
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/TLSEventsHandler.swift b/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/TLSEventsHandler.swift
index aab26fda8..386f6fb42 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/TLSEventsHandler.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/TLSEventsHandler.swift
@@ -22,15 +22,15 @@ final class TLSEventsHandler: ChannelInboundHandler, RemovableChannelHandler {
         // transitions to channelActive or failed
         case initialized
         // transitions to tlsEstablished or failed
-        case channelActive(Scheduled<Void>?)
+        case channelActive(ScheduledOnCurrentEventLoop<Void>?)
         // final success state
         case tlsEstablished
         // final success state
         case failed(Error)
     }
 
-    private var tlsEstablishedPromise: EventLoopPromise<String?>?
-    var tlsEstablishedFuture: EventLoopFuture<String?>? {
+    private var tlsEstablishedPromise: CurrentEventLoopPromise<String?>?
+    var tlsEstablishedFuture: CurrentEventLoopFuture<String?>? {
         return self.tlsEstablishedPromise?.futureResult
     }
 
@@ -42,7 +42,7 @@ final class TLSEventsHandler: ChannelInboundHandler, RemovableChannelHandler {
     }
 
     func handlerAdded(context: ChannelHandlerContext) {
-        self.tlsEstablishedPromise = context.eventLoop.makePromise(of: String?.self)
+        self.tlsEstablishedPromise = context.currentEventLoop.makePromise(of: String?.self)
 
         if context.channel.isActive {
             self.connectionStarted(context: context)
@@ -102,9 +102,9 @@ final class TLSEventsHandler: ChannelInboundHandler, RemovableChannelHandler {
             return
         }
 
-        var scheduled: Scheduled<Void>?
+        var scheduled: ScheduledOnCurrentEventLoop<Void>?
         if let deadline = deadline {
-            scheduled = context.eventLoop.scheduleTask(deadline: deadline) {
+            scheduled = context.currentEventLoop.scheduleTask(deadline: deadline) {
                 switch self.state {
                 case .initialized, .channelActive:
                     // close the connection, if the handshake timed out
@@ -121,3 +121,6 @@ final class TLSEventsHandler: ChannelInboundHandler, RemovableChannelHandler {
         self.state = .channelActive(scheduled)
     }
 }
+
+@available(*, unavailable)
+extension TLSEventsHandler: Sendable {}
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift
index 63cb70b99..b3c979bdf 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift
@@ -23,7 +23,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
 
     private var state: HTTP1ConnectionStateMachine = .init() {
         didSet {
-            self.eventLoop.assertInEventLoop()
+            self.eventLoop.wrapped.assertInEventLoop()
         }
     }
 
@@ -50,7 +50,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
     }
 
     private var idleReadTimeoutStateMachine: IdleReadStateMachine?
-    private var idleReadTimeoutTimer: Scheduled<Void>?
+    private var idleReadTimeoutTimer: ScheduledOnCurrentEventLoop<Void>?
 
     /// Cancelling a task in NIO does *not* guarantee that the task will not execute under certain race conditions.
     /// We therefore give each timer an ID and increase the ID every time we reset or cancel it.
@@ -59,11 +59,11 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
 
     private let backgroundLogger: Logger
     private var logger: Logger
-    private let eventLoop: EventLoop
+    private let eventLoop: CurrentEventLoop
     private let connectionIdLoggerMetadata: Logger.MetadataValue
 
     var onConnectionIdle: () -> Void = {}
-    init(eventLoop: EventLoop, backgroundLogger: Logger, connectionIdLoggerMetadata: Logger.MetadataValue) {
+    init(eventLoop: CurrentEventLoop, backgroundLogger: Logger, connectionIdLoggerMetadata: Logger.MetadataValue) {
         self.eventLoop = eventLoop
         self.backgroundLogger = backgroundLogger
         self.logger = backgroundLogger
@@ -150,7 +150,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
         self.request = req
 
         self.logger.debug("Request was scheduled on connection")
-        req.willExecuteRequest(self)
+        req.willExecuteRequest(HTTP1ClientChannelHandler.Executor(self))
 
         let action = self.state.runNewRequest(
             head: req.requestHead,
@@ -279,7 +279,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
             case .sendRequestEnd(let writePromise, let shouldClose):
                 let writePromise = writePromise ?? context.eventLoop.makePromise(of: Void.self)
                 // We need to defer succeeding the old request to avoid ordering issues
-                writePromise.futureResult.hop(to: context.eventLoop).whenComplete { result in
+                writePromise.futureResult.hop(to: context.currentEventLoop).whenComplete { result in
                     switch result {
                     case .success:
                         // If our final action was `sendRequestEnd`, that means we've already received
@@ -436,43 +436,53 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
 @available(*, unavailable)
 extension HTTP1ClientChannelHandler: Sendable {}
 
-extension HTTP1ClientChannelHandler: HTTPRequestExecutor {
-    func writeRequestBodyPart(_ data: IOData, request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {
-        if self.eventLoop.inEventLoop {
-            self.writeRequestBodyPart0(data, request: request, promise: promise)
-        } else {
-            self.eventLoop.execute {
-                self.writeRequestBodyPart0(data, request: request, promise: promise)
+extension HTTP1ClientChannelHandler {
+    struct Executor: HTTPRequestExecutor, @unchecked Sendable {
+        private let handler: HTTP1ClientChannelHandler
+        private let eventLoop: EventLoop
+        
+        init(_ handler: HTTP1ClientChannelHandler) {
+            self.eventLoop = handler.eventLoop.wrapped
+            self.handler = handler
+        }
+        
+        func writeRequestBodyPart(_ data: IOData, request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {
+            if self.eventLoop.inEventLoop {
+                self.handler.writeRequestBodyPart0(data, request: request, promise: promise)
+            } else {
+                self.eventLoop.execute {
+                    self.handler.writeRequestBodyPart0(data, request: request, promise: promise)
+                }
             }
         }
-    }
-
-    func finishRequestBodyStream(_ request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {
-        if self.eventLoop.inEventLoop {
-            self.finishRequestBodyStream0(request, promise: promise)
-        } else {
-            self.eventLoop.execute {
-                self.finishRequestBodyStream0(request, promise: promise)
+        
+        func finishRequestBodyStream(_ request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {
+            if self.eventLoop.inEventLoop {
+                self.handler.finishRequestBodyStream0(request, promise: promise)
+            } else {
+                self.eventLoop.execute {
+                    self.handler.finishRequestBodyStream0(request, promise: promise)
+                }
             }
         }
-    }
-
-    func demandResponseBodyStream(_ request: HTTPExecutableRequest) {
-        if self.eventLoop.inEventLoop {
-            self.demandResponseBodyStream0(request)
-        } else {
-            self.eventLoop.execute {
-                self.demandResponseBodyStream0(request)
+        
+        func demandResponseBodyStream(_ request: HTTPExecutableRequest) {
+            if self.eventLoop.inEventLoop {
+                self.handler.demandResponseBodyStream0(request)
+            } else {
+                self.eventLoop.execute {
+                    self.handler.demandResponseBodyStream0(request)
+                }
             }
         }
-    }
-
-    func cancelRequest(_ request: HTTPExecutableRequest) {
-        if self.eventLoop.inEventLoop {
-            self.cancelRequest0(request)
-        } else {
-            self.eventLoop.execute {
-                self.cancelRequest0(request)
+        
+        func cancelRequest(_ request: HTTPExecutableRequest) {
+            if self.eventLoop.inEventLoop {
+                self.handler.cancelRequest0(request)
+            } else {
+                self.eventLoop.execute {
+                    self.handler.cancelRequest0(request)
+                }
             }
         }
     }
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1Connection.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1Connection.swift
index ee0a78498..0fea4cda9 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1Connection.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1Connection.swift
@@ -17,7 +17,7 @@ import NIOCore
 import NIOHTTP1
 import NIOHTTPCompression
 
-protocol HTTP1ConnectionDelegate {
+protocol HTTP1ConnectionDelegate: Sendable {
     func http1ConnectionReleased(_: HTTP1Connection)
     func http1ConnectionClosed(_: HTTP1Connection)
 }
@@ -69,8 +69,9 @@ final class HTTP1Connection {
         if self.channel.eventLoop.inEventLoop {
             self.execute0(request: request)
         } else {
+            let sendableSelf = UnsafeTransfer(self)
             self.channel.eventLoop.execute {
-                self.execute0(request: request)
+                sendableSelf.wrappedValue.execute0(request: request)
             }
         }
     }
@@ -109,7 +110,7 @@ final class HTTP1Connection {
         }
 
         self.state = .active
-        self.channel.closeFuture.whenComplete { _ in
+        self.channel.closeFuture.iKnowIAmOnTheEventLoopOfThisFuture().whenComplete { _ in
             self.state = .closed
             self.delegate.http1ConnectionClosed(self)
         }
@@ -133,7 +134,7 @@ final class HTTP1Connection {
             }
 
             let channelHandler = HTTP1ClientChannelHandler(
-                eventLoop: channel.eventLoop,
+                eventLoop: channel.eventLoop.iKnowIAmOnThisEventLoop(),
                 backgroundLogger: logger,
                 connectionIdLoggerMetadata: "\(self.id)"
             )
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2ClientRequestHandler.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2ClientRequestHandler.swift
index 0e8e819e8..d14b7c312 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2ClientRequestHandler.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2ClientRequestHandler.swift
@@ -22,11 +22,11 @@ final class HTTP2ClientRequestHandler: ChannelDuplexHandler {
     typealias OutboundOut = HTTPClientRequestPart
     typealias InboundIn = HTTPClientResponsePart
 
-    private let eventLoop: EventLoop
+    private let eventLoop: CurrentEventLoop
 
     private var state: HTTPRequestStateMachine = .init(isChannelWritable: false) {
         willSet {
-            self.eventLoop.assertInEventLoop()
+            self.eventLoop.wrapped.assertInEventLoop()
         }
     }
 
@@ -44,14 +44,14 @@ final class HTTP2ClientRequestHandler: ChannelDuplexHandler {
     }
 
     private var idleReadTimeoutStateMachine: IdleReadStateMachine?
-    private var idleReadTimeoutTimer: Scheduled<Void>?
+    private var idleReadTimeoutTimer: ScheduledOnCurrentEventLoop<Void>?
 
-    init(eventLoop: EventLoop) {
+    init(eventLoop: CurrentEventLoop) {
         self.eventLoop = eventLoop
     }
 
     func handlerAdded(context: ChannelHandlerContext) {
-        assert(context.eventLoop === self.eventLoop,
+        assert(context.eventLoop === self.eventLoop.wrapped,
                "The handler must be added to a channel that runs on the eventLoop it was initialized with.")
         self.channelContext = context
 
@@ -110,7 +110,7 @@ final class HTTP2ClientRequestHandler: ChannelDuplexHandler {
         // a single request.
         self.request = request
 
-        request.willExecuteRequest(self)
+        request.willExecuteRequest(HTTP2ClientRequestHandler.Executor(self))
 
         let action = self.state.startRequest(
             head: request.requestHead,
@@ -343,43 +343,53 @@ final class HTTP2ClientRequestHandler: ChannelDuplexHandler {
     }
 }
 
-extension HTTP2ClientRequestHandler: HTTPRequestExecutor {
-    func writeRequestBodyPart(_ data: IOData, request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {
-        if self.eventLoop.inEventLoop {
-            self.writeRequestBodyPart0(data, request: request, promise: promise)
-        } else {
-            self.eventLoop.execute {
-                self.writeRequestBodyPart0(data, request: request, promise: promise)
+extension HTTP2ClientRequestHandler {
+    struct Executor: HTTPRequestExecutor, @unchecked Sendable {
+        private var handler: HTTP2ClientRequestHandler
+        private var eventLoop: EventLoop
+        
+        init(_ handler: HTTP2ClientRequestHandler) {
+            self.handler = handler
+            self.eventLoop = handler.eventLoop.wrapped
+        }
+        
+        func writeRequestBodyPart(_ data: IOData, request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {
+            if self.eventLoop.inEventLoop {
+                self.handler.writeRequestBodyPart0(data, request: request, promise: promise)
+            } else {
+                self.eventLoop.execute {
+                    self.handler.writeRequestBodyPart0(data, request: request, promise: promise)
+                }
             }
         }
-    }
-
-    func finishRequestBodyStream(_ request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {
-        if self.eventLoop.inEventLoop {
-            self.finishRequestBodyStream0(request, promise: promise)
-        } else {
-            self.eventLoop.execute {
-                self.finishRequestBodyStream0(request, promise: promise)
+        
+        func finishRequestBodyStream(_ request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {
+            if self.eventLoop.inEventLoop {
+                self.handler.finishRequestBodyStream0(request, promise: promise)
+            } else {
+                self.eventLoop.execute {
+                    self.handler.finishRequestBodyStream0(request, promise: promise)
+                }
             }
         }
-    }
-
-    func demandResponseBodyStream(_ request: HTTPExecutableRequest) {
-        if self.eventLoop.inEventLoop {
-            self.demandResponseBodyStream0(request)
-        } else {
-            self.eventLoop.execute {
-                self.demandResponseBodyStream0(request)
+        
+        func demandResponseBodyStream(_ request: HTTPExecutableRequest) {
+            if self.eventLoop.inEventLoop {
+                self.handler.demandResponseBodyStream0(request)
+            } else {
+                self.eventLoop.execute {
+                    self.handler.demandResponseBodyStream0(request)
+                }
             }
         }
-    }
-
-    func cancelRequest(_ request: HTTPExecutableRequest) {
-        if self.eventLoop.inEventLoop {
-            self.cancelRequest0(request)
-        } else {
-            self.eventLoop.execute {
-                self.cancelRequest0(request)
+        
+        func cancelRequest(_ request: HTTPExecutableRequest) {
+            if self.eventLoop.inEventLoop {
+                self.handler.cancelRequest0(request)
+            } else {
+                self.eventLoop.execute {
+                    self.handler.cancelRequest0(request)
+                }
             }
         }
     }
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2Connection.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2Connection.swift
index 2c3c3cc0a..3f38cdc3d 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2Connection.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2Connection.swift
@@ -17,7 +17,7 @@ import NIOCore
 import NIOHTTP2
 import NIOHTTPCompression
 
-protocol HTTP2ConnectionDelegate {
+protocol HTTP2ConnectionDelegate: Sendable {
     func http2Connection(_: HTTP2Connection, newMaxStreamSetting: Int)
     func http2ConnectionStreamClosed(_: HTTP2Connection, availableStreams: Int)
     func http2ConnectionGoAwayReceived(_: HTTP2Connection)
@@ -38,7 +38,7 @@ final class HTTP2Connection {
 
     enum State {
         case initialized
-        case starting(EventLoopPromise<Int>)
+        case starting(CurrentEventLoopPromise<Int>)
         case active(maxStreams: Int)
         case closing
         case closed
@@ -134,15 +134,16 @@ final class HTTP2Connection {
             delegate: delegate,
             logger: logger
         )
-        return connection._start0().map { maxStreams in (connection, maxStreams) }
+        return connection._start0().map { maxStreams in (connection, maxStreams) }.wrapped
     }
 
     func executeRequest(_ request: HTTPExecutableRequest) {
         if self.channel.eventLoop.inEventLoop {
             self.executeRequest0(request)
         } else {
+            let sendableSelf = UnsafeTransfer(self)
             self.channel.eventLoop.execute {
-                self.executeRequest0(request)
+                sendableSelf.wrappedValue.executeRequest0(request)
             }
         }
     }
@@ -153,8 +154,9 @@ final class HTTP2Connection {
         if self.channel.eventLoop.inEventLoop {
             self.shutdown0()
         } else {
+            let sendableSelf = UnsafeTransfer(self)
             self.channel.eventLoop.execute {
-                self.shutdown0()
+                sendableSelf.wrappedValue.shutdown0()
             }
         }
     }
@@ -169,13 +171,13 @@ final class HTTP2Connection {
         return promise.futureResult
     }
 
-    func _start0() -> EventLoopFuture<Int> {
+    func _start0() -> CurrentEventLoopFuture<Int> {
         self.channel.eventLoop.assertInEventLoop()
 
-        let readyToAcceptConnectionsPromise = self.channel.eventLoop.makePromise(of: Int.self)
+        let readyToAcceptConnectionsPromise = self.channel.eventLoop.iKnowIAmOnThisEventLoop().makePromise(of: Int.self)
 
         self.state = .starting(readyToAcceptConnectionsPromise)
-        self.channel.closeFuture.whenComplete { _ in
+        self.channel.closeFuture.iKnowIAmOnTheEventLoopOfThisFuture().whenComplete { _ in
             switch self.state {
             case .initialized, .closed:
                 preconditionFailure("invalid state \(self.state)")
@@ -218,8 +220,8 @@ final class HTTP2Connection {
             preconditionFailure("Invalid state: \(self.state). Sending requests is not allowed before we are started.")
 
         case .active:
-            let createStreamChannelPromise = self.channel.eventLoop.makePromise(of: Channel.self)
-            self.multiplexer.createStreamChannel(promise: createStreamChannelPromise) { channel -> EventLoopFuture<Void> in
+            let createStreamChannelPromise = self.channel.eventLoop.iKnowIAmOnThisEventLoop().makePromise(of: Channel.self)
+            self.multiplexer.createStreamChannel(promise: createStreamChannelPromise.wrapped) { channel -> EventLoopFuture<Void> in
                 do {
                     // the connection may have been asked to shutdown while we created the child. in
                     // this
@@ -238,7 +240,7 @@ final class HTTP2Connection {
                         try channel.pipeline.syncOperations.addHandler(decompressHandler)
                     }
 
-                    let handler = HTTP2ClientRequestHandler(eventLoop: channel.eventLoop)
+                    let handler = HTTP2ClientRequestHandler(eventLoop: channel.eventLoop.iKnowIAmOnThisEventLoop())
                     try channel.pipeline.syncOperations.addHandler(handler)
 
                     // We must add the new channel to the list of open channels BEFORE we write the
@@ -246,7 +248,7 @@ final class HTTP2Connection {
                     // before.
                     let box = ChannelBox(channel)
                     self.openStreams.insert(box)
-                    channel.closeFuture.whenComplete { _ in
+                    channel.closeFuture.iKnowIAmOnTheEventLoopOfThisFuture().whenComplete { _ in
                         self.openStreams.remove(box)
                     }
 
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool+Factory.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool+Factory.swift
index 1461a6620..dcdbc3984 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool+Factory.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool+Factory.swift
@@ -43,7 +43,7 @@ extension HTTPConnectionPool {
     }
 }
 
-protocol HTTPConnectionRequester {
+protocol HTTPConnectionRequester: Sendable {
     func http1ConnectionCreated(_: HTTP1Connection)
     func http2ConnectionCreated(_: HTTP2Connection, maximumStreams: Int)
     func failedToCreateHTTPConnection(_: HTTPConnectionPool.Connection.ID, error: Error)
@@ -62,8 +62,8 @@ extension HTTPConnectionPool.ConnectionFactory {
     ) {
         var logger = logger
         logger[metadataKey: "ahc-connection-id"] = "\(connectionID)"
-
-        self.makeChannel(requester: requester, connectionID: connectionID, deadline: deadline, eventLoop: eventLoop, logger: logger).whenComplete { result in
+        
+        self.makeChannel(requester: requester, connectionID: connectionID, deadline: deadline, eventLoop: eventLoop, logger: logger).whenComplete { [logger] result in
             switch result {
             case .success(.http1_1(let channel)):
                 do {
@@ -212,14 +212,17 @@ extension HTTPConnectionPool.ConnectionFactory {
             // The proxyEstablishedFuture is set as soon as the HTTP1ProxyConnectHandler is in a
             // pipeline. It is created in HTTP1ProxyConnectHandler's handlerAdded method.
             return proxyHandler.proxyEstablishedFuture!.flatMap {
-                channel.pipeline.removeHandler(proxyHandler).flatMap {
-                    channel.pipeline.removeHandler(decoder).flatMap {
-                        channel.pipeline.removeHandler(encoder)
-                    }
-                }
-            }.flatMap {
-                self.setupTLSInProxyConnectionIfNeeded(channel, deadline: deadline, logger: logger)
+                channel.pipeline.removeHandler(proxyHandler)
             }
+            .flatMap {
+                channel.pipeline.removeHandler(decoder)
+            }
+            .flatMap {
+                channel.pipeline.removeHandler(encoder)
+            }
+            .flatMap {
+                self.setupTLSInProxyConnectionIfNeeded(channel, deadline: deadline, logger: logger)
+            }.wrapped
         }
     }
 
@@ -249,12 +252,14 @@ extension HTTPConnectionPool.ConnectionFactory {
             // The socksEstablishedFuture is set as soon as the SOCKSEventsHandler is in a
             // pipeline. It is created in SOCKSEventsHandler's handlerAdded method.
             return socksEventHandler.socksEstablishedFuture!.flatMap {
-                channel.pipeline.removeHandler(socksEventHandler).flatMap {
-                    channel.pipeline.removeHandler(socksConnectHandler)
-                }
-            }.flatMap {
-                self.setupTLSInProxyConnectionIfNeeded(channel, deadline: deadline, logger: logger)
+                channel.pipeline.removeHandler(socksEventHandler)
+            }
+            .flatMap {
+                channel.pipeline.removeHandler(socksConnectHandler)
             }
+            .flatMap {
+                self.setupTLSInProxyConnectionIfNeeded(channel, deadline: deadline, logger: logger)
+            }.wrapped
         }
     }
 
@@ -287,7 +292,7 @@ extension HTTPConnectionPool.ConnectionFactory {
                 tlsConfiguration: tlsConfig,
                 eventLoop: channel.eventLoop,
                 logger: logger
-            )
+            ).iKnowIAmOnTheEventLoopOfThisFuture()
 
             return sslContextFuture.flatMap { sslContext -> EventLoopFuture<String?> in
                 do {
@@ -300,7 +305,7 @@ extension HTTPConnectionPool.ConnectionFactory {
 
                     // The tlsEstablishedFuture is set as soon as the TLSEventsHandler is in a
                     // pipeline. It is created in TLSEventsHandler's handlerAdded method.
-                    return tlsEventHandler.tlsEstablishedFuture!
+                    return tlsEventHandler.tlsEstablishedFuture!.wrapped
                 } catch {
                     return channel.eventLoop.makeFailedFuture(error)
                 }
@@ -308,7 +313,7 @@ extension HTTPConnectionPool.ConnectionFactory {
                 channel.pipeline.removeHandler(tlsEventHandler).flatMapThrowing {
                     try self.matchALPNToHTTPVersion(negotiated, channel: channel)
                 }
-            }
+            }.wrapped
         }
     }
 
@@ -371,7 +376,7 @@ extension HTTPConnectionPool.ConnectionFactory {
                 // pipeline. It is created in TLSEventsHandler's handlerAdded method.
                 return tlsEventHandler.tlsEstablishedFuture!.flatMap { negotiated in
                     channel.pipeline.removeHandler(tlsEventHandler).map { (channel, negotiated) }
-                }
+                }.wrapped
             } catch {
                 assert(channel.isActive == false, "if the channel is still active then TLSEventsHandler must be present but got error \(error)")
                 return channel.eventLoop.makeFailedFuture(HTTPClientError.remoteConnectionClosed)
@@ -410,10 +415,12 @@ extension HTTPConnectionPool.ConnectionFactory {
         #if canImport(Network)
         if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *), let tsBootstrap = NIOTSConnectionBootstrap(validatingGroup: eventLoop) {
             // create NIOClientTCPBootstrap with NIOTS TLS provider
+            let tsBootstrapSendable = UnsafeTransfer(tsBootstrap)
             let bootstrapFuture = tlsConfig.getNWProtocolTLSOptions(on: eventLoop, serverNameIndicatorOverride: key.serverNameIndicatorOverride).map {
                 options -> NIOClientTCPBootstrapProtocol in
 
-                tsBootstrap
+                tsBootstrapSendable
+                    .wrappedValue
                     .channelOption(NIOTSChannelOptions.waitForActivity, value: self.clientConfiguration.networkFrameworkWaitForConnectivity)
                     .connectTimeout(deadline - NIODeadline.now())
                     .tlsOptions(options)
@@ -444,7 +451,7 @@ extension HTTPConnectionPool.ConnectionFactory {
         let bootstrap = ClientBootstrap(group: eventLoop)
             .connectTimeout(deadline - NIODeadline.now())
             .channelInitializer { channel in
-                sslContextFuture.flatMap { sslContext -> EventLoopFuture<Void> in
+                sslContextFuture.iKnowIAmOnTheEventLoopOfThisFuture().flatMap { sslContext -> EventLoopFuture<Void> in
                     do {
                         let sync = channel.pipeline.syncOperations
                         let sslHandler = try NIOSSLClientHandler(
@@ -459,7 +466,7 @@ extension HTTPConnectionPool.ConnectionFactory {
                     } catch {
                         return channel.eventLoop.makeFailedFuture(error)
                     }
-                }
+                }.wrapped
             }
 
         return eventLoop.makeSucceededFuture(bootstrap)
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool.swift
index eac4cc21f..294ab78a8 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool.swift
@@ -21,7 +21,7 @@ protocol HTTPConnectionPoolDelegate {
     func connectionPoolDidShutdown(_ pool: HTTPConnectionPool, unclean: Bool)
 }
 
-final class HTTPConnectionPool {
+final class HTTPConnectionPool: @unchecked Sendable {
     private let stateLock = NIOLock()
     private var _state: StateMachine
     /// The connection idle timeout timers. Protected by the stateLock
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTPExecutableRequest.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTPExecutableRequest.swift
index d64ceedd6..bce55eb5b 100644
--- a/Sources/AsyncHTTPClient/ConnectionPool/HTTPExecutableRequest.swift
+++ b/Sources/AsyncHTTPClient/ConnectionPool/HTTPExecutableRequest.swift
@@ -132,7 +132,7 @@ import NIOSSL
 ///
 /// Use this handle to cancel the request, while it is waiting for a free connection, to execute the request.
 /// This protocol is only intended to be implemented by the `HTTPConnectionPool`.
-protocol HTTPRequestScheduler {
+protocol HTTPRequestScheduler: Sendable {
     /// Informs the task queuer that a request has been cancelled.
     func cancelRequest(_: HTTPSchedulableRequest)
 }
@@ -176,7 +176,7 @@ protocol HTTPSchedulableRequest: HTTPExecutableRequest {
 /// A handle to the request executor.
 ///
 /// This protocol is implemented by the `HTTP1ClientChannelHandler`.
-protocol HTTPRequestExecutor {
+protocol HTTPRequestExecutor: Sendable {
     /// Writes a body part into the channel pipeline
     ///
     /// This method may be **called on any thread**. The executor needs to ensure thread safety.
@@ -201,7 +201,7 @@ protocol HTTPRequestExecutor {
     func cancelRequest(_ task: HTTPExecutableRequest)
 }
 
-protocol HTTPExecutableRequest: AnyObject {
+protocol HTTPExecutableRequest: AnyObject, Sendable {
     /// The request's logger
     var logger: Logger { get }
 
diff --git a/Sources/AsyncHTTPClient/FileDownloadDelegate.swift b/Sources/AsyncHTTPClient/FileDownloadDelegate.swift
index 9a351f3c1..f54f078e6 100644
--- a/Sources/AsyncHTTPClient/FileDownloadDelegate.swift
+++ b/Sources/AsyncHTTPClient/FileDownloadDelegate.swift
@@ -34,8 +34,8 @@ public final class FileDownloadDelegate: HTTPClientResponseDelegate {
     private let reportHead: ((HTTPClient.Task<Progress>, HTTPResponseHead) -> Void)?
     private let reportProgress: ((HTTPClient.Task<Progress>, Progress) -> Void)?
 
-    private var fileHandleFuture: EventLoopFuture<NIOFileHandle>?
-    private var writeFuture: EventLoopFuture<Void>?
+    private var fileHandleFuture: CurrentEventLoopFuture<NIOFileHandle>?
+    private var writeFuture: CurrentEventLoopFuture<Void>?
 
     /// Initializes a new file download delegate.
     ///
@@ -159,7 +159,7 @@ public final class FileDownloadDelegate: HTTPClientResponseDelegate {
         self.progress.receivedBytes += buffer.readableBytes
         self.reportProgress?(task, self.progress)
 
-        let writeFuture: EventLoopFuture<Void>
+        let writeFuture: CurrentEventLoopFuture<Void>
         if let fileHandleFuture = self.fileHandleFuture {
             writeFuture = fileHandleFuture.flatMap {
                 io.write(fileHandle: $0, buffer: buffer, eventLoop: task.eventLoop)
@@ -170,7 +170,7 @@ public final class FileDownloadDelegate: HTTPClientResponseDelegate {
                 mode: .write,
                 flags: .allowFileCreation(),
                 eventLoop: task.eventLoop
-            )
+            ).iKnowIAmOnTheEventLoopOfThisFuture()
             self.fileHandleFuture = fileHandleFuture
             writeFuture = fileHandleFuture.flatMap {
                 io.write(fileHandle: $0, buffer: buffer, eventLoop: task.eventLoop)
@@ -178,7 +178,7 @@ public final class FileDownloadDelegate: HTTPClientResponseDelegate {
         }
 
         self.writeFuture = writeFuture
-        return writeFuture
+        return writeFuture.wrapped
     }
 
     private func close(fileHandle: NIOFileHandle) {
diff --git a/Sources/AsyncHTTPClient/HTTPClient.swift b/Sources/AsyncHTTPClient/HTTPClient.swift
index de6b57087..74404719f 100644
--- a/Sources/AsyncHTTPClient/HTTPClient.swift
+++ b/Sources/AsyncHTTPClient/HTTPClient.swift
@@ -14,6 +14,7 @@
 
 import Atomics
 import Foundation
+@preconcurrency import Dispatch
 import Logging
 import NIOConcurrencyHelpers
 import NIOCore
@@ -676,14 +677,14 @@ public class HTTPClient {
                 delegate: delegate
             )
 
-            var deadlineSchedule: Scheduled<Void>?
             if let deadline = deadline {
-                deadlineSchedule = taskEL.scheduleTask(deadline: deadline) {
-                    requestBag.deadlineExceeded()
+                let sendableRequestBag = UnsafeTransfer(requestBag)
+                let deadlineSchedule = taskEL.scheduleTask(deadline: deadline) {
+                    sendableRequestBag.wrappedValue.deadlineExceeded()
                 }
 
                 task.promise.futureResult.whenComplete { _ in
-                    deadlineSchedule?.cancel()
+                    deadlineSchedule.cancel()
                 }
             }
 
diff --git a/Sources/AsyncHTTPClient/HTTPHandler.swift b/Sources/AsyncHTTPClient/HTTPHandler.swift
index c5a3b3a4a..3a00c8851 100644
--- a/Sources/AsyncHTTPClient/HTTPHandler.swift
+++ b/Sources/AsyncHTTPClient/HTTPHandler.swift
@@ -235,7 +235,7 @@ extension HTTPClient {
     }
 
     /// Represents an HTTP response.
-    public struct Response {
+    public struct Response: Sendable {
         /// Remote host of the request.
         public var host: String
         /// Response HTTP status.
@@ -496,7 +496,7 @@ public final class ResponseAccumulator: HTTPClientResponseDelegate {
 ///          Users of the library are not required to keep a reference to the
 ///          object that implements this protocol, but may do so if needed.
 public protocol HTTPClientResponseDelegate: AnyObject {
-    associatedtype Response
+    associatedtype Response: Sendable
 
     /// Called when the request head is sent. Will be called once.
     ///
@@ -784,7 +784,7 @@ internal struct TaskCancelEvent {}
 
 // MARK: - RedirectHandler
 
-internal struct RedirectHandler<ResponseType> {
+internal struct RedirectHandler<ResponseType: Sendable> {
     let request: HTTPClient.Request
     let redirectState: RedirectState
     let execute: (HTTPClient.Request, RedirectState) -> HTTPClient.Task<ResponseType>
diff --git a/Sources/AsyncHTTPClient/NIOTransportServices/NWErrorHandler.swift b/Sources/AsyncHTTPClient/NIOTransportServices/NWErrorHandler.swift
index 9796bc2af..e7c49e4e5 100644
--- a/Sources/AsyncHTTPClient/NIOTransportServices/NWErrorHandler.swift
+++ b/Sources/AsyncHTTPClient/NIOTransportServices/NWErrorHandler.swift
@@ -13,7 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 #if canImport(Network)
-import Network
+@preconcurrency import Network
 #endif
 import NIOCore
 import NIOHTTP1
diff --git a/Sources/AsyncHTTPClient/NIOTransportServices/TLSConfiguration.swift b/Sources/AsyncHTTPClient/NIOTransportServices/TLSConfiguration.swift
index 06ae5e146..981f385e1 100644
--- a/Sources/AsyncHTTPClient/NIOTransportServices/TLSConfiguration.swift
+++ b/Sources/AsyncHTTPClient/NIOTransportServices/TLSConfiguration.swift
@@ -60,7 +60,7 @@ extension TLSVersion {
 @available(macOS 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *)
 extension TLSConfiguration {
     /// Dispatch queue used by Network framework TLS to control certificate verification
-    static var tlsDispatchQueue = DispatchQueue(label: "TLSDispatch")
+    static let tlsDispatchQueue = DispatchQueue(label: "TLSDispatch")
 
     /// create NWProtocolTLS.Options for use with NIOTransportServices from the NIOSSL TLSConfiguration
     ///
diff --git a/Sources/AsyncHTTPClient/RequestBag.swift b/Sources/AsyncHTTPClient/RequestBag.swift
index c5472fc6f..055f32eae 100644
--- a/Sources/AsyncHTTPClient/RequestBag.swift
+++ b/Sources/AsyncHTTPClient/RequestBag.swift
@@ -18,7 +18,7 @@ import NIOCore
 import NIOHTTP1
 import NIOSSL
 
-final class RequestBag<Delegate: HTTPClientResponseDelegate> {
+final class RequestBag<Delegate: HTTPClientResponseDelegate>: @unchecked Sendable {
     /// Defends against the call stack getting too large when consuming body parts.
     ///
     /// If the response body comes in lots of tiny chunks, we'll deliver those tiny chunks to users
@@ -135,7 +135,7 @@ final class RequestBag<Delegate: HTTPClientResponseDelegate> {
                 self.writeNextRequestPart($0)
             }
 
-            body.stream(writer).hop(to: self.eventLoop).whenComplete {
+            body.stream(writer).hop(to: self.eventLoop.iKnowIAmOnThisEventLoop()).whenComplete {
                 self.finishRequestBodyStream($0)
             }
 
@@ -157,8 +157,9 @@ final class RequestBag<Delegate: HTTPClientResponseDelegate> {
         if self.eventLoop.inEventLoop {
             return self.writeNextRequestPart0(part)
         } else {
+            let sendableSelf = UnsafeTransfer(self)
             return self.eventLoop.flatSubmit {
-                self.writeNextRequestPart0(part)
+                sendableSelf.wrappedValue.writeNextRequestPart0(part)
             }
         }
     }
diff --git a/Sources/AsyncHTTPClient/SSLContextCache.swift b/Sources/AsyncHTTPClient/SSLContextCache.swift
index 660a04942..763ea22d4 100644
--- a/Sources/AsyncHTTPClient/SSLContextCache.swift
+++ b/Sources/AsyncHTTPClient/SSLContextCache.swift
@@ -25,9 +25,11 @@ final class SSLContextCache {
 }
 
 extension SSLContextCache {
-    func sslContext(tlsConfiguration: TLSConfiguration,
-                    eventLoop: EventLoop,
-                    logger: Logger) -> EventLoopFuture<NIOSSLContext> {
+    func sslContext(
+        tlsConfiguration: TLSConfiguration,
+        eventLoop: EventLoop,
+        logger: Logger
+    ) -> EventLoopFuture<NIOSSLContext> {
         let eqTLSConfiguration = BestEffortHashableTLSConfiguration(wrapping: tlsConfiguration)
         let sslContext = self.lock.withLock {
             self.sslContextCache.find(key: eqTLSConfiguration)
diff --git a/Sources/AsyncHTTPClient/UnsafeTransfer.swift b/Sources/AsyncHTTPClient/UnsafeTransfer.swift
index ea5af56da..04a521cc4 100644
--- a/Sources/AsyncHTTPClient/UnsafeTransfer.swift
+++ b/Sources/AsyncHTTPClient/UnsafeTransfer.swift
@@ -2,7 +2,7 @@
 //
 // This source file is part of the AsyncHTTPClient open source project
 //
-// Copyright (c) 2022 Apple Inc. and the AsyncHTTPClient project authors
+// Copyright (c) 2022-2023 Apple Inc. and the AsyncHTTPClient project authors
 // Licensed under Apache License v2.0
 //
 // See LICENSE.txt for license information
@@ -12,6 +12,25 @@
 //
 //===----------------------------------------------------------------------===//
 
+/// ``UnsafeTransfer`` can be used to make non-`Sendable` values `Sendable`.
+/// As the name implies, the usage of this is unsafe because it disables the sendable checking of the compiler.
+/// It can be used similar to `@unsafe Sendable` but for values instead of types.
+@usableFromInline
+struct UnsafeTransfer<Wrapped> {
+    @usableFromInline
+    var wrappedValue: Wrapped
+    
+    @inlinable
+    init(_ wrappedValue: Wrapped) {
+        self.wrappedValue = wrappedValue
+    }
+}
+
+extension UnsafeTransfer: @unchecked Sendable {}
+
+extension UnsafeTransfer: Equatable where Wrapped: Equatable {}
+extension UnsafeTransfer: Hashable where Wrapped: Hashable {}
+
 /// ``UnsafeMutableTransferBox`` can be used to make non-`Sendable` values `Sendable` and mutable.
 /// It can be used to capture local mutable values in a `@Sendable` closure and mutate them from within the closure.
 /// As the name implies, the usage of this is unsafe because it disables the sendable checking of the compiler and does not add any synchronisation.
diff --git a/Tests/AsyncHTTPClientTests/HTTP1ClientChannelHandlerTests.swift b/Tests/AsyncHTTPClientTests/HTTP1ClientChannelHandlerTests.swift
index 2aa010491..93b13cce7 100644
--- a/Tests/AsyncHTTPClientTests/HTTP1ClientChannelHandlerTests.swift
+++ b/Tests/AsyncHTTPClientTests/HTTP1ClientChannelHandlerTests.swift
@@ -539,7 +539,7 @@ class HTTP1ClientChannelHandlerTests: XCTestCase {
         let eventLoopGroup = EmbeddedEventLoopGroup(loops: 1)
         let eventLoop = eventLoopGroup.next() as! EmbeddedEventLoop
         let handler = HTTP1ClientChannelHandler(
-            eventLoop: eventLoop,
+            eventLoop: eventLoop.iKnowIAmOnThisEventLoop(),
             backgroundLogger: Logger(label: "no-op", factory: SwiftLogNoOpLogHandler.init),
             connectionIdLoggerMetadata: "test connection"
         )
diff --git a/Tests/AsyncHTTPClientTests/HTTP1ConnectionTests.swift b/Tests/AsyncHTTPClientTests/HTTP1ConnectionTests.swift
index 3ff73de06..8305da0d8 100644
--- a/Tests/AsyncHTTPClientTests/HTTP1ConnectionTests.swift
+++ b/Tests/AsyncHTTPClientTests/HTTP1ConnectionTests.swift
@@ -96,8 +96,7 @@ class HTTP1ConnectionTests: XCTestCase {
         defer { XCTAssertNoThrow(try server.stop()) }
 
         let logger = Logger(label: "test")
-        let delegate = MockHTTP1ConnectionDelegate()
-        delegate.closePromise = clientEL.makePromise(of: Void.self)
+        let delegate = MockHTTP1ConnectionDelegate(closePromise: clientEL.makePromise(of: Void.self))
 
         let connection = try! ClientBootstrap(group: clientEL)
             .connect(to: .init(ipAddress: "127.0.0.1", port: server.serverPort))
@@ -729,10 +728,15 @@ class HTTP1ConnectionTests: XCTestCase {
     }
 }
 
-class MockHTTP1ConnectionDelegate: HTTP1ConnectionDelegate {
-    var releasePromise: EventLoopPromise<Void>?
-    var closePromise: EventLoopPromise<Void>?
-
+struct MockHTTP1ConnectionDelegate: HTTP1ConnectionDelegate {
+    let releasePromise: EventLoopPromise<Void>?
+    let closePromise: EventLoopPromise<Void>?
+    
+    init(releasePromise: EventLoopPromise<Void>? = nil, closePromise: EventLoopPromise<Void>? = nil) {
+        self.releasePromise = releasePromise
+        self.closePromise = closePromise
+    }
+    
     func http1ConnectionReleased(_: HTTP1Connection) {
         self.releasePromise?.succeed(())
     }
@@ -804,31 +808,31 @@ class AfterRequestCloseConnectionChannelHandler: ChannelInboundHandler {
     }
 }
 
-class MockConnectionDelegate: HTTP1ConnectionDelegate {
-    private var lock = NIOLock()
-
-    private var _hitConnectionReleased = 0
-    private var _hitConnectionClosed = 0
+struct MockConnectionDelegate: HTTP1ConnectionDelegate {
+    private struct State {
+        var hitConnectionReleased = 0
+        var hitConnectionClosed = 0
+    }
+    
+    private let state = NIOLockedValueBox(State())
 
     var hitConnectionReleased: Int {
-        self.lock.withLock { self._hitConnectionReleased }
+        self.state.withLockedValue { $0.hitConnectionReleased }
     }
 
     var hitConnectionClosed: Int {
-        self.lock.withLock { self._hitConnectionClosed }
+        self.state.withLockedValue { $0.hitConnectionClosed }
     }
 
-    init() {}
-
     func http1ConnectionReleased(_: HTTP1Connection) {
-        self.lock.withLock {
-            self._hitConnectionReleased += 1
+        self.state.withLockedValue {
+            $0.hitConnectionReleased += 1
         }
     }
 
     func http1ConnectionClosed(_: HTTP1Connection) {
-        self.lock.withLock {
-            self._hitConnectionClosed += 1
+        self.state.withLockedValue {
+            $0.hitConnectionClosed += 1
         }
     }
 }
diff --git a/Tests/AsyncHTTPClientTests/HTTP1ProxyConnectHandlerTests.swift b/Tests/AsyncHTTPClientTests/HTTP1ProxyConnectHandlerTests.swift
index b3917173f..74d9a93ea 100644
--- a/Tests/AsyncHTTPClientTests/HTTP1ProxyConnectHandlerTests.swift
+++ b/Tests/AsyncHTTPClientTests/HTTP1ProxyConnectHandlerTests.swift
@@ -51,7 +51,7 @@ class HTTP1ProxyConnectHandlerTests: XCTestCase {
         XCTAssertNoThrow(try embedded.writeInbound(HTTPClientResponsePart.head(responseHead)))
         XCTAssertNoThrow(try embedded.writeInbound(HTTPClientResponsePart.end(nil)))
 
-        XCTAssertNoThrow(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wait())
+        XCTAssertNoThrow(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wrapped.wait())
     }
 
     func testProxyConnectWithAuthorization() {
@@ -85,7 +85,7 @@ class HTTP1ProxyConnectHandlerTests: XCTestCase {
         XCTAssertNoThrow(try embedded.writeInbound(HTTPClientResponsePart.head(responseHead)))
         XCTAssertNoThrow(try embedded.writeInbound(HTTPClientResponsePart.end(nil)))
 
-        XCTAssertNoThrow(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wait())
+        XCTAssertNoThrow(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wrapped.wait())
     }
 
     func testProxyConnectWithoutAuthorizationFailure500() {
@@ -123,7 +123,7 @@ class HTTP1ProxyConnectHandlerTests: XCTestCase {
         XCTAssertFalse(embedded.isActive, "Channel should be closed in response to the error")
         XCTAssertNoThrow(try embedded.writeInbound(HTTPClientResponsePart.end(nil)))
 
-        XCTAssertThrowsError(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wait()) {
+        XCTAssertThrowsError(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wrapped.wait()) {
             XCTAssertEqual($0 as? HTTPClientError, .invalidProxyResponse)
         }
     }
@@ -163,7 +163,7 @@ class HTTP1ProxyConnectHandlerTests: XCTestCase {
         XCTAssertFalse(embedded.isActive, "Channel should be closed in response to the error")
         XCTAssertNoThrow(try embedded.writeInbound(HTTPClientResponsePart.end(nil)))
 
-        XCTAssertThrowsError(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wait()) {
+        XCTAssertThrowsError(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wrapped.wait()) {
             XCTAssertEqual($0 as? HTTPClientError, .proxyAuthenticationRequired)
         }
     }
@@ -203,7 +203,7 @@ class HTTP1ProxyConnectHandlerTests: XCTestCase {
         XCTAssertEqual(embedded.isActive, false)
         XCTAssertNoThrow(try embedded.writeInbound(HTTPClientResponsePart.end(nil)))
 
-        XCTAssertThrowsError(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wait()) {
+        XCTAssertThrowsError(try XCTUnwrap(proxyConnectHandler.proxyEstablishedFuture).wrapped.wait()) {
             XCTAssertEqual($0 as? HTTPClientError, .invalidProxyResponse)
         }
     }
diff --git a/Tests/AsyncHTTPClientTests/HTTP2ClientRequestHandlerTests.swift b/Tests/AsyncHTTPClientTests/HTTP2ClientRequestHandlerTests.swift
index 2b68fceb3..50fc2d464 100644
--- a/Tests/AsyncHTTPClientTests/HTTP2ClientRequestHandlerTests.swift
+++ b/Tests/AsyncHTTPClientTests/HTTP2ClientRequestHandlerTests.swift
@@ -23,7 +23,7 @@ class HTTP2ClientRequestHandlerTests: XCTestCase {
     func testResponseBackpressure() {
         let embedded = EmbeddedChannel()
         let readEventHandler = ReadEventHitHandler()
-        let requestHandler = HTTP2ClientRequestHandler(eventLoop: embedded.eventLoop)
+        let requestHandler = HTTP2ClientRequestHandler(eventLoop: embedded.eventLoop.iKnowIAmOnThisEventLoop())
         let logger = Logger(label: "test")
 
         XCTAssertNoThrow(try embedded.pipeline.syncOperations.addHandlers([readEventHandler, requestHandler]))
@@ -108,7 +108,7 @@ class HTTP2ClientRequestHandlerTests: XCTestCase {
 
     func testWriteBackpressure() {
         let embedded = EmbeddedChannel()
-        let requestHandler = HTTP2ClientRequestHandler(eventLoop: embedded.eventLoop)
+        let requestHandler = HTTP2ClientRequestHandler(eventLoop: embedded.eventLoop.iKnowIAmOnThisEventLoop())
         XCTAssertNoThrow(try embedded.pipeline.syncOperations.addHandler(requestHandler))
         let logger = Logger(label: "test")
 
@@ -187,7 +187,7 @@ class HTTP2ClientRequestHandlerTests: XCTestCase {
     func testIdleReadTimeout() {
         let embedded = EmbeddedChannel()
         let readEventHandler = ReadEventHitHandler()
-        let requestHandler = HTTP2ClientRequestHandler(eventLoop: embedded.eventLoop)
+        let requestHandler = HTTP2ClientRequestHandler(eventLoop: embedded.eventLoop.iKnowIAmOnThisEventLoop())
         XCTAssertNoThrow(try embedded.pipeline.syncOperations.addHandlers([readEventHandler, requestHandler]))
         XCTAssertNoThrow(try embedded.connect(to: .makeAddressResolvingHost("localhost", port: 0)).wait())
         let logger = Logger(label: "test")
@@ -237,7 +237,7 @@ class HTTP2ClientRequestHandlerTests: XCTestCase {
     func testIdleReadTimeoutIsCanceledIfRequestIsCanceled() {
         let embedded = EmbeddedChannel()
         let readEventHandler = ReadEventHitHandler()
-        let requestHandler = HTTP2ClientRequestHandler(eventLoop: embedded.eventLoop)
+        let requestHandler = HTTP2ClientRequestHandler(eventLoop: embedded.eventLoop.iKnowIAmOnThisEventLoop())
         XCTAssertNoThrow(try embedded.pipeline.syncOperations.addHandlers([readEventHandler, requestHandler]))
         XCTAssertNoThrow(try embedded.connect(to: .makeAddressResolvingHost("localhost", port: 0)).wait())
         let logger = Logger(label: "test")
@@ -307,7 +307,7 @@ class HTTP2ClientRequestHandlerTests: XCTestCase {
 
         for body in bodies {
             let embeddedEventLoop = EmbeddedEventLoop()
-            let requestHandler = HTTP2ClientRequestHandler(eventLoop: embeddedEventLoop)
+            let requestHandler = HTTP2ClientRequestHandler(eventLoop: embeddedEventLoop.iKnowIAmOnThisEventLoop())
             let embedded = EmbeddedChannel(handlers: [FailWriteHandler(), requestHandler], loop: embeddedEventLoop)
 
             let logger = Logger(label: "test")
@@ -359,7 +359,7 @@ class HTTP2ClientRequestHandlerTests: XCTestCase {
         let eventLoopGroup = EmbeddedEventLoopGroup(loops: 1)
         let eventLoop = eventLoopGroup.next() as! EmbeddedEventLoop
         let handler = HTTP2ClientRequestHandler(
-            eventLoop: eventLoop
+            eventLoop: eventLoop.iKnowIAmOnThisEventLoop()
         )
         let channel = EmbeddedChannel(handlers: [
             ChangeWritabilityOnFlush(),
diff --git a/Tests/AsyncHTTPClientTests/HTTP2ConnectionTests.swift b/Tests/AsyncHTTPClientTests/HTTP2ConnectionTests.swift
index 15e5cdff2..e4a117336 100644
--- a/Tests/AsyncHTTPClientTests/HTTP2ConnectionTests.swift
+++ b/Tests/AsyncHTTPClientTests/HTTP2ConnectionTests.swift
@@ -62,7 +62,7 @@ class HTTP2ConnectionTests: XCTestCase {
         // to really destroy the channel we need to tick once
         embedded.embeddedEventLoop.run()
 
-        XCTAssertThrowsError(try startFuture.wait())
+        XCTAssertThrowsError(try startFuture.wrapped.wait())
 
         // should not crash
         connection.shutdown()
@@ -340,7 +340,7 @@ class HTTP2ConnectionTests: XCTestCase {
     }
 }
 
-class TestConnectionCreator {
+final class TestConnectionCreator {
     enum Error: Swift.Error {
         case alreadyCreatingAnotherConnection
         case wantedHTTP2ConnectionButGotHTTP1
@@ -353,8 +353,7 @@ class TestConnectionCreator {
         case waitingForHTTP2Connection(EventLoopPromise<HTTP2Connection>)
     }
 
-    private var state: State = .idle
-    private let lock = NIOLock()
+    private let state = NIOLockedValueBox(State.idle)
 
     init() {}
 
@@ -378,13 +377,13 @@ class TestConnectionCreator {
             sslContextCache: .init()
         )
 
-        let promise = try self.lock.withLock { () -> EventLoopPromise<HTTP1Connection> in
-            guard case .idle = self.state else {
+        let promise = try self.state.withLockedValue { state -> EventLoopPromise<HTTP1Connection> in
+            guard case .idle = state else {
                 throw Error.alreadyCreatingAnotherConnection
             }
 
             let promise = eventLoop.makePromise(of: HTTP1Connection.self)
-            self.state = .waitingForHTTP1Connection(promise)
+            state = .waitingForHTTP1Connection(promise)
             return promise
         }
 
@@ -421,13 +420,13 @@ class TestConnectionCreator {
             sslContextCache: .init()
         )
 
-        let promise = try self.lock.withLock { () -> EventLoopPromise<HTTP2Connection> in
-            guard case .idle = self.state else {
+        let promise = try self.state.withLockedValue { state -> EventLoopPromise<HTTP2Connection> in
+            guard case .idle = state else {
                 throw Error.alreadyCreatingAnotherConnection
             }
 
             let promise = eventLoop.makePromise(of: HTTP2Connection.self)
-            self.state = .waitingForHTTP2Connection(promise)
+            state = .waitingForHTTP2Connection(promise)
             return promise
         }
 
@@ -461,9 +460,9 @@ extension TestConnectionCreator: HTTPConnectionRequester {
     }
 
     func http1ConnectionCreated(_ connection: HTTP1Connection) {
-        let wrapper = self.lock.withLock { () -> (EitherPromiseWrapper<HTTP1Connection, HTTP2Connection>) in
+        let wrapper = self.state.withLockedValue { state -> (EitherPromiseWrapper<HTTP1Connection, HTTP2Connection>) in
 
-            switch self.state {
+            switch state {
             case .waitingForHTTP1Connection(let promise):
                 return .succeed(promise, connection)
 
@@ -478,9 +477,9 @@ extension TestConnectionCreator: HTTPConnectionRequester {
     }
 
     func http2ConnectionCreated(_ connection: HTTP2Connection, maximumStreams: Int) {
-        let wrapper = self.lock.withLock { () -> (EitherPromiseWrapper<HTTP2Connection, HTTP1Connection>) in
+        let wrapper = self.state.withLockedValue { state -> (EitherPromiseWrapper<HTTP2Connection, HTTP1Connection>) in
 
-            switch self.state {
+            switch state {
             case .waitingForHTTP1Connection(let promise):
                 return .fail(promise, Error.wantedHTTP1ConnectionButGotHTTP2)
 
@@ -509,9 +508,9 @@ extension TestConnectionCreator: HTTPConnectionRequester {
     }
 
     func failedToCreateHTTPConnection(_: HTTPConnectionPool.Connection.ID, error: Swift.Error) {
-        let wrapper = self.lock.withLock { () -> (FailPromiseWrapper<HTTP1Connection, HTTP2Connection>) in
+        let wrapper = self.state.withLockedValue { state -> (FailPromiseWrapper<HTTP1Connection, HTTP2Connection>) in
 
-            switch self.state {
+            switch state {
             case .waitingForHTTP1Connection(let promise):
                 return .type1(promise)
 
@@ -530,48 +529,51 @@ extension TestConnectionCreator: HTTPConnectionRequester {
     }
 }
 
-class TestHTTP2ConnectionDelegate: HTTP2ConnectionDelegate {
+struct TestHTTP2ConnectionDelegate: HTTP2ConnectionDelegate {
     var hitStreamClosed: Int {
-        self.lock.withLock { self._hitStreamClosed }
+        self.state.withLockedValue { $0._hitStreamClosed }
     }
 
     var hitGoAwayReceived: Int {
-        self.lock.withLock { self._hitGoAwayReceived }
+        self.state.withLockedValue { $0._hitGoAwayReceived }
     }
 
     var hitConnectionClosed: Int {
-        self.lock.withLock { self._hitConnectionClosed }
+        self.state.withLockedValue { $0._hitConnectionClosed }
     }
 
     var maxStreamSetting: Int {
-        self.lock.withLock { self._maxStreamSetting }
+        self.state.withLockedValue { $0._maxStreamSetting }
     }
 
-    private let lock = NIOLock()
-    private var _hitStreamClosed: Int = 0
-    private var _hitGoAwayReceived: Int = 0
-    private var _hitConnectionClosed: Int = 0
-    private var _maxStreamSetting: Int = 100
+    private let state = NIOLockedValueBox(State())
+    private struct State {
+        var _hitStreamClosed: Int = 0
+        var _hitGoAwayReceived: Int = 0
+        var _hitConnectionClosed: Int = 0
+        var _maxStreamSetting: Int = 100
+    }
+    
 
     init() {}
 
     func http2Connection(_: HTTP2Connection, newMaxStreamSetting: Int) {}
 
     func http2ConnectionStreamClosed(_: HTTP2Connection, availableStreams: Int) {
-        self.lock.withLock {
-            self._hitStreamClosed += 1
+        self.state.withLockedValue {
+            $0._hitStreamClosed += 1
         }
     }
 
     func http2ConnectionGoAwayReceived(_: HTTP2Connection) {
-        self.lock.withLock {
-            self._hitGoAwayReceived += 1
+        self.state.withLockedValue {
+            $0._hitGoAwayReceived += 1
         }
     }
 
     func http2ConnectionClosed(_: HTTP2Connection) {
-        self.lock.withLock {
-            self._hitConnectionClosed += 1
+        self.state.withLockedValue {
+            $0._hitConnectionClosed += 1
         }
     }
 }
diff --git a/Tests/AsyncHTTPClientTests/HTTPConnectionPool+RequestQueueTests.swift b/Tests/AsyncHTTPClientTests/HTTPConnectionPool+RequestQueueTests.swift
index f8d6044cd..968ed5333 100644
--- a/Tests/AsyncHTTPClientTests/HTTPConnectionPool+RequestQueueTests.swift
+++ b/Tests/AsyncHTTPClientTests/HTTPConnectionPool+RequestQueueTests.swift
@@ -82,7 +82,7 @@ class HTTPConnectionPool_RequestQueueTests: XCTestCase {
     }
 }
 
-private class MockScheduledRequest: HTTPSchedulableRequest {
+private final class MockScheduledRequest: HTTPSchedulableRequest {
     let requiredEventLoop: EventLoop?
 
     init(requiredEventLoop: EventLoop?) {
diff --git a/Tests/AsyncHTTPClientTests/Mocks/MockHTTPExecutableRequest.swift b/Tests/AsyncHTTPClientTests/Mocks/MockHTTPExecutableRequest.swift
index aa0dc45eb..630e60254 100644
--- a/Tests/AsyncHTTPClientTests/Mocks/MockHTTPExecutableRequest.swift
+++ b/Tests/AsyncHTTPClientTests/Mocks/MockHTTPExecutableRequest.swift
@@ -17,7 +17,9 @@ import Logging
 import NIOCore
 import NIOHTTP1
 import XCTest
+import NIOConcurrencyHelpers
 
+@dynamicMemberLookup
 final class MockHTTPExecutableRequest: HTTPExecutableRequest {
     enum Event {
         /// ``Event`` without associated values
@@ -55,30 +57,63 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
         }
     }
 
-    var logger: Logging.Logger = Logger(label: "request")
-    var requestHead: NIOHTTP1.HTTPRequestHead
-    var requestFramingMetadata: RequestFramingMetadata
-    var requestOptions: RequestOptions = .forTests()
-
-    /// if true and ``HTTPExecutableRequest`` method is called without setting a corresponding callback on `self` e.g.
-    /// If ``HTTPExecutableRequest\.willExecuteRequest(_:)`` is called but ``willExecuteRequestCallback`` is not set,
-    /// ``XCTestFail(_:)`` will be called to fail the current test.
-    var raiseErrorIfUnimplementedMethodIsCalled: Bool = true
-    private var file: StaticString
-    private var line: UInt
-
-    var willExecuteRequestCallback: ((HTTPRequestExecutor) -> Void)?
-    var requestHeadSentCallback: (() -> Void)?
-    var resumeRequestBodyStreamCallback: (() -> Void)?
-    var pauseRequestBodyStreamCallback: (() -> Void)?
-    var receiveResponseHeadCallback: ((HTTPResponseHead) -> Void)?
-    var receiveResponseBodyPartsCallback: ((CircularBuffer<ByteBuffer>) -> Void)?
-    var succeedRequestCallback: ((CircularBuffer<ByteBuffer>?) -> Void)?
-    var failCallback: ((Error) -> Void)?
-
-    /// captures all ``HTTPExecutableRequest`` method calls in the order of occurrence, including arguments.
-    /// If you are not interested in the arguments you can use `events.map(\.kind)` to get all events without arguments.
-    private(set) var events: [Event] = []
+    let logger: Logging.Logger = Logger(label: "request")
+    
+
+    private let file: StaticString
+    private let line: UInt
+    
+    struct State: Sendable {
+        var requestHead: NIOHTTP1.HTTPRequestHead
+        var requestFramingMetadata: RequestFramingMetadata
+        var requestOptions: RequestOptions = .forTests()
+        /// if true and ``HTTPExecutableRequest`` method is called without setting a corresponding callback on `self` e.g.
+        /// If ``HTTPExecutableRequest\.willExecuteRequest(_:)`` is called but ``willExecuteRequestCallback`` is not set,
+        /// ``XCTestFail(_:)`` will be called to fail the current test.
+        var raiseErrorIfUnimplementedMethodIsCalled: Bool = true
+        var willExecuteRequestCallback: (@Sendable (HTTPRequestExecutor) -> Void)?
+        var requestHeadSentCallback: (@Sendable () -> Void)?
+        var resumeRequestBodyStreamCallback: (@Sendable () -> Void)?
+        var pauseRequestBodyStreamCallback: (@Sendable () -> Void)?
+        var receiveResponseHeadCallback: (@Sendable (HTTPResponseHead) -> Void)?
+        var receiveResponseBodyPartsCallback: (@Sendable (CircularBuffer<ByteBuffer>) -> Void)?
+        var succeedRequestCallback: (@Sendable (CircularBuffer<ByteBuffer>?) -> Void)?
+        var failCallback: (@Sendable (Error) -> Void)?
+        
+        /// captures all ``HTTPExecutableRequest`` method calls in the order of occurrence, including arguments.
+        /// If you are not interested in the arguments you can use `events.map(\.kind)` to get all events without arguments.
+        fileprivate(set) var events: [Event] = []
+    }
+    
+    private let state: NIOLockedValueBox<State>
+    
+    var requestHead: NIOHTTP1.HTTPRequestHead {
+        get { self.state.withLockedValue { $0.requestHead } }
+        set { self.state.withLockedValue { $0.requestHead = newValue } }
+    }
+    
+    var requestFramingMetadata: AsyncHTTPClient.RequestFramingMetadata {
+        get { self.state.withLockedValue { $0.requestFramingMetadata } }
+        set { self.state.withLockedValue { $0.requestFramingMetadata = newValue } }
+    }
+    
+    var requestOptions: AsyncHTTPClient.RequestOptions {
+        get { self.state.withLockedValue { $0.requestOptions } }
+        set { self.state.withLockedValue { $0.requestOptions = newValue } }
+    }
+    
+    subscript<Property: Sendable>(dynamicMember keyPath: KeyPath<State, Property>) -> Property {
+        state.withLockedValue { $0[keyPath: keyPath] }
+    }
+    
+    subscript<Property: Sendable>(dynamicMember keyPath: WritableKeyPath<State, Property>) -> Property {
+        get {
+            state.withLockedValue { $0[keyPath: keyPath] }
+        }
+        set {
+            state.withLockedValue { $0[keyPath: keyPath] = newValue }
+        }
+    }
 
     init(
         head: NIOHTTP1.HTTPRequestHead = .init(version: .http1_1, method: .GET, uri: "http://localhost/"),
@@ -86,8 +121,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
         file: StaticString = #file,
         line: UInt = #line
     ) {
-        self.requestHead = head
-        self.requestFramingMetadata = framingMetadata
+        self.state = .init(.init(requestHead: head, requestFramingMetadata: framingMetadata))
         self.file = file
         self.line = line
     }
@@ -99,7 +133,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
 
     func willExecuteRequest(_ executor: HTTPRequestExecutor) {
         self.events.append(.willExecuteRequest(executor))
-        guard let willExecuteRequestCallback = willExecuteRequestCallback else {
+        guard let willExecuteRequestCallback = self.willExecuteRequestCallback else {
             return self.calledUnimplementedMethod(#function)
         }
         willExecuteRequestCallback(executor)
@@ -107,7 +141,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
 
     func requestHeadSent() {
         self.events.append(.requestHeadSent)
-        guard let requestHeadSentCallback = requestHeadSentCallback else {
+        guard let requestHeadSentCallback = self.requestHeadSentCallback else {
             return self.calledUnimplementedMethod(#function)
         }
         requestHeadSentCallback()
@@ -115,7 +149,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
 
     func resumeRequestBodyStream() {
         self.events.append(.resumeRequestBodyStream)
-        guard let resumeRequestBodyStreamCallback = resumeRequestBodyStreamCallback else {
+        guard let resumeRequestBodyStreamCallback = self.resumeRequestBodyStreamCallback else {
             return self.calledUnimplementedMethod(#function)
         }
         resumeRequestBodyStreamCallback()
@@ -123,7 +157,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
 
     func pauseRequestBodyStream() {
         self.events.append(.pauseRequestBodyStream)
-        guard let pauseRequestBodyStreamCallback = pauseRequestBodyStreamCallback else {
+        guard let pauseRequestBodyStreamCallback = self.pauseRequestBodyStreamCallback else {
             return self.calledUnimplementedMethod(#function)
         }
         pauseRequestBodyStreamCallback()
@@ -131,7 +165,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
 
     func receiveResponseHead(_ head: HTTPResponseHead) {
         self.events.append(.receiveResponseHead(head))
-        guard let receiveResponseHeadCallback = receiveResponseHeadCallback else {
+        guard let receiveResponseHeadCallback = self.receiveResponseHeadCallback else {
             return self.calledUnimplementedMethod(#function)
         }
         receiveResponseHeadCallback(head)
@@ -139,7 +173,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
 
     func receiveResponseBodyParts(_ buffer: CircularBuffer<NIOCore.ByteBuffer>) {
         self.events.append(.receiveResponseBodyParts(buffer))
-        guard let receiveResponseBodyPartsCallback = receiveResponseBodyPartsCallback else {
+        guard let receiveResponseBodyPartsCallback = self.receiveResponseBodyPartsCallback else {
             return self.calledUnimplementedMethod(#function)
         }
         receiveResponseBodyPartsCallback(buffer)
@@ -147,7 +181,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
 
     func succeedRequest(_ buffer: CircularBuffer<NIOCore.ByteBuffer>?) {
         self.events.append(.succeedRequest(buffer))
-        guard let succeedRequestCallback = succeedRequestCallback else {
+        guard let succeedRequestCallback = self.succeedRequestCallback else {
             return self.calledUnimplementedMethod(#function)
         }
         succeedRequestCallback(buffer)
@@ -155,7 +189,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
 
     func fail(_ error: Error) {
         self.events.append(.fail(error))
-        guard let failCallback = failCallback else {
+        guard let failCallback = self.failCallback else {
             return self.calledUnimplementedMethod(#function)
         }
         failCallback(error)
diff --git a/Tests/AsyncHTTPClientTests/Mocks/MockRequestExecutor.swift b/Tests/AsyncHTTPClientTests/Mocks/MockRequestExecutor.swift
index b37ce8fa3..ec7553d5b 100644
--- a/Tests/AsyncHTTPClientTests/Mocks/MockRequestExecutor.swift
+++ b/Tests/AsyncHTTPClientTests/Mocks/MockRequestExecutor.swift
@@ -17,7 +17,7 @@ import NIOConcurrencyHelpers
 import NIOCore
 
 // This is a MockRequestExecutor, that is synchronized on its EventLoop.
-final class MockRequestExecutor {
+final class MockRequestExecutor: @unchecked Sendable {
     enum Errors: Error {
         case eof
         case unexpectedFileRegion
@@ -241,7 +241,7 @@ extension MockRequestExecutor: HTTPRequestExecutor {
 extension MockRequestExecutor {
     public struct TimeoutError: Error {}
 
-    final class BlockingQueue<Element> {
+    final class BlockingQueue<Element>: @unchecked Sendable {
         private let condition = ConditionLock(value: false)
         private var buffer = CircularBuffer<Result<Element, Error>>()
 
diff --git a/Tests/AsyncHTTPClientTests/RequestBagTests.swift b/Tests/AsyncHTTPClientTests/RequestBagTests.swift
index 75d57ba26..4c8163a6d 100644
--- a/Tests/AsyncHTTPClientTests/RequestBagTests.swift
+++ b/Tests/AsyncHTTPClientTests/RequestBagTests.swift
@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Atomics
 @testable import AsyncHTTPClient
 import Logging
 import NIOCore
@@ -961,13 +962,12 @@ class UploadCountingDelegate: HTTPClientResponseDelegate {
     }
 }
 
-class MockTaskQueuer: HTTPRequestScheduler {
-    private(set) var hitCancelCount = 0
-
-    init() {}
+final class  MockTaskQueuer: HTTPRequestScheduler {
+    private let _hitCancelCount = ManagedAtomic(0)
+    var hitCancelCount: Int { _hitCancelCount.load(ordering: .relaxed) }
 
     func cancelRequest(_: HTTPSchedulableRequest) {
-        self.hitCancelCount += 1
+        self._hitCancelCount.wrappingIncrement(ordering: .relaxed)
     }
 }
 
diff --git a/Tests/AsyncHTTPClientTests/SOCKSEventsHandlerTests.swift b/Tests/AsyncHTTPClientTests/SOCKSEventsHandlerTests.swift
index 066a631a5..bb7b3ca06 100644
--- a/Tests/AsyncHTTPClientTests/SOCKSEventsHandlerTests.swift
+++ b/Tests/AsyncHTTPClientTests/SOCKSEventsHandlerTests.swift
@@ -28,7 +28,7 @@ class SOCKSEventsHandlerTests: XCTestCase {
         XCTAssertNoThrow(try embedded.connect(to: .makeAddressResolvingHost("localhost", port: 0)).wait())
 
         embedded.pipeline.fireUserInboundEventTriggered(SOCKSProxyEstablishedEvent())
-        XCTAssertNoThrow(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wait())
+        XCTAssertNoThrow(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wrapped.wait())
     }
 
     func testHandlerFailsFutureWhenRemovedWithoutEvent() {
@@ -38,7 +38,7 @@ class SOCKSEventsHandlerTests: XCTestCase {
         XCTAssertNotNil(socksEventsHandler.socksEstablishedFuture)
 
         XCTAssertNoThrow(try embedded.pipeline.removeHandler(socksEventsHandler).wait())
-        XCTAssertThrowsError(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wait())
+        XCTAssertThrowsError(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wrapped.wait())
     }
 
     func testHandlerFailsFutureWhenHandshakeFails() {
@@ -49,7 +49,7 @@ class SOCKSEventsHandlerTests: XCTestCase {
 
         let error = SOCKSError.InvalidReservedByte(actual: 19)
         embedded.pipeline.fireErrorCaught(error)
-        XCTAssertThrowsError(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wait()) {
+        XCTAssertThrowsError(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wrapped.wait()) {
             XCTAssertEqual($0 as? SOCKSError.InvalidReservedByte, error)
         }
     }
@@ -65,7 +65,7 @@ class SOCKSEventsHandlerTests: XCTestCase {
 
         embedded.embeddedEventLoop.advanceTime(by: .milliseconds(20))
 
-        XCTAssertThrowsError(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wait()) {
+        XCTAssertThrowsError(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wrapped.wait()) {
             XCTAssertEqual($0 as? HTTPClientError, .socksHandshakeTimeout)
         }
         XCTAssertFalse(embedded.isActive, "The timeout shall close the connection")
@@ -82,7 +82,7 @@ class SOCKSEventsHandlerTests: XCTestCase {
 
         // schedules execute only on the next tick
         embedded.embeddedEventLoop.run()
-        XCTAssertThrowsError(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wait()) {
+        XCTAssertThrowsError(try XCTUnwrap(socksEventsHandler.socksEstablishedFuture).wrapped.wait()) {
             XCTAssertEqual($0 as? HTTPClientError, .socksHandshakeTimeout)
         }
         XCTAssertFalse(embedded.isActive, "The timeout shall close the connection")
diff --git a/Tests/AsyncHTTPClientTests/TLSEventsHandlerTests.swift b/Tests/AsyncHTTPClientTests/TLSEventsHandlerTests.swift
index c119c7e50..0fc3d51b9 100644
--- a/Tests/AsyncHTTPClientTests/TLSEventsHandlerTests.swift
+++ b/Tests/AsyncHTTPClientTests/TLSEventsHandlerTests.swift
@@ -29,7 +29,7 @@ class TLSEventsHandlerTests: XCTestCase {
         XCTAssertNoThrow(try embedded.connect(to: .makeAddressResolvingHost("localhost", port: 0)).wait())
 
         embedded.pipeline.fireUserInboundEventTriggered(TLSUserEvent.handshakeCompleted(negotiatedProtocol: "abcd1234"))
-        XCTAssertEqual(try XCTUnwrap(tlsEventsHandler.tlsEstablishedFuture).wait(), "abcd1234")
+        XCTAssertEqual(try XCTUnwrap(tlsEventsHandler.tlsEstablishedFuture).wrapped.wait(), "abcd1234")
     }
 
     func testHandlerFailsFutureWhenRemovedWithoutEvent() {
@@ -39,7 +39,7 @@ class TLSEventsHandlerTests: XCTestCase {
         XCTAssertNotNil(tlsEventsHandler.tlsEstablishedFuture)
 
         XCTAssertNoThrow(try embedded.pipeline.removeHandler(tlsEventsHandler).wait())
-        XCTAssertThrowsError(try XCTUnwrap(tlsEventsHandler.tlsEstablishedFuture).wait())
+        XCTAssertThrowsError(try XCTUnwrap(tlsEventsHandler.tlsEstablishedFuture).wrapped.wait())
     }
 
     func testHandlerFailsFutureWhenHandshakeFails() {
@@ -49,7 +49,7 @@ class TLSEventsHandlerTests: XCTestCase {
         XCTAssertNotNil(tlsEventsHandler.tlsEstablishedFuture)
 
         embedded.pipeline.fireErrorCaught(NIOSSLError.handshakeFailed(BoringSSLError.wantConnect))
-        XCTAssertThrowsError(try XCTUnwrap(tlsEventsHandler.tlsEstablishedFuture).wait()) {
+        XCTAssertThrowsError(try XCTUnwrap(tlsEventsHandler.tlsEstablishedFuture).wrapped.wait()) {
             XCTAssertEqual($0 as? NIOSSLError, .handshakeFailed(BoringSSLError.wantConnect))
         }
     }
@@ -66,6 +66,6 @@ class TLSEventsHandlerTests: XCTestCase {
         embedded.pipeline.fireUserInboundEventTriggered(TLSUserEvent.shutdownCompleted)
 
         embedded.pipeline.fireUserInboundEventTriggered(TLSUserEvent.handshakeCompleted(negotiatedProtocol: "alpn"))
-        XCTAssertEqual(try XCTUnwrap(tlsEventsHandler.tlsEstablishedFuture).wait(), "alpn")
+        XCTAssertEqual(try XCTUnwrap(tlsEventsHandler.tlsEstablishedFuture).wrapped.wait(), "alpn")
     }
 }