LCLPing – Build Information – Swift Package Index

Has it really been five years since Swift Package Index launched? Read our anniversary blog post!

Build Information

Successful build of LCLPing, reference 1.0.4 (436006), with Swift 6.1 for Android on 30 May 2025 18:43:55 UTC.

Swift 6 data race errors: 1

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4609320-0":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:android-6.1-latest swift build --swift-sdk aarch64-unknown-linux-android24 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures 2>&1

Build Log

[662/745] Compiling curve25519.cc
[663/745] Compiling cpu_arm_freebsd.cc
[664/745] Compiling cpu_aarch64_win.cc
[665/745] Compiling cpu_aarch64_sysreg.cc
[666/745] Compiling cpu_aarch64_linux.cc
[667/745] Compiling cpu_aarch64_openbsd.cc
[668/745] Compiling cpu_aarch64_fuchsia.cc
[669/745] Compiling cpu_aarch64_apple.cc
[670/745] Compiling conf.cc
[671/745] Compiling tls_cbc.cc
[672/745] Compiling get_cipher.cc
[673/745] Compiling e_null.cc
[674/745] Compiling e_rc2.cc
[675/745] Compiling e_tls.cc
[676/745] Compiling e_rc4.cc
[677/745] Compiling e_des.cc
[678/745] Compiling e_aesgcmsiv.cc
[679/745] Compiling e_aesctrhmac.cc
[680/745] Compiling derive_key.cc
[681/745] Compiling e_chacha20poly1305.cc
[682/745] Compiling chacha.cc
[683/745] Compiling cbb.cc
[684/745] Compiling unicode.cc
[685/745] Compiling cbs.cc
[686/745] Compiling buf.cc
[687/745] Compiling ber.cc
[688/745] Compiling asn1_compat.cc
[689/745] Compiling convert.cc
[690/745] Compiling blake2.cc
[691/745] Compiling socket_helper.cc
[692/745] Compiling bn_asn1.cc
[693/745] Compiling printf.cc
[694/745] Compiling socket.cc
[695/745] Compiling pair.cc
[696/745] Compiling file.cc
[697/745] Compiling hexdump.cc
[698/745] Compiling errno.cc
[699/745] Compiling fd.cc
[700/745] Compiling connect.cc
[701/745] Compiling bio_mem.cc
[702/745] Compiling bio.cc
[703/745] Compiling base64.cc
[704/745] Compiling tasn_typ.cc
[705/745] Compiling tasn_new.cc
[706/745] Compiling tasn_fre.cc
[707/745] Compiling tasn_utl.cc
[708/745] Compiling posix_time.cc
[709/745] Compiling tasn_enc.cc
[710/745] Compiling tasn_dec.cc
[711/745] Compiling f_string.cc
[712/745] Compiling f_int.cc
[713/745] Compiling asn_pack.cc
[714/745] Compiling asn1_par.cc
[715/745] Compiling a_octet.cc
[716/745] Compiling asn1_lib.cc
[717/745] Compiling a_strnid.cc
[718/745] Compiling a_strex.cc
[719/745] Compiling a_time.cc
[720/745] Write sources
[721/745] Compiling a_utctm.cc
[722/745] Write sources
[723/811] Compiling a_object.cc
[724/817] Compiling a_i2d_fp.cc
[725/817] Compiling a_int.cc
[726/817] Compiling a_mbstr.cc
[728/817] Compiling Atomics UnsafeAtomic.swift
[729/817] Compiling Atomics UnsafeAtomicLazyReference.swift
[730/819] Compiling Atomics ManagedAtomic.swift
[731/819] Compiling Atomics ManagedAtomicLazyReference.swift
[732/819] Compiling Atomics AtomicMemoryOrderings.swift
[733/819] Compiling Atomics DoubleWord.swift
[734/819] Compiling Atomics Primitives.shims.swift
[735/819] Compiling Atomics AtomicInteger.swift
[736/819] Compiling Atomics AtomicOptionalWrappable.swift
[737/819] Compiling Atomics AtomicReference.swift
[738/819] Compiling Atomics AtomicStorage.swift
[739/819] Compiling Atomics AtomicValue.swift
[740/819] Compiling BitCollections BitSet+CustomDebugStringConvertible.swift
[741/819] Compiling BitCollections BitSet+CustomReflectable.swift
[742/819] Compiling BitCollections BitSet+CustomStringConvertible.swift
[743/819] Compiling BitCollections BitSet+Equatable.swift
[744/819] Compiling BitCollections BitSet+ExpressibleByArrayLiteral.swift
[745/819] Compiling BitCollections BitSet+Extras.swift
[746/819] Compiling BitCollections BitSet+Hashable.swift
[747/819] Compiling BitCollections BitSet+Initializers.swift
[748/819] Compiling BitCollections BitSet+Invariants.swift
[749/819] Compiling BitCollections BitSet+Random.swift
[750/819] Compiling BitCollections BitSet+SetAlgebra basics.swift
[751/819] Compiling BitCollections BitSet+SetAlgebra conformance.swift
[752/819] Compiling BitCollections BitSet+SetAlgebra formIntersection.swift
[753/819] Compiling BitCollections BitSet+SetAlgebra formSymmetricDifference.swift
[754/826] Compiling BitCollections BitSet+SetAlgebra formUnion.swift
[755/826] Compiling BitCollections BitSet+SetAlgebra intersection.swift
[756/826] Compiling BitCollections BitSet+SetAlgebra isDisjoint.swift
[757/826] Compiling BitCollections BitSet+SetAlgebra isEqualSet.swift
[758/826] Compiling BitCollections BitSet+SetAlgebra isStrictSubset.swift
[759/826] Compiling BitCollections BitSet+SetAlgebra isStrictSuperset.swift
[760/826] Compiling BitCollections BitSet+SetAlgebra isSubset.swift
[761/826] Compiling BitCollections BitSet+SetAlgebra isSuperset.swift
[762/826] Compiling BitCollections BitSet+SetAlgebra subtract.swift
[763/826] Compiling BitCollections BitSet+SetAlgebra subtracting.swift
[764/826] Compiling BitCollections BitSet+SetAlgebra symmetricDifference.swift
[765/826] Compiling BitCollections BitSet+SetAlgebra union.swift
[766/826] Compiling BitCollections BitSet+Sorted Collection APIs.swift
[767/826] Compiling BitCollections BitSet.Counted.swift
[768/826] Compiling Atomics IntegerOperations.swift
[769/826] Compiling Atomics Unmanaged extensions.swift
[770/826] Compiling Atomics OptionalRawRepresentable.swift
[771/826] Compiling Atomics RawRepresentable.swift
[772/826] Compiling Atomics AtomicBool.swift
[773/826] Compiling Atomics IntegerConformances.swift
[774/826] Compiling Atomics PointerConformances.swift
[775/826] Compiling Atomics Primitives.native.swift
[778/826] Emitting module BitCollections
[791/826] Compiling BitCollections BitArray._UnsafeHandle.swift
[792/826] Compiling BitCollections BitArray.swift
[793/826] Compiling BitCollections BitSet+BidirectionalCollection.swift
[794/826] Compiling BitCollections BitSet+Codable.swift
[795/826] Compiling BitCollections BitSet.Index.swift
[796/826] Compiling BitCollections BitSet._UnsafeHandle.swift
[797/826] Compiling BitCollections BitSet.swift
[798/826] Compiling BitCollections Range+Utilities.swift
[799/826] Compiling BitCollections Slice+Utilities.swift
[800/826] Compiling BitCollections UInt+Tricks.swift
[801/826] Compiling BitCollections _Word.swift
[803/827] Emitting module Atomics
[803/829] Wrapping AST for BitCollections for debugging
[804/829] Compiling c-nioatomics.c
[806/829] Compiling Collections Collections.swift
[807/829] Emitting module Collections
[807/830] Compiling c-atomics.c
[815/837] Wrapping AST for Collections for debugging
[817/837] Wrapping AST for Atomics for debugging
[819/837] Compiling NIOConcurrencyHelpers lock.swift
[820/837] Compiling NIOConcurrencyHelpers NIOLockedValueBox.swift
[821/837] Compiling NIOConcurrencyHelpers NIOLock.swift
[822/837] Emitting module NIOConcurrencyHelpers
[823/837] Compiling NIOConcurrencyHelpers atomics.swift
[824/837] Compiling NIOConcurrencyHelpers NIOAtomic.swift
[825/838] Wrapping AST for NIOConcurrencyHelpers for debugging
[827/898] Compiling NIOCore IO.swift
[828/898] Compiling NIOCore IOData.swift
[829/898] Compiling NIOCore IPProtocol.swift
[830/898] Compiling NIOCore IntegerBitPacking.swift
[831/898] Compiling NIOCore IntegerTypes.swift
[832/898] Compiling NIOCore Interfaces.swift
[833/898] Compiling NIOCore Linux.swift
[834/898] Compiling NIOCore MarkedCircularBuffer.swift
[835/906] Compiling NIOCore MulticastChannel.swift
[836/906] Compiling NIOCore NIOAny.swift
[837/906] Compiling NIOCore NIOCloseOnErrorHandler.swift
[838/906] Compiling NIOCore NIOLoopBound.swift
[839/906] Compiling NIOCore NIOPooledRecvBufferAllocator.swift
[840/906] Compiling NIOCore NIOScheduledCallback.swift
[841/906] Compiling NIOCore NIOSendable.swift
[842/906] Compiling NIOCore RecvByteBufferAllocator.swift
[843/906] Compiling NIOCore EventLoopFuture+AssumeIsolated.swift
[844/906] Compiling NIOCore EventLoopFuture+Deprecated.swift
[845/906] Compiling NIOCore EventLoopFuture+WithEventLoop.swift
[846/906] Compiling NIOCore EventLoopFuture.swift
[847/906] Compiling NIOCore FileDescriptor.swift
[848/906] Compiling NIOCore FileHandle.swift
[849/906] Compiling NIOCore FileRegion.swift
[850/906] Compiling NIOCore GlobalSingletons.swift
[851/906] Compiling NIOCore CircularBuffer.swift
[852/906] Compiling NIOCore Codec.swift
[853/906] Compiling NIOCore ConvenienceOptionSupport.swift
[854/906] Compiling NIOCore DeadChannel.swift
[855/906] Compiling NIOCore DispatchQueue+WithFuture.swift
[856/906] Compiling NIOCore EventLoop+Deprecated.swift
[857/906] Compiling NIOCore EventLoop+SerialExecutor.swift
[858/906] Compiling NIOCore EventLoop.swift
[859/906] Compiling NIOCore NIOThrowingAsyncSequenceProducer.swift
[860/906] Compiling NIOCore BSDSocketAPI.swift
[861/906] Compiling NIOCore ByteBuffer-aux.swift
[862/906] Compiling NIOCore ByteBuffer-binaryEncodedLengthPrefix.swift
[863/906] Compiling NIOCore ByteBuffer-conversions.swift
[864/906] Compiling NIOCore ByteBuffer-core.swift
[865/906] Compiling NIOCore ByteBuffer-hex.swift
[866/906] Compiling NIOCore ByteBuffer-int.swift
[867/906] Compiling NIOCore ByteBuffer-lengthPrefix.swift
[868/906] Compiling NIOCore AddressedEnvelope.swift
[869/906] Compiling NIOCore AsyncAwaitSupport.swift
[870/906] Compiling NIOCore AsyncChannel.swift
[871/906] Compiling NIOCore AsyncChannelHandler.swift
[872/906] Compiling NIOCore AsyncChannelInboundStream.swift
[873/906] Compiling NIOCore AsyncChannelOutboundWriter.swift
[874/906] Compiling NIOCore NIOAsyncSequenceProducer.swift
[875/906] Compiling NIOCore NIOAsyncSequenceProducerStrategies.swift
[876/906] Compiling NIOCore NIOAsyncWriter.swift
[877/906] Compiling NIOCore SingleStepByteToMessageDecoder.swift
[878/906] Compiling NIOCore SocketAddresses.swift
[879/906] Compiling NIOCore SocketOptionProvider.swift
[880/906] Compiling NIOCore SystemCallHelpers.swift
[881/906] Compiling NIOCore TimeAmount+Duration.swift
[882/906] Compiling NIOCore TypeAssistedChannelHandler.swift
[883/906] Compiling NIOCore UniversalBootstrapSupport.swift
[884/906] Compiling NIOCore Utilities.swift
[885/906] Compiling NIOCore ByteBuffer-multi-int.swift
[886/906] Compiling NIOCore ByteBuffer-quicBinaryEncodingStrategy.swift
[887/906] Compiling NIOCore ByteBuffer-views.swift
[888/906] Compiling NIOCore Channel.swift
[889/906] Compiling NIOCore ChannelHandler.swift
[890/906] Compiling NIOCore ChannelHandlers.swift
[891/906] Compiling NIOCore ChannelInvoker.swift
[892/906] Compiling NIOCore ChannelOption.swift
[893/906] Compiling NIOCore ChannelPipeline.swift
[894/906] Emitting module NIOCore
[895/907] Wrapping AST for NIOCore for debugging
[897/957] Emitting module NIOEmbedded
[898/957] Compiling NIOEmbedded AsyncTestingEventLoop.swift
[899/957] Compiling NIOEmbedded AsyncTestingChannel.swift
[900/957] Compiling NIOEmbedded Embedded.swift
[901/958] Wrapping AST for NIOEmbedded for debugging
[903/958] Compiling NIOPosix Pool.swift
[904/958] Compiling NIOPosix PosixSingletons+ConcurrencyTakeOver.swift
[905/958] Compiling NIOPosix PosixSingletons.swift
[906/958] Compiling NIOPosix RawSocketBootstrap.swift
[907/958] Compiling NIOPosix Resolver.swift
[908/958] Compiling NIOPosix Selectable.swift
[909/958] Compiling NIOPosix SelectableChannel.swift
[910/958] Compiling NIOPosix SelectableEventLoop.swift
[911/958] Compiling NIOPosix SelectorEpoll.swift
[912/958] Compiling NIOPosix SelectorGeneric.swift
[913/958] Compiling NIOPosix SelectorKqueue.swift
[914/958] Compiling NIOPosix SelectorUring.swift
[915/958] Compiling NIOPosix ServerSocket.swift
[916/958] Compiling NIOPosix Socket.swift
[917/958] Compiling NIOPosix SocketChannel.swift
[918/958] Compiling NIOPosix SocketProtocols.swift
[919/958] Compiling NIOPosix System.swift
[920/958] Compiling NIOPosix Thread.swift
[921/964] Compiling NIOPosix IO.swift
[922/964] Compiling NIOPosix IntegerBitPacking.swift
[923/964] Compiling NIOPosix IntegerTypes.swift
[924/964] Compiling NIOPosix Linux.swift
[925/964] Compiling NIOPosix LinuxCPUSet.swift
[926/964] Compiling NIOPosix LinuxUring.swift
[927/964] Compiling NIOPosix MultiThreadedEventLoopGroup.swift
[928/964] Compiling NIOPosix NIOThreadPool.swift
[929/964] Compiling NIOPosix NonBlockingFileIO.swift
[930/964] Compiling NIOPosix PendingDatagramWritesManager.swift
[931/964] Compiling NIOPosix PendingWritesManager.swift
[932/964] Compiling NIOPosix PipeChannel.swift
[933/964] Compiling NIOPosix PipePair.swift
[934/964] Compiling NIOPosix BSDSocketAPICommon.swift
[935/964] Compiling NIOPosix BSDSocketAPIPosix.swift
[936/964] Compiling NIOPosix BSDSocketAPIWindows.swift
[937/964] Compiling NIOPosix BaseSocket.swift
[938/964] Compiling NIOPosix BaseSocketChannel+SocketOptionProvider.swift
[939/964] Compiling NIOPosix BaseSocketChannel.swift
[940/964] Compiling NIOPosix BaseStreamSocketChannel.swift
[941/964] Compiling NIOPosix Bootstrap.swift
[942/964] Compiling NIOPosix ControlMessage.swift
[943/964] Compiling NIOPosix DatagramVectorReadManager.swift
[944/964] Compiling NIOPosix Errors+Any.swift
[945/964] Compiling NIOPosix FileDescriptor.swift
[946/964] Compiling NIOPosix GetaddrinfoResolver.swift
[947/964] Compiling NIOPosix HappyEyeballs.swift
[948/964] Emitting module NIOPosix
[949/964] Compiling NIOPosix ThreadPosix.swift
[950/964] Compiling NIOPosix ThreadWindows.swift
[951/964] Compiling NIOPosix UnsafeTransfer.swift
[952/964] Compiling NIOPosix Utilities.swift
[953/964] Compiling NIOPosix VsockAddress.swift
[954/964] Compiling NIOPosix VsockChannelEvents.swift
[955/965] Wrapping AST for NIOPosix for debugging
[957/967] Compiling NIO Exports.swift
[958/967] Emitting module NIO
[959/968] Wrapping AST for NIO for debugging
[961/990] Compiling NIOTLS TLSEvents.swift
[962/990] Compiling NIOTLS NIOTypedApplicationProtocolNegotiationHandler.swift
[963/990] Emitting module NIOTLS
[964/990] Compiling NIOTLS ApplicationProtocolNegotiationHandler.swift
[965/990] Compiling NIOTLS ProtocolNegotiationHandlerStateMachine.swift
[966/990] Compiling NIOTLS SNIHandler.swift
[967/991] Wrapping AST for NIOTLS for debugging
[969/991] Compiling NIOHTTP1 NIOTypedHTTPClientUpgradeHandler.swift
[970/991] Compiling NIOHTTP1 NIOTypedHTTPClientUpgraderStateMachine.swift
[971/1022] Compiling NIOSSL SSLConnection.swift
[972/1022] Compiling NIOSSL NIOSSLServerHandler.swift
[973/1022] Compiling NIOSSL IdentityVerification.swift
[974/1022] Compiling NIOSSL SSLCertificate.swift
[975/1022] Compiling NIOSSL ByteBufferBIO.swift
[976/1022] Compiling NIOSSL CustomPrivateKey.swift
[977/1022] Compiling NIOSSL SSLCertificateExtensions.swift
[978/1022] Compiling NIOSSL SSLCertificateName.swift
[979/1022] Compiling NIOSSL NIOSSLHandler.swift
[980/1022] Compiling NIOSSL AndroidCABundle.swift
[981/1022] Compiling NIOSSL SSLCallbacks.swift
[982/1022] Compiling NIOSSL SSLPrivateKey.swift
[983/1022] Emitting module NIOHTTP1
[984/1022] Compiling NIOSSL LinuxCABundle.swift
[985/1022] Compiling NIOSSL NIOSSLClientHandler.swift
[986/1022] Compiling NIOSSL NIOSSLHandler+Configuration.swift
[987/1023] Wrapping AST for NIOHTTP1 for debugging
[989/1027] Compiling NIOSSL SubjectAlternativeName.swift
[990/1027] Compiling NIOSSL NIOSSLSecureBytes.swift
[991/1027] Compiling NIOSSL RNG.swift
[992/1027] Compiling NIOSSL SafeCompare.swift
[994/1031] Compiling NIOSSL SSLPublicKey.swift
[995/1031] Compiling NIOSSL SecurityFrameworkCertificateVerification.swift
[996/1031] Compiling NIOSSL String+unsafeUninitializedCapacity.swift
[1001/1031] Compiling NIOTestUtils ByteToMessageDecoderVerifier.swift
[1002/1031] Emitting module NIOTestUtils
[1003/1031] Emitting module NIOSSL
[1008/1031] Compiling NIOTestUtils NIOHTTP1TestServer.swift
[1009/1031] Compiling NIOTestUtils EventCounterHandler.swift
[1011/1032] Compiling NIOSSL SSLContext.swift
[1012/1032] Compiling NIOSSL SSLErrors.swift
[1013/1032] Compiling NIOSSL SSLInit.swift
[1014/1032] Compiling NIOSSL SSLPKCS12Bundle.swift
[1014/1032] Wrapping AST for NIOTestUtils for debugging
[1017/1032] Compiling NIOSSL ObjectIdentifier.swift
[1018/1032] Compiling NIOSSL PosixPort.swift
[1024/1032] Compiling NIOSSL Zeroization.swift
[1025/1032] Compiling NIOSSL TLSConfiguration.swift
[1026/1032] Compiling NIOSSL UniversalBootstrapSupport.swift
[1027/1032] Compiling NIOSSL UnsafeKeyAndChainTarget.swift
[1028/1033] Wrapping AST for NIOSSL for debugging
[1030/1062] Emitting module LCLPing
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:83:16: warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
    :
 81 |
 82 |     /// An empty summary.
 83 |     static let empty = PingSummary(
    |                |- warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: add '@MainActor' to make static property 'empty' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 |         min: .zero,
 85 |         max: .zero,
[1031/1066] Compiling LCLPing LCLPing+Time.swift
[1032/1066] Compiling LCLPing LCLPing+TimeInterval.swift
[1033/1066] Compiling LCLPing ObjectDecoder.swift
[1034/1066] Compiling LCLPing Utilities.swift
[1035/1066] Compiling LCLPing Configuration.swift
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:86:13: warning: capture of 'self' with non-sendable type 'HTTPTracingHandler' in a '@Sendable' closure
 17 | import NIOHTTP1
 18 |
 19 | internal final class HTTPTracingHandler: ChannelDuplexHandler {
    |                      `- note: class 'HTTPTracingHandler' does not conform to the 'Sendable' protocol
 20 |     typealias InboundIn = HTTPClientResponsePart
 21 |     typealias InboundOut = PingResponse
    :
 84 |         self.handler.handleWrite(request: request)
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
    |             `- warning: capture of 'self' with non-sendable type 'HTTPTracingHandler' in a '@Sendable' closure
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:87:67: warning: capture of 'request' with non-sendable type 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') in a '@Sendable' closure
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
    |                                                                   `- warning: capture of 'request' with non-sendable type 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') in a '@Sendable' closure
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
 89 |         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:87:67: warning: implicit capture of 'request' requires that 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') conforms to 'Sendable'; this is an error in the Swift 6 language mode
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
    |                                                                   `- warning: implicit capture of 'request' requires that 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') conforms to 'Sendable'; this is an error in the Swift 6 language mode
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
 89 |         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:93:21: warning: capture of 'self' with non-sendable type 'HTTPPingClient' in a '@Sendable' closure
 22 | /// Caller needs to provide a configuration that set the way the HTTP client initiates tests.
 23 | /// Caller can cancel the test via `cancel()`.
 24 | public final class HTTPPingClient: Pingable {
    |                    `- note: class 'HTTPPingClient' does not conform to the 'Sendable' protocol
 25 |
 26 |     private enum State {
    :
 91 |                 state = .running
 92 |                 return try self.pingClient.start().always { _ in
 93 |                     self.state.withLockedValue { state in
    |                     `- warning: capture of 'self' with non-sendable type 'HTTPPingClient' in a '@Sendable' closure
 94 |                         state = .idle
 95 |                     }
[1036/1066] Compiling LCLPing HTTPChannelHandlers.swift
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:86:13: warning: capture of 'self' with non-sendable type 'HTTPTracingHandler' in a '@Sendable' closure
 17 | import NIOHTTP1
 18 |
 19 | internal final class HTTPTracingHandler: ChannelDuplexHandler {
    |                      `- note: class 'HTTPTracingHandler' does not conform to the 'Sendable' protocol
 20 |     typealias InboundIn = HTTPClientResponsePart
 21 |     typealias InboundOut = PingResponse
    :
 84 |         self.handler.handleWrite(request: request)
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
    |             `- warning: capture of 'self' with non-sendable type 'HTTPTracingHandler' in a '@Sendable' closure
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:87:67: warning: capture of 'request' with non-sendable type 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') in a '@Sendable' closure
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
    |                                                                   `- warning: capture of 'request' with non-sendable type 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') in a '@Sendable' closure
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
 89 |         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:87:67: warning: implicit capture of 'request' requires that 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') conforms to 'Sendable'; this is an error in the Swift 6 language mode
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
    |                                                                   `- warning: implicit capture of 'request' requires that 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') conforms to 'Sendable'; this is an error in the Swift 6 language mode
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
 89 |         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:93:21: warning: capture of 'self' with non-sendable type 'HTTPPingClient' in a '@Sendable' closure
 22 | /// Caller needs to provide a configuration that set the way the HTTP client initiates tests.
 23 | /// Caller can cancel the test via `cancel()`.
 24 | public final class HTTPPingClient: Pingable {
    |                    `- note: class 'HTTPPingClient' does not conform to the 'Sendable' protocol
 25 |
 26 |     private enum State {
    :
 91 |                 state = .running
 92 |                 return try self.pingClient.start().always { _ in
 93 |                     self.state.withLockedValue { state in
    |                     `- warning: capture of 'self' with non-sendable type 'HTTPPingClient' in a '@Sendable' closure
 94 |                         state = .idle
 95 |                     }
[1037/1066] Compiling LCLPing HTTPHandler.swift
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:86:13: warning: capture of 'self' with non-sendable type 'HTTPTracingHandler' in a '@Sendable' closure
 17 | import NIOHTTP1
 18 |
 19 | internal final class HTTPTracingHandler: ChannelDuplexHandler {
    |                      `- note: class 'HTTPTracingHandler' does not conform to the 'Sendable' protocol
 20 |     typealias InboundIn = HTTPClientResponsePart
 21 |     typealias InboundOut = PingResponse
    :
 84 |         self.handler.handleWrite(request: request)
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
    |             `- warning: capture of 'self' with non-sendable type 'HTTPTracingHandler' in a '@Sendable' closure
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:87:67: warning: capture of 'request' with non-sendable type 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') in a '@Sendable' closure
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
    |                                                                   `- warning: capture of 'request' with non-sendable type 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') in a '@Sendable' closure
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
 89 |         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:87:67: warning: implicit capture of 'request' requires that 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') conforms to 'Sendable'; this is an error in the Swift 6 language mode
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
    |                                                                   `- warning: implicit capture of 'request' requires that 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') conforms to 'Sendable'; this is an error in the Swift 6 language mode
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
 89 |         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:93:21: warning: capture of 'self' with non-sendable type 'HTTPPingClient' in a '@Sendable' closure
 22 | /// Caller needs to provide a configuration that set the way the HTTP client initiates tests.
 23 | /// Caller can cancel the test via `cancel()`.
 24 | public final class HTTPPingClient: Pingable {
    |                    `- note: class 'HTTPPingClient' does not conform to the 'Sendable' protocol
 25 |
 26 |     private enum State {
    :
 91 |                 state = .running
 92 |                 return try self.pingClient.start().always { _ in
 93 |                     self.state.withLockedValue { state in
    |                     `- warning: capture of 'self' with non-sendable type 'HTTPPingClient' in a '@Sendable' closure
 94 |                         state = .idle
 95 |                     }
[1038/1066] Compiling LCLPing HTTPPingClient.swift
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:86:13: warning: capture of 'self' with non-sendable type 'HTTPTracingHandler' in a '@Sendable' closure
 17 | import NIOHTTP1
 18 |
 19 | internal final class HTTPTracingHandler: ChannelDuplexHandler {
    |                      `- note: class 'HTTPTracingHandler' does not conform to the 'Sendable' protocol
 20 |     typealias InboundIn = HTTPClientResponsePart
 21 |     typealias InboundOut = PingResponse
    :
 84 |         self.handler.handleWrite(request: request)
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
    |             `- warning: capture of 'self' with non-sendable type 'HTTPTracingHandler' in a '@Sendable' closure
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:87:67: warning: capture of 'request' with non-sendable type 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') in a '@Sendable' closure
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
    |                                                                   `- warning: capture of 'request' with non-sendable type 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') in a '@Sendable' closure
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
 89 |         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPChannelHandlers.swift:87:67: warning: implicit capture of 'request' requires that 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') conforms to 'Sendable'; this is an error in the Swift 6 language mode
 85 |         self.timer = context.eventLoop.scheduleTask(in: self.configuration.readTimeout) {
 86 |             self.timer = nil
 87 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: \(request.sequenceNumber) timeout!")
    |                                                                   `- warning: implicit capture of 'request' requires that 'HTTPTracingHandler.OutboundIn' (aka 'HTTPPingClient.Request') conforms to 'Sendable'; this is an error in the Swift 6 language mode
 88 |             self.handler.handleTimeout(sequenceNumber: request.sequenceNumber)
 89 |         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:93:21: warning: capture of 'self' with non-sendable type 'HTTPPingClient' in a '@Sendable' closure
 22 | /// Caller needs to provide a configuration that set the way the HTTP client initiates tests.
 23 | /// Caller can cancel the test via `cancel()`.
 24 | public final class HTTPPingClient: Pingable {
    |                    `- note: class 'HTTPPingClient' does not conform to the 'Sendable' protocol
 25 |
 26 |     private enum State {
    :
 91 |                 state = .running
 92 |                 return try self.pingClient.start().always { _ in
 93 |                     self.state.withLockedValue { state in
    |                     `- warning: capture of 'self' with non-sendable type 'HTTPPingClient' in a '@Sendable' closure
 94 |                         state = .idle
 95 |                     }
[1039/1066] Compiling LCLPing PingHandler.swift
/host/spi-builder-workspace/Sources/LCLPing/Reachability.swift:40:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
38 |         let httpConfig = try HTTPPingClient.Configuration(url: host, count: strategy.count)
39 |         let client = HTTPPingClient(configuration: httpConfig)
40 |         let result = try client.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
41 |         return result.isSimpleMajority()
42 |     case .icmp:
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/Reachability.swift:45:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
43 |         let icmpConfig = try ICMPPingClient.Configuration(endpoint: .ipv4(host, 0), count: strategy.count)
44 |         let client = ICMPPingClient(configuration: icmpConfig)
45 |         let result = try client.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
46 |         return result.isSimpleMajority()
47 |     }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
[1040/1066] Compiling LCLPing Pingable.swift
/host/spi-builder-workspace/Sources/LCLPing/Reachability.swift:40:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
38 |         let httpConfig = try HTTPPingClient.Configuration(url: host, count: strategy.count)
39 |         let client = HTTPPingClient(configuration: httpConfig)
40 |         let result = try client.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
41 |         return result.isSimpleMajority()
42 |     case .icmp:
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/Reachability.swift:45:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
43 |         let icmpConfig = try ICMPPingClient.Configuration(endpoint: .ipv4(host, 0), count: strategy.count)
44 |         let client = ICMPPingClient(configuration: icmpConfig)
45 |         let result = try client.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
46 |         return result.isSimpleMajority()
47 |     }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
[1041/1066] Compiling LCLPing Reachability.swift
/host/spi-builder-workspace/Sources/LCLPing/Reachability.swift:40:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
38 |         let httpConfig = try HTTPPingClient.Configuration(url: host, count: strategy.count)
39 |         let client = HTTPPingClient(configuration: httpConfig)
40 |         let result = try client.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
41 |         return result.isSimpleMajority()
42 |     case .icmp:
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/Reachability.swift:45:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
43 |         let icmpConfig = try ICMPPingClient.Configuration(endpoint: .ipv4(host, 0), count: strategy.count)
44 |         let client = ICMPPingClient(configuration: icmpConfig)
45 |         let result = try client.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
46 |         return result.isSimpleMajority()
47 |     }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
[1042/1066] Compiling LCLPing InboundHeaderRewriter.swift
/host/spi-builder-workspace/Sources/LCLPing/Reachability.swift:40:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
38 |         let httpConfig = try HTTPPingClient.Configuration(url: host, count: strategy.count)
39 |         let client = HTTPPingClient(configuration: httpConfig)
40 |         let result = try client.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
41 |         return result.isSimpleMajority()
42 |     case .icmp:
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/Reachability.swift:45:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
43 |         let icmpConfig = try ICMPPingClient.Configuration(endpoint: .ipv4(host, 0), count: strategy.count)
44 |         let client = ICMPPingClient(configuration: icmpConfig)
45 |         let result = try client.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
46 |         return result.isSimpleMajority()
47 |     }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
[1043/1066] Compiling LCLPing LCLPing+Array.swift
[1044/1066] Compiling LCLPing LCLPing+ChannelOption.swift
[1045/1066] Compiling LCLPing LCLPing+Double.swift
[1046/1066] Compiling LCLPing LCLPing+SocketOption.swift
[1047/1066] Compiling LCLPing Rewritable.swift
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:172:13: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
170 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to read data in \(self.networkLinkConfig.inDelay) ms. Should duplicate: \(shouldDuplicatePacket)")
171 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.inDelay)) {
172 |             context.fireChannelRead(data)
    |             `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
173 |             if shouldDuplicatePacket {
174 |                 context.fireChannelRead(data)
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1786:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1784 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1785 | /// `ChannelHandler`.
1786 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1787 |     // visible for ChannelPipeline to modify
1788 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:172:37: warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
170 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to read data in \(self.networkLinkConfig.inDelay) ms. Should duplicate: \(shouldDuplicatePacket)")
171 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.inDelay)) {
172 |             context.fireChannelRead(data)
    |                                     `- warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
173 |             if shouldDuplicatePacket {
174 |                 context.fireChannelRead(data)
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/NIOAny.swift:45:15: note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 43 | ///         }
 44 | ///     }
 45 | public struct NIOAny {
    |               `- note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 46 |     @usableFromInline
 47 |     let _storage: _NIOAny
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:176:97: warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
174 |                 context.fireChannelRead(data)
175 |             }
176 |             logger.debug("[\(#fileID)][\(#line)][\(#function)] fireChannelRead after delaying \(self.networkLinkConfig.inDelay) ms")
    |                                                                                                 `- warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
177 |         }
178 |
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:176:97: warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
174 |                 context.fireChannelRead(data)
175 |             }
176 |             logger.debug("[\(#fileID)][\(#line)][\(#function)] fireChannelRead after delaying \(self.networkLinkConfig.inDelay) ms")
    |                                                                                                 `- warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
177 |         }
178 |
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:195:17: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
193 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to send data in \(self.networkLinkConfig.outDelay) ms")
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
    |                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
197 |         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1786:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1784 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1785 | /// `ChannelHandler`.
1786 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1787 |     // visible for ChannelPipeline to modify
1788 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:195:39: warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
193 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to send data in \(self.networkLinkConfig.outDelay) ms")
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
    |                                       `- warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
197 |         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/NIOAny.swift:45:15: note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 43 | ///         }
 44 | ///     }
 45 | public struct NIOAny {
    |               `- note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 46 |     @usableFromInline
 47 |     let _storage: _NIOAny
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:196:96: warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
    |                                                                                                `- warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
197 |         }
198 |     }
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:196:96: warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
    |                                                                                                `- warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
197 |         }
198 |     }
[1048/1066] Compiling LCLPing TrafficControllerChannelHandler.swift
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:172:13: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
170 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to read data in \(self.networkLinkConfig.inDelay) ms. Should duplicate: \(shouldDuplicatePacket)")
171 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.inDelay)) {
172 |             context.fireChannelRead(data)
    |             `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
173 |             if shouldDuplicatePacket {
174 |                 context.fireChannelRead(data)
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1786:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1784 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1785 | /// `ChannelHandler`.
1786 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1787 |     // visible for ChannelPipeline to modify
1788 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:172:37: warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
170 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to read data in \(self.networkLinkConfig.inDelay) ms. Should duplicate: \(shouldDuplicatePacket)")
171 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.inDelay)) {
172 |             context.fireChannelRead(data)
    |                                     `- warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
173 |             if shouldDuplicatePacket {
174 |                 context.fireChannelRead(data)
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/NIOAny.swift:45:15: note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 43 | ///         }
 44 | ///     }
 45 | public struct NIOAny {
    |               `- note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 46 |     @usableFromInline
 47 |     let _storage: _NIOAny
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:176:97: warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
174 |                 context.fireChannelRead(data)
175 |             }
176 |             logger.debug("[\(#fileID)][\(#line)][\(#function)] fireChannelRead after delaying \(self.networkLinkConfig.inDelay) ms")
    |                                                                                                 `- warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
177 |         }
178 |
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:176:97: warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
174 |                 context.fireChannelRead(data)
175 |             }
176 |             logger.debug("[\(#fileID)][\(#line)][\(#function)] fireChannelRead after delaying \(self.networkLinkConfig.inDelay) ms")
    |                                                                                                 `- warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
177 |         }
178 |
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:195:17: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
193 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to send data in \(self.networkLinkConfig.outDelay) ms")
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
    |                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
197 |         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1786:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1784 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1785 | /// `ChannelHandler`.
1786 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1787 |     // visible for ChannelPipeline to modify
1788 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:195:39: warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
193 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to send data in \(self.networkLinkConfig.outDelay) ms")
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
    |                                       `- warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
197 |         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/NIOAny.swift:45:15: note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 43 | ///         }
 44 | ///     }
 45 | public struct NIOAny {
    |               `- note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 46 |     @usableFromInline
 47 |     let _storage: _NIOAny
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:196:96: warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
    |                                                                                                `- warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
197 |         }
198 |     }
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:196:96: warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
    |                                                                                                `- warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
197 |         }
198 |     }
[1049/1066] Compiling LCLPing Constants.swift
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:172:13: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
170 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to read data in \(self.networkLinkConfig.inDelay) ms. Should duplicate: \(shouldDuplicatePacket)")
171 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.inDelay)) {
172 |             context.fireChannelRead(data)
    |             `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
173 |             if shouldDuplicatePacket {
174 |                 context.fireChannelRead(data)
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1786:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1784 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1785 | /// `ChannelHandler`.
1786 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1787 |     // visible for ChannelPipeline to modify
1788 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:172:37: warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
170 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to read data in \(self.networkLinkConfig.inDelay) ms. Should duplicate: \(shouldDuplicatePacket)")
171 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.inDelay)) {
172 |             context.fireChannelRead(data)
    |                                     `- warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
173 |             if shouldDuplicatePacket {
174 |                 context.fireChannelRead(data)
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/NIOAny.swift:45:15: note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 43 | ///         }
 44 | ///     }
 45 | public struct NIOAny {
    |               `- note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 46 |     @usableFromInline
 47 |     let _storage: _NIOAny
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:176:97: warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
174 |                 context.fireChannelRead(data)
175 |             }
176 |             logger.debug("[\(#fileID)][\(#line)][\(#function)] fireChannelRead after delaying \(self.networkLinkConfig.inDelay) ms")
    |                                                                                                 `- warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
177 |         }
178 |
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:176:97: warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
174 |                 context.fireChannelRead(data)
175 |             }
176 |             logger.debug("[\(#fileID)][\(#line)][\(#function)] fireChannelRead after delaying \(self.networkLinkConfig.inDelay) ms")
    |                                                                                                 `- warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
177 |         }
178 |
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:195:17: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
193 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to send data in \(self.networkLinkConfig.outDelay) ms")
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
    |                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
197 |         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1786:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1784 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1785 | /// `ChannelHandler`.
1786 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1787 |     // visible for ChannelPipeline to modify
1788 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:195:39: warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
193 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to send data in \(self.networkLinkConfig.outDelay) ms")
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
    |                                       `- warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
197 |         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/NIOAny.swift:45:15: note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 43 | ///         }
 44 | ///     }
 45 | public struct NIOAny {
    |               `- note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 46 |     @usableFromInline
 47 |     let _storage: _NIOAny
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:196:96: warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
    |                                                                                                `- warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
197 |         }
198 |     }
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:196:96: warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
    |                                                                                                `- warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
197 |         }
198 |     }
[1050/1066] Compiling LCLPing Hex.swift
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:172:13: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
170 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to read data in \(self.networkLinkConfig.inDelay) ms. Should duplicate: \(shouldDuplicatePacket)")
171 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.inDelay)) {
172 |             context.fireChannelRead(data)
    |             `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
173 |             if shouldDuplicatePacket {
174 |                 context.fireChannelRead(data)
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1786:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1784 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1785 | /// `ChannelHandler`.
1786 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1787 |     // visible for ChannelPipeline to modify
1788 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:172:37: warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
170 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to read data in \(self.networkLinkConfig.inDelay) ms. Should duplicate: \(shouldDuplicatePacket)")
171 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.inDelay)) {
172 |             context.fireChannelRead(data)
    |                                     `- warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
173 |             if shouldDuplicatePacket {
174 |                 context.fireChannelRead(data)
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/NIOAny.swift:45:15: note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 43 | ///         }
 44 | ///     }
 45 | public struct NIOAny {
    |               `- note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 46 |     @usableFromInline
 47 |     let _storage: _NIOAny
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:176:97: warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
174 |                 context.fireChannelRead(data)
175 |             }
176 |             logger.debug("[\(#fileID)][\(#line)][\(#function)] fireChannelRead after delaying \(self.networkLinkConfig.inDelay) ms")
    |                                                                                                 `- warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
177 |         }
178 |
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:176:97: warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
174 |                 context.fireChannelRead(data)
175 |             }
176 |             logger.debug("[\(#fileID)][\(#line)][\(#function)] fireChannelRead after delaying \(self.networkLinkConfig.inDelay) ms")
    |                                                                                                 `- warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
177 |         }
178 |
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:195:17: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
193 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to send data in \(self.networkLinkConfig.outDelay) ms")
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
    |                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
197 |         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1786:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1784 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1785 | /// `ChannelHandler`.
1786 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1787 |     // visible for ChannelPipeline to modify
1788 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:195:39: warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
193 |         logger.debug("[\(#fileID)][\(#line)][\(#function)]: schedule to send data in \(self.networkLinkConfig.outDelay) ms")
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
    |                                       `- warning: capture of 'data' with non-sendable type 'NIOAny' in a '@Sendable' closure
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
197 |         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/NIOAny.swift:45:15: note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 43 | ///         }
 44 | ///     }
 45 | public struct NIOAny {
    |               `- note: struct 'NIOAny' does not conform to the 'Sendable' protocol
 46 |     @usableFromInline
 47 |     let _storage: _NIOAny
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:196:96: warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
    |                                                                                                `- warning: capture of 'self' with non-sendable type 'TrafficControllerChannelHandler' in a '@Sendable' closure
197 |         }
198 |     }
/host/spi-builder-workspace/Sources/LCLPing/TestUtils/TrafficControllerChannelHandler.swift:196:96: warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
 19 | ///
 20 | /// - Note: This channel handler should usually be placed at the first position in the channel handlers pipeline.
 21 | final class TrafficControllerChannelHandler: ChannelDuplexHandler {
    |             `- note: class 'TrafficControllerChannelHandler' does not conform to the 'Sendable' protocol
 22 |
 23 |     /// The configuration to simulate different network conditions.
    :
194 |         context.eventLoop.scheduleTask(in: .milliseconds(self.networkLinkConfig.outDelay)) {
195 |             _ = context.writeAndFlush(data)
196 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: writeAndFlush after delaying \(self.networkLinkConfig.outDelay) ms")
    |                                                                                                `- warning: implicit capture of 'self' requires that 'TrafficControllerChannelHandler' conforms to 'Sendable'; this is an error in the Swift 6 language mode
197 |         }
198 |     }
[1051/1066] Compiling LCLPing PingResponse.swift
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:83:16: warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
    :
 81 |
 82 |     /// An empty summary.
 83 |     static let empty = PingSummary(
    |                |- warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: add '@MainActor' to make static property 'empty' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 |         min: .zero,
 85 |         max: .zero,
[1052/1066] Compiling LCLPing PingResult.swift
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:83:16: warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
    :
 81 |
 82 |     /// An empty summary.
 83 |     static let empty = PingSummary(
    |                |- warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: add '@MainActor' to make static property 'empty' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 |         min: .zero,
 85 |         max: .zero,
[1053/1066] Compiling LCLPing PingState.swift
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:83:16: warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
    :
 81 |
 82 |     /// An empty summary.
 83 |     static let empty = PingSummary(
    |                |- warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: add '@MainActor' to make static property 'empty' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 |         min: .zero,
 85 |         max: .zero,
[1054/1066] Compiling LCLPing PingSummary.swift
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:83:16: warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
    :
 81 |
 82 |     /// An empty summary.
 83 |     static let empty = PingSummary(
    |                |- warning: static property 'empty' is not concurrency-safe because non-'Sendable' type 'PingSummary' may have shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: add '@MainActor' to make static property 'empty' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 |         min: .zero,
 85 |         max: .zero,
[1055/1066] Compiling LCLPing HTTPSchema.swift
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:85:41: warning: type 'HTTPPingClient.Request' does not conform to the 'Sendable' protocol
 83 |                             channel.eventLoop.scheduleTask(in: self.configuration.readTimeout * cnt) {
 84 |                                 let request = self.configuration.makeHTTPRequest(for: cnt)
 85 |                                 channel.write(request, promise: nil)
    |                                         `- warning: type 'HTTPPingClient.Request' does not conform to the 'Sendable' protocol
 86 |                             }
 87 |                         case .failure(let error):
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:106:56: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
104 |                                 $0.append(response)
105 |                                 if $0.count == self.configuration.count {
106 |                                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
    |                                                        `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
107 |                                 }
108 |                             }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:78:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 76 |                         switch result {
 77 |                         case .success(let channel):
 78 |                             self.channels.withLockedValue { channels in
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 79 |                                 channels.append(channel)
 80 |                             }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:84:47: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 82 |                             logger.debug("Scheduled #\(cnt) request")
 83 |                             channel.eventLoop.scheduleTask(in: self.configuration.readTimeout * cnt) {
 84 |                                 let request = self.configuration.makeHTTPRequest(for: cnt)
    |                                               `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 85 |                                 channel.write(request, promise: nil)
 86 |                             }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:90:33: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 88 |                             promise.fail(error)
 89 |                             self.stateLock.withLockVoid {
 90 |                                 self.state = .error
    |                                 `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 91 |                             }
 92 |                         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:96:25: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 94 |
 95 |                     promise.futureResult.whenComplete { res in
 96 |                         self.channels.withLockedValue { channels in
    |                         `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 97 |                             if !channels.isEmpty {
 98 |                                 channels.removeFirst()
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:105:48: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
103 |                             self.responses.withLockedValue {
104 |                                 $0.append(response)
105 |                                 if $0.count == self.configuration.count {
    |                                                `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
106 |                                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
107 |                                 }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:118:25: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
116 |                     switch result {
117 |                     case .success:
118 |                         self.stateLock.withLockVoid {
    |                         `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
119 |                             self.state = .finished
120 |                         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:119:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
117 |                     case .success:
118 |                         self.stateLock.withLockVoid {
119 |                             self.state = .finished
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
120 |                         }
121 |                     case .failure:
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:123:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
121 |                     case .failure:
122 |                         self.stateLock.withLockVoid {
123 |                             self.state = .error
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
124 |                         }
125 |                     }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:146:40: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
144 |                 }
145 |                 self.responses.withLockedValue {
146 |                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
    |                                        `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
147 |                 }
148 |                 shutdown()
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:170:20: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
168 |             .connectTimeout(self.configuration.connectionTimeout)
169 |             .channelInitializer { channel in
170 |                 if self.configuration.schema.enableTLS {
    |                    `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
171 |                     do {
172 |                         let tlsConfiguration = TLSConfiguration.makeClientConfiguration()
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPChannelHandlers.swift:71:13: warning: capture of 'self' with non-sendable type 'ICMPDuplexer' in a '@Sendable' closure
 15 | import NIOCore
 16 |
 17 | internal final class ICMPDuplexer: ChannelDuplexHandler {
    |                      `- note: class 'ICMPDuplexer' does not conform to the 'Sendable' protocol
 18 |     typealias InboundIn = ICMPPingClient.ICMPHeader
 19 |     typealias InboundOut = PingResponse
    :
 69 |         let scheduledTimer = context.eventLoop.scheduleTask(in: self.configuration.timeout) {
 70 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: timer for \(request.sequenceNum) is invoked => time out!")
 71 |             self.timer.removeValue(forKey: request.sequenceNum)
    |             `- warning: capture of 'self' with non-sendable type 'ICMPDuplexer' in a '@Sendable' closure
 72 |             self.handler.handleTimeout(sequenceNumber: Int(request.sequenceNum))
 73 |         }
[1056/1066] Compiling LCLPing NIOHTTPClient.swift
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:85:41: warning: type 'HTTPPingClient.Request' does not conform to the 'Sendable' protocol
 83 |                             channel.eventLoop.scheduleTask(in: self.configuration.readTimeout * cnt) {
 84 |                                 let request = self.configuration.makeHTTPRequest(for: cnt)
 85 |                                 channel.write(request, promise: nil)
    |                                         `- warning: type 'HTTPPingClient.Request' does not conform to the 'Sendable' protocol
 86 |                             }
 87 |                         case .failure(let error):
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:106:56: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
104 |                                 $0.append(response)
105 |                                 if $0.count == self.configuration.count {
106 |                                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
    |                                                        `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
107 |                                 }
108 |                             }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:78:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 76 |                         switch result {
 77 |                         case .success(let channel):
 78 |                             self.channels.withLockedValue { channels in
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 79 |                                 channels.append(channel)
 80 |                             }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:84:47: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 82 |                             logger.debug("Scheduled #\(cnt) request")
 83 |                             channel.eventLoop.scheduleTask(in: self.configuration.readTimeout * cnt) {
 84 |                                 let request = self.configuration.makeHTTPRequest(for: cnt)
    |                                               `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 85 |                                 channel.write(request, promise: nil)
 86 |                             }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:90:33: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 88 |                             promise.fail(error)
 89 |                             self.stateLock.withLockVoid {
 90 |                                 self.state = .error
    |                                 `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 91 |                             }
 92 |                         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:96:25: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 94 |
 95 |                     promise.futureResult.whenComplete { res in
 96 |                         self.channels.withLockedValue { channels in
    |                         `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 97 |                             if !channels.isEmpty {
 98 |                                 channels.removeFirst()
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:105:48: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
103 |                             self.responses.withLockedValue {
104 |                                 $0.append(response)
105 |                                 if $0.count == self.configuration.count {
    |                                                `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
106 |                                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
107 |                                 }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:118:25: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
116 |                     switch result {
117 |                     case .success:
118 |                         self.stateLock.withLockVoid {
    |                         `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
119 |                             self.state = .finished
120 |                         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:119:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
117 |                     case .success:
118 |                         self.stateLock.withLockVoid {
119 |                             self.state = .finished
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
120 |                         }
121 |                     case .failure:
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:123:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
121 |                     case .failure:
122 |                         self.stateLock.withLockVoid {
123 |                             self.state = .error
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
124 |                         }
125 |                     }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:146:40: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
144 |                 }
145 |                 self.responses.withLockedValue {
146 |                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
    |                                        `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
147 |                 }
148 |                 shutdown()
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:170:20: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
168 |             .connectTimeout(self.configuration.connectionTimeout)
169 |             .channelInitializer { channel in
170 |                 if self.configuration.schema.enableTLS {
    |                    `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
171 |                     do {
172 |                         let tlsConfiguration = TLSConfiguration.makeClientConfiguration()
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPChannelHandlers.swift:71:13: warning: capture of 'self' with non-sendable type 'ICMPDuplexer' in a '@Sendable' closure
 15 | import NIOCore
 16 |
 17 | internal final class ICMPDuplexer: ChannelDuplexHandler {
    |                      `- note: class 'ICMPDuplexer' does not conform to the 'Sendable' protocol
 18 |     typealias InboundIn = ICMPPingClient.ICMPHeader
 19 |     typealias InboundOut = PingResponse
    :
 69 |         let scheduledTimer = context.eventLoop.scheduleTask(in: self.configuration.timeout) {
 70 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: timer for \(request.sequenceNum) is invoked => time out!")
 71 |             self.timer.removeValue(forKey: request.sequenceNum)
    |             `- warning: capture of 'self' with non-sendable type 'ICMPDuplexer' in a '@Sendable' closure
 72 |             self.handler.handleTimeout(sequenceNumber: Int(request.sequenceNum))
 73 |         }
[1057/1066] Compiling LCLPing URLSessionClient.swift
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:85:41: warning: type 'HTTPPingClient.Request' does not conform to the 'Sendable' protocol
 83 |                             channel.eventLoop.scheduleTask(in: self.configuration.readTimeout * cnt) {
 84 |                                 let request = self.configuration.makeHTTPRequest(for: cnt)
 85 |                                 channel.write(request, promise: nil)
    |                                         `- warning: type 'HTTPPingClient.Request' does not conform to the 'Sendable' protocol
 86 |                             }
 87 |                         case .failure(let error):
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:106:56: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
104 |                                 $0.append(response)
105 |                                 if $0.count == self.configuration.count {
106 |                                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
    |                                                        `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
107 |                                 }
108 |                             }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:78:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 76 |                         switch result {
 77 |                         case .success(let channel):
 78 |                             self.channels.withLockedValue { channels in
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 79 |                                 channels.append(channel)
 80 |                             }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:84:47: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 82 |                             logger.debug("Scheduled #\(cnt) request")
 83 |                             channel.eventLoop.scheduleTask(in: self.configuration.readTimeout * cnt) {
 84 |                                 let request = self.configuration.makeHTTPRequest(for: cnt)
    |                                               `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 85 |                                 channel.write(request, promise: nil)
 86 |                             }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:90:33: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 88 |                             promise.fail(error)
 89 |                             self.stateLock.withLockVoid {
 90 |                                 self.state = .error
    |                                 `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 91 |                             }
 92 |                         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:96:25: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 94 |
 95 |                     promise.futureResult.whenComplete { res in
 96 |                         self.channels.withLockedValue { channels in
    |                         `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 97 |                             if !channels.isEmpty {
 98 |                                 channels.removeFirst()
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:105:48: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
103 |                             self.responses.withLockedValue {
104 |                                 $0.append(response)
105 |                                 if $0.count == self.configuration.count {
    |                                                `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
106 |                                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
107 |                                 }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:118:25: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
116 |                     switch result {
117 |                     case .success:
118 |                         self.stateLock.withLockVoid {
    |                         `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
119 |                             self.state = .finished
120 |                         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:119:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
117 |                     case .success:
118 |                         self.stateLock.withLockVoid {
119 |                             self.state = .finished
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
120 |                         }
121 |                     case .failure:
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:123:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
121 |                     case .failure:
122 |                         self.stateLock.withLockVoid {
123 |                             self.state = .error
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
124 |                         }
125 |                     }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:146:40: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
144 |                 }
145 |                 self.responses.withLockedValue {
146 |                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
    |                                        `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
147 |                 }
148 |                 shutdown()
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:170:20: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
168 |             .connectTimeout(self.configuration.connectionTimeout)
169 |             .channelInitializer { channel in
170 |                 if self.configuration.schema.enableTLS {
    |                    `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
171 |                     do {
172 |                         let tlsConfiguration = TLSConfiguration.makeClientConfiguration()
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPChannelHandlers.swift:71:13: warning: capture of 'self' with non-sendable type 'ICMPDuplexer' in a '@Sendable' closure
 15 | import NIOCore
 16 |
 17 | internal final class ICMPDuplexer: ChannelDuplexHandler {
    |                      `- note: class 'ICMPDuplexer' does not conform to the 'Sendable' protocol
 18 |     typealias InboundIn = ICMPPingClient.ICMPHeader
 19 |     typealias InboundOut = PingResponse
    :
 69 |         let scheduledTimer = context.eventLoop.scheduleTask(in: self.configuration.timeout) {
 70 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: timer for \(request.sequenceNum) is invoked => time out!")
 71 |             self.timer.removeValue(forKey: request.sequenceNum)
    |             `- warning: capture of 'self' with non-sendable type 'ICMPDuplexer' in a '@Sendable' closure
 72 |             self.handler.handleTimeout(sequenceNumber: Int(request.sequenceNum))
 73 |         }
[1058/1066] Compiling LCLPing ICMPChannelHandlers.swift
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:85:41: warning: type 'HTTPPingClient.Request' does not conform to the 'Sendable' protocol
 83 |                             channel.eventLoop.scheduleTask(in: self.configuration.readTimeout * cnt) {
 84 |                                 let request = self.configuration.makeHTTPRequest(for: cnt)
 85 |                                 channel.write(request, promise: nil)
    |                                         `- warning: type 'HTTPPingClient.Request' does not conform to the 'Sendable' protocol
 86 |                             }
 87 |                         case .failure(let error):
/host/spi-builder-workspace/Sources/LCLPing/HTTP/HTTPPingClient.swift:124:19: note: consider making struct 'Request' conform to the 'Sendable' protocol
122 |     ///
123 |     /// The information in this data will be used to construct the corresponding HTTP request.
124 |     public struct Request {
    |                   `- note: consider making struct 'Request' conform to the 'Sendable' protocol
125 |         /// The sequence number of the ICMP test. This number should be monotonically increasing.
126 |         let sequenceNumber: Int
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:106:56: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
104 |                                 $0.append(response)
105 |                                 if $0.count == self.configuration.count {
106 |                                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
    |                                                        `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
107 |                                 }
108 |                             }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:78:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 76 |                         switch result {
 77 |                         case .success(let channel):
 78 |                             self.channels.withLockedValue { channels in
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 79 |                                 channels.append(channel)
 80 |                             }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:84:47: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 82 |                             logger.debug("Scheduled #\(cnt) request")
 83 |                             channel.eventLoop.scheduleTask(in: self.configuration.readTimeout * cnt) {
 84 |                                 let request = self.configuration.makeHTTPRequest(for: cnt)
    |                                               `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 85 |                                 channel.write(request, promise: nil)
 86 |                             }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:90:33: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 88 |                             promise.fail(error)
 89 |                             self.stateLock.withLockVoid {
 90 |                                 self.state = .error
    |                                 `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 91 |                             }
 92 |                         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:96:25: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
 94 |
 95 |                     promise.futureResult.whenComplete { res in
 96 |                         self.channels.withLockedValue { channels in
    |                         `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 97 |                             if !channels.isEmpty {
 98 |                                 channels.removeFirst()
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:105:48: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
103 |                             self.responses.withLockedValue {
104 |                                 $0.append(response)
105 |                                 if $0.count == self.configuration.count {
    |                                                `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
106 |                                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
107 |                                 }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:118:25: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
116 |                     switch result {
117 |                     case .success:
118 |                         self.stateLock.withLockVoid {
    |                         `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
119 |                             self.state = .finished
120 |                         }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:119:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
117 |                     case .success:
118 |                         self.stateLock.withLockVoid {
119 |                             self.state = .finished
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
120 |                         }
121 |                     case .failure:
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:123:29: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
121 |                     case .failure:
122 |                         self.stateLock.withLockVoid {
123 |                             self.state = .error
    |                             `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in an isolated closure; this is an error in the Swift 6 language mode
124 |                         }
125 |                     }
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:146:40: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
144 |                 }
145 |                 self.responses.withLockedValue {
146 |                     self.resultPromise.succeed($0.summarize(host: resolvedAddress))
    |                                        `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
147 |                 }
148 |                 shutdown()
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/HTTP/NIOHTTPClient.swift:170:20: warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
 18 | import NIOConcurrencyHelpers
 19 |
 20 | final class NIOHTTPClient: Pingable {
    |             `- note: class 'NIOHTTPClient' does not conform to the 'Sendable' protocol
 21 |     private let eventLoopGroup: EventLoopGroup
 22 |     private let configuration: HTTPPingClient.Configuration
    :
168 |             .connectTimeout(self.configuration.connectionTimeout)
169 |             .channelInitializer { channel in
170 |                 if self.configuration.schema.enableTLS {
    |                    `- warning: capture of 'self' with non-sendable type 'NIOHTTPClient' in a '@Sendable' closure
171 |                     do {
172 |                         let tlsConfiguration = TLSConfiguration.makeClientConfiguration()
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPChannelHandlers.swift:71:13: warning: capture of 'self' with non-sendable type 'ICMPDuplexer' in a '@Sendable' closure
 15 | import NIOCore
 16 |
 17 | internal final class ICMPDuplexer: ChannelDuplexHandler {
    |                      `- note: class 'ICMPDuplexer' does not conform to the 'Sendable' protocol
 18 |     typealias InboundIn = ICMPPingClient.ICMPHeader
 19 |     typealias InboundOut = PingResponse
    :
 69 |         let scheduledTimer = context.eventLoop.scheduleTask(in: self.configuration.timeout) {
 70 |             logger.debug("[\(#fileID)][\(#line)][\(#function)]: timer for \(request.sequenceNum) is invoked => time out!")
 71 |             self.timer.removeValue(forKey: request.sequenceNum)
    |             `- warning: capture of 'self' with non-sendable type 'ICMPDuplexer' in a '@Sendable' closure
 72 |             self.handler.handleTimeout(sequenceNumber: Int(request.sequenceNum))
 73 |         }
[1059/1066] Compiling LCLPing ICMPHandler.swift
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:69:77: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
 67 |                 self.state = .running
 68 |
 69 |                 return self.connect(to: self.configuration.resolvedAddress).flatMap { channel in
    |                                                                             `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
 70 |                     self.channel = channel
 71 |                     channel.closeFuture.whenComplete { result in
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:103:84: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
101 |                     send(0)
102 |
103 |                     return sendPromise.futureResult.and(self.promise.futureResult).flatMap { (_, pingResponse) in
    |                                                                                    `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
105 |                         self.stateLock.withLock {
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:108:50: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
106 |                             self.state = .finished
107 |                         }
108 |                         return channel.eventLoop.makeSucceededFuture(summary)
    |                                                  `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
109 |                     }
110 |                 }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:70:21: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 68 |
 69 |                 return self.connect(to: self.configuration.resolvedAddress).flatMap { channel in
 70 |                     self.channel = channel
    |                     `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 71 |                     channel.closeFuture.whenComplete { result in
 72 |                         switch result {
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:76:29: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 74 |                             ()
 75 |                         case .failure:
 76 |                             self.stateLock.withLockVoid {
    |                             `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 77 |                                 self.state = .error
 78 |                             }
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:77:33: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 75 |                         case .failure:
 76 |                             self.stateLock.withLockVoid {
 77 |                                 self.state = .error
    |                                 `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 78 |                             }
 79 |                         }
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:86:35: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated local function; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 84 |
 85 |                     func send(_ cnt: Int) {
 86 |                         if cnt == self.configuration.count {
    |                                   `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated local function; this is an error in the Swift 6 language mode
 87 |                             sendPromise.succeed()
 88 |                             return
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:94:112: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 92 |                         logger.debug("Scheduled #\(cnt) request")
 93 |                         channel.eventLoop.scheduleTask(in: cnt * self.configuration.interval) {
 94 |                             channel.writeAndFlush(ICMPPingClient.Request(sequenceNum: UInt16(cnt), identifier: self.identifier), promise: p)
    |                                                                                                                `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 95 |                         }.futureResult.hop(to: el).cascadeFailure(to: sendPromise)
 96 |
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:104:68: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
102 |
103 |                     return sendPromise.futureResult.and(self.promise.futureResult).flatMap { (_, pingResponse) in
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
    |                                                                    `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
105 |                         self.stateLock.withLock {
106 |                             self.state = .finished
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:106:29: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
105 |                         self.stateLock.withLock {
106 |                             self.state = .finished
    |                             `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
107 |                         }
108 |                         return channel.eventLoop.makeSucceededFuture(summary)
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:166:49: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
164 |                     IPDecoder(),
165 |                     ICMPDecoder(),
166 |                     ICMPDuplexer(configuration: self.configuration, promise: self.promise)
    |                                                 `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
167 |                 ]
168 |                 #endif
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:173:25: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
171 |                 } catch {
172 |                     self.stateLock.withLockVoid {
173 |                         self.state = .error
    |                         `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
174 |                     }
175 |                     return channel.eventLoop.makeFailedFuture(error)
[1060/1066] Compiling LCLPing ICMPPingClient.swift
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:69:77: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
 67 |                 self.state = .running
 68 |
 69 |                 return self.connect(to: self.configuration.resolvedAddress).flatMap { channel in
    |                                                                             `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
 70 |                     self.channel = channel
 71 |                     channel.closeFuture.whenComplete { result in
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:103:84: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
101 |                     send(0)
102 |
103 |                     return sendPromise.futureResult.and(self.promise.futureResult).flatMap { (_, pingResponse) in
    |                                                                                    `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
105 |                         self.stateLock.withLock {
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:108:50: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
106 |                             self.state = .finished
107 |                         }
108 |                         return channel.eventLoop.makeSucceededFuture(summary)
    |                                                  `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
109 |                     }
110 |                 }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:70:21: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 68 |
 69 |                 return self.connect(to: self.configuration.resolvedAddress).flatMap { channel in
 70 |                     self.channel = channel
    |                     `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 71 |                     channel.closeFuture.whenComplete { result in
 72 |                         switch result {
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:76:29: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 74 |                             ()
 75 |                         case .failure:
 76 |                             self.stateLock.withLockVoid {
    |                             `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 77 |                                 self.state = .error
 78 |                             }
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:77:33: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 75 |                         case .failure:
 76 |                             self.stateLock.withLockVoid {
 77 |                                 self.state = .error
    |                                 `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 78 |                             }
 79 |                         }
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:86:35: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated local function; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 84 |
 85 |                     func send(_ cnt: Int) {
 86 |                         if cnt == self.configuration.count {
    |                                   `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated local function; this is an error in the Swift 6 language mode
 87 |                             sendPromise.succeed()
 88 |                             return
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:94:112: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 92 |                         logger.debug("Scheduled #\(cnt) request")
 93 |                         channel.eventLoop.scheduleTask(in: cnt * self.configuration.interval) {
 94 |                             channel.writeAndFlush(ICMPPingClient.Request(sequenceNum: UInt16(cnt), identifier: self.identifier), promise: p)
    |                                                                                                                `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 95 |                         }.futureResult.hop(to: el).cascadeFailure(to: sendPromise)
 96 |
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:104:68: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
102 |
103 |                     return sendPromise.futureResult.and(self.promise.futureResult).flatMap { (_, pingResponse) in
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
    |                                                                    `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
105 |                         self.stateLock.withLock {
106 |                             self.state = .finished
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:106:29: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
105 |                         self.stateLock.withLock {
106 |                             self.state = .finished
    |                             `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
107 |                         }
108 |                         return channel.eventLoop.makeSucceededFuture(summary)
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:166:49: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
164 |                     IPDecoder(),
165 |                     ICMPDecoder(),
166 |                     ICMPDuplexer(configuration: self.configuration, promise: self.promise)
    |                                                 `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
167 |                 ]
168 |                 #endif
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:173:25: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
171 |                 } catch {
172 |                     self.stateLock.withLockVoid {
173 |                         self.state = .error
    |                         `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
174 |                     }
175 |                     return channel.eventLoop.makeFailedFuture(error)
[1061/1066] Compiling LCLPing Errors+LCLPing.swift
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:69:77: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
 67 |                 self.state = .running
 68 |
 69 |                 return self.connect(to: self.configuration.resolvedAddress).flatMap { channel in
    |                                                                             `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
 70 |                     self.channel = channel
 71 |                     channel.closeFuture.whenComplete { result in
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:103:84: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
101 |                     send(0)
102 |
103 |                     return sendPromise.futureResult.and(self.promise.futureResult).flatMap { (_, pingResponse) in
    |                                                                                    `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
105 |                         self.stateLock.withLock {
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:108:50: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
106 |                             self.state = .finished
107 |                         }
108 |                         return channel.eventLoop.makeSucceededFuture(summary)
    |                                                  `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
109 |                     }
110 |                 }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:70:21: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 68 |
 69 |                 return self.connect(to: self.configuration.resolvedAddress).flatMap { channel in
 70 |                     self.channel = channel
    |                     `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 71 |                     channel.closeFuture.whenComplete { result in
 72 |                         switch result {
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:76:29: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 74 |                             ()
 75 |                         case .failure:
 76 |                             self.stateLock.withLockVoid {
    |                             `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 77 |                                 self.state = .error
 78 |                             }
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:77:33: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 75 |                         case .failure:
 76 |                             self.stateLock.withLockVoid {
 77 |                                 self.state = .error
    |                                 `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 78 |                             }
 79 |                         }
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:86:35: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated local function; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 84 |
 85 |                     func send(_ cnt: Int) {
 86 |                         if cnt == self.configuration.count {
    |                                   `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated local function; this is an error in the Swift 6 language mode
 87 |                             sendPromise.succeed()
 88 |                             return
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:94:112: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 92 |                         logger.debug("Scheduled #\(cnt) request")
 93 |                         channel.eventLoop.scheduleTask(in: cnt * self.configuration.interval) {
 94 |                             channel.writeAndFlush(ICMPPingClient.Request(sequenceNum: UInt16(cnt), identifier: self.identifier), promise: p)
    |                                                                                                                `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 95 |                         }.futureResult.hop(to: el).cascadeFailure(to: sendPromise)
 96 |
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:104:68: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
102 |
103 |                     return sendPromise.futureResult.and(self.promise.futureResult).flatMap { (_, pingResponse) in
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
    |                                                                    `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
105 |                         self.stateLock.withLock {
106 |                             self.state = .finished
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:106:29: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
105 |                         self.stateLock.withLock {
106 |                             self.state = .finished
    |                             `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
107 |                         }
108 |                         return channel.eventLoop.makeSucceededFuture(summary)
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:166:49: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
164 |                     IPDecoder(),
165 |                     ICMPDecoder(),
166 |                     ICMPDuplexer(configuration: self.configuration, promise: self.promise)
    |                                                 `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
167 |                 ]
168 |                 #endif
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:173:25: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
171 |                 } catch {
172 |                     self.stateLock.withLockVoid {
173 |                         self.state = .error
    |                         `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
174 |                     }
175 |                     return channel.eventLoop.makeFailedFuture(error)
[1062/1066] Compiling LCLPing HTTPLatency.swift
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:69:77: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
 67 |                 self.state = .running
 68 |
 69 |                 return self.connect(to: self.configuration.resolvedAddress).flatMap { channel in
    |                                                                             `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
 70 |                     self.channel = channel
 71 |                     channel.closeFuture.whenComplete { result in
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:103:84: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
101 |                     send(0)
102 |
103 |                     return sendPromise.futureResult.and(self.promise.futureResult).flatMap { (_, pingResponse) in
    |                                                                                    `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
105 |                         self.stateLock.withLock {
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:108:50: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
106 |                             self.state = .finished
107 |                         }
108 |                         return channel.eventLoop.makeSucceededFuture(summary)
    |                                                  `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
109 |                     }
110 |                 }
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: consider making struct 'PingSummary' conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:70:21: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 68 |
 69 |                 return self.connect(to: self.configuration.resolvedAddress).flatMap { channel in
 70 |                     self.channel = channel
    |                     `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 71 |                     channel.closeFuture.whenComplete { result in
 72 |                         switch result {
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:76:29: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 74 |                             ()
 75 |                         case .failure:
 76 |                             self.stateLock.withLockVoid {
    |                             `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 77 |                                 self.state = .error
 78 |                             }
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:77:33: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 75 |                         case .failure:
 76 |                             self.stateLock.withLockVoid {
 77 |                                 self.state = .error
    |                                 `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 78 |                             }
 79 |                         }
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:86:35: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated local function; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 84 |
 85 |                     func send(_ cnt: Int) {
 86 |                         if cnt == self.configuration.count {
    |                                   `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated local function; this is an error in the Swift 6 language mode
 87 |                             sendPromise.succeed()
 88 |                             return
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:94:112: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
 92 |                         logger.debug("Scheduled #\(cnt) request")
 93 |                         channel.eventLoop.scheduleTask(in: cnt * self.configuration.interval) {
 94 |                             channel.writeAndFlush(ICMPPingClient.Request(sequenceNum: UInt16(cnt), identifier: self.identifier), promise: p)
    |                                                                                                                `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 95 |                         }.futureResult.hop(to: el).cascadeFailure(to: sendPromise)
 96 |
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:104:68: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
102 |
103 |                     return sendPromise.futureResult.and(self.promise.futureResult).flatMap { (_, pingResponse) in
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
    |                                                                    `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
105 |                         self.stateLock.withLock {
106 |                             self.state = .finished
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:106:29: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
104 |                         let summary = pingResponse.summarize(host: self.configuration.resolvedAddress)
105 |                         self.stateLock.withLock {
106 |                             self.state = .finished
    |                             `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
107 |                         }
108 |                         return channel.eventLoop.makeSucceededFuture(summary)
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:166:49: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
164 |                     IPDecoder(),
165 |                     ICMPDecoder(),
166 |                     ICMPDuplexer(configuration: self.configuration, promise: self.promise)
    |                                                 `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in a '@Sendable' closure
167 |                 ]
168 |                 #endif
/host/spi-builder-workspace/Sources/LCLPing/ICMP/ICMPPingClient.swift:173:25: warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
 19 | /// Caller needs to provide a configuration that set the way the ICMP client initiates tests.
 20 | /// Caller can also cancel the test via `cancel()`.
 21 | public final class ICMPPingClient: Pingable {
    |                    `- note: class 'ICMPPingClient' does not conform to the 'Sendable' protocol
 22 |
 23 |     private let eventLoopGroup: EventLoopGroup
    :
171 |                 } catch {
172 |                     self.stateLock.withLockVoid {
173 |                         self.state = .error
    |                         `- warning: capture of 'self' with non-sendable type 'ICMPPingClient' in an isolated closure; this is an error in the Swift 6 language mode
174 |                     }
175 |                     return channel.eventLoop.makeFailedFuture(error)
[1063/1067] Wrapping AST for LCLPing for debugging
[1065/1069] Compiling Demo main.swift
/host/spi-builder-workspace/Sources/Demo/main.swift:27:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
25 | do {
26 |     // run the test using SwiftNIO EventLoopFuture
27 |     let result = try icmpClient.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
28 |     print(result)
29 | } catch {
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: struct 'PingSummary' does not conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: struct 'PingSummary' does not conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/Demo/main.swift:15:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'LCLPing'
13 |
14 | import Foundation
15 | import LCLPing
   | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'LCLPing'
16 |
17 | // create ping configuration for each run
/host/spi-builder-workspace/Sources/Demo/main.swift:34:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
32 |
33 | do {
34 |     let result = try httpClient.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
35 |     print(result)
36 | } catch {
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: struct 'PingSummary' does not conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: struct 'PingSummary' does not conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
[1066/1069] Emitting module Demo
/host/spi-builder-workspace/Sources/Demo/main.swift:27:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
25 | do {
26 |     // run the test using SwiftNIO EventLoopFuture
27 |     let result = try icmpClient.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
28 |     print(result)
29 | } catch {
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: struct 'PingSummary' does not conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: struct 'PingSummary' does not conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
/host/spi-builder-workspace/Sources/Demo/main.swift:15:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'LCLPing'
13 |
14 | import Foundation
15 | import LCLPing
   | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'LCLPing'
16 |
17 | // create ping configuration for each run
/host/spi-builder-workspace/Sources/Demo/main.swift:34:41: warning: type 'PingSummary' does not conform to the 'Sendable' protocol
32 |
33 | do {
34 |     let result = try httpClient.start().wait()
   |                                         `- warning: type 'PingSummary' does not conform to the 'Sendable' protocol
35 |     print(result)
36 | } catch {
/host/spi-builder-workspace/Sources/LCLPing/Models/PingSummary.swift:18:15: note: struct 'PingSummary' does not conform to the 'Sendable' protocol
 16 | /// A summary of the ping test, including the min, max, average, median, standard deviation,
 17 | /// and detailed view of each test result.
 18 | public struct PingSummary: Equatable, Encodable {
    |               `- note: struct 'PingSummary' does not conform to the 'Sendable' protocol
 19 |     /// The minimum in the test results.
 20 |     public let min: Double
[1067/1070] Wrapping AST for Demo for debugging
[1068/1070] Write Objects.LinkFileList
[1069/1070] Linking Demo
Build complete! (148.19s)
Build complete.
{
  "dependencies" : [
    {
      "identity" : "swift-nio",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "2.81.0",
            "upper_bound" : "3.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-nio.git"
    },
    {
      "identity" : "swift-log",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.5.3",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-log.git"
    },
    {
      "identity" : "swift-nio-ssl",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "2.25.0",
            "upper_bound" : "3.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-nio-ssl.git"
    },
    {
      "identity" : "swift-collections",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.1.1",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-collections.git"
    }
  ],
  "manifest_display_name" : "LCLPing",
  "name" : "LCLPing",
  "path" : "/host/spi-builder-workspace",
  "platforms" : [
    {
      "name" : "macos",
      "version" : "10.15"
    },
    {
      "name" : "ios",
      "version" : "14.0"
    }
  ],
  "products" : [
    {
      "name" : "LCLPing",
      "targets" : [
        "LCLPing"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "Demo",
      "targets" : [
        "Demo"
      ],
      "type" : {
        "executable" : null
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "UtilitiesTests",
      "module_type" : "SwiftTarget",
      "name" : "UtilitiesTests",
      "path" : "Tests/UtilitiesTests",
      "sources" : [
        "ArrayTests.swift",
        "Common.swift",
        "DoubleTests.swift",
        "MatchServerTimingTests.swift",
        "ObjectDecoderTests.swift",
        "SummarizePingResponseTests.swift",
        "TimeTests.swift"
      ],
      "target_dependencies" : [
        "LCLPing"
      ],
      "type" : "test"
    },
    {
      "c99name" : "ModelTests",
      "module_type" : "SwiftTarget",
      "name" : "ModelTests",
      "path" : "Tests/ModelTests",
      "sources" : [
        "HTTPConfigurationTest.swift",
        "ICMPChecksumTests.swift"
      ],
      "target_dependencies" : [
        "LCLPing"
      ],
      "type" : "test"
    },
    {
      "c99name" : "LCLPing",
      "module_type" : "SwiftTarget",
      "name" : "LCLPing",
      "path" : "Sources/LCLPing",
      "product_dependencies" : [
        "NIO",
        "NIOCore",
        "NIOPosix",
        "NIOHTTP1",
        "NIOTestUtils",
        "NIOConcurrencyHelpers",
        "Logging",
        "NIOSSL",
        "Collections"
      ],
      "product_memberships" : [
        "LCLPing",
        "Demo"
      ],
      "sources" : [
        "Configuration.swift",
        "HTTP/HTTPChannelHandlers.swift",
        "HTTP/HTTPHandler.swift",
        "HTTP/HTTPPingClient.swift",
        "HTTP/HTTPSchema.swift",
        "HTTP/NIOHTTPClient.swift",
        "HTTP/URLSessionClient.swift",
        "ICMP/ICMPChannelHandlers.swift",
        "ICMP/ICMPHandler.swift",
        "ICMP/ICMPPingClient.swift",
        "Models/Errors+LCLPing.swift",
        "Models/HTTPLatency.swift",
        "Models/PingResponse.swift",
        "Models/PingResult.swift",
        "Models/PingState.swift",
        "Models/PingSummary.swift",
        "PingHandler.swift",
        "Pingable.swift",
        "Reachability.swift",
        "TestUtils/InboundHeaderRewriter.swift",
        "TestUtils/Rewritable.swift",
        "TestUtils/TrafficControllerChannelHandler.swift",
        "Utilities/Constants.swift",
        "Utilities/Hex.swift",
        "Utilities/LCLPing+Array.swift",
        "Utilities/LCLPing+ChannelOption.swift",
        "Utilities/LCLPing+Double.swift",
        "Utilities/LCLPing+SocketOption.swift",
        "Utilities/LCLPing+Time.swift",
        "Utilities/LCLPing+TimeInterval.swift",
        "Utilities/ObjectDecoder.swift",
        "Utilities/Utilities.swift"
      ],
      "type" : "library"
    },
    {
      "c99name" : "IntegrationTests",
      "module_type" : "SwiftTarget",
      "name" : "IntegrationTests",
      "path" : "Tests/IntegrationTests",
      "sources" : [
        "HTTPIntegrationTests.swift",
        "ICMPIntegrationTests.swift"
      ],
      "target_dependencies" : [
        "LCLPing"
      ],
      "type" : "test"
    },
    {
      "c99name" : "ICMPChannelTests",
      "module_type" : "SwiftTarget",
      "name" : "ICMPChannelTests",
      "path" : "Tests/ICMPChannelTests",
      "sources" : [
        "Common.swift",
        "ICMPDecoderTests.swift",
        "ICMPDuplexerTests.swift",
        "IPDecoderTests.swift"
      ],
      "target_dependencies" : [
        "LCLPing"
      ],
      "type" : "test"
    },
    {
      "c99name" : "HTTPChannelTests",
      "module_type" : "SwiftTarget",
      "name" : "HTTPChannelTests",
      "path" : "Tests/HTTPChannelTests",
      "sources" : [
        "HTTPTracingHandlerTests.swift"
      ],
      "target_dependencies" : [
        "LCLPing"
      ],
      "type" : "test"
    },
    {
      "c99name" : "Demo",
      "module_type" : "SwiftTarget",
      "name" : "Demo",
      "path" : "Sources/Demo",
      "product_memberships" : [
        "Demo"
      ],
      "sources" : [
        "main.swift"
      ],
      "target_dependencies" : [
        "LCLPing"
      ],
      "type" : "executable"
    }
  ],
  "tools_version" : "5.8"
}
android-6.1-latest: Pulling from finestructure/spi-images
Digest: sha256:fe1962677657b2408c217cb5cceb3c09bc1d91486e360cebbc6eee461a5945d8
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:android-6.1-latest
Done.