Swift Package Index

Build Information

Successful build of swift-nio-ssh, reference 0.4.0 (c997b6), with Swift 6.1 for Linux on 5 Apr 2026 07:12:11 UTC.

Swift 6 data race errors: 17

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4609320-2":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:basic-6.1-latest swift build --triple x86_64-unknown-linux-gnu 2>&1

Build Log

148 | /// associated server side type is `NIOSSHUserAuthenticationRequest`.
149 | public struct NIOSSHUserAuthenticationOffer {
    |               `- note: consider making struct 'NIOSSHUserAuthenticationOffer' conform to the 'Sendable' protocol
150 |     public var username: String
151 |
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:28:23: warning: static property 'publicKey' is not concurrency-safe because non-'Sendable' type 'NIOSSHAvailableUserAuthenticationMethods' may have shared mutable state; this is an error in the Swift 6 language mode
 19 | /// not as a separate authentication method. When using certificates, the publicKey
 20 | /// method is used with a certified key.
 21 | public struct NIOSSHAvailableUserAuthenticationMethods: OptionSet {
    |               `- note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 22 |     public var rawValue: UInt8
 23 |
    :
 26 |     }
 27 |
 28 |     public static let publicKey: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 0)
    |                       |- warning: static property 'publicKey' is not concurrency-safe because non-'Sendable' type 'NIOSSHAvailableUserAuthenticationMethods' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'publicKey' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 29 |     public static let password: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 1)
 30 |     public static let hostBased: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 2)
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:29:23: warning: static property 'password' is not concurrency-safe because non-'Sendable' type 'NIOSSHAvailableUserAuthenticationMethods' may have shared mutable state; this is an error in the Swift 6 language mode
 19 | /// not as a separate authentication method. When using certificates, the publicKey
 20 | /// method is used with a certified key.
 21 | public struct NIOSSHAvailableUserAuthenticationMethods: OptionSet {
    |               `- note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 22 |     public var rawValue: UInt8
 23 |
    :
 27 |
 28 |     public static let publicKey: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 0)
 29 |     public static let password: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 1)
    |                       |- warning: static property 'password' is not concurrency-safe because non-'Sendable' type 'NIOSSHAvailableUserAuthenticationMethods' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'password' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 30 |     public static let hostBased: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 2)
 31 |
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:30:23: warning: static property 'hostBased' is not concurrency-safe because non-'Sendable' type 'NIOSSHAvailableUserAuthenticationMethods' may have shared mutable state; this is an error in the Swift 6 language mode
 19 | /// not as a separate authentication method. When using certificates, the publicKey
 20 | /// method is used with a certified key.
 21 | public struct NIOSSHAvailableUserAuthenticationMethods: OptionSet {
    |               `- note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 22 |     public var rawValue: UInt8
 23 |
    :
 28 |     public static let publicKey: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 0)
 29 |     public static let password: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 1)
 30 |     public static let hostBased: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 2)
    |                       |- warning: static property 'hostBased' is not concurrency-safe because non-'Sendable' type 'NIOSSHAvailableUserAuthenticationMethods' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'hostBased' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 31 |
 32 |     public static let all: NIOSSHAvailableUserAuthenticationMethods = [.publicKey, .password, .hostBased]
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:32:23: warning: static property 'all' is not concurrency-safe because non-'Sendable' type 'NIOSSHAvailableUserAuthenticationMethods' may have shared mutable state; this is an error in the Swift 6 language mode
 19 | /// not as a separate authentication method. When using certificates, the publicKey
 20 | /// method is used with a certified key.
 21 | public struct NIOSSHAvailableUserAuthenticationMethods: OptionSet {
    |               `- note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 22 |     public var rawValue: UInt8
 23 |
    :
 30 |     public static let hostBased: NIOSSHAvailableUserAuthenticationMethods = .init(rawValue: 1 << 2)
 31 |
 32 |     public static let all: NIOSSHAvailableUserAuthenticationMethods = [.publicKey, .password, .hostBased]
    |                       |- warning: static property 'all' is not concurrency-safe because non-'Sendable' type 'NIOSSHAvailableUserAuthenticationMethods' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'all' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 33 | }
 34 |
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:416:34: warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
414 |             guard key.isValidSignature(signature, for: dataToSign) else {
415 |                 // Whoops, signature not valid.
416 |                 return self.loop.makeSucceededFuture(.failure(.init(authentications: supportedMethods.strings, partialSuccess: false)))
    |                                  `- warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
417 |             }
418 |
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:235:6: note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
233 | }
234 |
235 | enum NIOSSHUserAuthenticationResponseMessage {
    |      `- note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
236 |     case success
237 |     case failure(SSHMessage.UserAuthFailureMessage)
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:437:38: warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
435 |                 } catch {
436 |                     // Certificate validation failed
437 |                     return self.loop.makeSucceededFuture(.failure(.init(authentications: supportedMethods.strings, partialSuccess: false)))
    |                                      `- warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
438 |                 }
439 |             }
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:235:6: note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
233 | }
234 |
235 | enum NIOSSHUserAuthenticationResponseMessage {
    |      `- note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
236 |     case success
237 |     case failure(SSHMessage.UserAuthFailureMessage)
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:469:38: warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
467 |                     )
468 |                     // Certificate is valid
469 |                     return self.loop.makeSucceededFuture(.publicKeyOK(.init(key: key)))
    |                                      `- warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
470 |                 } catch {
471 |                     // Certificate validation failed, reject it
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:235:6: note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
233 | }
234 |
235 | enum NIOSSHUserAuthenticationResponseMessage {
    |      `- note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
236 |     case success
237 |     case failure(SSHMessage.UserAuthFailureMessage)
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:472:38: warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
470 |                 } catch {
471 |                     // Certificate validation failed, reject it
472 |                     return self.loop.makeSucceededFuture(.failure(.init(authentications: delegate.supportedAuthenticationMethods.strings, partialSuccess: false)))
    |                                      `- warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
473 |                 }
474 |             }
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:235:6: note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
233 | }
234 |
235 | enum NIOSSHUserAuthenticationResponseMessage {
    |      `- note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
236 |     case success
237 |     case failure(SSHMessage.UserAuthFailureMessage)
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:476:30: warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
474 |             }
475 |             // For now we do a shortcut: we just say that all non-certificate keys are acceptable, rather than ask the delegate.
476 |             return self.loop.makeSucceededFuture(.publicKeyOK(.init(key: key)))
    |                              `- warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
477 |
478 |         case .publicKey(.unknown):
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:235:6: note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
233 | }
234 |
235 | enum NIOSSHUserAuthenticationResponseMessage {
    |      `- note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
236 |     case success
237 |     case failure(SSHMessage.UserAuthFailureMessage)
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:480:30: warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
478 |         case .publicKey(.unknown):
479 |             // We don't known the algorithm, the auth attempt has failed.
480 |             return self.loop.makeSucceededFuture(.failure(.init(authentications: delegate.supportedAuthenticationMethods.strings, partialSuccess: false)))
    |                              `- warning: type 'NIOSSHUserAuthenticationResponseMessage' does not conform to the 'Sendable' protocol
481 |
482 |         case .none:
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:235:6: note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
233 | }
234 |
235 | enum NIOSSHUserAuthenticationResponseMessage {
    |      `- note: consider making enum 'NIOSSHUserAuthenticationResponseMessage' conform to the 'Sendable' protocol
236 |     case success
237 |     case failure(SSHMessage.UserAuthFailureMessage)
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:426:25: warning: initialization of immutable value 'criticalOptions' was never used; consider replacing with assignment to '_' or removing it
424 |                 // This is a certificate and we have trusted CAs configured
425 |                 do {
426 |                     let criticalOptions = try certifiedKey.validate(
    |                         `- warning: initialization of immutable value 'criticalOptions' was never used; consider replacing with assignment to '_' or removing it
427 |                         principal: request.username,
428 |                         type: .user,
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:406:50: warning: capture of 'supportedMethods' with non-sendable type 'NIOSSHAvailableUserAuthenticationMethods' in a '@Sendable' closure
404 |
405 |             return promise.futureResult.map { outcome in
406 |                 .init(outcome, supportedMethods: supportedMethods)
    |                                                  `- warning: capture of 'supportedMethods' with non-sendable type 'NIOSSHAvailableUserAuthenticationMethods' in a '@Sendable' closure
407 |             }
408 |
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:21:15: note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 19 | /// not as a separate authentication method. When using certificates, the publicKey
 20 | /// method is used with a certified key.
 21 | public struct NIOSSHAvailableUserAuthenticationMethods: OptionSet {
    |               `- note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 22 |     public var rawValue: UInt8
 23 |
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:451:50: warning: capture of 'supportedMethods' with non-sendable type 'NIOSSHAvailableUserAuthenticationMethods' in a '@Sendable' closure
449 |
450 |             return promise.futureResult.map { outcome in
451 |                 .init(outcome, supportedMethods: supportedMethods)
    |                                                  `- warning: capture of 'supportedMethods' with non-sendable type 'NIOSSHAvailableUserAuthenticationMethods' in a '@Sendable' closure
452 |             }
453 |
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:21:15: note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 19 | /// not as a separate authentication method. When using certificates, the publicKey
 20 | /// method is used with a certified key.
 21 | public struct NIOSSHAvailableUserAuthenticationMethods: OptionSet {
    |               `- note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 22 |     public var rawValue: UInt8
 23 |
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationStateMachine.swift:489:50: warning: capture of 'supportedMethods' with non-sendable type 'NIOSSHAvailableUserAuthenticationMethods' in a '@Sendable' closure
487 |
488 |             return promise.futureResult.map { outcome in
489 |                 .init(outcome, supportedMethods: supportedMethods)
    |                                                  `- warning: capture of 'supportedMethods' with non-sendable type 'NIOSSHAvailableUserAuthenticationMethods' in a '@Sendable' closure
490 |             }
491 |         }
/host/spi-builder-workspace/Sources/NIOSSH/User Authentication/UserAuthenticationMethod.swift:21:15: note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 19 | /// not as a separate authentication method. When using certificates, the publicKey
 20 | /// method is used with a certified key.
 21 | public struct NIOSSHAvailableUserAuthenticationMethods: OptionSet {
    |               `- note: consider making struct 'NIOSSHAvailableUserAuthenticationMethods' conform to the 'Sendable' protocol
 22 |     public var rawValue: UInt8
 23 |
[427/460] Compiling NIOSSH NIOSSHPrivateKey.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:286:16: warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
284 |
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
    |                |- warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:287:16: warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
    |                |- warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemes' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemes' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:288:16: warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
    |                |- warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:289:16: warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
    |                |- warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:290:16: warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
    |                |- warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:291:16: warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
    |                |- warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:292:16: warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
    |                |- warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signaturesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signaturesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
294 | }
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:293:16: warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
    |                |- warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signatures' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signatures' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
294 | }
295 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:91:25: warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 89 |             switch self {
 90 |             case .tcpForwarding(let promise):
 91 |                 promise.succeed(result.map(GlobalRequest.TCPForwardingResponse.init))
    |                         `- warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 92 |             case .unknown(let promise):
 93 |                 promise.succeed(result?.buffer)
/host/spi-builder-workspace/Sources/NIOSSH/GlobalRequestDelegate.swift:52:19: note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 50 |
 51 |     /// The data associated with a successful response to a TCP forwarding request.
 52 |     public struct TCPForwardingResponse: Hashable {
    |                   `- note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 53 |         /// If requested to listen on a port, and the port the client requested was 0, this is set to the
 54 |         /// port that was actually bound. Otherwise is nil.
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:29: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                             `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:65: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                                                                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:25: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                         `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:121: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                                                                                                                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:411:23: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
409 |             switch result {
410 |             case .success:
411 |                 guard self.context != nil else {
    |                       `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
412 |                     // This write succeeded, but we're out of the pipeline anyway. Fail the promise.
413 |                     promise?.fail(ChannelError.eof)
[428/460] Compiling NIOSSH NIOSSHPublicKey.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:286:16: warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
284 |
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
    |                |- warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:287:16: warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
    |                |- warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemes' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemes' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:288:16: warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
    |                |- warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:289:16: warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
    |                |- warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:290:16: warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
    |                |- warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:291:16: warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
    |                |- warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:292:16: warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
    |                |- warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signaturesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signaturesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
294 | }
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:293:16: warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
    |                |- warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signatures' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signatures' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
294 | }
295 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:91:25: warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 89 |             switch self {
 90 |             case .tcpForwarding(let promise):
 91 |                 promise.succeed(result.map(GlobalRequest.TCPForwardingResponse.init))
    |                         `- warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 92 |             case .unknown(let promise):
 93 |                 promise.succeed(result?.buffer)
/host/spi-builder-workspace/Sources/NIOSSH/GlobalRequestDelegate.swift:52:19: note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 50 |
 51 |     /// The data associated with a successful response to a TCP forwarding request.
 52 |     public struct TCPForwardingResponse: Hashable {
    |                   `- note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 53 |         /// If requested to listen on a port, and the port the client requested was 0, this is set to the
 54 |         /// port that was actually bound. Otherwise is nil.
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:29: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                             `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:65: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                                                                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:25: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                         `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:121: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                                                                                                                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:411:23: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
409 |             switch result {
410 |             case .success:
411 |                 guard self.context != nil else {
    |                       `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
412 |                     // This write succeeded, but we're out of the pipeline anyway. Fail the promise.
413 |                     promise?.fail(ChannelError.eof)
[429/460] Compiling NIOSSH NIOSSHSignature.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:286:16: warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
284 |
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
    |                |- warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:287:16: warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
    |                |- warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemes' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemes' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:288:16: warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
    |                |- warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:289:16: warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
    |                |- warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:290:16: warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
    |                |- warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:291:16: warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
    |                |- warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:292:16: warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
    |                |- warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signaturesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signaturesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
294 | }
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:293:16: warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
    |                |- warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signatures' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signatures' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
294 | }
295 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:91:25: warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 89 |             switch self {
 90 |             case .tcpForwarding(let promise):
 91 |                 promise.succeed(result.map(GlobalRequest.TCPForwardingResponse.init))
    |                         `- warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 92 |             case .unknown(let promise):
 93 |                 promise.succeed(result?.buffer)
/host/spi-builder-workspace/Sources/NIOSSH/GlobalRequestDelegate.swift:52:19: note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 50 |
 51 |     /// The data associated with a successful response to a TCP forwarding request.
 52 |     public struct TCPForwardingResponse: Hashable {
    |                   `- note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 53 |         /// If requested to listen on a port, and the port the client requested was 0, this is set to the
 54 |         /// port that was actually bound. Otherwise is nil.
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:29: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                             `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:65: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                                                                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:25: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                         `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:121: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                                                                                                                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:411:23: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
409 |             switch result {
410 |             case .success:
411 |                 guard self.context != nil else {
    |                       `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
412 |                     // This write succeeded, but we're out of the pipeline anyway. Fail the promise.
413 |                     promise?.fail(ChannelError.eof)
[430/460] Compiling NIOSSH NIOSSHError.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:286:16: warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
284 |
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
    |                |- warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:287:16: warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
    |                |- warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemes' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemes' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:288:16: warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
    |                |- warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:289:16: warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
    |                |- warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:290:16: warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
    |                |- warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:291:16: warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
    |                |- warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:292:16: warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
    |                |- warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signaturesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signaturesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
294 | }
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:293:16: warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
    |                |- warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signatures' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signatures' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
294 | }
295 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:91:25: warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 89 |             switch self {
 90 |             case .tcpForwarding(let promise):
 91 |                 promise.succeed(result.map(GlobalRequest.TCPForwardingResponse.init))
    |                         `- warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 92 |             case .unknown(let promise):
 93 |                 promise.succeed(result?.buffer)
/host/spi-builder-workspace/Sources/NIOSSH/GlobalRequestDelegate.swift:52:19: note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 50 |
 51 |     /// The data associated with a successful response to a TCP forwarding request.
 52 |     public struct TCPForwardingResponse: Hashable {
    |                   `- note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 53 |         /// If requested to listen on a port, and the port the client requested was 0, this is set to the
 54 |         /// port that was actually bound. Otherwise is nil.
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:29: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                             `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:65: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                                                                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:25: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                         `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:121: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                                                                                                                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:411:23: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
409 |             switch result {
410 |             case .success:
411 |                 guard self.context != nil else {
    |                       `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
412 |                     // This write succeeded, but we're out of the pipeline anyway. Fail the promise.
413 |                     promise?.fail(ChannelError.eof)
[431/460] Compiling NIOSSH NIOSSHHandler.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:286:16: warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
284 |
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
    |                |- warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:287:16: warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
    |                |- warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemes' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemes' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:288:16: warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
    |                |- warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:289:16: warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
    |                |- warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:290:16: warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
    |                |- warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:291:16: warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
    |                |- warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:292:16: warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
    |                |- warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signaturesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signaturesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
294 | }
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:293:16: warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
    |                |- warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signatures' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signatures' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
294 | }
295 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:91:25: warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 89 |             switch self {
 90 |             case .tcpForwarding(let promise):
 91 |                 promise.succeed(result.map(GlobalRequest.TCPForwardingResponse.init))
    |                         `- warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 92 |             case .unknown(let promise):
 93 |                 promise.succeed(result?.buffer)
/host/spi-builder-workspace/Sources/NIOSSH/GlobalRequestDelegate.swift:52:19: note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 50 |
 51 |     /// The data associated with a successful response to a TCP forwarding request.
 52 |     public struct TCPForwardingResponse: Hashable {
    |                   `- note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 53 |         /// If requested to listen on a port, and the port the client requested was 0, this is set to the
 54 |         /// port that was actually bound. Otherwise is nil.
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:29: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                             `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:65: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                                                                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:25: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                         `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:121: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                                                                                                                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:411:23: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
409 |             switch result {
410 |             case .success:
411 |                 guard self.context != nil else {
    |                       `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
412 |                     // This write succeeded, but we're out of the pipeline anyway. Fail the promise.
413 |                     promise?.fail(ChannelError.eof)
[432/460] Compiling NIOSSH NIOSSHSendable.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:286:16: warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
284 |
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
    |                |- warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:287:16: warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
    |                |- warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemes' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemes' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:288:16: warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
    |                |- warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:289:16: warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
    |                |- warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:290:16: warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
    |                |- warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:291:16: warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
    |                |- warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:292:16: warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
    |                |- warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signaturesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signaturesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
294 | }
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:293:16: warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
    |                |- warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signatures' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signatures' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
294 | }
295 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:91:25: warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 89 |             switch self {
 90 |             case .tcpForwarding(let promise):
 91 |                 promise.succeed(result.map(GlobalRequest.TCPForwardingResponse.init))
    |                         `- warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 92 |             case .unknown(let promise):
 93 |                 promise.succeed(result?.buffer)
/host/spi-builder-workspace/Sources/NIOSSH/GlobalRequestDelegate.swift:52:19: note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 50 |
 51 |     /// The data associated with a successful response to a TCP forwarding request.
 52 |     public struct TCPForwardingResponse: Hashable {
    |                   `- note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 53 |         /// If requested to listen on a port, and the port the client requested was 0, this is set to the
 54 |         /// port that was actually bound. Otherwise is nil.
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:29: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                             `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:65: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                                                                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:25: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                         `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:121: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                                                                                                                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:411:23: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
409 |             switch result {
410 |             case .success:
411 |                 guard self.context != nil else {
    |                       `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
412 |                     // This write succeeded, but we're out of the pipeline anyway. Fail the promise.
413 |                     promise?.fail(ChannelError.eof)
[433/460] Compiling NIOSSH Role.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:286:16: warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
284 |
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
    |                |- warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:287:16: warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
    |                |- warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemes' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemes' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:288:16: warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
    |                |- warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:289:16: warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
    |                |- warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:290:16: warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
    |                |- warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:291:16: warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
    |                |- warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:292:16: warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
    |                |- warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signaturesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signaturesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
294 | }
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:293:16: warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
    |                |- warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signatures' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signatures' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
294 | }
295 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:91:25: warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 89 |             switch self {
 90 |             case .tcpForwarding(let promise):
 91 |                 promise.succeed(result.map(GlobalRequest.TCPForwardingResponse.init))
    |                         `- warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 92 |             case .unknown(let promise):
 93 |                 promise.succeed(result?.buffer)
/host/spi-builder-workspace/Sources/NIOSSH/GlobalRequestDelegate.swift:52:19: note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 50 |
 51 |     /// The data associated with a successful response to a TCP forwarding request.
 52 |     public struct TCPForwardingResponse: Hashable {
    |                   `- note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 53 |         /// If requested to listen on a port, and the port the client requested was 0, this is set to the
 54 |         /// port that was actually bound. Otherwise is nil.
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:29: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                             `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:65: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                                                                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:25: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                         `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:121: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                                                                                                                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:411:23: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
409 |             switch result {
410 |             case .success:
411 |                 guard self.context != nil else {
    |                       `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
412 |                     // This write succeeded, but we're out of the pipeline anyway. Fail the promise.
413 |                     promise?.fail(ChannelError.eof)
[434/460] Compiling NIOSSH SSHClientConfiguration.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:286:16: warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
284 |
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
    |                |- warning: static property 'transportProtectionSchemesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:287:16: warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
285 | private enum _CustomAlgorithms {
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
    |                |- warning: static property 'transportProtectionSchemes' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'transportProtectionSchemes' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'transportProtectionSchemes' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:288:16: warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
286 |     static var transportProtectionSchemesLock = NIOLock()
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
    |                |- warning: static property 'keyExchangeAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:289:16: warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
287 |     static var transportProtectionSchemes = [NIOSSHTransportProtection.Type]()
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
    |                |- warning: static property 'keyExchangeAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'keyExchangeAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'keyExchangeAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:290:16: warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
288 |     static var keyExchangeAlgorithmsLock = NIOLock()
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
    |                |- warning: static property 'publicKeyAlgorithmsLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithmsLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithmsLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:291:16: warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
289 |     static var keyExchangeAlgorithms = [NIOSSHKeyExchangeAlgorithmProtocol.Type]()
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
    |                |- warning: static property 'publicKeyAlgorithms' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'publicKeyAlgorithms' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'publicKeyAlgorithms' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:292:16: warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
290 |     static var publicKeyAlgorithmsLock = NIOLock()
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
    |                |- warning: static property 'signaturesLock' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signaturesLock' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signaturesLock' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
294 | }
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHPublicKey.swift:293:16: warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
291 |     static var publicKeyAlgorithms: [NIOSSHPublicKeyProtocol.Type] = []
292 |     static var signaturesLock = NIOLock()
293 |     static var signatures: [NIOSSHSignatureProtocol.Type] = []
    |                |- warning: static property 'signatures' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'signatures' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'signatures' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
294 | }
295 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:91:25: warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 89 |             switch self {
 90 |             case .tcpForwarding(let promise):
 91 |                 promise.succeed(result.map(GlobalRequest.TCPForwardingResponse.init))
    |                         `- warning: type 'GlobalRequest.TCPForwardingResponse' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 92 |             case .unknown(let promise):
 93 |                 promise.succeed(result?.buffer)
/host/spi-builder-workspace/Sources/NIOSSH/GlobalRequestDelegate.swift:52:19: note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 50 |
 51 |     /// The data associated with a successful response to a TCP forwarding request.
 52 |     public struct TCPForwardingResponse: Hashable {
    |                   `- note: consider making struct 'TCPForwardingResponse' conform to the 'Sendable' protocol
 53 |         /// If requested to listen on a port, and the port the client requested was 0, this is set to the
 54 |         /// port that was actually bound. Otherwise is nil.
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:29: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                             `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:209:65: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
207 |                 case .success(.some(let message)):
208 |                     do {
209 |                         try self.writeMessage(message, context: context)
    |                                                                 `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
210 |                         self.pendingWrite = false
211 |                         context.flush()
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:25: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                         `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:369:121: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
367 |                 switch result {
368 |                 case .success(let tcpForwardingResponse):
369 |                     try self.writeMessage(.init(.requestSuccess(.init(.tcpForwarding(tcpForwardingResponse), allocator: context.channel.allocator))), context: context)
    |                                                                                                                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
370 |                     context.flush()
371 |                 case .failure:
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:411:23: warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
 24 | /// other usage models, including port forwarding. It is also able to construct somewhat
 25 | /// arbitrary secure multiplexed channels.
 26 | public final class NIOSSHHandler {
    |                    `- note: class 'NIOSSHHandler' does not conform to the 'Sendable' protocol
 27 |     internal var channel: Channel? {
 28 |         self.context.map { $0.channel }
    :
409 |             switch result {
410 |             case .success:
411 |                 guard self.context != nil else {
    |                       `- warning: capture of 'self' with non-sendable type 'NIOSSHHandler' in a '@Sendable' closure
412 |                     // This write succeeded, but we're out of the pipeline anyway. Fail the promise.
413 |                     promise?.fail(ChannelError.eof)
[435/460] Compiling NIOSSH GlobalRequestDelegate.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:418:27: warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
416 |
417 |         /// A certificate valid for identifying a user.
418 |         public static let user = CertificateType(rawValue: 1)
    |                           |- warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'user' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
419 |
420 |         /// A certificate valid for identifying a host.
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:421:27: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
419 |
420 |         /// A certificate valid for identifying a host.
421 |         public static let host = CertificateType(rawValue: 2)
    |                           |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'host' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
422 |     }
423 | }
[436/460] Compiling NIOSSH ECDHCompatibleKey.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:418:27: warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
416 |
417 |         /// A certificate valid for identifying a user.
418 |         public static let user = CertificateType(rawValue: 1)
    |                           |- warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'user' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
419 |
420 |         /// A certificate valid for identifying a host.
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:421:27: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
419 |
420 |         /// A certificate valid for identifying a host.
421 |         public static let host = CertificateType(rawValue: 2)
    |                           |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'host' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
422 |     }
423 | }
[437/460] Compiling NIOSSH EllipticCurveKeyExchange.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:418:27: warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
416 |
417 |         /// A certificate valid for identifying a user.
418 |         public static let user = CertificateType(rawValue: 1)
    |                           |- warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'user' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
419 |
420 |         /// A certificate valid for identifying a host.
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:421:27: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
419 |
420 |         /// A certificate valid for identifying a host.
421 |         public static let host = CertificateType(rawValue: 2)
    |                           |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'host' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
422 |     }
423 | }
[438/460] Compiling NIOSSH SSHKeyExchangeResult.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:418:27: warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
416 |
417 |         /// A certificate valid for identifying a user.
418 |         public static let user = CertificateType(rawValue: 1)
    |                           |- warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'user' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
419 |
420 |         /// A certificate valid for identifying a host.
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:421:27: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
419 |
420 |         /// A certificate valid for identifying a host.
421 |         public static let host = CertificateType(rawValue: 2)
    |                           |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'host' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
422 |     }
423 | }
[439/460] Compiling NIOSSH SSHKeyExchangeStateMachine.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:418:27: warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
416 |
417 |         /// A certificate valid for identifying a user.
418 |         public static let user = CertificateType(rawValue: 1)
    |                           |- warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'user' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
419 |
420 |         /// A certificate valid for identifying a host.
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:421:27: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
419 |
420 |         /// A certificate valid for identifying a host.
421 |         public static let host = CertificateType(rawValue: 2)
    |                           |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'host' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
422 |     }
423 | }
[440/460] Compiling NIOSSH ClientServerAuthenticationDelegate.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:418:27: warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
416 |
417 |         /// A certificate valid for identifying a user.
418 |         public static let user = CertificateType(rawValue: 1)
    |                           |- warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'user' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
419 |
420 |         /// A certificate valid for identifying a host.
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:421:27: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
419 |
420 |         /// A certificate valid for identifying a host.
421 |         public static let host = CertificateType(rawValue: 2)
    |                           |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'host' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
422 |     }
423 | }
[441/460] Compiling NIOSSH CustomKeys.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:418:27: warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
416 |
417 |         /// A certificate valid for identifying a user.
418 |         public static let user = CertificateType(rawValue: 1)
    |                           |- warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'user' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
419 |
420 |         /// A certificate valid for identifying a host.
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:421:27: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
419 |
420 |         /// A certificate valid for identifying a host.
421 |         public static let host = CertificateType(rawValue: 2)
    |                           |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'host' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
422 |     }
423 | }
[442/460] Compiling NIOSSH NIOSSHCertifiedPublicKey.swift
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:418:27: warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
416 |
417 |         /// A certificate valid for identifying a user.
418 |         public static let user = CertificateType(rawValue: 1)
    |                           |- warning: static property 'user' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'user' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
419 |
420 |         /// A certificate valid for identifying a host.
/host/spi-builder-workspace/Sources/NIOSSH/Keys And Signatures/NIOSSHCertifiedPublicKey.swift:421:27: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
408 |     /// For extensibility purposes this is not defined as an enumeration, but instead as a `RawRepresentable` type
409 |     /// wrapping the base type.
410 |     public struct CertificateType: RawRepresentable {
    |                   `- note: consider making struct 'CertificateType' conform to the 'Sendable' protocol
411 |         public var rawValue: UInt32
412 |
    :
419 |
420 |         /// A certificate valid for identifying a host.
421 |         public static let host = CertificateType(rawValue: 2)
    |                           |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'NIOSSHCertifiedPublicKey.CertificateType' may have shared mutable state; this is an error in the Swift 6 language mode
    |                           |- note: add '@MainActor' to make static property 'host' part of global actor 'MainActor'
    |                           `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
422 |     }
423 | }
[443/460] Compiling NIOSSH SSHEncryptablePacketPayload.swift
[444/460] Compiling NIOSSH SSHMessages.swift
[445/460] Compiling NIOSSH SSHPacketParser.swift
[446/460] Compiling NIOSSH SSHPacketSerializer.swift
[447/460] Compiling NIOSSH SSHServerConfiguration.swift
[448/460] Compiling NIOSSH SSHTerminalModes.swift
[449/460] Compiling NIOSSH AESGCM.swift
[450/460] Compiling NIOSSH SSHTransportProtection.swift
[452/479] Compiling NIOSSHPerformanceTester shared.swift
[453/479] Compiling NIOSSHPerformanceTester BenchmarkHandshake.swift
/host/spi-builder-workspace/Sources/NIOSSHPerformanceTester/BenchmarkHandshake.swift:38:48: warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
36 |             b2b.server.connect(to: try .init(unixDomainSocketPath: "/foo"), promise: nil)
37 |
38 |             try b2b.client.pipeline.addHandler(NIOSSHHandler(role: self.clientRole, allocator: b2b.client.allocator, inboundChildChannelInitializer: nil)).wait()
   |                                                `- warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
39 |             try b2b.server.pipeline.addHandler(NIOSSHHandler(role: self.serverRole, allocator: b2b.server.allocator, inboundChildChannelInitializer: nil)).wait()
40 |             try b2b.interactInMemory()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:81:1: note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 79 |
 80 | @available(*, unavailable)
 81 | extension NIOSSHHandler: Sendable {}
    | `- note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 82 |
 83 | extension NIOSSHHandler {
/host/spi-builder-workspace/Sources/NIOSSHPerformanceTester/BenchmarkHandshake.swift:39:48: warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
37 |
38 |             try b2b.client.pipeline.addHandler(NIOSSHHandler(role: self.clientRole, allocator: b2b.client.allocator, inboundChildChannelInitializer: nil)).wait()
39 |             try b2b.server.pipeline.addHandler(NIOSSHHandler(role: self.serverRole, allocator: b2b.server.allocator, inboundChildChannelInitializer: nil)).wait()
   |                                                `- warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
40 |             try b2b.interactInMemory()
41 |         }
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:81:1: note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 79 |
 80 | @available(*, unavailable)
 81 | extension NIOSSHHandler: Sendable {}
    | `- note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 82 |
 83 | extension NIOSSHHandler {
[454/479] Compiling NIOSSHPerformanceTester Benchmark.swift
[455/479] Emitting module NIOSSHPerformanceTester
[456/479] Compiling NIOSSHClient GlueHandler.swift
[457/479] Compiling NIOSSHClient InteractivePasswordPromptDelegate.swift
[458/479] Compiling NIOSSHClient PortForwardingServer.swift
[459/479] Emitting module NIOSSHClient
/host/spi-builder-workspace/Sources/NIOSSHClient/main.swift:52:39: warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
 50 | let bootstrap = ClientBootstrap(group: group)
 51 |     .channelInitializer { channel in
 52 |         channel.pipeline.addHandlers([NIOSSHHandler(role: .client(.init(userAuthDelegate: InteractivePasswordPromptDelegate(username: parseResult.user, password: parseResult.password), serverAuthDelegate: AcceptAllHostKeysDelegate())), allocator: channel.allocator, inboundChildChannelInitializer: nil), ErrorHandler()])
    |                                       `- warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
 53 |     }
 54 |     .channelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:81:1: note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 79 |
 80 | @available(*, unavailable)
 81 | extension NIOSSHHandler: Sendable {}
    | `- note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 82 |
 83 | extension NIOSSHHandler {
[460/479] Compiling NIOSSHServer GlueHandler.swift
[461/479] Compiling NIOSSHPerformanceTester main.swift
[462/479] Compiling NIOSSHPerformanceTester BenchmarkLinearThroughput.swift
/host/spi-builder-workspace/Sources/NIOSSHPerformanceTester/BenchmarkLinearThroughput.swift:39:49: warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
37 |         let clientHandler = NIOSSHHandler(role: self.clientRole, allocator: self.b2b.client.allocator, inboundChildChannelInitializer: nil)
38 |
39 |         try self.b2b.client.pipeline.addHandler(clientHandler).wait()
   |                                                 `- warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
40 |         try self.b2b.server.pipeline.addHandler(NIOSSHHandler(role: self.serverRole, allocator: self.b2b.server.allocator, inboundChildChannelInitializer: nil)).wait()
41 |         try self.b2b.interactInMemory()
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:81:1: note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 79 |
 80 | @available(*, unavailable)
 81 | extension NIOSSHHandler: Sendable {}
    | `- note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 82 |
 83 | extension NIOSSHHandler {
/host/spi-builder-workspace/Sources/NIOSSHPerformanceTester/BenchmarkLinearThroughput.swift:40:49: warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
38 |
39 |         try self.b2b.client.pipeline.addHandler(clientHandler).wait()
40 |         try self.b2b.server.pipeline.addHandler(NIOSSHHandler(role: self.serverRole, allocator: self.b2b.server.allocator, inboundChildChannelInitializer: nil)).wait()
   |                                                 `- warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
41 |         try self.b2b.interactInMemory()
42 |
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:81:1: note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 79 |
 80 | @available(*, unavailable)
 81 | extension NIOSSHHandler: Sendable {}
    | `- note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 82 |
 83 | extension NIOSSHHandler {
[463/479] Compiling NIOSSHServer main.swift
/host/spi-builder-workspace/Sources/NIOSSHServer/main.swift:79:39: warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
77 | let bootstrap = ServerBootstrap(group: group)
78 |     .childChannelInitializer { channel in
79 |         channel.pipeline.addHandlers([NIOSSHHandler(role: .server(.init(hostKeys: [hostKey], userAuthDelegate: HardcodedPasswordDelegate(), globalRequestDelegate: RemotePortForwarderGlobalRequestDelegate())), allocator: channel.allocator, inboundChildChannelInitializer: sshChildChannelInitializer(_:_:)), ErrorHandler()])
   |                                       `- warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
80 |     }
81 |     .serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:81:1: note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 79 |
 80 | @available(*, unavailable)
 81 | extension NIOSSHHandler: Sendable {}
    | `- note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 82 |
 83 | extension NIOSSHHandler {
[464/479] Compiling NIOSSHServer RemotePortForwarding.swift
[465/480] Emitting module NIOSSHServer
/host/spi-builder-workspace/Sources/NIOSSHServer/main.swift:79:39: warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
77 | let bootstrap = ServerBootstrap(group: group)
78 |     .childChannelInitializer { channel in
79 |         channel.pipeline.addHandlers([NIOSSHHandler(role: .server(.init(hostKeys: [hostKey], userAuthDelegate: HardcodedPasswordDelegate(), globalRequestDelegate: RemotePortForwarderGlobalRequestDelegate())), allocator: channel.allocator, inboundChildChannelInitializer: sshChildChannelInitializer(_:_:)), ErrorHandler()])
   |                                       `- warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
80 |     }
81 |     .serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:81:1: note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 79 |
 80 | @available(*, unavailable)
 81 | extension NIOSSHHandler: Sendable {}
    | `- note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 82 |
 83 | extension NIOSSHHandler {
[466/480] Compiling NIOSSHServer ExecHandler.swift
/host/spi-builder-workspace/Sources/NIOSSHServer/ExecHandler.swift:117:49: warning: type 'GlueHandler' does not conform to the 'Sendable' protocol
115 |
116 |                 let (ours, theirs) = GlueHandler.matchedPair()
117 |                 try channel.pipeline.addHandler(ours).wait()
    |                                                 `- warning: type 'GlueHandler' does not conform to the 'Sendable' protocol
118 |
119 |                 _ = try NIOPipeBootstrap(group: channel.eventLoop)
/host/spi-builder-workspace/Sources/NIOSSHServer/GlueHandler.swift:17:13: note: class 'GlueHandler' does not conform to the 'Sendable' protocol
 15 | import NIOCore
 16 |
 17 | final class GlueHandler {
    |             `- note: class 'GlueHandler' does not conform to the 'Sendable' protocol
 18 |     private var partner: GlueHandler?
 19 |
/host/spi-builder-workspace/Sources/NIOSSHServer/ExecHandler.swift:123:23: warning: 'withPipes(inputDescriptor:outputDescriptor:)' is deprecated: renamed to 'takingOwnershipOfDescriptors(input:output:)'
121 |                     .channelInitializer { pipeChannel in
122 |                         pipeChannel.pipeline.addHandler(theirs)
123 |                     }.withPipes(inputDescriptor: outPipe.fileHandleForReading.fileDescriptor, outputDescriptor: inPipe.fileHandleForWriting.fileDescriptor).wait()
    |                       |- warning: 'withPipes(inputDescriptor:outputDescriptor:)' is deprecated: renamed to 'takingOwnershipOfDescriptors(input:output:)'
    |                       `- note: use 'takingOwnershipOfDescriptors(input:output:)' instead
124 |
125 |                 // Ok, great, we've sorted stdout and stdin. For stderr we need a different strategy: we just park a thread for this.
/host/spi-builder-workspace/Sources/NIOSSHServer/ExecHandler.swift:122:57: warning: capture of 'theirs' with non-sendable type 'GlueHandler' in a '@Sendable' closure
120 |                     .channelOption(ChannelOptions.allowRemoteHalfClosure, value: true)
121 |                     .channelInitializer { pipeChannel in
122 |                         pipeChannel.pipeline.addHandler(theirs)
    |                                                         `- warning: capture of 'theirs' with non-sendable type 'GlueHandler' in a '@Sendable' closure
123 |                     }.withPipes(inputDescriptor: outPipe.fileHandleForReading.fileDescriptor, outputDescriptor: inPipe.fileHandleForWriting.fileDescriptor).wait()
124 |
/host/spi-builder-workspace/Sources/NIOSSHServer/GlueHandler.swift:17:13: note: class 'GlueHandler' does not conform to the 'Sendable' protocol
 15 | import NIOCore
 16 |
 17 | final class GlueHandler {
    |             `- note: class 'GlueHandler' does not conform to the 'Sendable' protocol
 18 |     private var partner: GlueHandler?
 19 |
[467/480] Compiling NIOSSHServer DataToBufferCodec.swift
[468/480] Compiling NIOSSHClient ExecHandler.swift
/host/spi-builder-workspace/Sources/NIOSSHClient/ExecHandler.swift:51:19: warning: 'withPipes(inputDescriptor:outputDescriptor:)' is deprecated: renamed to 'takingOwnershipOfDescriptors(input:output:)'
 49 |                 bootstrap.channelOption(ChannelOptions.allowRemoteHalfClosure, value: true).channelInitializer { channel in
 50 |                     channel.pipeline.addHandler(theirs)
 51 |                 }.withPipes(inputDescriptor: 0, outputDescriptor: 1).whenComplete { result in
    |                   |- warning: 'withPipes(inputDescriptor:outputDescriptor:)' is deprecated: renamed to 'takingOwnershipOfDescriptors(input:output:)'
    |                   `- note: use 'takingOwnershipOfDescriptors(input:output:)' instead
 52 |                     switch result {
 53 |                     case .success:
/host/spi-builder-workspace/Sources/NIOSSHClient/ExecHandler.swift:49:17: warning: capture of 'bootstrap' with non-sendable type 'NIOPipeBootstrap' in a '@Sendable' closure; this is an error in the Swift 6 language mode
 47 |         context.channel.pipeline.addHandler(ours, position: .last).whenSuccess { _ in
 48 |             DispatchQueue(label: "pipe bootstrap").async {
 49 |                 bootstrap.channelOption(ChannelOptions.allowRemoteHalfClosure, value: true).channelInitializer { channel in
    |                 `- warning: capture of 'bootstrap' with non-sendable type 'NIOPipeBootstrap' in a '@Sendable' closure; this is an error in the Swift 6 language mode
 50 |                     channel.pipeline.addHandler(theirs)
 51 |                 }.withPipes(inputDescriptor: 0, outputDescriptor: 1).whenComplete { result in
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOPosix/Bootstrap.swift:2245:20: note: class 'NIOPipeBootstrap' does not conform to the 'Sendable' protocol
2243 | ///                       .takingOwnershipOfDescriptors(input: STDIN_FILENO, output: STDOUT_FILENO)
2244 | ///
2245 | public final class NIOPipeBootstrap {
     |                    `- note: class 'NIOPipeBootstrap' does not conform to the 'Sendable' protocol
2246 |     private let group: EventLoopGroup
2247 |     private var channelInitializer: Optional<ChannelInitializerCallback>
/host/spi-builder-workspace/Sources/NIOSSHClient/ExecHandler.swift:56:25: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure; this is an error in the Swift 6 language mode
 54 |                         // We need to exec a thing.
 55 |                         let execRequest = SSHChannelRequestEvent.ExecRequest(command: self.command, wantReply: false)
 56 |                         context.triggerUserOutboundEvent(execRequest).whenFailure { _ in
    |                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure; this is an error in the Swift 6 language mode
 57 |                             context.close(promise: nil)
 58 |                         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
/host/spi-builder-workspace/Sources/NIOSSHClient/ExecHandler.swift:50:49: warning: capture of 'theirs' with non-sendable type 'GlueHandler' in a '@Sendable' closure
 48 |             DispatchQueue(label: "pipe bootstrap").async {
 49 |                 bootstrap.channelOption(ChannelOptions.allowRemoteHalfClosure, value: true).channelInitializer { channel in
 50 |                     channel.pipeline.addHandler(theirs)
    |                                                 `- warning: capture of 'theirs' with non-sendable type 'GlueHandler' in a '@Sendable' closure
 51 |                 }.withPipes(inputDescriptor: 0, outputDescriptor: 1).whenComplete { result in
 52 |                     switch result {
/host/spi-builder-workspace/Sources/NIOSSHClient/GlueHandler.swift:17:13: note: class 'GlueHandler' does not conform to the 'Sendable' protocol
 15 | import NIOCore
 16 |
 17 | final class GlueHandler {
    |             `- note: class 'GlueHandler' does not conform to the 'Sendable' protocol
 18 |     private var partner: GlueHandler?
 19 |
/host/spi-builder-workspace/Sources/NIOSSHClient/ExecHandler.swift:55:87: warning: capture of 'self' with non-sendable type 'ExampleExecHandler' in a '@Sendable' closure
 18 | import NIOSSH
 19 |
 20 | final class ExampleExecHandler: ChannelDuplexHandler {
    |             `- note: class 'ExampleExecHandler' does not conform to the 'Sendable' protocol
 21 |     typealias InboundIn = SSHChannelData
 22 |     typealias InboundOut = ByteBuffer
    :
 53 |                     case .success:
 54 |                         // We need to exec a thing.
 55 |                         let execRequest = SSHChannelRequestEvent.ExecRequest(command: self.command, wantReply: false)
    |                                                                                       `- warning: capture of 'self' with non-sendable type 'ExampleExecHandler' in a '@Sendable' closure
 56 |                         context.triggerUserOutboundEvent(execRequest).whenFailure { _ in
 57 |                             context.close(promise: nil)
/host/spi-builder-workspace/Sources/NIOSSHClient/ExecHandler.swift:56:25: warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
 54 |                         // We need to exec a thing.
 55 |                         let execRequest = SSHChannelRequestEvent.ExecRequest(command: self.command, wantReply: false)
 56 |                         context.triggerUserOutboundEvent(execRequest).whenFailure { _ in
    |                         `- warning: capture of 'context' with non-sendable type 'ChannelHandlerContext' in a '@Sendable' closure
 57 |                             context.close(promise: nil)
 58 |                         }
/host/spi-builder-workspace/.build/checkouts/swift-nio/Sources/NIOCore/ChannelPipeline.swift:1859:20: note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1857 | /// at the right point in time. Often, the right behaviour is to react to an event and then forward it to the next
1858 | /// `ChannelHandler`.
1859 | public final class ChannelHandlerContext: ChannelInvoker {
     |                    `- note: class 'ChannelHandlerContext' does not conform to the 'Sendable' protocol
1860 |     // visible for ChannelPipeline to modify
1861 |     fileprivate var next: Optional<ChannelHandlerContext>
[469/480] Compiling NIOSSHClient main.swift
/host/spi-builder-workspace/Sources/NIOSSHClient/main.swift:52:39: warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
 50 | let bootstrap = ClientBootstrap(group: group)
 51 |     .channelInitializer { channel in
 52 |         channel.pipeline.addHandlers([NIOSSHHandler(role: .client(.init(userAuthDelegate: InteractivePasswordPromptDelegate(username: parseResult.user, password: parseResult.password), serverAuthDelegate: AcceptAllHostKeysDelegate())), allocator: channel.allocator, inboundChildChannelInitializer: nil), ErrorHandler()])
    |                                       `- warning: conformance of 'NIOSSHHandler' to 'Sendable' is unavailable; this is an error in the Swift 6 language mode
 53 |     }
 54 |     .channelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
/host/spi-builder-workspace/Sources/NIOSSH/NIOSSHHandler.swift:81:1: note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 79 |
 80 | @available(*, unavailable)
 81 | extension NIOSSHHandler: Sendable {}
    | `- note: conformance of 'NIOSSHHandler' to 'Sendable' has been explicitly marked unavailable here
 82 |
 83 | extension NIOSSHHandler {
[470/480] Compiling NIOSSHClient SimpleCLIParser.swift
[473/482] Wrapping AST for NIOSSHPerformanceTester for debugging
[474/482] Write Objects.LinkFileList
[475/482] Wrapping AST for NIOSSHClient for debugging
[476/482] Write Objects.LinkFileList
[477/482] Wrapping AST for NIOSSHServer for debugging
[478/482] Write Objects.LinkFileList
[479/482] Linking NIOSSHClient
[480/482] Linking NIOSSHPerformanceTester
[481/482] Linking NIOSSHServer
Build complete! (119.61s)
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-crypto",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.0.0",
            "upper_bound" : "4.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-crypto.git"
    },
    {
      "identity" : "swift-atomics",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.0.2",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-atomics.git"
    },
    {
      "identity" : "swift-docc-plugin",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.0.0",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-docc-plugin"
    }
  ],
  "manifest_display_name" : "swift-nio-ssh",
  "name" : "swift-nio-ssh",
  "path" : "/host/spi-builder-workspace",
  "platforms" : [
    {
      "name" : "macos",
      "version" : "10.15"
    },
    {
      "name" : "ios",
      "version" : "13.0"
    },
    {
      "name" : "watchos",
      "version" : "6.0"
    },
    {
      "name" : "tvos",
      "version" : "13.0"
    }
  ],
  "products" : [
    {
      "name" : "NIOSSH",
      "targets" : [
        "NIOSSH"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "NIOSSHServer",
      "targets" : [
        "NIOSSHServer"
      ],
      "type" : {
        "executable" : null
      }
    },
    {
      "name" : "NIOSSHPerformanceTester",
      "targets" : [
        "NIOSSHPerformanceTester"
      ],
      "type" : {
        "executable" : null
      }
    },
    {
      "name" : "NIOSSHClient",
      "targets" : [
        "NIOSSHClient"
      ],
      "type" : {
        "executable" : null
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "NIOSSHTests",
      "module_type" : "SwiftTarget",
      "name" : "NIOSSHTests",
      "path" : "Tests/NIOSSHTests",
      "product_dependencies" : [
        "NIOCore",
        "NIOEmbedded",
        "NIOFoundationCompat"
      ],
      "sources" : [
        "AESGCMTests.swift",
        "ByteBuffer+SSHTests.swift",
        "CertificateAuthenticationIntegrationTests.swift",
        "CertifiedKeyTests.swift",
        "ChildChannelMultiplexerTests.swift",
        "ECKeyExchangeTests.swift",
        "EndToEndTests.swift",
        "FuzzResultTests.swift",
        "HostKeyTests.swift",
        "SSHConfigurationCertificateTests.swift",
        "SSHConnectionStateMachineTests.swift",
        "SSHEncryptedTrafficTests.swift",
        "SSHHandlerTests.swift",
        "SSHKeyExchangeCertificateTests.swift",
        "SSHKeyExchangeStateMachineTests.swift",
        "SSHMessagesTests.swift",
        "SSHPackerSerializerTests.swift",
        "SSHPacketParserTests.swift",
        "UserAuthenticationStateMachineTests.swift",
        "Utilities.swift",
        "UtilitiesTests.swift"
      ],
      "target_dependencies" : [
        "NIOSSH"
      ],
      "type" : "test"
    },
    {
      "c99name" : "NIOSSHServer",
      "module_type" : "SwiftTarget",
      "name" : "NIOSSHServer",
      "path" : "Sources/NIOSSHServer",
      "product_dependencies" : [
        "NIOCore",
        "NIOPosix",
        "NIOFoundationCompat",
        "Crypto"
      ],
      "product_memberships" : [
        "NIOSSHServer"
      ],
      "sources" : [
        "DataToBufferCodec.swift",
        "ExecHandler.swift",
        "GlueHandler.swift",
        "RemotePortForwarding.swift",
        "main.swift"
      ],
      "target_dependencies" : [
        "NIOSSH"
      ],
      "type" : "executable"
    },
    {
      "c99name" : "NIOSSHPerformanceTester",
      "module_type" : "SwiftTarget",
      "name" : "NIOSSHPerformanceTester",
      "path" : "Sources/NIOSSHPerformanceTester",
      "product_dependencies" : [
        "NIOCore",
        "NIOEmbedded",
        "Crypto"
      ],
      "product_memberships" : [
        "NIOSSHPerformanceTester"
      ],
      "sources" : [
        "Benchmark.swift",
        "BenchmarkHandshake.swift",
        "BenchmarkLinearThroughput.swift",
        "main.swift",
        "shared.swift"
      ],
      "target_dependencies" : [
        "NIOSSH"
      ],
      "type" : "executable"
    },
    {
      "c99name" : "NIOSSHClient",
      "module_type" : "SwiftTarget",
      "name" : "NIOSSHClient",
      "path" : "Sources/NIOSSHClient",
      "product_dependencies" : [
        "NIOCore",
        "NIOPosix",
        "NIOConcurrencyHelpers"
      ],
      "product_memberships" : [
        "NIOSSHClient"
      ],
      "sources" : [
        "ExecHandler.swift",
        "GlueHandler.swift",
        "InteractivePasswordPromptDelegate.swift",
        "PortForwardingServer.swift",
        "SimpleCLIParser.swift",
        "main.swift"
      ],
      "target_dependencies" : [
        "NIOSSH"
      ],
      "type" : "executable"
    },
    {
      "c99name" : "NIOSSH",
      "module_type" : "SwiftTarget",
      "name" : "NIOSSH",
      "path" : "Sources/NIOSSH",
      "product_dependencies" : [
        "NIOCore",
        "NIOConcurrencyHelpers",
        "NIOFoundationCompat",
        "Crypto",
        "Atomics"
      ],
      "product_memberships" : [
        "NIOSSH",
        "NIOSSHServer",
        "NIOSSHPerformanceTester",
        "NIOSSHClient"
      ],
      "sources" : [
        "ByteBuffer+SSH.swift",
        "CSPRNG/CSPRNG.swift",
        "Child Channels/ChildChannelOptions.swift",
        "Child Channels/ChildChannelStateMachine.swift",
        "Child Channels/ChildChannelUserEvents.swift",
        "Child Channels/ChildChannelWindowManager.swift",
        "Child Channels/ChildChannelWritabilityManager.swift",
        "Child Channels/OutboundFlowController.swift",
        "Child Channels/SSHChannelData.swift",
        "Child Channels/SSHChannelIdentifier.swift",
        "Child Channels/SSHChannelMultiplexer.swift",
        "Child Channels/SSHChannelType.swift",
        "Child Channels/SSHChildChannel.swift",
        "Connection State Machine/Operations/AcceptsChannelMessages.swift",
        "Connection State Machine/Operations/AcceptsKeyExchangeMessages.swift",
        "Connection State Machine/Operations/AcceptsUserAuthMessages.swift",
        "Connection State Machine/Operations/AcceptsVersionMessages.swift",
        "Connection State Machine/Operations/SendsChannelMessages.swift",
        "Connection State Machine/Operations/SendsKeyExchangeMessages.swift",
        "Connection State Machine/Operations/SendsUserAuthMessages.swift",
        "Connection State Machine/SSHConnectionStateMachine.swift",
        "Connection State Machine/States/ActiveState.swift",
        "Connection State Machine/States/IdleState.swift",
        "Connection State Machine/States/KeyExchangeState.swift",
        "Connection State Machine/States/ReceivedKexInitWhenActiveState.swift",
        "Connection State Machine/States/ReceivedNewKeysState.swift",
        "Connection State Machine/States/RekeyingReceivedNewKeysState.swift",
        "Connection State Machine/States/RekeyingSentNewKeysState.swift",
        "Connection State Machine/States/RekeyingState.swift",
        "Connection State Machine/States/SentKexInitWhenActiveState.swift",
        "Connection State Machine/States/SentNewKeysState.swift",
        "Connection State Machine/States/SentVersionState.swift",
        "Connection State Machine/States/UserAuthenticationState.swift",
        "Constants.swift",
        "GlobalRequestDelegate.swift",
        "Key Exchange/ECDHCompatibleKey.swift",
        "Key Exchange/EllipticCurveKeyExchange.swift",
        "Key Exchange/SSHKeyExchangeResult.swift",
        "Key Exchange/SSHKeyExchangeStateMachine.swift",
        "Keys And Signatures/ClientServerAuthenticationDelegate.swift",
        "Keys And Signatures/CustomKeys.swift",
        "Keys And Signatures/NIOSSHCertifiedPublicKey.swift",
        "Keys And Signatures/NIOSSHPrivateKey.swift",
        "Keys And Signatures/NIOSSHPublicKey.swift",
        "Keys And Signatures/NIOSSHSignature.swift",
        "NIOSSHError.swift",
        "NIOSSHHandler.swift",
        "NIOSSHSendable.swift",
        "Role.swift",
        "SSHClientConfiguration.swift",
        "SSHEncryptablePacketPayload.swift",
        "SSHMessages.swift",
        "SSHPacketParser.swift",
        "SSHPacketSerializer.swift",
        "SSHServerConfiguration.swift",
        "SSHTerminalModes.swift",
        "TransportProtection/AESGCM.swift",
        "TransportProtection/SSHTransportProtection.swift",
        "User Authentication/ClientUserAuthenticationDelegate.swift",
        "User Authentication/DenyAllServerAuthDelegate.swift",
        "User Authentication/ServerUserAuthenticationDelegate.swift",
        "User Authentication/SimplePasswordDelegate.swift",
        "User Authentication/UserAuthDelegate.swift",
        "User Authentication/UserAuthSignablePayload.swift",
        "User Authentication/UserAuthenticationMethod.swift",
        "User Authentication/UserAuthenticationStateMachine.swift"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "5.10"
}
basic-6.1-latest: Pulling from swiftpackageindex/spi-images
Digest: sha256:108e10880bce35e9496fba26782956e40a8e91a2a227f9b90af7e4cd93d2c183
Status: Image is up to date for registry.gitlab.com/swiftpackageindex/spi-images:basic-6.1-latest
Done.