Swift Package Index

Build Information

Successful build of Emitter, reference main (5480d5), with Swift 6.2 (beta) for Linux on 20 Jun 2025 07:51:21 UTC.

Swift 6 data race errors: 0

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4609320-0":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.2-latest swift build --triple x86_64-unknown-linux-gnu 2>&1

Build Log

[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[31/64] Compiling Emitter Subscription.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:12:45: warning: capture of 'subscriber' with non-Sendable type 'Sub' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 7 |   // MARK: Lifecycle
 8 |
 9 |   init<Sub: Subscriber>(
   |        `- note: consider making generic parameter 'Sub' conform to the 'Sendable' protocol
10 |     subscriber: Sub
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
   |                                             `- warning: capture of 'subscriber' with non-Sendable type 'Sub' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
13 |   }
14 |
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:12:45: warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
10 |     subscriber: Sub
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
   |                                             `- warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
13 |   }
14 |
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:10:5: warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |
 9 |   init<Sub: Subscriber>(
10 |     subscriber: Sub
   |     `- warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/SubscribeMain.swift:39:14: warning: sending 'emission' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
37 |   fileprivate func receive(emission: Emission<Output, Failure>) {
38 |     Task { @MainActor in
39 |       switch emission {
   |              |- warning: sending 'emission' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |              `- note: task-isolated 'emission' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses
40 |       case .value(let value):
41 |         valueFunc(value)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/SubscribeMain.swift:41:9: warning: sending 'self' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
39 |       switch emission {
40 |       case .value(let value):
41 |         valueFunc(value)
   |         |- warning: sending 'self' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |         `- note: task-isolated 'self' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses
42 |       case .failed(let error):
43 |         failedFunc?(error)
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[32/64] Compiling Emitter TransformProxy.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:12:45: warning: capture of 'subscriber' with non-Sendable type 'Sub' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 7 |   // MARK: Lifecycle
 8 |
 9 |   init<Sub: Subscriber>(
   |        `- note: consider making generic parameter 'Sub' conform to the 'Sendable' protocol
10 |     subscriber: Sub
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
   |                                             `- warning: capture of 'subscriber' with non-Sendable type 'Sub' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
13 |   }
14 |
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:12:45: warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
10 |     subscriber: Sub
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
   |                                             `- warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
13 |   }
14 |
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:10:5: warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |
 9 |   init<Sub: Subscriber>(
10 |     subscriber: Sub
   |     `- warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/SubscribeMain.swift:39:14: warning: sending 'emission' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
37 |   fileprivate func receive(emission: Emission<Output, Failure>) {
38 |     Task { @MainActor in
39 |       switch emission {
   |              |- warning: sending 'emission' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |              `- note: task-isolated 'emission' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses
40 |       case .value(let value):
41 |         valueFunc(value)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/SubscribeMain.swift:41:9: warning: sending 'self' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
39 |       switch emission {
40 |       case .value(let value):
41 |         valueFunc(value)
   |         |- warning: sending 'self' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |         `- note: task-isolated 'self' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses
42 |       case .failed(let error):
43 |         failedFunc?(error)
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[33/64] Compiling Emitter AsyncValue.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:12:45: warning: capture of 'subscriber' with non-Sendable type 'Sub' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 7 |   // MARK: Lifecycle
 8 |
 9 |   init<Sub: Subscriber>(
   |        `- note: consider making generic parameter 'Sub' conform to the 'Sendable' protocol
10 |     subscriber: Sub
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
   |                                             `- warning: capture of 'subscriber' with non-Sendable type 'Sub' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
13 |   }
14 |
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:12:45: warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
10 |     subscriber: Sub
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
   |                                             `- warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
13 |   }
14 |
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:10:5: warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |
 9 |   init<Sub: Subscriber>(
10 |     subscriber: Sub
   |     `- warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/SubscribeMain.swift:39:14: warning: sending 'emission' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
37 |   fileprivate func receive(emission: Emission<Output, Failure>) {
38 |     Task { @MainActor in
39 |       switch emission {
   |              |- warning: sending 'emission' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |              `- note: task-isolated 'emission' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses
40 |       case .value(let value):
41 |         valueFunc(value)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/SubscribeMain.swift:41:9: warning: sending 'self' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
39 |       switch emission {
40 |       case .value(let value):
41 |         valueFunc(value)
   |         |- warning: sending 'self' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |         `- note: task-isolated 'self' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses
42 |       case .failed(let error):
43 |         failedFunc?(error)
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[34/64] Compiling Emitter Locked.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:12:45: warning: capture of 'subscriber' with non-Sendable type 'Sub' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 7 |   // MARK: Lifecycle
 8 |
 9 |   init<Sub: Subscriber>(
   |        `- note: consider making generic parameter 'Sub' conform to the 'Sendable' protocol
10 |     subscriber: Sub
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
   |                                             `- warning: capture of 'subscriber' with non-Sendable type 'Sub' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
13 |   }
14 |
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:12:45: warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
10 |     subscriber: Sub
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
   |                                             `- warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
13 |   }
14 |
/host/spi-builder-workspace/Sources/Emitter/Subscribers/Subscription.swift:10:5: warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |
 9 |   init<Sub: Subscriber>(
10 |     subscriber: Sub
   |     `- warning: capture of non-Sendable type 'Sub.Type' in an isolated closure; this is an error in the Swift 6 language mode
11 |   ) where Output == Sub.Input, Failure == Sub.Failure {
12 |     self.subscriberReceiver = { emission in subscriber.receive(emission: emission) }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/SubscribeMain.swift:39:14: warning: sending 'emission' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
37 |   fileprivate func receive(emission: Emission<Output, Failure>) {
38 |     Task { @MainActor in
39 |       switch emission {
   |              |- warning: sending 'emission' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |              `- note: task-isolated 'emission' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses
40 |       case .value(let value):
41 |         valueFunc(value)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/SubscribeMain.swift:41:9: warning: sending 'self' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
39 |       switch emission {
40 |       case .value(let value):
41 |         valueFunc(value)
   |         |- warning: sending 'self' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |         `- note: task-isolated 'self' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses
42 |       case .failed(let error):
43 |         failedFunc?(error)
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[35/64] Compiling Emitter JustEmitter.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:22: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                      `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:20: warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                    `- warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
46 |           }
47 |         }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:30:25: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
28 |     public typealias Output = Upstream.Output
29 |
30 |     public func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                         `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
31 |       let wasFirst = isFirst.withLock { isFirst in
32 |         if isFirst {
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:19: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:40:14: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
38 |       }
39 |       if wasFirst {
40 |         Task.detached {
   |              `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- note: closure captures 'self' which is accessible to code in the current task
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated value of non-Sendable type 'Upstream.Output' to actor-isolated instance method 'resolve(to:)' risks causing races in between task-isolated and actor-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
46 |           }
47 |         }
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[36/64] Compiling Emitter NeverEmitter.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:22: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                      `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:20: warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                    `- warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
46 |           }
47 |         }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:30:25: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
28 |     public typealias Output = Upstream.Output
29 |
30 |     public func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                         `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
31 |       let wasFirst = isFirst.withLock { isFirst in
32 |         if isFirst {
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:19: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:40:14: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
38 |       }
39 |       if wasFirst {
40 |         Task.detached {
   |              `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- note: closure captures 'self' which is accessible to code in the current task
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated value of non-Sendable type 'Upstream.Output' to actor-isolated instance method 'resolve(to:)' risks causing races in between task-isolated and actor-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
46 |           }
47 |         }
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[37/64] Compiling Emitter PublishSubject.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:22: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                      `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:20: warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                    `- warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
46 |           }
47 |         }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:30:25: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
28 |     public typealias Output = Upstream.Output
29 |
30 |     public func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                         `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
31 |       let wasFirst = isFirst.withLock { isFirst in
32 |         if isFirst {
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:19: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:40:14: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
38 |       }
39 |       if wasFirst {
40 |         Task.detached {
   |              `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- note: closure captures 'self' which is accessible to code in the current task
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated value of non-Sendable type 'Upstream.Output' to actor-isolated instance method 'resolve(to:)' risks causing races in between task-isolated and actor-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
46 |           }
47 |         }
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[38/64] Compiling Emitter ValueSubject.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:22: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                      `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:20: warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                    `- warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
46 |           }
47 |         }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:30:25: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
28 |     public typealias Output = Upstream.Output
29 |
30 |     public func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                         `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
31 |       let wasFirst = isFirst.withLock { isFirst in
32 |         if isFirst {
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:19: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:40:14: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
38 |       }
39 |       if wasFirst {
40 |         Task.detached {
   |              `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- note: closure captures 'self' which is accessible to code in the current task
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated value of non-Sendable type 'Upstream.Output' to actor-isolated instance method 'resolve(to:)' risks causing races in between task-isolated and actor-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
46 |           }
47 |         }
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[39/64] Compiling Emitter EmissionDataProxy.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:22: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                      `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:20: warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                    `- warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
46 |           }
47 |         }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:30:25: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
28 |     public typealias Output = Upstream.Output
29 |
30 |     public func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                         `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
31 |       let wasFirst = isFirst.withLock { isFirst in
32 |         if isFirst {
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:19: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:40:14: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
38 |       }
39 |       if wasFirst {
40 |         Task.detached {
   |              `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- note: closure captures 'self' which is accessible to code in the current task
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated value of non-Sendable type 'Upstream.Output' to actor-isolated instance method 'resolve(to:)' risks causing races in between task-isolated and actor-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
46 |           }
47 |         }
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[40/64] Compiling Emitter FirstValue.swift
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:22: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                      `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: type 'Self.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:20: warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                    `- warning: non-Sendable type 'AsyncValue<Self.Output?>' cannot be sent into actor-isolated context in call to property 'value'; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:7:35: warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 5 |     get async {
 6 |       let sub = Emitters.FirstValue(upstream: self)
 7 |       return await sub.asyncValue.value
   |                                   `- warning: non-Sendable type 'Self.Output?' of property 'value' cannot exit actor-isolated context; this is an error in the Swift 6 language mode
 8 |     }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              `- warning: type 'Upstream.Output' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
46 |           }
47 |         }
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:30:25: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
28 |     public typealias Output = Upstream.Output
29 |
30 |     public func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                         `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
31 |       let wasFirst = isFirst.withLock { isFirst in
32 |         if isFirst {
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:19: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:54:49: warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
52 |     // MARK: Internal
53 |
54 |     let asyncValue = AsyncValue<Upstream.Output?>()
   |                                                 `- warning: non-Sendable 'AsyncValue<Upstream.Output?>'-typed result can not be returned from actor-isolated initializer 'init()' to nonisolated context; this is an error in the Swift 6 language mode
55 |
56 |     // MARK: Private
/host/spi-builder-workspace/Sources/Emitter/Utilities/AsyncValue.swift:4:7: note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  2 |
  3 | /// A value `T` which will eventually be resolved for access.
  4 | actor AsyncValue<T: Sendable> {
    |       `- note: generic actor 'AsyncValue' does not conform to the 'Sendable' protocol
  5 |
  6 |   // MARK: Lifecycle
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:40:14: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
38 |       }
39 |       if wasFirst {
40 |         Task.detached {
   |              `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure; this is an error in the Swift 6 language mode
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                   `- note: closure captures 'self' which is accessible to code in the current task
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending value of non-Sendable type 'Upstream.Output' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated value of non-Sendable type 'Upstream.Output' to actor-isolated instance method 'resolve(to:)' risks causing races in between task-isolated and actor-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:43:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
41 |           switch emission {
42 |           case .value(let value):
43 |             await asyncValue.resolve(to: value)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
44 |           default:
45 |             await asyncValue.resolve(to: nil)
/host/spi-builder-workspace/Sources/Emitter/Subscribers/FirstValue.swift:45:30: warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
43 |             await asyncValue.resolve(to: value)
44 |           default:
45 |             await asyncValue.resolve(to: nil)
   |                              |- warning: sending 'self.asyncValue' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                              `- note: sending task-isolated 'self.asyncValue' to actor-isolated instance method 'resolve(to:)' risks causing data races between actor-isolated and task-isolated uses
46 |           }
47 |         }
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[41/64] Compiling Emitter Union.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestThree.swift:25:67: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 23 |     _ otherB: UpstreamB,
 24 |     _ otherC: UpstreamC
 25 |   ) -> some Emitter<(Output, UpstreamB.Output, UpstreamC.Output), Error> {
    |                                                                   `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 26 |     Emitters
 27 |       .CombineLatestThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestTwo.swift:20:49: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 18 |   public func combineLatest<UpstreamB: Emitter>(
 19 |     _ otherB: UpstreamB
 20 |   ) -> some Emitter<(Output, UpstreamB.Output), Error> {
    |                                                 `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 21 |     Emitters
 22 |       .CombineLatestTwo(upstreamA: self, upstreamB: otherB)
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:19:24: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
17 |   public func compactMap<T>(
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
   |                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
20 |     map(transformer)
21 |       .compact()
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:14:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |   }
 9 |
10 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
11 |     _ transformer: @escaping @Sendable (Output) -> T?
12 |   ) -> some Emitter<T, Failure> {
13 |     map(transformer)
14 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:21:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
17 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
20 |     map(transformer)
21 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
22 |   }
23 | }
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[42/64] Compiling Emitter CombineLatestThree.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestThree.swift:25:67: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 23 |     _ otherB: UpstreamB,
 24 |     _ otherC: UpstreamC
 25 |   ) -> some Emitter<(Output, UpstreamB.Output, UpstreamC.Output), Error> {
    |                                                                   `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 26 |     Emitters
 27 |       .CombineLatestThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestTwo.swift:20:49: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 18 |   public func combineLatest<UpstreamB: Emitter>(
 19 |     _ otherB: UpstreamB
 20 |   ) -> some Emitter<(Output, UpstreamB.Output), Error> {
    |                                                 `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 21 |     Emitters
 22 |       .CombineLatestTwo(upstreamA: self, upstreamB: otherB)
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:19:24: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
17 |   public func compactMap<T>(
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
   |                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
20 |     map(transformer)
21 |       .compact()
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:14:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |   }
 9 |
10 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
11 |     _ transformer: @escaping @Sendable (Output) -> T?
12 |   ) -> some Emitter<T, Failure> {
13 |     map(transformer)
14 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:21:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
17 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
20 |     map(transformer)
21 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
22 |   }
23 | }
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[43/64] Compiling Emitter CombineLatestTwo.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestThree.swift:25:67: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 23 |     _ otherB: UpstreamB,
 24 |     _ otherC: UpstreamC
 25 |   ) -> some Emitter<(Output, UpstreamB.Output, UpstreamC.Output), Error> {
    |                                                                   `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 26 |     Emitters
 27 |       .CombineLatestThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestTwo.swift:20:49: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 18 |   public func combineLatest<UpstreamB: Emitter>(
 19 |     _ otherB: UpstreamB
 20 |   ) -> some Emitter<(Output, UpstreamB.Output), Error> {
    |                                                 `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 21 |     Emitters
 22 |       .CombineLatestTwo(upstreamA: self, upstreamB: otherB)
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:19:24: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
17 |   public func compactMap<T>(
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
   |                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
20 |     map(transformer)
21 |       .compact()
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:14:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |   }
 9 |
10 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
11 |     _ transformer: @escaping @Sendable (Output) -> T?
12 |   ) -> some Emitter<T, Failure> {
13 |     map(transformer)
14 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:21:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
17 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
20 |     map(transformer)
21 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
22 |   }
23 | }
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[44/64] Compiling Emitter CompactMap.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestThree.swift:25:67: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 23 |     _ otherB: UpstreamB,
 24 |     _ otherC: UpstreamC
 25 |   ) -> some Emitter<(Output, UpstreamB.Output, UpstreamC.Output), Error> {
    |                                                                   `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 26 |     Emitters
 27 |       .CombineLatestThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestTwo.swift:20:49: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 18 |   public func combineLatest<UpstreamB: Emitter>(
 19 |     _ otherB: UpstreamB
 20 |   ) -> some Emitter<(Output, UpstreamB.Output), Error> {
    |                                                 `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 21 |     Emitters
 22 |       .CombineLatestTwo(upstreamA: self, upstreamB: otherB)
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:19:24: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
17 |   public func compactMap<T>(
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
   |                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
20 |     map(transformer)
21 |       .compact()
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:14:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |   }
 9 |
10 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
11 |     _ transformer: @escaping @Sendable (Output) -> T?
12 |   ) -> some Emitter<T, Failure> {
13 |     map(transformer)
14 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:21:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
17 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
20 |     map(transformer)
21 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
22 |   }
23 | }
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[45/64] Compiling Emitter Dedupe.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestThree.swift:25:67: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 23 |     _ otherB: UpstreamB,
 24 |     _ otherC: UpstreamC
 25 |   ) -> some Emitter<(Output, UpstreamB.Output, UpstreamC.Output), Error> {
    |                                                                   `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 26 |     Emitters
 27 |       .CombineLatestThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestTwo.swift:20:49: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 18 |   public func combineLatest<UpstreamB: Emitter>(
 19 |     _ otherB: UpstreamB
 20 |   ) -> some Emitter<(Output, UpstreamB.Output), Error> {
    |                                                 `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 21 |     Emitters
 22 |       .CombineLatestTwo(upstreamA: self, upstreamB: otherB)
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:19:24: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
17 |   public func compactMap<T>(
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
   |                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
20 |     map(transformer)
21 |       .compact()
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:14:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |   }
 9 |
10 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
11 |     _ transformer: @escaping @Sendable (Output) -> T?
12 |   ) -> some Emitter<T, Failure> {
13 |     map(transformer)
14 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:21:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
17 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
20 |     map(transformer)
21 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
22 |   }
23 | }
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[46/64] Compiling Emitter Filter.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestThree.swift:25:67: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 23 |     _ otherB: UpstreamB,
 24 |     _ otherC: UpstreamC
 25 |   ) -> some Emitter<(Output, UpstreamB.Output, UpstreamC.Output), Error> {
    |                                                                   `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 26 |     Emitters
 27 |       .CombineLatestThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
/host/spi-builder-workspace/Sources/Emitter/Operators/CombineLatestTwo.swift:20:49: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 18 |   public func combineLatest<UpstreamB: Emitter>(
 19 |     _ otherB: UpstreamB
 20 |   ) -> some Emitter<(Output, UpstreamB.Output), Error> {
    |                                                 `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 21 |     Emitters
 22 |       .CombineLatestTwo(upstreamA: self, upstreamB: otherB)
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:19:24: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
17 |   public func compactMap<T>(
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
   |                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
20 |     map(transformer)
21 |       .compact()
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:14:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
 8 |   }
 9 |
10 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
11 |     _ transformer: @escaping @Sendable (Output) -> T?
12 |   ) -> some Emitter<T, Failure> {
13 |     map(transformer)
14 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
/host/spi-builder-workspace/Sources/Emitter/Operators/CompactMap.swift:21:8: warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
15 |   }
16 |
17 |   public func compactMap<T>(
   |                          `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
18 |     _ transformer: @escaping @Sendable (Output) throws -> T?
19 |   ) -> some Emitter<T, Error> {
20 |     map(transformer)
21 |       .compact()
   |        `- warning: type 'T' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
22 |   }
23 | }
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[47/64] Compiling Emitter First.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:24:25: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
    |                         `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 25 |       self.upstream = upstream
 26 |     }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
[48/64] Compiling Emitter FlatMapLatest.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:24:25: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
    |                         `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 25 |       self.upstream = upstream
 26 |     }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
[49/64] Compiling Emitter Map.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:24:25: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
    |                         `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 25 |       self.upstream = upstream
 26 |     }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
[50/64] Compiling Emitter MapFailure.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:24:25: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
    |                         `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 25 |       self.upstream = upstream
 26 |     }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
[51/64] Compiling Emitter MergeThree.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:24:25: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
    |                         `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 25 |       self.upstream = upstream
 26 |     }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
[52/64] Compiling Emitter MergeTwo.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:24:25: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
    |                         `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 25 |       self.upstream = upstream
 26 |     }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
/host/spi-builder-workspace/Sources/Emitter/Operators/FlatMapLatest.swift:22:7: warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 20 |     public init(
 21 |       upstream: Upstream,
 22 |       producer: @escaping @Sendable (Upstream.Output) -> some Emitter<TransformedOutput, Failure>
    |       `- warning: capture of non-Sendable type '(some Emitter<TransformedOutput, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 23 |     ) {
 24 |       self.producer = { producer($0).erase() }
[53/64] Compiling Emitter AsyncToEmitterBridge.swift
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:4:34: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 2 | extension Emitters {
 3 |   public static func bridge<Seq: AsyncSequence>(_ sequence: Seq)
 4 |     -> some Emitter<Seq.Element, Error>
   |                                  `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 5 |   {
 6 |     AsyncToEmitterBridge(sequence)
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                             `- note: consider making generic parameter 'Seq' conform to the 'Sendable' protocol
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:2:46: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                                              `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                               `- note: consider making generic parameter 'some Emitter<Output, Failure>' conform to the 'Sendable' protocol
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:7:22: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                      `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Bridging/EmitterToAsyncBridge.swift:20:24: warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
18 |       let disposable = emitter.subscribe(
19 |         value: { value in
20 |           continuation.yield(value)
   |                        |- warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                        `- note: task-isolated 'value' is passed as a 'sending' parameter; Uses in callee may race with later task-isolated uses
21 |         },
22 |         finished: {
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[54/64] Compiling Emitter CombineToEmitterBridge.swift
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:4:34: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 2 | extension Emitters {
 3 |   public static func bridge<Seq: AsyncSequence>(_ sequence: Seq)
 4 |     -> some Emitter<Seq.Element, Error>
   |                                  `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 5 |   {
 6 |     AsyncToEmitterBridge(sequence)
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                             `- note: consider making generic parameter 'Seq' conform to the 'Sendable' protocol
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:2:46: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                                              `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                               `- note: consider making generic parameter 'some Emitter<Output, Failure>' conform to the 'Sendable' protocol
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:7:22: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                      `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Bridging/EmitterToAsyncBridge.swift:20:24: warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
18 |       let disposable = emitter.subscribe(
19 |         value: { value in
20 |           continuation.yield(value)
   |                        |- warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                        `- note: task-isolated 'value' is passed as a 'sending' parameter; Uses in callee may race with later task-isolated uses
21 |         },
22 |         finished: {
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[55/64] Compiling Emitter EmitterToAsyncBridge.swift
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:4:34: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 2 | extension Emitters {
 3 |   public static func bridge<Seq: AsyncSequence>(_ sequence: Seq)
 4 |     -> some Emitter<Seq.Element, Error>
   |                                  `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 5 |   {
 6 |     AsyncToEmitterBridge(sequence)
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                             `- note: consider making generic parameter 'Seq' conform to the 'Sendable' protocol
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:2:46: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                                              `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                               `- note: consider making generic parameter 'some Emitter<Output, Failure>' conform to the 'Sendable' protocol
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:7:22: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                      `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Bridging/EmitterToAsyncBridge.swift:20:24: warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
18 |       let disposable = emitter.subscribe(
19 |         value: { value in
20 |           continuation.yield(value)
   |                        |- warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                        `- note: task-isolated 'value' is passed as a 'sending' parameter; Uses in callee may race with later task-isolated uses
21 |         },
22 |         finished: {
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[56/64] Compiling Emitter EmitterToCombineBridge.swift
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:4:34: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 2 | extension Emitters {
 3 |   public static func bridge<Seq: AsyncSequence>(_ sequence: Seq)
 4 |     -> some Emitter<Seq.Element, Error>
   |                                  `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 5 |   {
 6 |     AsyncToEmitterBridge(sequence)
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                             `- note: consider making generic parameter 'Seq' conform to the 'Sendable' protocol
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:2:46: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                                              `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                               `- note: consider making generic parameter 'some Emitter<Output, Failure>' conform to the 'Sendable' protocol
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:7:22: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                      `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Bridging/EmitterToAsyncBridge.swift:20:24: warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
18 |       let disposable = emitter.subscribe(
19 |         value: { value in
20 |           continuation.yield(value)
   |                        |- warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                        `- note: task-isolated 'value' is passed as a 'sending' parameter; Uses in callee may race with later task-isolated uses
21 |         },
22 |         finished: {
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[57/64] Compiling Emitter SequenceToEmitterBridge.swift
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:4:34: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 2 | extension Emitters {
 3 |   public static func bridge<Seq: AsyncSequence>(_ sequence: Seq)
 4 |     -> some Emitter<Seq.Element, Error>
   |                                  `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 5 |   {
 6 |     AsyncToEmitterBridge(sequence)
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                             `- note: consider making generic parameter 'Seq' conform to the 'Sendable' protocol
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:2:46: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                                              `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                               `- note: consider making generic parameter 'some Emitter<Output, Failure>' conform to the 'Sendable' protocol
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:7:22: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                      `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Bridging/EmitterToAsyncBridge.swift:20:24: warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
18 |       let disposable = emitter.subscribe(
19 |         value: { value in
20 |           continuation.yield(value)
   |                        |- warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                        `- note: task-isolated 'value' is passed as a 'sending' parameter; Uses in callee may race with later task-isolated uses
21 |         },
22 |         finished: {
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[58/64] Compiling Emitter AnyEmitter.swift
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:4:34: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 2 | extension Emitters {
 3 |   public static func bridge<Seq: AsyncSequence>(_ sequence: Seq)
 4 |     -> some Emitter<Seq.Element, Error>
   |                                  `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 5 |   {
 6 |     AsyncToEmitterBridge(sequence)
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.AsyncIterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:34:36: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
32 |         ErasedDisposable(Task {
33 |           do {
34 |             for try await value in seq {
   |                                    `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
35 |               emit(.value(value))
36 |             }
/host/spi-builder-workspace/Sources/Emitter/Bridging/AsyncToEmitterBridge.swift:26:15: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
24 |   public typealias Output = Seq.Element
25 |
26 |   public func subscribe<S: Subscriber>(_ subscriber: S) -> AutoDisposable
   |               `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
27 |     where Seq.Element == S.Input, S.Failure == any Error
28 |   {
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                             `- note: consider making generic parameter 'Seq' conform to the 'Sendable' protocol
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of 'sequence' with non-Sendable type 'Seq' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Iterator.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:4:16: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
   |                `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 |         emit(.value(i))
 6 |       }
/host/spi-builder-workspace/Sources/Emitter/Bridging/SequenceToEmitterBridge.swift:2:46: warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 1 | extension Emitters {
 2 |   public static func bridge<Seq: Sequence>(_ sequence: Seq) -> some Emitter<Seq.Element, Never> {
   |                                              `- warning: capture of non-Sendable type 'Seq.Type' in an isolated closure; this is an error in the Swift 6 language mode
 3 |     Emitters.create(Emission<Seq.Element, Never>.self) { emit in
 4 |       for i in sequence {
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                               `- note: consider making generic parameter 'some Emitter<Output, Failure>' conform to the 'Sendable' protocol
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of 'emitter' with non-Sendable type 'some Emitter<Output, Failure>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:8:28: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
   |                            `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 9 |   }
10 |
/host/spi-builder-workspace/Sources/Emitter/Erasure/AnyEmitter.swift:7:22: warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 5 | public struct AnyEmitter<Output, Failure: Error>: Emitter {
 6 |
 7 |   fileprivate init(_ emitter: some Emitter<Output, Failure>) {
   |                      `- warning: capture of non-Sendable type '(some Emitter<Output, Failure>).Type' in an isolated closure; this is an error in the Swift 6 language mode
 8 |     self.subscribeFunc = { emitter.subscribe($0) }
 9 |   }
/host/spi-builder-workspace/Sources/Emitter/Bridging/EmitterToAsyncBridge.swift:20:24: warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
18 |       let disposable = emitter.subscribe(
19 |         value: { value in
20 |           continuation.yield(value)
   |                        |- warning: sending 'value' risks causing data races; this is an error in the Swift 6 language mode [#SendingRisksDataRace]
   |                        `- note: task-isolated 'value' is passed as a 'sending' parameter; Uses in callee may race with later task-isolated uses
21 |         },
22 |         finished: {
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[#SendingRisksDataRace]: <https://docs.swift.org/compiler/documentation/diagnostics/sending-risks-data-race>
[59/64] Compiling Emitter Print.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
52 |     // MARK: Private
53 |
54 |     private struct Sub<Downstream: Subscriber>: Subscriber
   |                    `- note: consider making generic struct 'Sub' conform to the 'Sendable' protocol
55 |       where Downstream.Input == Output, Downstream.Failure == Failure
56 |     {
   :
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Shared.swift:194:17: warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
 54 |     // MARK: Private
 55 |
 56 |     private struct SharedSub<Input, Failure: Error>: Subscriber {
    |                    `- note: consider making generic struct 'SharedSub' conform to the 'Sendable' protocol
 57 |
 58 |       // MARK: Lifecycle
    :
192 |     }
193 |
194 |     private let sharedSub = Locked<SharedSub<Output, Failure>?>(nil)
    |                 `- warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
195 |
196 |     private let upstream: Upstream
/host/spi-builder-workspace/Sources/Emitter/Operators/TryMap.swift:6:40: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 4 |   public func map<TransformedOutput>(
 5 |     _ transformer: @escaping @Sendable (Output) throws -> TransformedOutput
 6 |   ) -> some Emitter<TransformedOutput, Error> {
   |                                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 7 |     Emitters.TryMap(upstream: self, transformer: transformer)
 8 |   }
/host/spi-builder-workspace/Sources/Emitter/Operators/UnionThree.swift:18:73: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 16 |     _ otherB: UpstreamB,
 17 |     _ otherC: UpstreamC
 18 |   ) -> some Emitter<Union3<Output, UpstreamB.Output, UpstreamC.Output>, Error> {
    |                                                                         `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 19 |     Emitters
 20 |       .UnionThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[60/64] Compiling Emitter Redirect.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
52 |     // MARK: Private
53 |
54 |     private struct Sub<Downstream: Subscriber>: Subscriber
   |                    `- note: consider making generic struct 'Sub' conform to the 'Sendable' protocol
55 |       where Downstream.Input == Output, Downstream.Failure == Failure
56 |     {
   :
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Shared.swift:194:17: warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
 54 |     // MARK: Private
 55 |
 56 |     private struct SharedSub<Input, Failure: Error>: Subscriber {
    |                    `- note: consider making generic struct 'SharedSub' conform to the 'Sendable' protocol
 57 |
 58 |       // MARK: Lifecycle
    :
192 |     }
193 |
194 |     private let sharedSub = Locked<SharedSub<Output, Failure>?>(nil)
    |                 `- warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
195 |
196 |     private let upstream: Upstream
/host/spi-builder-workspace/Sources/Emitter/Operators/TryMap.swift:6:40: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 4 |   public func map<TransformedOutput>(
 5 |     _ transformer: @escaping @Sendable (Output) throws -> TransformedOutput
 6 |   ) -> some Emitter<TransformedOutput, Error> {
   |                                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 7 |     Emitters.TryMap(upstream: self, transformer: transformer)
 8 |   }
/host/spi-builder-workspace/Sources/Emitter/Operators/UnionThree.swift:18:73: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 16 |     _ otherB: UpstreamB,
 17 |     _ otherC: UpstreamC
 18 |   ) -> some Emitter<Union3<Output, UpstreamB.Output, UpstreamC.Output>, Error> {
    |                                                                         `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 19 |     Emitters
 20 |       .UnionThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[61/64] Compiling Emitter ReplaceFailures.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
52 |     // MARK: Private
53 |
54 |     private struct Sub<Downstream: Subscriber>: Subscriber
   |                    `- note: consider making generic struct 'Sub' conform to the 'Sendable' protocol
55 |       where Downstream.Input == Output, Downstream.Failure == Failure
56 |     {
   :
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Shared.swift:194:17: warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
 54 |     // MARK: Private
 55 |
 56 |     private struct SharedSub<Input, Failure: Error>: Subscriber {
    |                    `- note: consider making generic struct 'SharedSub' conform to the 'Sendable' protocol
 57 |
 58 |       // MARK: Lifecycle
    :
192 |     }
193 |
194 |     private let sharedSub = Locked<SharedSub<Output, Failure>?>(nil)
    |                 `- warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
195 |
196 |     private let upstream: Upstream
/host/spi-builder-workspace/Sources/Emitter/Operators/TryMap.swift:6:40: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 4 |   public func map<TransformedOutput>(
 5 |     _ transformer: @escaping @Sendable (Output) throws -> TransformedOutput
 6 |   ) -> some Emitter<TransformedOutput, Error> {
   |                                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 7 |     Emitters.TryMap(upstream: self, transformer: transformer)
 8 |   }
/host/spi-builder-workspace/Sources/Emitter/Operators/UnionThree.swift:18:73: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 16 |     _ otherB: UpstreamB,
 17 |     _ otherC: UpstreamC
 18 |   ) -> some Emitter<Union3<Output, UpstreamB.Output, UpstreamC.Output>, Error> {
    |                                                                         `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 19 |     Emitters
 20 |       .UnionThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[62/64] Compiling Emitter Shared.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
52 |     // MARK: Private
53 |
54 |     private struct Sub<Downstream: Subscriber>: Subscriber
   |                    `- note: consider making generic struct 'Sub' conform to the 'Sendable' protocol
55 |       where Downstream.Input == Output, Downstream.Failure == Failure
56 |     {
   :
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Shared.swift:194:17: warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
 54 |     // MARK: Private
 55 |
 56 |     private struct SharedSub<Input, Failure: Error>: Subscriber {
    |                    `- note: consider making generic struct 'SharedSub' conform to the 'Sendable' protocol
 57 |
 58 |       // MARK: Lifecycle
    :
192 |     }
193 |
194 |     private let sharedSub = Locked<SharedSub<Output, Failure>?>(nil)
    |                 `- warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
195 |
196 |     private let upstream: Upstream
/host/spi-builder-workspace/Sources/Emitter/Operators/TryMap.swift:6:40: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 4 |   public func map<TransformedOutput>(
 5 |     _ transformer: @escaping @Sendable (Output) throws -> TransformedOutput
 6 |   ) -> some Emitter<TransformedOutput, Error> {
   |                                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 7 |     Emitters.TryMap(upstream: self, transformer: transformer)
 8 |   }
/host/spi-builder-workspace/Sources/Emitter/Operators/UnionThree.swift:18:73: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 16 |     _ otherB: UpstreamB,
 17 |     _ otherC: UpstreamC
 18 |   ) -> some Emitter<Union3<Output, UpstreamB.Output, UpstreamC.Output>, Error> {
    |                                                                         `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 19 |     Emitters
 20 |       .UnionThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[63/64] Compiling Emitter TryMap.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
52 |     // MARK: Private
53 |
54 |     private struct Sub<Downstream: Subscriber>: Subscriber
   |                    `- note: consider making generic struct 'Sub' conform to the 'Sendable' protocol
55 |       where Downstream.Input == Output, Downstream.Failure == Failure
56 |     {
   :
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Shared.swift:194:17: warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
 54 |     // MARK: Private
 55 |
 56 |     private struct SharedSub<Input, Failure: Error>: Subscriber {
    |                    `- note: consider making generic struct 'SharedSub' conform to the 'Sendable' protocol
 57 |
 58 |       // MARK: Lifecycle
    :
192 |     }
193 |
194 |     private let sharedSub = Locked<SharedSub<Output, Failure>?>(nil)
    |                 `- warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
195 |
196 |     private let upstream: Upstream
/host/spi-builder-workspace/Sources/Emitter/Operators/TryMap.swift:6:40: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 4 |   public func map<TransformedOutput>(
 5 |     _ transformer: @escaping @Sendable (Output) throws -> TransformedOutput
 6 |   ) -> some Emitter<TransformedOutput, Error> {
   |                                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 7 |     Emitters.TryMap(upstream: self, transformer: transformer)
 8 |   }
/host/spi-builder-workspace/Sources/Emitter/Operators/UnionThree.swift:18:73: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 16 |     _ otherB: UpstreamB,
 17 |     _ otherC: UpstreamC
 18 |   ) -> some Emitter<Union3<Output, UpstreamB.Output, UpstreamC.Output>, Error> {
    |                                                                         `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 19 |     Emitters
 20 |       .UnionThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[64/64] Compiling Emitter UnionThree.swift
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
52 |     // MARK: Private
53 |
54 |     private struct Sub<Downstream: Subscriber>: Subscriber
   |                    `- note: consider making generic struct 'Sub' conform to the 'Sendable' protocol
55 |       where Downstream.Input == Output, Downstream.Failure == Failure
56 |     {
   :
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of 'self' with non-Sendable type 'Emitters.Redirect<Upstream>.Sub<Downstream>' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:70:33: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
70 |         redirection(emission) { downstream.receive(emission: $0) }
   |                                 `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
71 |       }
72 |
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Upstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Redirect.swift:69:24: warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
67 |       }
68 |
69 |       fileprivate func receive(emission: Emission<Upstream.Output, Upstream.Failure>) {
   |                        `- warning: capture of non-Sendable type 'Downstream.Type' in an isolated closure; this is an error in the Swift 6 language mode
70 |         redirection(emission) { downstream.receive(emission: $0) }
71 |       }
/host/spi-builder-workspace/Sources/Emitter/Operators/Shared.swift:194:17: warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
 54 |     // MARK: Private
 55 |
 56 |     private struct SharedSub<Input, Failure: Error>: Subscriber {
    |                    `- note: consider making generic struct 'SharedSub' conform to the 'Sendable' protocol
 57 |
 58 |       // MARK: Lifecycle
    :
192 |     }
193 |
194 |     private let sharedSub = Locked<SharedSub<Output, Failure>?>(nil)
    |                 `- warning: stored property 'sharedSub' of 'Sendable'-conforming generic struct 'Shared' has non-Sendable type 'Locked<Emitters.Shared<Upstream>.SharedSub<Emitters.Shared<Upstream>.Output, Emitters.Shared<Upstream>.Failure>?>' (aka 'Locked<Optional<Emitters.Shared<Upstream>.SharedSub<Upstream.Output, Upstream.Failure>>>'); this is an error in the Swift 6 language mode
195 |
196 |     private let upstream: Upstream
/host/spi-builder-workspace/Sources/Emitter/Operators/TryMap.swift:6:40: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 4 |   public func map<TransformedOutput>(
 5 |     _ transformer: @escaping @Sendable (Output) throws -> TransformedOutput
 6 |   ) -> some Emitter<TransformedOutput, Error> {
   |                                        `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 7 |     Emitters.TryMap(upstream: self, transformer: transformer)
 8 |   }
/host/spi-builder-workspace/Sources/Emitter/Operators/UnionThree.swift:18:73: warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 16 |     _ otherB: UpstreamB,
 17 |     _ otherC: UpstreamC
 18 |   ) -> some Emitter<Union3<Output, UpstreamB.Output, UpstreamC.Output>, Error> {
    |                                                                         `- warning: use of protocol 'Error' as a type must be written 'any Error'; this will be an error in a future Swift language mode [#ExistentialAny]
 19 |     Emitters
 20 |       .UnionThree(upstreamA: self, upstreamB: otherB, upstreamC: otherC)
[#ExistentialAny]: <https://docs.swift.org/compiler/documentation/diagnostics/existential-any>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
Build complete! (15.91s)
Build complete.
{
  "dependencies" : [
    {
      "identity" : "disposable",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.0.0",
            "upper_bound" : "1.1.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/GoodHatsLLC/Disposable.git"
    }
  ],
  "manifest_display_name" : "Emitter",
  "name" : "Emitter",
  "path" : "/host/spi-builder-workspace",
  "platforms" : [
    {
      "name" : "macos",
      "version" : "12.3"
    },
    {
      "name" : "ios",
      "version" : "15.4"
    },
    {
      "name" : "tvos",
      "version" : "15.4"
    },
    {
      "name" : "watchos",
      "version" : "8.5"
    },
    {
      "name" : "maccatalyst",
      "version" : "15.4"
    }
  ],
  "products" : [
    {
      "name" : "Emitter",
      "targets" : [
        "Emitter"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "EmitterTests",
      "module_type" : "SwiftTarget",
      "name" : "EmitterTests",
      "path" : "Tests/EmitterTests",
      "product_dependencies" : [
        "Disposable"
      ],
      "sources" : [
        "Benchmarks/Benchmarks.swift",
        "Benchmarks/Blackhole.swift",
        "BridgingTests/AsyncToEmitterTests.swift",
        "BridgingTests/CombineToEmitterTests.swift",
        "BridgingTests/EmitterToAsyncTests.swift",
        "BridgingTests/EmitterToCombineTests.swift",
        "LifecycleTests/FinishTests.swift",
        "OperatorTests/CombineLatestThreeTests.swift",
        "OperatorTests/CombineLatestTwoTests.swift",
        "OperatorTests/CompactMapTests.swift",
        "OperatorTests/DedupingTests.swift",
        "OperatorTests/FilterTests.swift",
        "OperatorTests/FirstTests.swift",
        "OperatorTests/FlatMapLatestTests.swift",
        "OperatorTests/MapFailureTests.swift",
        "OperatorTests/MapTests.swift",
        "OperatorTests/Merge2Tests.swift",
        "OperatorTests/Merge3Tests.swift",
        "OperatorTests/ReplacingFailuresTests.swift",
        "OperatorTests/SharedTests.swift",
        "OperatorTests/TryMapTests.swift",
        "OperatorTests/UnionThreeTests.swift",
        "OperatorTests/UnionTwoTests.swift",
        "OperatorTests/WithFailureTypeTests.swift",
        "OperatorTests/WithPrefixTests.swift",
        "OperatorTests/WithSuffixTests.swift",
        "SourceTests/CreateTests.swift",
        "SourceTests/PublishSubjectTests.swift",
        "SourceTests/ValueSubjectTests.swift",
        "StressTests/ThreadingTests.swift",
        "SubscriberTests/FirstValueTests.swift",
        "Utils/AsyncValue.swift",
        "Utils/Flush.swift",
        "Utils/Unchecked.swift"
      ],
      "target_dependencies" : [
        "Emitter"
      ],
      "type" : "test"
    },
    {
      "c99name" : "Emitter",
      "module_type" : "SwiftTarget",
      "name" : "Emitter",
      "path" : "Sources/Emitter",
      "product_dependencies" : [
        "Disposable"
      ],
      "product_memberships" : [
        "Emitter"
      ],
      "sources" : [
        "Bridging/AsyncToEmitterBridge.swift",
        "Bridging/CombineToEmitterBridge.swift",
        "Bridging/EmitterToAsyncBridge.swift",
        "Bridging/EmitterToCombineBridge.swift",
        "Bridging/SequenceToEmitterBridge.swift",
        "Erasure/AnyEmitter.swift",
        "Export.swift",
        "Interface/Emission.swift",
        "Interface/Emitter.swift",
        "Interface/Subject.swift",
        "Interface/Subscriber.swift",
        "Interface/Tuple.swift",
        "Interface/Union.swift",
        "Operators/CombineLatestThree.swift",
        "Operators/CombineLatestTwo.swift",
        "Operators/CompactMap.swift",
        "Operators/Dedupe.swift",
        "Operators/Filter.swift",
        "Operators/First.swift",
        "Operators/FlatMapLatest.swift",
        "Operators/Map.swift",
        "Operators/MapFailure.swift",
        "Operators/MergeThree.swift",
        "Operators/MergeTwo.swift",
        "Operators/Print.swift",
        "Operators/Redirect.swift",
        "Operators/ReplaceFailures.swift",
        "Operators/Shared.swift",
        "Operators/TryMap.swift",
        "Operators/UnionThree.swift",
        "Operators/UnionTwo.swift",
        "Operators/WithFailureType.swift",
        "Operators/WithPrefix.swift",
        "Operators/WithSuffix.swift",
        "Sources/Create.swift",
        "Sources/FailureEmitter.swift",
        "Sources/JustEmitter.swift",
        "Sources/NeverEmitter.swift",
        "Sources/PublishSubject.swift",
        "Sources/ValueSubject.swift",
        "Subscribers/EmissionDataProxy.swift",
        "Subscribers/FirstValue.swift",
        "Subscribers/Subscribe.swift",
        "Subscribers/SubscribeMain.swift",
        "Subscribers/Subscription.swift",
        "Subscribers/TransformProxy.swift",
        "Utilities/AsyncValue.swift",
        "Utilities/Locked.swift"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "5.8"
}
basic-6.2-latest: Pulling from finestructure/spi-images
Digest: sha256:f81a7bd7aa87a0f81848d48c5bcc03f5f78deebd37fa5f9be9913077205d3687
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.2-latest
Done.