The Swift Package Index logo.Swift Package Index

Build Information

Successful build of swift-signal-handling, reference 1.1.4 (c50ae0), with Swift 6.4 for Linux on 21 Sep 2026 15:49:14 UTC.

Swift 6 data race errors: 0

Build Command

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

Build Log

    |                    |- warning: static property 'busError' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'busError' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 85 | 	public static let abortTrap              = Signal(rawValue: SIGABRT)
 86 | 	/** Usually the same as `abortTrap`. */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:85:20: warning: static property 'abortTrap' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 83 | 	public static let segmentationFault      = Signal(rawValue: SIGSEGV)
 84 | 	public static let busError               = Signal(rawValue: SIGBUS)
 85 | 	public static let abortTrap              = Signal(rawValue: SIGABRT)
    |                    |- warning: static property 'abortTrap' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'abortTrap' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 86 | 	/** Usually the same as `abortTrap`. */
 87 | 	public static let iot                    = Signal(rawValue: SIGIOT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:87:20: warning: static property 'iot' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 85 | 	public static let abortTrap              = Signal(rawValue: SIGABRT)
 86 | 	/** Usually the same as `abortTrap`. */
 87 | 	public static let iot                    = Signal(rawValue: SIGIOT)
    |                    |- warning: static property 'iot' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'iot' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 88 | 	public static let traceBreakpointTrap    = Signal(rawValue: SIGTRAP)
 89 | #if !os(Linux)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:88:20: warning: static property 'traceBreakpointTrap' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 86 | 	/** Usually the same as `abortTrap`. */
 87 | 	public static let iot                    = Signal(rawValue: SIGIOT)
 88 | 	public static let traceBreakpointTrap    = Signal(rawValue: SIGTRAP)
    |                    |- warning: static property 'traceBreakpointTrap' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'traceBreakpointTrap' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 89 | #if !os(Linux)
 90 | 	public static let emulatorTrap           = Signal(rawValue: SIGEMT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:92:20: warning: static property 'badSystemCall' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 90 | 	public static let emulatorTrap           = Signal(rawValue: SIGEMT)
 91 | #endif
 92 | 	public static let badSystemCall          = Signal(rawValue: SIGSYS)
    |                    |- warning: static property 'badSystemCall' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'badSystemCall' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 93 |
 94 | 	/* *** Termination Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:108:20: warning: static property 'terminated' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
106 |
107 | 	/** “Normal” kill signal. */
108 | 	public static let terminated = Signal(rawValue: SIGTERM)
    |                    |- warning: static property 'terminated' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'terminated' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
109 | 	/** Usually `Ctrl-C`. */
110 | 	public static let interrupt  = Signal(rawValue: SIGINT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:110:20: warning: static property 'interrupt' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
108 | 	public static let terminated = Signal(rawValue: SIGTERM)
109 | 	/** Usually `Ctrl-C`. */
110 | 	public static let interrupt  = Signal(rawValue: SIGINT)
    |                    |- warning: static property 'interrupt' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'interrupt' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
111 | 	/** Used to quit w/ generation of a core dump. Usually `Ctrl-\`. */
112 | 	public static let quit       = Signal(rawValue: SIGQUIT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:112:20: warning: static property 'quit' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
110 | 	public static let interrupt  = Signal(rawValue: SIGINT)
111 | 	/** Used to quit w/ generation of a core dump. Usually `Ctrl-\`. */
112 | 	public static let quit       = Signal(rawValue: SIGQUIT)
    |                    |- warning: static property 'quit' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'quit' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
113 | 	public static let killed     = Signal(rawValue: SIGKILL)
114 | 	/** The user’s terminal disconnected. */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:113:20: warning: static property 'killed' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
111 | 	/** Used to quit w/ generation of a core dump. Usually `Ctrl-\`. */
112 | 	public static let quit       = Signal(rawValue: SIGQUIT)
113 | 	public static let killed     = Signal(rawValue: SIGKILL)
    |                    |- warning: static property 'killed' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'killed' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
114 | 	/** The user’s terminal disconnected. */
115 | 	public static let hangup     = Signal(rawValue: SIGHUP)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:115:20: warning: static property 'hangup' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
113 | 	public static let killed     = Signal(rawValue: SIGKILL)
114 | 	/** The user’s terminal disconnected. */
115 | 	public static let hangup     = Signal(rawValue: SIGHUP)
    |                    |- warning: static property 'hangup' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'hangup' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
116 |
117 | 	/* *** Alarm Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:128:20: warning: static property 'alarmClock' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
126 | 	}
127 |
128 | 	public static let alarmClock            = Signal(rawValue: SIGALRM)
    |                    |- warning: static property 'alarmClock' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'alarmClock' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
129 | 	public static let virtualTimerExpired   = Signal(rawValue: SIGVTALRM)
130 | 	public static let profilingTimerExpired = Signal(rawValue: SIGPROF)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:129:20: warning: static property 'virtualTimerExpired' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
127 |
128 | 	public static let alarmClock            = Signal(rawValue: SIGALRM)
129 | 	public static let virtualTimerExpired   = Signal(rawValue: SIGVTALRM)
    |                    |- warning: static property 'virtualTimerExpired' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'virtualTimerExpired' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | 	public static let profilingTimerExpired = Signal(rawValue: SIGPROF)
131 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:130:20: warning: static property 'profilingTimerExpired' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
128 | 	public static let alarmClock            = Signal(rawValue: SIGALRM)
129 | 	public static let virtualTimerExpired   = Signal(rawValue: SIGVTALRM)
130 | 	public static let profilingTimerExpired = Signal(rawValue: SIGPROF)
    |                    |- warning: static property 'profilingTimerExpired' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'profilingTimerExpired' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
131 |
132 | 	/* *** Asynchronous I/O Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:143:20: warning: static property 'ioPossible' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
141 | 	}
142 |
143 | 	public static let ioPossible        = Signal(rawValue: SIGIO)
    |                    |- warning: static property 'ioPossible' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'ioPossible' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
144 | 	public static let urgentIOCondition = Signal(rawValue: SIGURG)
145 | #if os(Linux)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:144:20: warning: static property 'urgentIOCondition' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
142 |
143 | 	public static let ioPossible        = Signal(rawValue: SIGIO)
144 | 	public static let urgentIOCondition = Signal(rawValue: SIGURG)
    |                    |- warning: static property 'urgentIOCondition' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'urgentIOCondition' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
145 | #if os(Linux)
146 | 	/** System V signal name, similar to SIGIO. */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:147:20: warning: static property 'poll' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
145 | #if os(Linux)
146 | 	/** System V signal name, similar to SIGIO. */
147 | 	public static let poll              = Signal(rawValue: SIGPOLL)
    |                    |- warning: static property 'poll' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'poll' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
148 | #endif
149 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:164:20: warning: static property 'childExited' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
162 | 	}
163 |
164 | 	public static let childExited       = Signal(rawValue: SIGCHLD)
    |                    |- warning: static property 'childExited' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'childExited' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
165 | 	/* Obsolete name for SIGCHLD. */
166 | //	public static let cildExited        = Signal(rawValue: SIGCLD)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:167:20: warning: static property 'continued' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
165 | 	/* Obsolete name for SIGCHLD. */
166 | //	public static let cildExited        = Signal(rawValue: SIGCLD)
167 | 	public static let continued         = Signal(rawValue: SIGCONT)
    |                    |- warning: static property 'continued' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'continued' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
168 | 	/** Suspends the program. Cannot be handled, ignored or blocked. */
169 | 	public static let suspendedBySignal = Signal(rawValue: SIGSTOP)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:169:20: warning: static property 'suspendedBySignal' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
167 | 	public static let continued         = Signal(rawValue: SIGCONT)
168 | 	/** Suspends the program. Cannot be handled, ignored or blocked. */
169 | 	public static let suspendedBySignal = Signal(rawValue: SIGSTOP)
    |                    |- warning: static property 'suspendedBySignal' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'suspendedBySignal' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
170 | 	/** Suspends the program but can be handled and ignored. Usually `Ctrl-Z`. */
171 | 	public static let suspended         = Signal(rawValue: SIGTSTP)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:171:20: warning: static property 'suspended' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
169 | 	public static let suspendedBySignal = Signal(rawValue: SIGSTOP)
170 | 	/** Suspends the program but can be handled and ignored. Usually `Ctrl-Z`. */
171 | 	public static let suspended         = Signal(rawValue: SIGTSTP)
    |                    |- warning: static property 'suspended' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'suspended' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
172 | 	public static let stoppedTTYInput   = Signal(rawValue: SIGTTIN)
173 | 	public static let stoppedTTYOutput  = Signal(rawValue: SIGTTOU)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:172:20: warning: static property 'stoppedTTYInput' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
170 | 	/** Suspends the program but can be handled and ignored. Usually `Ctrl-Z`. */
171 | 	public static let suspended         = Signal(rawValue: SIGTSTP)
172 | 	public static let stoppedTTYInput   = Signal(rawValue: SIGTTIN)
    |                    |- warning: static property 'stoppedTTYInput' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'stoppedTTYInput' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
173 | 	public static let stoppedTTYOutput  = Signal(rawValue: SIGTTOU)
174 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:173:20: warning: static property 'stoppedTTYOutput' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
171 | 	public static let suspended         = Signal(rawValue: SIGTSTP)
172 | 	public static let stoppedTTYInput   = Signal(rawValue: SIGTTIN)
173 | 	public static let stoppedTTYOutput  = Signal(rawValue: SIGTTOU)
    |                    |- warning: static property 'stoppedTTYOutput' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'stoppedTTYOutput' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
174 |
175 | 	/* *** Operation Error Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:186:20: warning: static property 'brokenPipe' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
184 | 	}
185 |
186 | 	public static let brokenPipe            = Signal(rawValue: SIGPIPE)
    |                    |- warning: static property 'brokenPipe' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'brokenPipe' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
187 | //	public static let resourceLost          = Signal(rawValue: SIGLOST)
188 | 	public static let cputimeLimitExceeded  = Signal(rawValue: SIGXCPU)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:188:20: warning: static property 'cputimeLimitExceeded' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
186 | 	public static let brokenPipe            = Signal(rawValue: SIGPIPE)
187 | //	public static let resourceLost          = Signal(rawValue: SIGLOST)
188 | 	public static let cputimeLimitExceeded  = Signal(rawValue: SIGXCPU)
    |                    |- warning: static property 'cputimeLimitExceeded' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'cputimeLimitExceeded' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
189 | 	public static let filesizeLimitExceeded = Signal(rawValue: SIGXFSZ)
190 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:189:20: warning: static property 'filesizeLimitExceeded' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
187 | //	public static let resourceLost          = Signal(rawValue: SIGLOST)
188 | 	public static let cputimeLimitExceeded  = Signal(rawValue: SIGXCPU)
189 | 	public static let filesizeLimitExceeded = Signal(rawValue: SIGXFSZ)
    |                    |- warning: static property 'filesizeLimitExceeded' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'filesizeLimitExceeded' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
190 |
191 | 	/* *** Miscellaneous Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:208:20: warning: static property 'userDefinedSignal1' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
206 | 	}
207 |
208 | 	public static let userDefinedSignal1 = Signal(rawValue: SIGUSR1)
    |                    |- warning: static property 'userDefinedSignal1' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'userDefinedSignal1' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
209 | 	public static let userDefinedSignal2 = Signal(rawValue: SIGUSR2)
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:209:20: warning: static property 'userDefinedSignal2' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
207 |
208 | 	public static let userDefinedSignal1 = Signal(rawValue: SIGUSR1)
209 | 	public static let userDefinedSignal2 = Signal(rawValue: SIGUSR2)
    |                    |- warning: static property 'userDefinedSignal2' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'userDefinedSignal2' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
211 | #if !os(Linux)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:210:20: warning: static property 'windowSizeChanges' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
208 | 	public static let userDefinedSignal1 = Signal(rawValue: SIGUSR1)
209 | 	public static let userDefinedSignal2 = Signal(rawValue: SIGUSR2)
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
    |                    |- warning: static property 'windowSizeChanges' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'windowSizeChanges' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
211 | #if !os(Linux)
212 | 	public static let informationRequest = Signal(rawValue: SIGINFO)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:226:20: warning: static property 'stackFault' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
224 | 	}
225 |
226 | 	public static let stackFault   = Signal(rawValue: SIGSTKFLT)
    |                    |- warning: static property 'stackFault' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'stackFault' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
227 | 	public static let powerFailure = Signal(rawValue: SIGPWR)
228 | #endif
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:227:20: warning: static property 'powerFailure' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
225 |
226 | 	public static let stackFault   = Signal(rawValue: SIGSTKFLT)
227 | 	public static let powerFailure = Signal(rawValue: SIGPWR)
    |                    |- warning: static property 'powerFailure' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'powerFailure' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
228 | #endif
229 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/DelayedSigaction.swift:10:21: warning: static property 'latestID' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 8 | public struct DelayedSigaction : Hashable {
 9 |
10 | 	private static var latestID = 0
   |                     |- warning: static property 'latestID' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                     |- note: convert 'latestID' to a 'let' constant to make 'Sendable' shared state immutable
   |                     |- note: add '@MainActor' to make static property 'latestID' part of global actor 'MainActor'
   |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
11 |
12 | 	internal var id: Int
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:173:14: warning: static property 'action' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
171 | 		static let lock = NSConditionLock(condition: Self.nothingToDo.rawValue)
172 |
173 | 		static var action: Action = .nop
    |              |- warning: static property 'action' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |              |- note: convert 'action' to a 'let' constant to make 'Sendable' shared state immutable
    |              |- note: add '@MainActor' to make static property 'action' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
174 | 		static var error: Error?
175 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:174:14: warning: static property 'error' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
172 |
173 | 		static var action: Action = .nop
174 | 		static var error: Error?
    |              |- warning: static property 'error' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |              |- note: convert 'error' to a 'let' constant to make 'Sendable' shared state immutable
    |              |- note: add '@MainActor' to make static property 'error' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
175 |
176 | 		case nothingToDo
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:191:21: warning: static property 'bootstrapDone' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
189 | 	private static let signalProcessingQueue = DispatchQueue(label: "com.xcode-actions.blocked-signals-processing-queue")
190 |
191 | 	private static var bootstrapDone = false
    |                     |- warning: static property 'bootstrapDone' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                     |- note: convert 'bootstrapDone' to a 'let' constant to make 'Sendable' shared state immutable
    |                     |- note: add '@MainActor' to make static property 'bootstrapDone' part of global actor 'MainActor'
    |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 | 	private static var blockedSignals = [Signal: BlockedSignal]()
193 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:192:21: warning: static property 'blockedSignals' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
190 |
191 | 	private static var bootstrapDone = false
192 | 	private static var blockedSignals = [Signal: BlockedSignal]()
    |                     |- warning: static property 'blockedSignals' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                     |- note: convert 'blockedSignals' to a 'let' constant to make 'Sendable' shared state immutable
    |                     |- note: add '@MainActor' to make static property 'blockedSignals' part of global actor 'MainActor'
    |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
193 |
194 | 	private static func executeOnThread(_ action: ThreadSync.Action) throws {
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:130:14: warning: static property 'action' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
128 | 		static let lock = NSConditionLock(condition: Self.nothingToDo.rawValue)
129 |
130 | 		static var action: Action = .nop
    |              |- warning: static property 'action' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |              |- note: convert 'action' to a 'let' constant to make 'Sendable' shared state immutable
    |              |- note: add '@MainActor' to make static property 'action' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
131 | 		static var completionResult: ErrorAndLogs?
132 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:131:14: warning: static property 'completionResult' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
129 |
130 | 		static var action: Action = .nop
131 | 		static var completionResult: ErrorAndLogs?
    |              |- warning: static property 'completionResult' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |              |- note: convert 'completionResult' to a 'let' constant to make 'Sendable' shared state immutable
    |              |- note: add '@MainActor' to make static property 'completionResult' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
132 |
133 | 		case nothingToDo
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:150:21: warning: static property 'hasCreatedProcessingThread' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
148 | 	private static let signalProcessingQueue = DispatchQueue(label: "com.xcode-actions.unsigactioned-signals-processing-queue")
149 |
150 | 	private static var hasCreatedProcessingThread = false
    |                     |- warning: static property 'hasCreatedProcessingThread' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                     |- note: convert 'hasCreatedProcessingThread' to a 'let' constant to make 'Sendable' shared state immutable
    |                     |- note: add '@MainActor' to make static property 'hasCreatedProcessingThread' part of global actor 'MainActor'
    |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
151 | 	private static var unsigactionedSignals = [Signal: UnsigactionedSignal]()
152 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:151:21: warning: static property 'unsigactionedSignals' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
149 |
150 | 	private static var hasCreatedProcessingThread = false
151 | 	private static var unsigactionedSignals = [Signal: UnsigactionedSignal]()
    |                     |- warning: static property 'unsigactionedSignals' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                     |- note: convert 'unsigactionedSignals' to a 'let' constant to make 'Sendable' shared state immutable
    |                     |- note: add '@MainActor' to make static property 'unsigactionedSignals' part of global actor 'MainActor'
    |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
152 |
153 | 	private static func executeOnThread(_ action: ThreadSync.Action) throws {
/host/spi-builder-workspace/Sources/SignalHandling/SignalHandlingConfig.swift:9:20: warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 7 | public enum SignalHandlingConfig {
 8 |
 9 | 	public static var logger: Logging.Logger? = {
   |                    |- warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: convert 'logger' to a 'let' constant to make 'Sendable' shared state immutable
   |                    |- note: add '@MainActor' to make static property 'logger' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
10 | 		return Logger(label: "com.xcode-actions.signal-handling")
11 | 	}()
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
[108 / 148] SignalHandling
[119 / 148] SignalHandling
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:34:20: warning: static property 'killingSignals' is not concurrency-safe because non-'Sendable' type 'Set<Signal>' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 32 |
 33 | 	 - Important: As previously mentionned, this list is hand-crafted and might be missing signals or having too many of them. */
 34 | 	public static let killingSignals: Set<Signal> = {
    |                    |- warning: static property 'killingSignals' is not concurrency-safe because non-'Sendable' type 'Set<Signal>' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'killingSignals' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 35 | 		return Set(arrayLiteral:
 36 | 			.terminated, /* Default kill */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:48:20: warning: static property 'toForwardToSubprocesses' is not concurrency-safe because non-'Sendable' type 'Set<Signal>' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 46 | 	 - Important: As previously mentionned, this list is hand-crafted and does not correspond to any system development notion,
 47 | 	  or anything that I know of. */
 48 | 	public static let toForwardToSubprocesses: Set<Signal> = {
    |                    |- warning: static property 'toForwardToSubprocesses' is not concurrency-safe because non-'Sendable' type 'Set<Signal>' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'toForwardToSubprocesses' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 49 | 		return Set(arrayLiteral:
 50 | 			.suspended, /* Ctrl-Z */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:79:20: warning: static property 'arithmeticError' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 77 | 	/**
 78 | 	 - Note: FPE means Floating-Point Exception but this signal is sent for any arithmetic error. */
 79 | 	public static let arithmeticError        = Signal(rawValue: SIGFPE)
    |                    |- warning: static property 'arithmeticError' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'arithmeticError' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 80 | 	@available(*, unavailable, renamed: "arithmeticError")
 81 | 	public static let floatingPointException = Signal(rawValue: SIGFPE)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:81:20: warning: static property 'floatingPointException' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 79 | 	public static let arithmeticError        = Signal(rawValue: SIGFPE)
 80 | 	@available(*, unavailable, renamed: "arithmeticError")
 81 | 	public static let floatingPointException = Signal(rawValue: SIGFPE)
    |                    |- warning: static property 'floatingPointException' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'floatingPointException' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 82 | 	public static let illegalInstruction     = Signal(rawValue: SIGILL)
 83 | 	public static let segmentationFault      = Signal(rawValue: SIGSEGV)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:82:20: warning: static property 'illegalInstruction' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 80 | 	@available(*, unavailable, renamed: "arithmeticError")
 81 | 	public static let floatingPointException = Signal(rawValue: SIGFPE)
 82 | 	public static let illegalInstruction     = Signal(rawValue: SIGILL)
    |                    |- warning: static property 'illegalInstruction' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'illegalInstruction' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 83 | 	public static let segmentationFault      = Signal(rawValue: SIGSEGV)
 84 | 	public static let busError               = Signal(rawValue: SIGBUS)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:83:20: warning: static property 'segmentationFault' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 81 | 	public static let floatingPointException = Signal(rawValue: SIGFPE)
 82 | 	public static let illegalInstruction     = Signal(rawValue: SIGILL)
 83 | 	public static let segmentationFault      = Signal(rawValue: SIGSEGV)
    |                    |- warning: static property 'segmentationFault' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'segmentationFault' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 | 	public static let busError               = Signal(rawValue: SIGBUS)
 85 | 	public static let abortTrap              = Signal(rawValue: SIGABRT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:84:20: warning: static property 'busError' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 82 | 	public static let illegalInstruction     = Signal(rawValue: SIGILL)
 83 | 	public static let segmentationFault      = Signal(rawValue: SIGSEGV)
 84 | 	public static let busError               = Signal(rawValue: SIGBUS)
    |                    |- warning: static property 'busError' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'busError' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 85 | 	public static let abortTrap              = Signal(rawValue: SIGABRT)
 86 | 	/** Usually the same as `abortTrap`. */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:85:20: warning: static property 'abortTrap' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 83 | 	public static let segmentationFault      = Signal(rawValue: SIGSEGV)
 84 | 	public static let busError               = Signal(rawValue: SIGBUS)
 85 | 	public static let abortTrap              = Signal(rawValue: SIGABRT)
    |                    |- warning: static property 'abortTrap' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'abortTrap' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 86 | 	/** Usually the same as `abortTrap`. */
 87 | 	public static let iot                    = Signal(rawValue: SIGIOT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:87:20: warning: static property 'iot' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 85 | 	public static let abortTrap              = Signal(rawValue: SIGABRT)
 86 | 	/** Usually the same as `abortTrap`. */
 87 | 	public static let iot                    = Signal(rawValue: SIGIOT)
    |                    |- warning: static property 'iot' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'iot' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 88 | 	public static let traceBreakpointTrap    = Signal(rawValue: SIGTRAP)
 89 | #if !os(Linux)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:88:20: warning: static property 'traceBreakpointTrap' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 86 | 	/** Usually the same as `abortTrap`. */
 87 | 	public static let iot                    = Signal(rawValue: SIGIOT)
 88 | 	public static let traceBreakpointTrap    = Signal(rawValue: SIGTRAP)
    |                    |- warning: static property 'traceBreakpointTrap' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'traceBreakpointTrap' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 89 | #if !os(Linux)
 90 | 	public static let emulatorTrap           = Signal(rawValue: SIGEMT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:92:20: warning: static property 'badSystemCall' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
 90 | 	public static let emulatorTrap           = Signal(rawValue: SIGEMT)
 91 | #endif
 92 | 	public static let badSystemCall          = Signal(rawValue: SIGSYS)
    |                    |- warning: static property 'badSystemCall' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'badSystemCall' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 93 |
 94 | 	/* *** Termination Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:108:20: warning: static property 'terminated' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
106 |
107 | 	/** “Normal” kill signal. */
108 | 	public static let terminated = Signal(rawValue: SIGTERM)
    |                    |- warning: static property 'terminated' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'terminated' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
109 | 	/** Usually `Ctrl-C`. */
110 | 	public static let interrupt  = Signal(rawValue: SIGINT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:110:20: warning: static property 'interrupt' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
108 | 	public static let terminated = Signal(rawValue: SIGTERM)
109 | 	/** Usually `Ctrl-C`. */
110 | 	public static let interrupt  = Signal(rawValue: SIGINT)
    |                    |- warning: static property 'interrupt' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'interrupt' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
111 | 	/** Used to quit w/ generation of a core dump. Usually `Ctrl-\`. */
112 | 	public static let quit       = Signal(rawValue: SIGQUIT)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:112:20: warning: static property 'quit' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
110 | 	public static let interrupt  = Signal(rawValue: SIGINT)
111 | 	/** Used to quit w/ generation of a core dump. Usually `Ctrl-\`. */
112 | 	public static let quit       = Signal(rawValue: SIGQUIT)
    |                    |- warning: static property 'quit' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'quit' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
113 | 	public static let killed     = Signal(rawValue: SIGKILL)
114 | 	/** The user’s terminal disconnected. */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:113:20: warning: static property 'killed' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
111 | 	/** Used to quit w/ generation of a core dump. Usually `Ctrl-\`. */
112 | 	public static let quit       = Signal(rawValue: SIGQUIT)
113 | 	public static let killed     = Signal(rawValue: SIGKILL)
    |                    |- warning: static property 'killed' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'killed' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
114 | 	/** The user’s terminal disconnected. */
115 | 	public static let hangup     = Signal(rawValue: SIGHUP)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:115:20: warning: static property 'hangup' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
113 | 	public static let killed     = Signal(rawValue: SIGKILL)
114 | 	/** The user’s terminal disconnected. */
115 | 	public static let hangup     = Signal(rawValue: SIGHUP)
    |                    |- warning: static property 'hangup' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'hangup' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
116 |
117 | 	/* *** Alarm Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:128:20: warning: static property 'alarmClock' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
126 | 	}
127 |
128 | 	public static let alarmClock            = Signal(rawValue: SIGALRM)
    |                    |- warning: static property 'alarmClock' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'alarmClock' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
129 | 	public static let virtualTimerExpired   = Signal(rawValue: SIGVTALRM)
130 | 	public static let profilingTimerExpired = Signal(rawValue: SIGPROF)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:129:20: warning: static property 'virtualTimerExpired' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
127 |
128 | 	public static let alarmClock            = Signal(rawValue: SIGALRM)
129 | 	public static let virtualTimerExpired   = Signal(rawValue: SIGVTALRM)
    |                    |- warning: static property 'virtualTimerExpired' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'virtualTimerExpired' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | 	public static let profilingTimerExpired = Signal(rawValue: SIGPROF)
131 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:130:20: warning: static property 'profilingTimerExpired' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
128 | 	public static let alarmClock            = Signal(rawValue: SIGALRM)
129 | 	public static let virtualTimerExpired   = Signal(rawValue: SIGVTALRM)
130 | 	public static let profilingTimerExpired = Signal(rawValue: SIGPROF)
    |                    |- warning: static property 'profilingTimerExpired' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'profilingTimerExpired' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
131 |
132 | 	/* *** Asynchronous I/O Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:143:20: warning: static property 'ioPossible' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
141 | 	}
142 |
143 | 	public static let ioPossible        = Signal(rawValue: SIGIO)
    |                    |- warning: static property 'ioPossible' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'ioPossible' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
144 | 	public static let urgentIOCondition = Signal(rawValue: SIGURG)
145 | #if os(Linux)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:144:20: warning: static property 'urgentIOCondition' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
142 |
143 | 	public static let ioPossible        = Signal(rawValue: SIGIO)
144 | 	public static let urgentIOCondition = Signal(rawValue: SIGURG)
    |                    |- warning: static property 'urgentIOCondition' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'urgentIOCondition' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
145 | #if os(Linux)
146 | 	/** System V signal name, similar to SIGIO. */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:147:20: warning: static property 'poll' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
145 | #if os(Linux)
146 | 	/** System V signal name, similar to SIGIO. */
147 | 	public static let poll              = Signal(rawValue: SIGPOLL)
    |                    |- warning: static property 'poll' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'poll' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
148 | #endif
149 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:164:20: warning: static property 'childExited' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
162 | 	}
163 |
164 | 	public static let childExited       = Signal(rawValue: SIGCHLD)
    |                    |- warning: static property 'childExited' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'childExited' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
165 | 	/* Obsolete name for SIGCHLD. */
166 | //	public static let cildExited        = Signal(rawValue: SIGCLD)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:167:20: warning: static property 'continued' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
165 | 	/* Obsolete name for SIGCHLD. */
166 | //	public static let cildExited        = Signal(rawValue: SIGCLD)
167 | 	public static let continued         = Signal(rawValue: SIGCONT)
    |                    |- warning: static property 'continued' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'continued' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
168 | 	/** Suspends the program. Cannot be handled, ignored or blocked. */
169 | 	public static let suspendedBySignal = Signal(rawValue: SIGSTOP)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:169:20: warning: static property 'suspendedBySignal' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
167 | 	public static let continued         = Signal(rawValue: SIGCONT)
168 | 	/** Suspends the program. Cannot be handled, ignored or blocked. */
169 | 	public static let suspendedBySignal = Signal(rawValue: SIGSTOP)
    |                    |- warning: static property 'suspendedBySignal' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'suspendedBySignal' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
170 | 	/** Suspends the program but can be handled and ignored. Usually `Ctrl-Z`. */
171 | 	public static let suspended         = Signal(rawValue: SIGTSTP)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:171:20: warning: static property 'suspended' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
169 | 	public static let suspendedBySignal = Signal(rawValue: SIGSTOP)
170 | 	/** Suspends the program but can be handled and ignored. Usually `Ctrl-Z`. */
171 | 	public static let suspended         = Signal(rawValue: SIGTSTP)
    |                    |- warning: static property 'suspended' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'suspended' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
172 | 	public static let stoppedTTYInput   = Signal(rawValue: SIGTTIN)
173 | 	public static let stoppedTTYOutput  = Signal(rawValue: SIGTTOU)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:172:20: warning: static property 'stoppedTTYInput' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
170 | 	/** Suspends the program but can be handled and ignored. Usually `Ctrl-Z`. */
171 | 	public static let suspended         = Signal(rawValue: SIGTSTP)
172 | 	public static let stoppedTTYInput   = Signal(rawValue: SIGTTIN)
    |                    |- warning: static property 'stoppedTTYInput' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'stoppedTTYInput' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
173 | 	public static let stoppedTTYOutput  = Signal(rawValue: SIGTTOU)
174 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:173:20: warning: static property 'stoppedTTYOutput' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
171 | 	public static let suspended         = Signal(rawValue: SIGTSTP)
172 | 	public static let stoppedTTYInput   = Signal(rawValue: SIGTTIN)
173 | 	public static let stoppedTTYOutput  = Signal(rawValue: SIGTTOU)
    |                    |- warning: static property 'stoppedTTYOutput' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'stoppedTTYOutput' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
174 |
175 | 	/* *** Operation Error Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:186:20: warning: static property 'brokenPipe' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
184 | 	}
185 |
186 | 	public static let brokenPipe            = Signal(rawValue: SIGPIPE)
    |                    |- warning: static property 'brokenPipe' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'brokenPipe' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
187 | //	public static let resourceLost          = Signal(rawValue: SIGLOST)
188 | 	public static let cputimeLimitExceeded  = Signal(rawValue: SIGXCPU)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:188:20: warning: static property 'cputimeLimitExceeded' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
186 | 	public static let brokenPipe            = Signal(rawValue: SIGPIPE)
187 | //	public static let resourceLost          = Signal(rawValue: SIGLOST)
188 | 	public static let cputimeLimitExceeded  = Signal(rawValue: SIGXCPU)
    |                    |- warning: static property 'cputimeLimitExceeded' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'cputimeLimitExceeded' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
189 | 	public static let filesizeLimitExceeded = Signal(rawValue: SIGXFSZ)
190 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:189:20: warning: static property 'filesizeLimitExceeded' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
187 | //	public static let resourceLost          = Signal(rawValue: SIGLOST)
188 | 	public static let cputimeLimitExceeded  = Signal(rawValue: SIGXCPU)
189 | 	public static let filesizeLimitExceeded = Signal(rawValue: SIGXFSZ)
    |                    |- warning: static property 'filesizeLimitExceeded' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'filesizeLimitExceeded' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
190 |
191 | 	/* *** Miscellaneous Signals *** */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:208:20: warning: static property 'userDefinedSignal1' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
206 | 	}
207 |
208 | 	public static let userDefinedSignal1 = Signal(rawValue: SIGUSR1)
    |                    |- warning: static property 'userDefinedSignal1' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'userDefinedSignal1' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
209 | 	public static let userDefinedSignal2 = Signal(rawValue: SIGUSR2)
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:209:20: warning: static property 'userDefinedSignal2' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
207 |
208 | 	public static let userDefinedSignal1 = Signal(rawValue: SIGUSR1)
209 | 	public static let userDefinedSignal2 = Signal(rawValue: SIGUSR2)
    |                    |- warning: static property 'userDefinedSignal2' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'userDefinedSignal2' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
211 | #if !os(Linux)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:210:20: warning: static property 'windowSizeChanges' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
208 | 	public static let userDefinedSignal1 = Signal(rawValue: SIGUSR1)
209 | 	public static let userDefinedSignal2 = Signal(rawValue: SIGUSR2)
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
    |                    |- warning: static property 'windowSizeChanges' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'windowSizeChanges' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
211 | #if !os(Linux)
212 | 	public static let informationRequest = Signal(rawValue: SIGINFO)
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:226:20: warning: static property 'stackFault' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
224 | 	}
225 |
226 | 	public static let stackFault   = Signal(rawValue: SIGSTKFLT)
    |                    |- warning: static property 'stackFault' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'stackFault' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
227 | 	public static let powerFailure = Signal(rawValue: SIGPWR)
228 | #endif
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:227:20: warning: static property 'powerFailure' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
    :
225 |
226 | 	public static let stackFault   = Signal(rawValue: SIGSTKFLT)
227 | 	public static let powerFailure = Signal(rawValue: SIGPWR)
    |                    |- warning: static property 'powerFailure' is not concurrency-safe because non-'Sendable' type 'Signal' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'powerFailure' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
228 | #endif
229 |
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/DelayedSigaction.swift:10:21: warning: static property 'latestID' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 8 | public struct DelayedSigaction : Hashable {
 9 |
10 | 	private static var latestID = 0
   |                     |- warning: static property 'latestID' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                     |- note: convert 'latestID' to a 'let' constant to make 'Sendable' shared state immutable
   |                     |- note: add '@MainActor' to make static property 'latestID' part of global actor 'MainActor'
   |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
11 |
12 | 	internal var id: Int
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:173:14: warning: static property 'action' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
171 | 		static let lock = NSConditionLock(condition: Self.nothingToDo.rawValue)
172 |
173 | 		static var action: Action = .nop
    |              |- warning: static property 'action' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |              |- note: convert 'action' to a 'let' constant to make 'Sendable' shared state immutable
    |              |- note: add '@MainActor' to make static property 'action' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
174 | 		static var error: Error?
175 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:174:14: warning: static property 'error' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
172 |
173 | 		static var action: Action = .nop
174 | 		static var error: Error?
    |              |- warning: static property 'error' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |              |- note: convert 'error' to a 'let' constant to make 'Sendable' shared state immutable
    |              |- note: add '@MainActor' to make static property 'error' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
175 |
176 | 		case nothingToDo
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:191:21: warning: static property 'bootstrapDone' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
189 | 	private static let signalProcessingQueue = DispatchQueue(label: "com.xcode-actions.blocked-signals-processing-queue")
190 |
191 | 	private static var bootstrapDone = false
    |                     |- warning: static property 'bootstrapDone' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                     |- note: convert 'bootstrapDone' to a 'let' constant to make 'Sendable' shared state immutable
    |                     |- note: add '@MainActor' to make static property 'bootstrapDone' part of global actor 'MainActor'
    |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 | 	private static var blockedSignals = [Signal: BlockedSignal]()
193 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:192:21: warning: static property 'blockedSignals' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
190 |
191 | 	private static var bootstrapDone = false
192 | 	private static var blockedSignals = [Signal: BlockedSignal]()
    |                     |- warning: static property 'blockedSignals' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                     |- note: convert 'blockedSignals' to a 'let' constant to make 'Sendable' shared state immutable
    |                     |- note: add '@MainActor' to make static property 'blockedSignals' part of global actor 'MainActor'
    |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
193 |
194 | 	private static func executeOnThread(_ action: ThreadSync.Action) throws {
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:82:5: warning: mutation of captured var 'error' in concurrently-executing code; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
 80 | 			let ret = pthread_sigmask(SIG_SETMASK, &noSignals, nil /* old signals */)
 81 | 			if ret != 0 {
 82 | 				error = SignalHandlingError.destructiveSystemError(Errno(rawValue: ret))
    |     `- warning: mutation of captured var 'error' in concurrently-executing code; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
 83 | 			}
 84 | 			group.leave()
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:255:13: warning: capture of 'currentSigaction' with non-Sendable type 'Sigaction' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
253 | 			 * https://github.com/apple/swift-corelibs-libdispatch/pull/560 */
254 | 			signalProcessingQueue.async{
255 | 				do {try currentSigaction.install(on: signal)}
    |             `- warning: capture of 'currentSigaction' with non-Sendable type 'Sigaction' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
256 | 				catch {
257 | 					SignalHandlingConfig.logger?.error(
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:7:15: note: consider making struct 'Sigaction' conform to the 'Sendable' protocol
  5 |
  6 |
  7 | public struct Sigaction : Equatable, RawRepresentable {
    |               `- note: consider making struct 'Sigaction' conform to the 'Sendable' protocol
  8 |
  9 | 	public static let ignoreAction = Sigaction(handler: .ignoreHandler)
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:255:42: warning: capture of 'signal' with non-Sendable type 'Signal' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
253 | 			 * https://github.com/apple/swift-corelibs-libdispatch/pull/560 */
254 | 			signalProcessingQueue.async{
255 | 				do {try currentSigaction.install(on: signal)}
    |                                          `- warning: capture of 'signal' with non-Sendable type 'Signal' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
256 | 				catch {
257 | 					SignalHandlingConfig.logger?.error(
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:7:15: note: consider making struct 'Signal' conform to the 'Sendable' protocol
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Block.swift:259:31: warning: implicit capture of 'signal' requires that 'Signal' conforms to 'Sendable'; this is an error in the Swift 6 language mode
257 | 					SignalHandlingConfig.logger?.error(
258 | 						"Cannot set original sigaction back for signal after signal source activation. You might never be called in the sigaction handler and get an infinite loop of signal calls once this signal has been sent once.",
259 | 						metadata: ["signal": "\(signal)", "error": "\(error)"]
    |                               `- warning: implicit capture of 'signal' requires that 'Signal' conforms to 'Sendable'; this is an error in the Swift 6 language mode
260 | 					)
261 | 				}
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Signal.swift:7:15: note: consider making struct 'Signal' conform to the 'Sendable' protocol
  5 | /* Could be an enum?
  6 |  * I’d say no to be able to represent signals we don’t know are a part of the system. */
  7 | public struct Signal : RawRepresentable, Hashable, Codable, CaseIterable, CustomStringConvertible {
    |               `- note: consider making struct 'Signal' conform to the 'Sendable' protocol
  8 |
  9 | 	/* Signal 0 is not considered.
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[125 / 148] Logging
/host/spi-builder-workspace/Sources/SignalHandling/SignalHandlingConfig.swift:9:20: warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 7 | public enum SignalHandlingConfig {
 8 |
 9 | 	public static var logger: Logging.Logger? = {
   |                    |- warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: convert 'logger' to a 'let' constant to make 'Sendable' shared state immutable
   |                    |- note: add '@MainActor' to make static property 'logger' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
10 | 		return Logger(label: "com.xcode-actions.signal-handling")
11 | 	}()
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:130:14: warning: static property 'action' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
128 | 		static let lock = NSConditionLock(condition: Self.nothingToDo.rawValue)
129 |
130 | 		static var action: Action = .nop
    |              |- warning: static property 'action' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |              |- note: convert 'action' to a 'let' constant to make 'Sendable' shared state immutable
    |              |- note: add '@MainActor' to make static property 'action' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
131 | 		static var completionResult: ErrorAndLogs?
132 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:131:14: warning: static property 'completionResult' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
129 |
130 | 		static var action: Action = .nop
131 | 		static var completionResult: ErrorAndLogs?
    |              |- warning: static property 'completionResult' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |              |- note: convert 'completionResult' to a 'let' constant to make 'Sendable' shared state immutable
    |              |- note: add '@MainActor' to make static property 'completionResult' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
132 |
133 | 		case nothingToDo
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:150:21: warning: static property 'hasCreatedProcessingThread' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
148 | 	private static let signalProcessingQueue = DispatchQueue(label: "com.xcode-actions.unsigactioned-signals-processing-queue")
149 |
150 | 	private static var hasCreatedProcessingThread = false
    |                     |- warning: static property 'hasCreatedProcessingThread' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                     |- note: convert 'hasCreatedProcessingThread' to a 'let' constant to make 'Sendable' shared state immutable
    |                     |- note: add '@MainActor' to make static property 'hasCreatedProcessingThread' part of global actor 'MainActor'
    |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
151 | 	private static var unsigactionedSignals = [Signal: UnsigactionedSignal]()
152 |
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:151:21: warning: static property 'unsigactionedSignals' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
149 |
150 | 	private static var hasCreatedProcessingThread = false
151 | 	private static var unsigactionedSignals = [Signal: UnsigactionedSignal]()
    |                     |- warning: static property 'unsigactionedSignals' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                     |- note: convert 'unsigactionedSignals' to a 'let' constant to make 'Sendable' shared state immutable
    |                     |- note: add '@MainActor' to make static property 'unsigactionedSignals' part of global actor 'MainActor'
    |                     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
152 |
153 | 	private static func executeOnThread(_ action: ThreadSync.Action) throws {
/host/spi-builder-workspace/Sources/SignalHandling/DelayedSigaction/SigactionDelayer_Unsig.swift:302:5: warning: mutation of captured var 'error' in concurrently-executing code; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
300 | 			let ret = pthread_sigmask(SIG_SETMASK, &noSignals, nil /* old signals */)
301 | 			if ret != 0 {
302 | 				error = SignalHandlingError.destructiveSystemError(Errno(rawValue: ret))
    |     `- warning: mutation of captured var 'error' in concurrently-executing code; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
303 | 			}
304 | 			group.leave()
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[130 / 148] CLTLogger-product
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:9:20: warning: static property 'ignoreAction' is not concurrency-safe because non-'Sendable' type 'Sigaction' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 |
  6 |
  7 | public struct Sigaction : Equatable, RawRepresentable {
    |               `- note: consider making struct 'Sigaction' conform to the 'Sendable' protocol
  8 |
  9 | 	public static let ignoreAction = Sigaction(handler: .ignoreHandler)
    |                    |- warning: static property 'ignoreAction' is not concurrency-safe because non-'Sendable' type 'Sigaction' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'ignoreAction' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 10 | 	public static let defaultAction = Sigaction(handler: .defaultHandler)
 11 |
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:10:20: warning: static property 'defaultAction' is not concurrency-safe because non-'Sendable' type 'Sigaction' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
  5 |
  6 |
  7 | public struct Sigaction : Equatable, RawRepresentable {
    |               `- note: consider making struct 'Sigaction' conform to the 'Sendable' protocol
  8 |
  9 | 	public static let ignoreAction = Sigaction(handler: .ignoreHandler)
 10 | 	public static let defaultAction = Sigaction(handler: .defaultHandler)
    |                    |- warning: static property 'defaultAction' is not concurrency-safe because non-'Sendable' type 'Sigaction' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
    |                    |- note: add '@MainActor' to make static property 'defaultAction' part of global actor 'MainActor'
    |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 11 |
 12 | 	/**
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift:11:20: warning: static property 'noChildStop' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 4 |
 5 | /** Flag list is from `sigaction(2)` on macOS. */
 6 | public struct SigactionFlags : OptionSet {
   |               `- note: consider making struct 'SigactionFlags' conform to the 'Sendable' protocol
 7 |
 8 | 	/**
 9 | 	 If this bit is set when installing a catching function for the `SIGCHLD` signal,
10 | 	  the `SIGCHLD` signal will be generated only when a child process exits, not when a child process stops. */
11 | 	public static let noChildStop = SigactionFlags(rawValue: SA_NOCLDSTOP)
   |                    |- warning: static property 'noChildStop' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: add '@MainActor' to make static property 'noChildStop' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
12 |
13 | 	/**
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift:19:20: warning: static property 'noChildWait' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 4 |
 5 | /** Flag list is from `sigaction(2)` on macOS. */
 6 | public struct SigactionFlags : OptionSet {
   |               `- note: consider making struct 'SigactionFlags' conform to the 'Sendable' protocol
 7 |
 8 | 	/**
   :
17 | 	  it blocks until all of the calling process’s child processes terminate,
18 | 	  and then returns a value of -1 with errno set to ECHILD. */
19 | 	public static let noChildWait = SigactionFlags(rawValue: SA_NOCLDWAIT)
   |                    |- warning: static property 'noChildWait' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: add '@MainActor' to make static property 'noChildWait' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
20 |
21 | 	/**
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift:23:20: warning: static property 'onStack' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 4 |
 5 | /** Flag list is from `sigaction(2)` on macOS. */
 6 | public struct SigactionFlags : OptionSet {
   |               `- note: consider making struct 'SigactionFlags' conform to the 'Sendable' protocol
 7 |
 8 | 	/**
   :
21 | 	/**
22 | 	 If this bit is set, the system will deliver the signal to the process on a signal stack, specified with `sigaltstack(2)`. */
23 | 	public static let onStack = SigactionFlags(rawValue: SA_ONSTACK)
   |                    |- warning: static property 'onStack' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: add '@MainActor' to make static property 'onStack' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
24 |
25 | 	/**
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift:27:20: warning: static property 'noDefer' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 4 |
 5 | /** Flag list is from `sigaction(2)` on macOS. */
 6 | public struct SigactionFlags : OptionSet {
   |               `- note: consider making struct 'SigactionFlags' conform to the 'Sendable' protocol
 7 |
 8 | 	/**
   :
25 | 	/**
26 | 	 If this bit is set, further occurrences of the delivered signal are not masked during the execution of the handler. */
27 | 	public static let noDefer = SigactionFlags(rawValue: SA_NODEFER)
   |                    |- warning: static property 'noDefer' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: add '@MainActor' to make static property 'noDefer' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
28 |
29 | 	/**
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift:31:20: warning: static property 'resetHandler' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 4 |
 5 | /** Flag list is from `sigaction(2)` on macOS. */
 6 | public struct SigactionFlags : OptionSet {
   |               `- note: consider making struct 'SigactionFlags' conform to the 'Sendable' protocol
 7 |
 8 | 	/**
   :
29 | 	/**
30 | 	 If this bit is set, the handler is reset back to `SIG_DFL` at the moment the signal is delivered. */
31 | 	public static let resetHandler = SigactionFlags(rawValue: CInt(SA_RESETHAND) /* On Linux, an UInt32 instead of Int32, so we cast… */)
   |                    |- warning: static property 'resetHandler' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: add '@MainActor' to make static property 'resetHandler' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
32 |
33 | 	/** See `sigaction(2)`. */
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift:34:20: warning: static property 'restart' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 4 |
 5 | /** Flag list is from `sigaction(2)` on macOS. */
 6 | public struct SigactionFlags : OptionSet {
   |               `- note: consider making struct 'SigactionFlags' conform to the 'Sendable' protocol
 7 |
 8 | 	/**
   :
32 |
33 | 	/** See `sigaction(2)`. */
34 | 	public static let restart = SigactionFlags(rawValue: SA_RESTART)
   |                    |- warning: static property 'restart' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: add '@MainActor' to make static property 'restart' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
35 |
36 | 	/**
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift:40:20: warning: static property 'siginfo' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 4 |
 5 | /** Flag list is from `sigaction(2)` on macOS. */
 6 | public struct SigactionFlags : OptionSet {
   |               `- note: consider making struct 'SigactionFlags' conform to the 'Sendable' protocol
 7 |
 8 | 	/**
   :
38 | 	  and should match the matching prototype.
39 | 	 This bit should not be set when assigning `SIG_DFL` or `SIG_IGN`. */
40 | 	public static let siginfo = SigactionFlags(rawValue: SA_SIGINFO)
   |                    |- warning: static property 'siginfo' is not concurrency-safe because non-'Sendable' type 'SigactionFlags' may have shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |                    |- note: add '@MainActor' to make static property 'siginfo' part of global actor 'MainActor'
   |                    `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
41 |
42 | 	public let rawValue: CInt
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
[136 / 159] SignalHandling
[138 / 159] ArgumentParser
[139 / 159] ArgumentParser
[139 / 159] CLTLogger
[141 / 160] CLTLogger
[146 / 161] SystemPackage
[149 / 161] ArgumentParser
[156 / 169] signal-handling-tests-helper-product
[157 / 169] signal-handling-tests-helper-product
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/main.swift:9:13: warning: static property 'configuration' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 7 | struct SignalHandlingTestsHelper : ParsableCommand {
 8 |
 9 | 	static var configuration = CommandConfiguration(
   |             |- warning: static property 'configuration' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |             |- note: convert 'configuration' to a 'let' constant to make 'Sendable' shared state immutable
   |             |- note: add '@MainActor' to make static property 'configuration' part of global actor 'MainActor'
   |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
10 | 		subcommands: [
11 | 			ManualTest.self,
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/ManualDispatchMemTest.swift:24:13: warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
22 | struct ManualDispatchMemTest : ParsableCommand {
23 |
24 | 	static var logger: Logger?
   |             |- warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |             |- note: convert 'logger' to a 'let' constant to make 'Sendable' shared state immutable
   |             |- note: add '@MainActor' to make static property 'logger' part of global actor 'MainActor'
   |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
25 |
26 | 	func run() throws {
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/ManualTest.swift:13:13: warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
11 | struct ManualTest : ParsableCommand {
12 |
13 | 	static var logger: Logger?
   |             |- warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |             |- note: convert 'logger' to a 'let' constant to make 'Sendable' shared state immutable
   |             |- note: add '@MainActor' to make static property 'logger' part of global actor 'MainActor'
   |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
14 |
15 | 	enum DelayMode : String, ExpressibleByArgument {
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/main.swift:9:13: warning: static property 'configuration' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
 7 | struct SignalHandlingTestsHelper : ParsableCommand {
 8 |
 9 | 	static var configuration = CommandConfiguration(
   |             |- warning: static property 'configuration' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |             |- note: convert 'configuration' to a 'let' constant to make 'Sendable' shared state immutable
   |             |- note: add '@MainActor' to make static property 'configuration' part of global actor 'MainActor'
   |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
10 | 		subcommands: [
11 | 			ManualTest.self,
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
[159 / 169] signal-handling-tests-helper-product
[162 / 169] signal-handling-tests-helper-product
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/DelaySignalUnsigaction.swift:18:24: warning: reference to static property 'logger' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
16 | 	func run() throws {
17 | 		LoggingSystem.bootstrap{ _ in CLTLogger(multilineMode: .allMultiline) }
18 | 		SignalHandlingConfig.logger?.logLevel = .trace
   |                        `- warning: reference to static property 'logger' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
19 |
20 | 		let signal = Signal(rawValue: signalNumber)
/host/spi-builder-workspace/Sources/SignalHandling/SignalHandlingConfig.swift:9:20: note: static property declared here
 7 | public enum SignalHandlingConfig {
 8 |
 9 | 	public static var logger: Logging.Logger? = {
   |                    `- note: static property declared here
10 | 		return Logger(label: "com.xcode-actions.signal-handling")
11 | 	}()
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/DelaySignalUnsigaction.swift:27:5: warning: capture of 'doneHandler' with non-Sendable type '(Bool) -> Void' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
25 | 			DispatchQueue.global().asyncAfter(deadline: .now() + .milliseconds(500), execute: {
26 | 				writeToStdout("allowing signal to be resent")
27 | 				doneHandler(true)
   |     |- warning: capture of 'doneHandler' with non-Sendable type '(Bool) -> Void' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
   |     `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
28 | 			})
29 | 		})
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/ManualDispatchMemTest.swift:24:13: warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
22 | struct ManualDispatchMemTest : ParsableCommand {
23 |
24 | 	static var logger: Logger?
   |             |- warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |             |- note: convert 'logger' to a 'let' constant to make 'Sendable' shared state immutable
   |             |- note: add '@MainActor' to make static property 'logger' part of global actor 'MainActor'
   |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
25 |
26 | 	func run() throws {
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/ManualDispatchMemTest.swift:32:24: warning: reference to static property 'logger' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
30 | 		logger.logLevel = .trace
31 | 		Self.logger = logger /* We must do this to be able to use the logger from the C handler. */
32 | 		SignalHandlingConfig.logger?.logLevel = .trace
   |                        `- warning: reference to static property 'logger' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
33 |
34 | 		let signal = Signal.interrupt
/host/spi-builder-workspace/Sources/SignalHandling/SignalHandlingConfig.swift:9:20: note: static property declared here
 7 | public enum SignalHandlingConfig {
 8 |
 9 | 	public static var logger: Logging.Logger? = {
   |                    `- note: static property declared here
10 | 		return Logger(label: "com.xcode-actions.signal-handling")
11 | 	}()
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
[163 / 169] SignalHandling
[164 / 169] ArgumentParser
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/ManualTest.swift:13:13: warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
11 | struct ManualTest : ParsableCommand {
12 |
13 | 	static var logger: Logger?
   |             |- warning: static property 'logger' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable\MutableGlobalVariable]8;;\]
   |             |- note: convert 'logger' to a 'let' constant to make 'Sendable' shared state immutable
   |             |- note: add '@MainActor' to make static property 'logger' part of global actor 'MainActor'
   |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
14 |
15 | 	enum DelayMode : String, ExpressibleByArgument {
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/ManualTest.swift:33:24: warning: reference to static property 'logger' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
31 | 		logger.logLevel = .trace
32 | 		Self.logger = logger /* We must do this to be able to use the logger from the C handler. */
33 | 		SignalHandlingConfig.logger?.logLevel = .trace
   |                        `- warning: reference to static property 'logger' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
34 |
35 | 		try Sigaction(handler: .ansiC({ _ in Self.logger?.debug("In libxct-test-helper sigaction handler for interrupt") })).install(on: .interrupt)
/host/spi-builder-workspace/Sources/SignalHandling/SignalHandlingConfig.swift:9:20: note: static property declared here
 7 | public enum SignalHandlingConfig {
 8 |
 9 | 	public static var logger: Logging.Logger? = {
   |                    `- note: static property declared here
10 | 		return Logger(label: "com.xcode-actions.signal-handling")
11 | 	}()
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/ManualTest.swift:46:5: warning: capture of 'doneHandler' with non-Sendable type '(Bool) -> Void' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
44 | 			DispatchQueue.global().asyncAfter(deadline: .now() + .milliseconds(500), execute: { [logger] in
45 | 				logger.info("Allowing signal to be resent")
46 | 				doneHandler(true)
   |     |- warning: capture of 'doneHandler' with non-Sendable type '(Bool) -> Void' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
   |     `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
47 | 			})
48 | 		}
[#MutableGlobalVariable]: <https://docs.swift.org/compiler/documentation/diagnostics/mutable-global-variable>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/DelaySignalBlock.swift:20:24: warning: reference to static property 'logger' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
18 |
19 | 		LoggingSystem.bootstrap{ _ in CLTLogger(multilineMode: .allMultiline) }
20 | 		SignalHandlingConfig.logger?.logLevel = .trace
   |                        `- warning: reference to static property 'logger' is not concurrency-safe because it involves shared mutable state; this is an error in the Swift 6 language mode
21 |
22 | 		let signal = Signal(rawValue: signalNumber)
/host/spi-builder-workspace/Sources/SignalHandling/SignalHandlingConfig.swift:9:20: note: static property declared here
 7 | public enum SignalHandlingConfig {
 8 |
 9 | 	public static var logger: Logging.Logger? = {
   |                    `- note: static property declared here
10 | 		return Logger(label: "com.xcode-actions.signal-handling")
11 | 	}()
/host/spi-builder-workspace/Sources/signal-handling-tests-helper/DelaySignalBlock.swift:29:5: warning: capture of 'doneHandler' with non-Sendable type '(Bool) -> Void' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
27 | 			DispatchQueue.global().asyncAfter(deadline: .now() + .milliseconds(500), execute: {
28 | 				writeToStdout("allowing signal to be resent")
29 | 				doneHandler(true)
   |     |- warning: capture of 'doneHandler' with non-Sendable type '(Bool) -> Void' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#]8;;https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures\SendableClosureCaptures]8;;\]
   |     `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
30 | 			})
31 | 		})
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[165 / 170] signal-handling-tests-helper-product
[167 / 170] ArgumentParser
[171 / 171] signal-handling-tests-helper-product
Build complete! (12.18 secs)
Build complete.
{
  "dependencies" : [
    {
      "identity" : "swift-argument-parser",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.0.0",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-argument-parser.git"
    },
    {
      "identity" : "swift-log",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.4.2",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-log.git"
    },
    {
      "identity" : "swift-system",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.0.0",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/apple/swift-system.git"
    },
    {
      "identity" : "clt-logger",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.0.0-beta.4",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/xcode-actions/clt-logger.git"
    }
  ],
  "manifest_display_name" : "swift-signal-handling",
  "name" : "swift-signal-handling",
  "path" : "/host/spi-builder-workspace",
  "platforms" : [
    {
      "name" : "macos",
      "version" : "11.0"
    },
    {
      "name" : "tvos",
      "version" : "14.0"
    },
    {
      "name" : "ios",
      "version" : "14.0"
    },
    {
      "name" : "watchos",
      "version" : "7.0"
    }
  ],
  "products" : [
    {
      "name" : "SignalHandling",
      "targets" : [
        "SignalHandling"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "signal-handling-tests-helper",
      "targets" : [
        "signal-handling-tests-helper"
      ],
      "type" : {
        "executable" : null
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "signal_handling_tests_helper",
      "module_type" : "SwiftTarget",
      "name" : "signal-handling-tests-helper",
      "path" : "Sources/signal-handling-tests-helper",
      "product_dependencies" : [
        "ArgumentParser",
        "CLTLogger",
        "Logging"
      ],
      "product_memberships" : [
        "signal-handling-tests-helper"
      ],
      "sources" : [
        "ConditionLock.swift",
        "DelaySignalBlock.swift",
        "DelaySignalUnsigaction.swift",
        "ManualDispatchMemTest.swift",
        "ManualTest.swift",
        "main.swift"
      ],
      "target_dependencies" : [
        "SignalHandling"
      ],
      "type" : "executable"
    },
    {
      "c99name" : "SignalHandlingTests",
      "module_type" : "SwiftTarget",
      "name" : "SignalHandlingTests",
      "path" : "Tests/SignalHandlingTests",
      "product_dependencies" : [
        "CLTLogger",
        "Logging"
      ],
      "sources" : [
        "LockTest.swift",
        "SignalHandlingTests.swift",
        "Utils.swift"
      ],
      "target_dependencies" : [
        "signal-handling-tests-helper"
      ],
      "type" : "test"
    },
    {
      "c99name" : "SignalHandling",
      "module_type" : "SwiftTarget",
      "name" : "SignalHandling",
      "path" : "Sources/SignalHandling",
      "product_dependencies" : [
        "Logging",
        "SystemPackage"
      ],
      "product_memberships" : [
        "SignalHandling",
        "signal-handling-tests-helper"
      ],
      "sources" : [
        "CStructsInSwift/Sigaction.swift",
        "CStructsInSwift/SigactionFlag.swift",
        "CStructsInSwift/SigactionHandler.swift",
        "CStructsInSwift/Signal.swift",
        "DelayedSigaction/DelayedSigaction.swift",
        "DelayedSigaction/DelayedSigactionHandler.swift",
        "DelayedSigaction/SigactionDelayer_Block.swift",
        "DelayedSigaction/SigactionDelayer_Unsig.swift",
        "SignalHandlingConfig.swift",
        "SignalHandlingError.swift",
        "Utils.swift"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "5.8"
}
basic-6.4-latest: Pulling from saguaro1/spi-images
Digest: sha256:c77fcce225e223ac0fafed844619173fc6de8d62dd560eeb28db3182af6a282b
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:basic-6.4-latest
Done.