Sextant – Build Information – Swift Package Index

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

Build Information

Failed to build Sextant, reference v0.4.38 (d4f794), with Swift 6.1 for Wasm on 28 Sep 2025 00:17:57 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4609320-1":/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:wasm-6.1-latest swift build --swift-sdk wasm32-unknown-wasi 2>&1

Build Log

 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:9:13: warning: let 'relationalOperatorNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
  9 | private let relationalOperatorNE = Hitch("!=")
    |             |- warning: let 'relationalOperatorNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:11:13: warning: let 'relationalOperatorTSNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 | private let relationalOperatorNE = Hitch("!=")
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
    |             |- warning: let 'relationalOperatorTSNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTSNE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:12:13: warning: let 'relationalOperatorLT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
 12 | private let relationalOperatorLT = Hitch("<")
    |             |- warning: let 'relationalOperatorLT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorLT' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:13:13: warning: let 'relationalOperatorGT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 11 | private let relationalOperatorTSNE = Hitch("!==")
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
    |             |- warning: let 'relationalOperatorGT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorGT' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:14:13: warning: let 'relationalOperatorREGEX' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
    |             |- warning: let 'relationalOperatorREGEX' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorREGEX' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:15:13: warning: let 'relationalOperatorNIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
    |             |- warning: let 'relationalOperatorNIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNIN' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:16:13: warning: let 'relationalOperatorIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
    |             |- warning: let 'relationalOperatorIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorIN' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:17:13: warning: let 'relationalOperatorCONTAINS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
    |             |- warning: let 'relationalOperatorCONTAINS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorCONTAINS' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:18:13: warning: let 'relationalOperatorALL' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
    |             |- warning: let 'relationalOperatorALL' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorALL' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:19:13: warning: let 'relationalOperatorSIZE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
    |             |- warning: let 'relationalOperatorSIZE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorSIZE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:20:13: warning: let 'relationalOperatorEXISTS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
    |             |- warning: let 'relationalOperatorEXISTS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEXISTS' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:21:13: warning: let 'relationalOperatorTYPE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
    |             |- warning: let 'relationalOperatorTYPE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTYPE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:23:13: warning: let 'relationalOperatorEMPTY' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
    |             |- warning: let 'relationalOperatorEMPTY' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEMPTY' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:24:13: warning: let 'relationalOperatorSUBSETOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
    |             |- warning: let 'relationalOperatorSUBSETOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorSUBSETOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:25:13: warning: let 'relationalOperatorANYOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
    |             |- warning: let 'relationalOperatorANYOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorANYOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
 27 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:26:13: warning: let 'relationalOperatorNONEOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
    |             |- warning: let 'relationalOperatorNONEOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNONEOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 27 |
 28 | enum RelationalOperator {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
[63/86] Compiling Sextant RelationalOperator.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:4:5: warning: let 'kLogicalOperatorAND' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 2 | import Hitch
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
   |     `- warning: let 'kLogicalOperatorAND' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
 1 | import Foundation
 2 | import Hitch
   | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorAND' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:5:5: warning: let 'kLogicalOperatorOR' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
 5 | let kLogicalOperatorOR = Hitch("||")
   |     |- warning: let 'kLogicalOperatorOR' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorOR' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 6 | let kLogicalOperatorNOT = Hitch("!")
 7 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:6:5: warning: let 'kLogicalOperatorNOT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 4 | let kLogicalOperatorAND = Hitch("&&")
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
   |     |- warning: let 'kLogicalOperatorNOT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorNOT' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 7 |
 8 | class LogicalOperator: CustomStringConvertible, Equatable {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:4:13: warning: let 'relationalOperatorGTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  2 | import Hitch
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
    |             `- warning: let 'relationalOperatorGTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
    |             |- note: add '@MainActor' to make let 'relationalOperatorGTE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:5:13: warning: let 'relationalOperatorLTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
  5 | private let relationalOperatorLTE = Hitch("<=")
    |             |- warning: let 'relationalOperatorLTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorLTE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 | private let relationalOperatorEQ = Hitch("==")
  7 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:6:13: warning: let 'relationalOperatorEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  4 | private let relationalOperatorGTE = Hitch(">=")
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
    |             |- warning: let 'relationalOperatorEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEQ' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:8:13: warning: let 'relationalOperatorTSEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 | private let relationalOperatorEQ = Hitch("==")
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
    |             |- warning: let 'relationalOperatorTSEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTSEQ' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 | private let relationalOperatorNE = Hitch("!=")
 10 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:9:13: warning: let 'relationalOperatorNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
  9 | private let relationalOperatorNE = Hitch("!=")
    |             |- warning: let 'relationalOperatorNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:11:13: warning: let 'relationalOperatorTSNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 | private let relationalOperatorNE = Hitch("!=")
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
    |             |- warning: let 'relationalOperatorTSNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTSNE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:12:13: warning: let 'relationalOperatorLT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
 12 | private let relationalOperatorLT = Hitch("<")
    |             |- warning: let 'relationalOperatorLT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorLT' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:13:13: warning: let 'relationalOperatorGT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 11 | private let relationalOperatorTSNE = Hitch("!==")
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
    |             |- warning: let 'relationalOperatorGT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorGT' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:14:13: warning: let 'relationalOperatorREGEX' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
    |             |- warning: let 'relationalOperatorREGEX' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorREGEX' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:15:13: warning: let 'relationalOperatorNIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
    |             |- warning: let 'relationalOperatorNIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNIN' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:16:13: warning: let 'relationalOperatorIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
    |             |- warning: let 'relationalOperatorIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorIN' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:17:13: warning: let 'relationalOperatorCONTAINS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
    |             |- warning: let 'relationalOperatorCONTAINS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorCONTAINS' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:18:13: warning: let 'relationalOperatorALL' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
    |             |- warning: let 'relationalOperatorALL' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorALL' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:19:13: warning: let 'relationalOperatorSIZE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
    |             |- warning: let 'relationalOperatorSIZE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorSIZE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:20:13: warning: let 'relationalOperatorEXISTS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
    |             |- warning: let 'relationalOperatorEXISTS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEXISTS' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:21:13: warning: let 'relationalOperatorTYPE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
    |             |- warning: let 'relationalOperatorTYPE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTYPE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:23:13: warning: let 'relationalOperatorEMPTY' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
    |             |- warning: let 'relationalOperatorEMPTY' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEMPTY' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:24:13: warning: let 'relationalOperatorSUBSETOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
    |             |- warning: let 'relationalOperatorSUBSETOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorSUBSETOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:25:13: warning: let 'relationalOperatorANYOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
    |             |- warning: let 'relationalOperatorANYOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorANYOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
 27 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:26:13: warning: let 'relationalOperatorNONEOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
    |             |- warning: let 'relationalOperatorNONEOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNONEOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 27 |
 28 | enum RelationalOperator {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
[64/86] Compiling Sextant BooleanNode.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:4:5: warning: let 'kLogicalOperatorAND' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 2 | import Hitch
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
   |     `- warning: let 'kLogicalOperatorAND' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
 1 | import Foundation
 2 | import Hitch
   | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorAND' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:5:5: warning: let 'kLogicalOperatorOR' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
 5 | let kLogicalOperatorOR = Hitch("||")
   |     |- warning: let 'kLogicalOperatorOR' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorOR' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 6 | let kLogicalOperatorNOT = Hitch("!")
 7 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:6:5: warning: let 'kLogicalOperatorNOT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 4 | let kLogicalOperatorAND = Hitch("&&")
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
   |     |- warning: let 'kLogicalOperatorNOT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorNOT' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 7 |
 8 | class LogicalOperator: CustomStringConvertible, Equatable {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:4:13: warning: let 'relationalOperatorGTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  2 | import Hitch
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
    |             `- warning: let 'relationalOperatorGTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
    |             |- note: add '@MainActor' to make let 'relationalOperatorGTE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:5:13: warning: let 'relationalOperatorLTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
  5 | private let relationalOperatorLTE = Hitch("<=")
    |             |- warning: let 'relationalOperatorLTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorLTE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 | private let relationalOperatorEQ = Hitch("==")
  7 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:6:13: warning: let 'relationalOperatorEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  4 | private let relationalOperatorGTE = Hitch(">=")
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
    |             |- warning: let 'relationalOperatorEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEQ' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:8:13: warning: let 'relationalOperatorTSEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 | private let relationalOperatorEQ = Hitch("==")
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
    |             |- warning: let 'relationalOperatorTSEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTSEQ' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 | private let relationalOperatorNE = Hitch("!=")
 10 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:9:13: warning: let 'relationalOperatorNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
  9 | private let relationalOperatorNE = Hitch("!=")
    |             |- warning: let 'relationalOperatorNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:11:13: warning: let 'relationalOperatorTSNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 | private let relationalOperatorNE = Hitch("!=")
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
    |             |- warning: let 'relationalOperatorTSNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTSNE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:12:13: warning: let 'relationalOperatorLT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
 12 | private let relationalOperatorLT = Hitch("<")
    |             |- warning: let 'relationalOperatorLT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorLT' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:13:13: warning: let 'relationalOperatorGT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 11 | private let relationalOperatorTSNE = Hitch("!==")
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
    |             |- warning: let 'relationalOperatorGT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorGT' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:14:13: warning: let 'relationalOperatorREGEX' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
    |             |- warning: let 'relationalOperatorREGEX' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorREGEX' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:15:13: warning: let 'relationalOperatorNIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
    |             |- warning: let 'relationalOperatorNIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNIN' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:16:13: warning: let 'relationalOperatorIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
    |             |- warning: let 'relationalOperatorIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorIN' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:17:13: warning: let 'relationalOperatorCONTAINS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
    |             |- warning: let 'relationalOperatorCONTAINS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorCONTAINS' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:18:13: warning: let 'relationalOperatorALL' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
    |             |- warning: let 'relationalOperatorALL' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorALL' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:19:13: warning: let 'relationalOperatorSIZE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
    |             |- warning: let 'relationalOperatorSIZE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorSIZE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:20:13: warning: let 'relationalOperatorEXISTS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
    |             |- warning: let 'relationalOperatorEXISTS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEXISTS' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:21:13: warning: let 'relationalOperatorTYPE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
    |             |- warning: let 'relationalOperatorTYPE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTYPE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:23:13: warning: let 'relationalOperatorEMPTY' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
    |             |- warning: let 'relationalOperatorEMPTY' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEMPTY' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:24:13: warning: let 'relationalOperatorSUBSETOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
    |             |- warning: let 'relationalOperatorSUBSETOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorSUBSETOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:25:13: warning: let 'relationalOperatorANYOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
    |             |- warning: let 'relationalOperatorANYOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorANYOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
 27 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:26:13: warning: let 'relationalOperatorNONEOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
    |             |- warning: let 'relationalOperatorNONEOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNONEOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 27 |
 28 | enum RelationalOperator {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
[65/86] Compiling Sextant ExpressionNode.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:4:5: warning: let 'kLogicalOperatorAND' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 2 | import Hitch
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
   |     `- warning: let 'kLogicalOperatorAND' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
 1 | import Foundation
 2 | import Hitch
   | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorAND' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:5:5: warning: let 'kLogicalOperatorOR' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 3 |
 4 | let kLogicalOperatorAND = Hitch("&&")
 5 | let kLogicalOperatorOR = Hitch("||")
   |     |- warning: let 'kLogicalOperatorOR' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorOR' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 6 | let kLogicalOperatorNOT = Hitch("!")
 7 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/LogicalOperator.swift:6:5: warning: let 'kLogicalOperatorNOT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 4 | let kLogicalOperatorAND = Hitch("&&")
 5 | let kLogicalOperatorOR = Hitch("||")
 6 | let kLogicalOperatorNOT = Hitch("!")
   |     |- warning: let 'kLogicalOperatorNOT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
   |     |- note: add '@MainActor' to make let 'kLogicalOperatorNOT' part of global actor 'MainActor'
   |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 7 |
 8 | class LogicalOperator: CustomStringConvertible, Equatable {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:4:13: warning: let 'relationalOperatorGTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  2 | import Hitch
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
    |             `- warning: let 'relationalOperatorGTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
    |             |- note: add '@MainActor' to make let 'relationalOperatorGTE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:5:13: warning: let 'relationalOperatorLTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 |
  4 | private let relationalOperatorGTE = Hitch(">=")
  5 | private let relationalOperatorLTE = Hitch("<=")
    |             |- warning: let 'relationalOperatorLTE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorLTE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 | private let relationalOperatorEQ = Hitch("==")
  7 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:6:13: warning: let 'relationalOperatorEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  4 | private let relationalOperatorGTE = Hitch(">=")
  5 | private let relationalOperatorLTE = Hitch("<=")
  6 | private let relationalOperatorEQ = Hitch("==")
    |             |- warning: let 'relationalOperatorEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEQ' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:8:13: warning: let 'relationalOperatorTSEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 | private let relationalOperatorEQ = Hitch("==")
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
    |             |- warning: let 'relationalOperatorTSEQ' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTSEQ' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  9 | private let relationalOperatorNE = Hitch("!=")
 10 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:9:13: warning: let 'relationalOperatorNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  7 |
  8 | private let relationalOperatorTSEQ = Hitch("===")
  9 | private let relationalOperatorNE = Hitch("!=")
    |             |- warning: let 'relationalOperatorNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:11:13: warning: let 'relationalOperatorTSNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 | private let relationalOperatorNE = Hitch("!=")
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
    |             |- warning: let 'relationalOperatorTSNE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTSNE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:12:13: warning: let 'relationalOperatorLT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 10 |
 11 | private let relationalOperatorTSNE = Hitch("!==")
 12 | private let relationalOperatorLT = Hitch("<")
    |             |- warning: let 'relationalOperatorLT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorLT' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:13:13: warning: let 'relationalOperatorGT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 11 | private let relationalOperatorTSNE = Hitch("!==")
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
    |             |- warning: let 'relationalOperatorGT' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorGT' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:14:13: warning: let 'relationalOperatorREGEX' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 | private let relationalOperatorLT = Hitch("<")
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
    |             |- warning: let 'relationalOperatorREGEX' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorREGEX' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:15:13: warning: let 'relationalOperatorNIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 13 | private let relationalOperatorGT = Hitch(">")
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
    |             |- warning: let 'relationalOperatorNIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNIN' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:16:13: warning: let 'relationalOperatorIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 14 | private let relationalOperatorREGEX = Hitch("=~")
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
    |             |- warning: let 'relationalOperatorIN' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorIN' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:17:13: warning: let 'relationalOperatorCONTAINS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 | private let relationalOperatorNIN = Hitch("NIN")
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
    |             |- warning: let 'relationalOperatorCONTAINS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorCONTAINS' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:18:13: warning: let 'relationalOperatorALL' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 16 | private let relationalOperatorIN = Hitch("IN")
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
    |             |- warning: let 'relationalOperatorALL' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorALL' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:19:13: warning: let 'relationalOperatorSIZE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 17 | private let relationalOperatorCONTAINS = Hitch("CONTAINS")
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
    |             |- warning: let 'relationalOperatorSIZE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorSIZE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:20:13: warning: let 'relationalOperatorEXISTS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 18 | private let relationalOperatorALL = Hitch("ALL")
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
    |             |- warning: let 'relationalOperatorEXISTS' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEXISTS' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:21:13: warning: let 'relationalOperatorTYPE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 19 | private let relationalOperatorSIZE = Hitch("SIZE")
 20 | private let relationalOperatorEXISTS = Hitch("EXISTS")
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
    |             |- warning: let 'relationalOperatorTYPE' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorTYPE' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:23:13: warning: let 'relationalOperatorEMPTY' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 21 | private let relationalOperatorTYPE = Hitch("TYPE")
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
    |             |- warning: let 'relationalOperatorEMPTY' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorEMPTY' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:24:13: warning: let 'relationalOperatorSUBSETOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 22 | // private let relationalOperatorMATCHES Hitch("matches"))
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
    |             |- warning: let 'relationalOperatorSUBSETOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorSUBSETOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:25:13: warning: let 'relationalOperatorANYOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 23 | private let relationalOperatorEMPTY = Hitch("EMPTY")
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
    |             |- warning: let 'relationalOperatorANYOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorANYOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
 27 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/Filter/RelationalOperator.swift:26:13: warning: let 'relationalOperatorNONEOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 24 | private let relationalOperatorSUBSETOF = Hitch("SUBSETOF")
 25 | private let relationalOperatorANYOF = Hitch("ANYOF")
 26 | private let relationalOperatorNONEOF = Hitch("NONEOF")
    |             |- warning: let 'relationalOperatorNONEOF' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: add '@MainActor' to make let 'relationalOperatorNONEOF' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 27 |
 28 | enum RelationalOperator {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
[66/86] Compiling Sextant ScanPathToken.swift
[67/86] Compiling Sextant WildcardPathToken.swift
[68/86] Compiling Sextant ArrayPathTokenPredicate.swift
[69/86] Compiling Sextant FakePredicate.swift
[70/86] Compiling Sextant FilterPathTokenPredicate.swift
[71/86] Compiling Sextant PredicatePathToken.swift
[72/86] Compiling Sextant PropertyPathTokenPredicate.swift
[73/86] Compiling Sextant Path.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:5:13: warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             `- warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 |
  7 | final class FunctionPathToken: PathToken {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             |- note: add '@MainActor' to make let 'hitchDot' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 |
  7 | final class FunctionPathToken: PathToken {
[74/86] Compiling Sextant PathCompiler.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:5:13: warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             `- warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 |
  7 | final class FunctionPathToken: PathToken {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             |- note: add '@MainActor' to make let 'hitchDot' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 |
  7 | final class FunctionPathToken: PathToken {
[75/86] Compiling Sextant RootPath.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:5:13: warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             `- warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 |
  7 | final class FunctionPathToken: PathToken {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             |- note: add '@MainActor' to make let 'hitchDot' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 |
  7 | final class FunctionPathToken: PathToken {
[76/86] Compiling Sextant ArrayIndexToken.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:5:13: warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             `- warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 |
  7 | final class FunctionPathToken: PathToken {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             |- note: add '@MainActor' to make let 'hitchDot' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 |
  7 | final class FunctionPathToken: PathToken {
[77/86] Compiling Sextant ArrayPathToken.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:5:13: warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             `- warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 |
  7 | final class FunctionPathToken: PathToken {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             |- note: add '@MainActor' to make let 'hitchDot' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 |
  7 | final class FunctionPathToken: PathToken {
[78/86] Compiling Sextant ArraySliceToken.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:5:13: warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             `- warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 |
  7 | final class FunctionPathToken: PathToken {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             |- note: add '@MainActor' to make let 'hitchDot' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 |
  7 | final class FunctionPathToken: PathToken {
[79/86] Compiling Sextant FunctionPathToken.swift
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:5:13: warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             `- warning: let 'hitchDot' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  6 |
  7 | final class FunctionPathToken: PathToken {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Internal/PathToken/FunctionPathToken.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 |
  5 | private let hitchDot = Hitch(".")
    |             |- note: add '@MainActor' to make let 'hitchDot' part of global actor 'MainActor'
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
  6 |
  7 | final class FunctionPathToken: PathToken {
[80/86] Compiling Sextant ScanPredicate.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:11:5: warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     `- warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 | import Chronometer
    :
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     |- note: add '@MainActor' to make let 'nullHitch' 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/Sextant/Sextant.swift:14:5: warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
 14 | let trueHitch = Hitch("true")
    |     |- warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'trueHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 |
 16 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:17:5: warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 |
 16 |
 17 | let falseHitch = Hitch("false")
    |     |- warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'falseHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 |
 19 | extension JsonAny {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:191:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
188 | }
189 |
190 | public final class Sextant {
    |                    `- note: class 'Sextant' does not conform to the 'Sendable' protocol
191 |     public static let shared = Sextant()
    |                       |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'shared' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 |     private init() { }
193 |
[81/86] Compiling Sextant WildcardPathTokenPredicate.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:11:5: warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     `- warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 | import Chronometer
    :
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     |- note: add '@MainActor' to make let 'nullHitch' 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/Sextant/Sextant.swift:14:5: warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
 14 | let trueHitch = Hitch("true")
    |     |- warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'trueHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 |
 16 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:17:5: warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 |
 16 |
 17 | let falseHitch = Hitch("false")
    |     |- warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'falseHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 |
 19 | extension JsonAny {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:191:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
188 | }
189 |
190 | public final class Sextant {
    |                    `- note: class 'Sextant' does not conform to the 'Sendable' protocol
191 |     public static let shared = Sextant()
    |                       |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'shared' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 |     private init() { }
193 |
[82/86] Compiling Sextant Sextant+Internal.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:11:5: warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     `- warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 | import Chronometer
    :
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     |- note: add '@MainActor' to make let 'nullHitch' 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/Sextant/Sextant.swift:14:5: warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
 14 | let trueHitch = Hitch("true")
    |     |- warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'trueHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 |
 16 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:17:5: warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 |
 16 |
 17 | let falseHitch = Hitch("false")
    |     |- warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'falseHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 |
 19 | extension JsonAny {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:191:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
188 | }
189 |
190 | public final class Sextant {
    |                    `- note: class 'Sextant' does not conform to the 'Sendable' protocol
191 |     public static let shared = Sextant()
    |                       |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'shared' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 |     private init() { }
193 |
[83/86] Compiling Sextant Sextant+Many.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:11:5: warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     `- warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 | import Chronometer
    :
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     |- note: add '@MainActor' to make let 'nullHitch' 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/Sextant/Sextant.swift:14:5: warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
 14 | let trueHitch = Hitch("true")
    |     |- warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'trueHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 |
 16 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:17:5: warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 |
 16 |
 17 | let falseHitch = Hitch("false")
    |     |- warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'falseHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 |
 19 | extension JsonAny {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:191:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
188 | }
189 |
190 | public final class Sextant {
    |                    `- note: class 'Sextant' does not conform to the 'Sendable' protocol
191 |     public static let shared = Sextant()
    |                       |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'shared' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 |     private init() { }
193 |
[84/86] Compiling Sextant Sextant+Single.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:11:5: warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     `- warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 | import Chronometer
    :
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     |- note: add '@MainActor' to make let 'nullHitch' 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/Sextant/Sextant.swift:14:5: warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
 14 | let trueHitch = Hitch("true")
    |     |- warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'trueHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 |
 16 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:17:5: warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 |
 16 |
 17 | let falseHitch = Hitch("false")
    |     |- warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'falseHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 |
 19 | extension JsonAny {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:191:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
188 | }
189 |
190 | public final class Sextant {
    |                    `- note: class 'Sextant' does not conform to the 'Sendable' protocol
191 |     public static let shared = Sextant()
    |                       |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'shared' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 |     private init() { }
193 |
[85/86] Compiling Sextant Sextant+Update.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:11:5: warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     `- warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 | import Chronometer
    :
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     |- note: add '@MainActor' to make let 'nullHitch' 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/Sextant/Sextant.swift:14:5: warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
 14 | let trueHitch = Hitch("true")
    |     |- warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'trueHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 |
 16 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:17:5: warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 |
 16 |
 17 | let falseHitch = Hitch("false")
    |     |- warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'falseHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 |
 19 | extension JsonAny {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:191:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
188 | }
189 |
190 | public final class Sextant {
    |                    `- note: class 'Sextant' does not conform to the 'Sendable' protocol
191 |     public static let shared = Sextant()
    |                       |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'shared' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 |     private init() { }
193 |
[86/86] Compiling Sextant Sextant.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:11:5: warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     `- warning: let 'nullHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:2:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  1 | import Foundation
  2 | import Hitch
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Hitch'
  3 | import Spanker
  4 | import Chronometer
    :
  9 |
 10 |
 11 | let nullHitch = Hitch("null")
    |     |- note: add '@MainActor' to make let 'nullHitch' 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/Sextant/Sextant.swift:14:5: warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 12 |
 13 |
 14 | let trueHitch = Hitch("true")
    |     |- warning: let 'trueHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'trueHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 15 |
 16 |
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:17:5: warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
 15 |
 16 |
 17 | let falseHitch = Hitch("false")
    |     |- warning: let 'falseHitch' is not concurrency-safe because non-'Sendable' type 'Hitch' may have shared mutable state; this is an error in the Swift 6 language mode
    |     |- note: add '@MainActor' to make let 'falseHitch' part of global actor 'MainActor'
    |     `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 18 |
 19 | extension JsonAny {
/host/spi-builder-workspace/.build/checkouts/Hitch/Sources/Hitch/Hitch.swift:35:20: note: class 'Hitch' does not conform to the 'Sendable' protocol
 33 | // Note: being a subclass of NSObject is required (BOO) due to runtime crash on Linux when storing Hitch values in a dictionary
 34 | // See unit test testCastAnyToHitch().
 35 | public final class Hitch: NSObject, Hitchable, ExpressibleByStringLiteral, Sequence, Comparable, Codable {
    |                    `- note: class 'Hitch' does not conform to the 'Sendable' protocol
 36 |     public static let empty: Hitch = ""
 37 |
/host/spi-builder-workspace/Sources/Sextant/Sextant.swift:191:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
188 | }
189 |
190 | public final class Sextant {
    |                    `- note: class 'Sextant' does not conform to the 'Sendable' protocol
191 |     public static let shared = Sextant()
    |                       |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'Sextant' may have shared mutable state; this is an error in the Swift 6 language mode
    |                       |- note: add '@MainActor' to make static property 'shared' part of global actor 'MainActor'
    |                       `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 |     private init() { }
193 |
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4609320-1":/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:wasm-6.1-latest swift build --swift-sdk wasm32-unknown-wasi 2>&1
wasm-6.1-latest: Pulling from finestructure/spi-images
Digest: sha256:062e4aaff76454b333ce7957a8e87c3beb342f1dedb64399abb81cdea021b526
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:wasm-6.1-latest
[0/1] Planning build
[1/1] Compiling plugin GenerateManual
[2/2] Compiling plugin GenerateDoccReference
Building for debugging...
[2/3] Write swift-version-24593BA9C3E375BF.txt
[4/17] Compiling Hitch Int8+Ascii.swift
[5/18] Emitting module Chronometer
[6/18] Compiling Chronometer Chronometer.swift
[8/19] Compiling Hitch UInt8+Ascii.swift
[9/19] Compiling Hitch Hitch.swift
[10/19] Compiling Hitch Hitch+FormatOperator.swift
[11/19] Compiling Hitch Hitch+MD5.swift
[12/19] Compiling Hitch Hitch+Shared.swift
[13/19] Compiling Hitch Hitch+CodeBlock.swift
[14/19] Compiling Hitch Hitch+Format.swift
[15/19] Compiling Hitch Hitch+Base32.swift
[16/19] Compiling Hitch Hitch+Base64.swift
[17/19] Emitting module Hitch
[18/19] Compiling Hitch CHitch.swift
[19/19] Compiling Hitch HalfHitch.swift
[21/24] Compiling Spanker Spanker+Reader.swift
[22/24] Emitting module Spanker
[23/24] Compiling Spanker Spanker+Subscripts.swift
[24/24] Compiling Spanker Spanker.swift
[26/75] Compiling Sextant LogicalOperator.swift
[27/75] Compiling Sextant PatternFlags.swift
[28/75] Compiling Sextant PredicateContext.swift
[29/75] Compiling Sextant RelationalExpressionNode.swift
[30/75] Compiling Sextant RelationalOperator.swift
[31/75] Compiling Sextant BooleanNode.swift
[32/75] Compiling Sextant ExpressionNode.swift
[33/82] Emitting module Sextant
[34/82] Compiling Sextant ScanPathToken.swift
[35/82] Compiling Sextant WildcardPathToken.swift
[36/82] Compiling Sextant ArrayPathTokenPredicate.swift
[37/82] Compiling Sextant FakePredicate.swift
[38/82] Compiling Sextant FilterPathTokenPredicate.swift
[39/82] Compiling Sextant PredicatePathToken.swift
[40/82] Compiling Sextant PropertyPathTokenPredicate.swift
[41/82] Compiling Sextant JsonNode.swift
[42/82] Compiling Sextant NullNode.swift
[43/82] Compiling Sextant NumberNode.swift
[44/82] Compiling Sextant PathNode.swift
[45/82] Compiling Sextant PatternNode.swift
[46/82] Compiling Sextant StringNode.swift
[47/82] Compiling Sextant ValueNode.swift
[48/82] Compiling Sextant ArrayIndexOperation.swift
[49/82] Compiling Sextant ArraySliceOperation.swift
[50/82] Compiling Sextant Parameter.swift
[51/82] Compiling Sextant ArrayIndexPath.swift
[52/82] Compiling Sextant CompiledPath.swift
[53/82] Compiling Sextant NullPath.swift
[54/82] Compiling Sextant ObjectPropertyPath.swift
[55/82] Compiling Sextant Path.swift
[56/82] Compiling Sextant PathCompiler.swift
[57/82] Compiling Sextant RootPath.swift
[58/82] Compiling Sextant ArrayIndexToken.swift
[59/82] Compiling Sextant ArrayPathToken.swift
[60/82] Compiling Sextant ArraySliceToken.swift
[61/82] Compiling Sextant FunctionPathToken.swift
[62/82] Compiling Sextant PathFunction+Spanker.swift
[63/82] Compiling Sextant PathFunction.swift
[64/82] Compiling Sextant PathToken+Spanker.swift
[65/82] Compiling Sextant PathToken.swift
[66/82] Compiling Sextant PropertyPathToken.swift
[67/82] Compiling Sextant RootPathToken.swift
[68/82] Compiling Sextant ScanPathToken+Spanker.swift
[69/82] Compiling Sextant CharacterIndex.swift
[70/82] Compiling Sextant EvaluationContext.swift
[71/82] Compiling Sextant CompiledFilter.swift
[72/82] Compiling Sextant Evaluator.swift
[73/82] Compiling Sextant Filter.swift
[74/82] Compiling Sextant FilterCompiler.swift
[75/82] Compiling Sextant LogicalExpressionNode.swift
[76/82] Compiling Sextant ScanPredicate.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
[77/82] Compiling Sextant WildcardPathTokenPredicate.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
[78/82] Compiling Sextant Sextant+Internal.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
[79/82] Compiling Sextant Sextant+Many.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
[80/82] Compiling Sextant Sextant+Single.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
[81/82] Compiling Sextant Sextant+Update.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
[82/82] Compiling Sextant Sextant.swift
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:16:5: error: cannot find 'Thread' in scope
 14 |
 15 | func clearerror() {
 16 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = nil
    |     `- error: cannot find 'Thread' in scope
 17 | }
 18 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:20:12: error: cannot find 'Thread' in scope
 18 |
 19 | func geterror() -> String? {
 20 |     return Thread.current.threadDictionary["__SEXTANT_ERROR"] as? String
    |            `- error: cannot find 'Thread' in scope
 21 | }
 22 |
/host/spi-builder-workspace/Sources/Sextant/Sextant+Internal.swift:24:5: error: cannot find 'Thread' in scope
 22 |
 23 | func error(_ error: String) {
 24 |     Thread.current.threadDictionary["__SEXTANT_ERROR"] = error
    |     `- error: cannot find 'Thread' in scope
 25 |     #if DEBUG
 26 |     // print("Error: " + error)
BUILD FAILURE 6.1 wasm