Swift Package Index

Build Information

Failed to build swift-signal-handling, reference 1.1.4 (c50ae0), with Swift 6.1 for Android on 20 Nov 2025 18:35:50 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4606859-3":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/finestructure/spi-images:android-6.1-latest swift build --swift-sdk aarch64-unknown-linux-android24 2>&1

Build Log

 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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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:90:62: error: cannot find 'SIGEMT' in scope
 88 | 	public static let traceBreakpointTrap    = Signal(rawValue: SIGTRAP)
 89 | #if !os(Linux)
 90 | 	public static let emulatorTrap           = Signal(rawValue: SIGEMT)
    |                                                              `- error: cannot find 'SIGEMT' in scope
 91 | #endif
 92 | 	public static let badSystemCall          = Signal(rawValue: SIGSYS)
/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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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: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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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:212:58: error: cannot find 'SIGINFO' in scope
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
211 | #if !os(Linux)
212 | 	public static let informationRequest = Signal(rawValue: SIGINFO)
    |                                                          `- error: cannot find 'SIGINFO' in scope
213 | #endif
214 |
/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 | 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
   |                     |- 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
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
    |              |- 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
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
    |              |- 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
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
    |                     |- 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
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
    |                     |- 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
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
    |              |- 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
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
    |              |- 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
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
    |                     |- 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
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
    |                     |- 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
 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
   |                    |- 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 | 	}()
[72/129] Compiling SignalHandling Sigaction.swift
/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
  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
    |                    |- 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
  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
    |                    |- 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/Sigaction.swift:48:59: error: value of type 'sigaction' has no member '__sigaction_u'
 46 |
 47 | #if !os(Linux)
 48 | 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_u.__sa_handler, to: Int.self)) {
    |                                                           `- error: value of type 'sigaction' has no member '__sigaction_u'
 49 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
 50 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:49:49: error: cannot find 'SIG_IGN' in scope
 47 | #if !os(Linux)
 48 | 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_u.__sa_handler, to: Int.self)) {
 49 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
    |                                                 `- error: cannot find 'SIG_IGN' in scope
 50 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
 51 | 			default:
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:50:49: error: cannot find 'SIG_DFL' in scope
 48 | 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_u.__sa_handler, to: Int.self)) {
 49 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
 50 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
    |                                                 `- error: cannot find 'SIG_DFL' in scope
 51 | 			default:
 52 | 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_u.__sa_sigaction)}
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:52:65: error: value of type 'sigaction' has no member '__sigaction_u'
 50 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
 51 | 			default:
 52 | 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_u.__sa_sigaction)}
    |                                                                 `- error: value of type 'sigaction' has no member '__sigaction_u'
 53 | 				else                        {self.handler = .ansiC(rawValue.__sigaction_u.__sa_handler)}
 54 | 		}
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:53:65: error: value of type 'sigaction' has no member '__sigaction_u'
 51 | 			default:
 52 | 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_u.__sa_sigaction)}
 53 | 				else                        {self.handler = .ansiC(rawValue.__sigaction_u.__sa_handler)}
    |                                                                 `- error: value of type 'sigaction' has no member '__sigaction_u'
 54 | 		}
 55 | #else
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:73:72: error: cannot find 'errno' in scope
 71 | 		var action = sigaction()
 72 | 		guard sigaction(signal.rawValue, nil, &action) == 0 else {
 73 | 			throw SignalHandlingError.nonDestructiveSystemError(Errno(rawValue: errno))
    |                                                                        `- error: cannot find 'errno' in scope
 74 | 		}
 75 | 		self.init(rawValue: action)
/root/.swiftpm/swift-sdks/swift-6.1-RELEASE-android-24-0.1.artifactbundle/swift-6.1-release-android-24-sdk/android-27c-sysroot/usr/include/errno.h:58:9: note: macro 'errno' unavailable: structure not supported
56 |  * thread.
57 |  */
58 | #define errno (*__errno())
   |         `- note: macro 'errno' unavailable: structure not supported
59 |
60 | __END_DECLS
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:89:59: error: cannot find 'SIG_IGN' in scope
 87 | #if !os(Linux)
 88 | 		switch handler {
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
    |                                                           `- error: cannot find 'SIG_IGN' in scope
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:89:30: error: value of type 'sigaction' has no member '__sigaction_u'
 87 | #if !os(Linux)
 88 | 		switch handler {
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
    |                              `- error: value of type 'sigaction' has no member '__sigaction_u'
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:90:59: error: cannot find 'SIG_DFL' in scope
 88 | 		switch handler {
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
    |                                                           `- error: cannot find 'SIG_DFL' in scope
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
 92 | 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:90:30: error: value of type 'sigaction' has no member '__sigaction_u'
 88 | 		switch handler {
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
    |                              `- error: value of type 'sigaction' has no member '__sigaction_u'
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
 92 | 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:91:30: error: value of type 'sigaction' has no member '__sigaction_u'
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
    |                              `- error: value of type 'sigaction' has no member '__sigaction_u'
 92 | 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
 93 | 		}
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:92:30: error: value of type 'sigaction' has no member '__sigaction_u'
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
 92 | 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
    |                              `- error: value of type 'sigaction' has no member '__sigaction_u'
 93 | 		}
 94 | #else
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:131:72: error: cannot find 'errno' in scope
129 | 		var newCAction = self.rawValue
130 | 		guard sigaction(signal.rawValue, &newCAction, &oldCAction) == 0 else {
131 | 			throw SignalHandlingError.nonDestructiveSystemError(Errno(rawValue: errno))
    |                                                                        `- error: cannot find 'errno' in scope
132 | 		}
133 | 		let oldSigaction = Sigaction(rawValue: oldCAction)
/root/.swiftpm/swift-sdks/swift-6.1-RELEASE-android-24-0.1.artifactbundle/swift-6.1-release-android-24-sdk/android-27c-sysroot/usr/include/errno.h:58:9: note: macro 'errno' unavailable: structure not supported
56 |  * thread.
57 |  */
58 | #define errno (*__errno())
   |         `- note: macro 'errno' unavailable: structure not supported
59 |
60 | __END_DECLS
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:136:70: error: cannot find 'errno' in scope
134 | 		if revertIfIgnored && oldSigaction == .ignoreAction {
135 | 			guard sigaction(signal.rawValue, &oldCAction, nil) == 0 else {
136 | 				throw SignalHandlingError.destructiveSystemError(Errno(rawValue: errno))
    |                                                                      `- error: cannot find 'errno' in scope
137 | 			}
138 | 			return nil
/root/.swiftpm/swift-sdks/swift-6.1-RELEASE-android-24-0.1.artifactbundle/swift-6.1-release-android-24-sdk/android-27c-sysroot/usr/include/errno.h:58:9: note: macro 'errno' unavailable: structure not supported
56 |  * thread.
57 |  */
58 | #define errno (*__errno())
   |         `- note: macro 'errno' unavailable: structure not supported
59 |
60 | __END_DECLS
/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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
[73/129] Compiling SignalHandling SigactionFlag.swift
/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
  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
    |                    |- 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
  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
    |                    |- 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/Sigaction.swift:48:59: error: value of type 'sigaction' has no member '__sigaction_u'
 46 |
 47 | #if !os(Linux)
 48 | 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_u.__sa_handler, to: Int.self)) {
    |                                                           `- error: value of type 'sigaction' has no member '__sigaction_u'
 49 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
 50 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:49:49: error: cannot find 'SIG_IGN' in scope
 47 | #if !os(Linux)
 48 | 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_u.__sa_handler, to: Int.self)) {
 49 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
    |                                                 `- error: cannot find 'SIG_IGN' in scope
 50 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
 51 | 			default:
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:50:49: error: cannot find 'SIG_DFL' in scope
 48 | 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_u.__sa_handler, to: Int.self)) {
 49 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
 50 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
    |                                                 `- error: cannot find 'SIG_DFL' in scope
 51 | 			default:
 52 | 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_u.__sa_sigaction)}
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:52:65: error: value of type 'sigaction' has no member '__sigaction_u'
 50 | 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
 51 | 			default:
 52 | 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_u.__sa_sigaction)}
    |                                                                 `- error: value of type 'sigaction' has no member '__sigaction_u'
 53 | 				else                        {self.handler = .ansiC(rawValue.__sigaction_u.__sa_handler)}
 54 | 		}
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:53:65: error: value of type 'sigaction' has no member '__sigaction_u'
 51 | 			default:
 52 | 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_u.__sa_sigaction)}
 53 | 				else                        {self.handler = .ansiC(rawValue.__sigaction_u.__sa_handler)}
    |                                                                 `- error: value of type 'sigaction' has no member '__sigaction_u'
 54 | 		}
 55 | #else
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:73:72: error: cannot find 'errno' in scope
 71 | 		var action = sigaction()
 72 | 		guard sigaction(signal.rawValue, nil, &action) == 0 else {
 73 | 			throw SignalHandlingError.nonDestructiveSystemError(Errno(rawValue: errno))
    |                                                                        `- error: cannot find 'errno' in scope
 74 | 		}
 75 | 		self.init(rawValue: action)
/root/.swiftpm/swift-sdks/swift-6.1-RELEASE-android-24-0.1.artifactbundle/swift-6.1-release-android-24-sdk/android-27c-sysroot/usr/include/errno.h:58:9: note: macro 'errno' unavailable: structure not supported
56 |  * thread.
57 |  */
58 | #define errno (*__errno())
   |         `- note: macro 'errno' unavailable: structure not supported
59 |
60 | __END_DECLS
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:89:59: error: cannot find 'SIG_IGN' in scope
 87 | #if !os(Linux)
 88 | 		switch handler {
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
    |                                                           `- error: cannot find 'SIG_IGN' in scope
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:89:30: error: value of type 'sigaction' has no member '__sigaction_u'
 87 | #if !os(Linux)
 88 | 		switch handler {
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
    |                              `- error: value of type 'sigaction' has no member '__sigaction_u'
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:90:59: error: cannot find 'SIG_DFL' in scope
 88 | 		switch handler {
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
    |                                                           `- error: cannot find 'SIG_DFL' in scope
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
 92 | 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:90:30: error: value of type 'sigaction' has no member '__sigaction_u'
 88 | 		switch handler {
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
    |                              `- error: value of type 'sigaction' has no member '__sigaction_u'
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
 92 | 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:91:30: error: value of type 'sigaction' has no member '__sigaction_u'
 89 | 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
    |                              `- error: value of type 'sigaction' has no member '__sigaction_u'
 92 | 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
 93 | 		}
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:92:30: error: value of type 'sigaction' has no member '__sigaction_u'
 90 | 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 91 | 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
 92 | 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
    |                              `- error: value of type 'sigaction' has no member '__sigaction_u'
 93 | 		}
 94 | #else
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:131:72: error: cannot find 'errno' in scope
129 | 		var newCAction = self.rawValue
130 | 		guard sigaction(signal.rawValue, &newCAction, &oldCAction) == 0 else {
131 | 			throw SignalHandlingError.nonDestructiveSystemError(Errno(rawValue: errno))
    |                                                                        `- error: cannot find 'errno' in scope
132 | 		}
133 | 		let oldSigaction = Sigaction(rawValue: oldCAction)
/root/.swiftpm/swift-sdks/swift-6.1-RELEASE-android-24-0.1.artifactbundle/swift-6.1-release-android-24-sdk/android-27c-sysroot/usr/include/errno.h:58:9: note: macro 'errno' unavailable: structure not supported
56 |  * thread.
57 |  */
58 | #define errno (*__errno())
   |         `- note: macro 'errno' unavailable: structure not supported
59 |
60 | __END_DECLS
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/Sigaction.swift:136:70: error: cannot find 'errno' in scope
134 | 		if revertIfIgnored && oldSigaction == .ignoreAction {
135 | 			guard sigaction(signal.rawValue, &oldCAction, nil) == 0 else {
136 | 				throw SignalHandlingError.destructiveSystemError(Errno(rawValue: errno))
    |                                                                      `- error: cannot find 'errno' in scope
137 | 			}
138 | 			return nil
/root/.swiftpm/swift-sdks/swift-6.1-RELEASE-android-24-0.1.artifactbundle/swift-6.1-release-android-24-sdk/android-27c-sysroot/usr/include/errno.h:58:9: note: macro 'errno' unavailable: structure not supported
56 |  * thread.
57 |  */
58 | #define errno (*__errno())
   |         `- note: macro 'errno' unavailable: structure not supported
59 |
60 | __END_DECLS
/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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
 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
   |                    |- 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
[74/129] Compiling SignalHandling SigactionHandler.swift
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionHandler.swift:38:73: error: cannot find 'SIG_IGN' in scope
36 | 	var asOpaquePointer: OpaquePointer? {
37 | 		switch self {
38 | 			case .ignoreHandler:  return OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self))
   |                                                                         `- error: cannot find 'SIG_IGN' in scope
39 | 			case .defaultHandler: return OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self))
40 | 			case .ansiC(let h):   return OpaquePointer(bitPattern: unsafeBitCast(h, to: Int.self))
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionHandler.swift:39:73: error: cannot find 'SIG_DFL' in scope
37 | 		switch self {
38 | 			case .ignoreHandler:  return OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self))
39 | 			case .defaultHandler: return OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self))
   |                                                                         `- error: cannot find 'SIG_DFL' in scope
40 | 			case .ansiC(let h):   return OpaquePointer(bitPattern: unsafeBitCast(h, to: Int.self))
41 | 			case .posix(let h):   return OpaquePointer(bitPattern: unsafeBitCast(h, to: Int.self))
/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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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:90:62: error: cannot find 'SIGEMT' in scope
 88 | 	public static let traceBreakpointTrap    = Signal(rawValue: SIGTRAP)
 89 | #if !os(Linux)
 90 | 	public static let emulatorTrap           = Signal(rawValue: SIGEMT)
    |                                                              `- error: cannot find 'SIGEMT' in scope
 91 | #endif
 92 | 	public static let badSystemCall          = Signal(rawValue: SIGSYS)
/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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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: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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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:212:58: error: cannot find 'SIGINFO' in scope
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
211 | #if !os(Linux)
212 | 	public static let informationRequest = Signal(rawValue: SIGINFO)
    |                                                          `- error: cannot find 'SIGINFO' in scope
213 | #endif
214 |
[75/129] Compiling SignalHandling Signal.swift
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionHandler.swift:38:73: error: cannot find 'SIG_IGN' in scope
36 | 	var asOpaquePointer: OpaquePointer? {
37 | 		switch self {
38 | 			case .ignoreHandler:  return OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self))
   |                                                                         `- error: cannot find 'SIG_IGN' in scope
39 | 			case .defaultHandler: return OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self))
40 | 			case .ansiC(let h):   return OpaquePointer(bitPattern: unsafeBitCast(h, to: Int.self))
/host/spi-builder-workspace/Sources/SignalHandling/CStructsInSwift/SigactionHandler.swift:39:73: error: cannot find 'SIG_DFL' in scope
37 | 		switch self {
38 | 			case .ignoreHandler:  return OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self))
39 | 			case .defaultHandler: return OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self))
   |                                                                         `- error: cannot find 'SIG_DFL' in scope
40 | 			case .ansiC(let h):   return OpaquePointer(bitPattern: unsafeBitCast(h, to: Int.self))
41 | 			case .posix(let h):   return OpaquePointer(bitPattern: unsafeBitCast(h, to: Int.self))
/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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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:90:62: error: cannot find 'SIGEMT' in scope
 88 | 	public static let traceBreakpointTrap    = Signal(rawValue: SIGTRAP)
 89 | #if !os(Linux)
 90 | 	public static let emulatorTrap           = Signal(rawValue: SIGEMT)
    |                                                              `- error: cannot find 'SIGEMT' in scope
 91 | #endif
 92 | 	public static let badSystemCall          = Signal(rawValue: SIGSYS)
/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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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: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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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
  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
    |                    |- 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:212:58: error: cannot find 'SIGINFO' in scope
210 | 	public static let windowSizeChanges  = Signal(rawValue: SIGWINCH)
211 | #if !os(Linux)
212 | 	public static let informationRequest = Signal(rawValue: SIGINFO)
    |                                                          `- error: cannot find 'SIGINFO' in scope
213 | #endif
214 |
[76/129] Compiling SignalHandling SigactionDelayer_Block.swift
/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
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
    |              |- 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
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
    |              |- 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
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
    |                     |- 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
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
    |                     |- 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
 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
 83 | 			}
 84 | 			group.leave()
[77/129] Compiling SignalHandling SigactionDelayer_Unsig.swift
/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
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
    |              |- 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
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
    |              |- 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
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
    |                     |- 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
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
    |                     |- 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
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
303 | 			}
304 | 			group.leave()
BUILD FAILURE 6.1 android