Swift Package Index

Build Information

Failed to build SwiftPropertyLaws, reference v4.10.0 (9e774f), with Swift 6.1 for Linux on 13 Oct 2026 02:13:01 UTC.

Build Command

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

Build Log

<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1155/1432] Compiling AsyncAlgorithms AsyncChunksOfCountOrSignalSequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1156/1432] Compiling AsyncAlgorithms AsyncChunksOfCountSequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1157/1432] Compiling AsyncAlgorithms AsyncSyncSequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1158/1432] Compiling AsyncAlgorithms AsyncThrottleSequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1159/1432] Compiling AsyncAlgorithms AsyncThrowingExclusiveReductionsSequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1160/1432] Compiling AsyncAlgorithms AsyncThrowingInclusiveReductionsSequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1161/1432] Compiling AsyncAlgorithms AsyncTimerSequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1162/1432] Compiling AsyncAlgorithms AsyncBufferSequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1163/1432] Compiling AsyncAlgorithms BoundedBufferStateMachine.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1164/1432] Compiling AsyncAlgorithms BoundedBufferStorage.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1165/1432] Compiling AsyncAlgorithms AsyncCombineLatest3Sequence.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[1166/1432] Compiling AsyncAlgorithms CombineLatestStateMachine.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-53886768-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:basic-6.1-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-6.1-latest: Pulling from saguaro1/spi-images
Digest: sha256:13a529f31207afe6597b18f20995fc2db944100da935819188c653038756cb1b
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:basic-6.1-latest
[0/1] Planning build
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:36:59: warning: 'path' is deprecated: renamed to 'url'
 34 |         let tool = try context.tool(named: "PropertyLawDiscoveryTool")
 35 |         let process = Process()
 36 |         process.executableURL = URL(fileURLWithPath: tool.path.string)
    |                                                           |- warning: 'path' is deprecated: renamed to 'url'
    |                                                           `- note: use 'url' instead
 37 |         var toolArgs: [String] = [
 38 |             "--target", target,
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:36:64: warning: 'string' is deprecated: Use `URL` type instead of `Path`.
 34 |         let tool = try context.tool(named: "PropertyLawDiscoveryTool")
 35 |         let process = Process()
 36 |         process.executableURL = URL(fileURLWithPath: tool.path.string)
    |                                                                `- warning: 'string' is deprecated: Use `URL` type instead of `Path`.
 37 |         var toolArgs: [String] = [
 38 |             "--target", target,
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:77:40: warning: 'directory' is deprecated: renamed to 'directoryURL'
 75 |     /// doesn't exist; commit 5 will create the dir if missing.
 76 |     private func defaultOutputPath(for target: Target, in context: PluginContext) -> String {
 77 |         let testsDir = context.package.directory
    |                                        |- warning: 'directory' is deprecated: renamed to 'directoryURL'
    |                                        `- note: use 'directoryURL' instead
 78 |             .appending(["Tests", "\(target.name)Tests"])
 79 |         return testsDir.appending(["PropertyLawTests.generated.swift"]).string
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:78:14: warning: 'appending' is deprecated: Use `URL` type instead of `Path`.
 76 |     private func defaultOutputPath(for target: Target, in context: PluginContext) -> String {
 77 |         let testsDir = context.package.directory
 78 |             .appending(["Tests", "\(target.name)Tests"])
    |              `- warning: 'appending' is deprecated: Use `URL` type instead of `Path`.
 79 |         return testsDir.appending(["PropertyLawTests.generated.swift"]).string
 80 |     }
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:79:25: warning: 'appending' is deprecated: Use `URL` type instead of `Path`.
 77 |         let testsDir = context.package.directory
 78 |             .appending(["Tests", "\(target.name)Tests"])
 79 |         return testsDir.appending(["PropertyLawTests.generated.swift"]).string
    |                         `- warning: 'appending' is deprecated: Use `URL` type instead of `Path`.
 80 |     }
 81 |
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:79:73: warning: 'string' is deprecated: Use `URL` type instead of `Path`.
 77 |         let testsDir = context.package.directory
 78 |             .appending(["Tests", "\(target.name)Tests"])
 79 |         return testsDir.appending(["PropertyLawTests.generated.swift"]).string
    |                                                                         `- warning: 'string' is deprecated: Use `URL` type instead of `Path`.
 80 |     }
 81 |
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:129:26: warning: 'path' is deprecated: renamed to 'url'
127 |         guard let sourceModuleTarget = target as? SourceModuleTarget else { return [] }
128 |         return sourceModuleTarget.sourceFiles
129 |             .filter { $0.path.extension == "swift" }
    |                          |- warning: 'path' is deprecated: renamed to 'url'
    |                          `- note: use 'url' instead
130 |             .map { $0.path.string }
131 |             .sorted()
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:129:31: warning: 'extension' is deprecated: Use `URL` type instead of `Path`.
127 |         guard let sourceModuleTarget = target as? SourceModuleTarget else { return [] }
128 |         return sourceModuleTarget.sourceFiles
129 |             .filter { $0.path.extension == "swift" }
    |                               `- warning: 'extension' is deprecated: Use `URL` type instead of `Path`.
130 |             .map { $0.path.string }
131 |             .sorted()
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:130:23: warning: 'path' is deprecated: renamed to 'url'
128 |         return sourceModuleTarget.sourceFiles
129 |             .filter { $0.path.extension == "swift" }
130 |             .map { $0.path.string }
    |                       |- warning: 'path' is deprecated: renamed to 'url'
    |                       `- note: use 'url' instead
131 |             .sorted()
132 |     }
/host/spi-builder-workspace/Plugins/PropertyLawDiscoveryPlugin/plugin.swift:130:28: warning: 'string' is deprecated: Use `URL` type instead of `Path`.
128 |         return sourceModuleTarget.sourceFiles
129 |             .filter { $0.path.extension == "swift" }
130 |             .map { $0.path.string }
    |                            `- warning: 'string' is deprecated: Use `URL` type instead of `Path`.
131 |             .sorted()
132 |     }
[1/1] Compiling plugin PropertyLawDiscoveryPlugin
Building for debugging...
[1/38] Write swift-version-24593BA9C3E375BF.txt
[3/61] Compiling SwiftSyntax602 Empty.swift
[4/61] Emitting module SwiftSyntax602
[5/61] Emitting module SwiftSyntax601
[6/62] Compiling SwiftSyntax510 Empty.swift
[7/62] Emitting module SwiftSyntax510
[8/62] Compiling SwiftSyntax601 Empty.swift
[9/62] Emitting module SwiftSyntax601
[10/64] Compiling RealModule RealFunctions.swift
[11/65] Compiling SwiftSyntax600 Empty.swift
[14/65] Compiling SwiftSyntax601 Empty.swift
[15/66] Emitting module SwiftSyntax600
[16/67] Compiling RealModule Real.swift
[18/67] Compiling SwiftSyntax600 Empty.swift
[19/66] Emitting module SwiftSyntax600
[20/67] Compiling RealModule Float80+Real.swift
[21/67] Compiling RealModule RelaxedArithmetic.swift
[24/67] Compiling SwiftSyntax602 Empty.swift
[25/65] Emitting module SwiftSyntax602
[26/66] Compiling RealModule Float16+Real.swift
[27/68] Compiling RealModule ElementaryFunctions.swift
[28/68] Compiling RealModule Float+Real.swift
[30/72] Compiling RealModule AugmentedArithmetic.swift
[31/72] Compiling RealModule Double+Real.swift
[32/72] Compiling RealModule AlgebraicField.swift
[33/72] Compiling RealModule ApproximateEquality.swift
[35/70] Compiling SwiftSyntax509 Empty.swift
[36/70] Emitting module SwiftSyntax509
[38/102] Compiling SwiftSyntax509 Empty.swift
[40/103] Compiling SwiftSyntax510 Empty.swift
[41/103] Emitting module SwiftSyntax510
[42/124] Emitting module RealModule
[43/125] Compiling RealModule RealFunctions.swift
[44/156] Compiling RealModule Real.swift
[45/156] Compiling PropertyBased Gen+Frequency.swift
[46/156] Compiling PropertyBased ClosedIntegerRange.swift
[49/154] Compiling RealModule RelaxedArithmetic.swift
[50/154] Compiling RealModule Float80+Real.swift
[52/154] Compiling RealModule Float16+Real.swift
[53/185] Compiling PropertyBased EnableShrinkTrait.swift
[54/185] Compiling PropertyBased FixedSeedTrait.swift
[55/185] Compiling PropertyBased ClosedIntegerRange.swift
[56/185] Compiling PropertyBased Date+String.swift
[57/185] Emitting module RealModule
[59/251] Emitting module PropertyLawCore
[60/269] Compiling SwiftSyntax SourceEdit.swift
[61/269] Compiling SwiftSyntax SourceLength.swift
[62/271] Compiling SwiftSyntax RawSyntax.swift
[63/271] Compiling SwiftSyntax RawSyntaxArena.swift
[64/278] Compiling SwiftSyntax Convenience.swift
[65/278] Compiling SwiftSyntax CustomTraits.swift
[66/278] Compiling SwiftSyntax Assert.swift
[67/278] Compiling SwiftSyntax BumpPtrAllocator.swift
[68/278] Compiling SwiftSyntax CommonAncestor.swift
[69/278] Compiling SwiftSyntax EditorPlaceholder.swift
[70/278] Compiling SwiftSyntax Identifier.swift
[71/278] Compiling SwiftSyntax MemoryLayout.swift
[72/278] Compiling SwiftSyntax MissingNodeInitializers.swift
[74/286] Emitting module PropertyLawCore
[77/286] Compiling SwiftSyntax CustomTraits.swift
[78/286] Compiling SwiftSyntax EditorPlaceholder.swift
[79/302] Compiling SwiftSyntax Identifier.swift
[80/302] Compiling SwiftSyntax MemoryLayout.swift
[81/302] Compiling SwiftSyntax MissingNodeInitializers.swift
[82/302] Compiling SwiftSyntax RawSyntaxLayoutView.swift
[83/302] Compiling SwiftSyntax RawSyntaxNodeProtocol.swift
[84/302] Compiling SwiftSyntax RawSyntaxTokenView.swift
[85/324] Compiling SwiftSyntax AbsolutePosition.swift
[86/324] Compiling SwiftSyntax AbsoluteSyntaxInfo.swift
[87/324] Compiling SwiftSyntax ArenaAllocatedBuffer.swift
[89/328] Compiling SwiftSyntax SourceEdit.swift
[90/328] Compiling SwiftSyntax ChildNameForKeyPath.swift
[91/338] Compiling SwiftSyntax RawSyntaxArena.swift
[96/358] Compiling SwiftSyntax SyntaxKind.swift
[97/358] Compiling SwiftSyntax RawSyntaxNodesEF.swift
[98/358] Compiling SwiftSyntax RawSyntaxNodesGHI.swift
[99/358] Compiling SwiftSyntax RawSyntaxNodesJKLMN.swift
[100/362] Compiling InternalCollectionsUtilities _SortedCollection.swift
[101/362] Compiling InternalCollectionsUtilities _UniqueCollection.swift
[102/362] Compiling InternalCollectionsUtilities LifetimeOverride.swift
[103/362] Compiling InternalCollectionsUtilities RandomAccessCollection+Offsets.swift
[104/362] Compiling InternalCollectionsUtilities Span+Extras.swift
[105/362] Compiling InternalCollectionsUtilities Debugging.swift
[106/362] Compiling InternalCollectionsUtilities Descriptions.swift
[107/362] Compiling InternalCollectionsUtilities FixedWidthInteger+roundUpToPowerOfTwo.swift
[108/362] Compiling InternalCollectionsUtilities Integer rank.swift
[109/362] Compiling InternalCollectionsUtilities UInt+first and last set bit.swift
[110/362] Compiling InternalCollectionsUtilities UInt+reversed.swift
[123/362] Compiling InternalCollectionsUtilities UnsafeBufferPointer+Extras.swift
[124/362] Compiling InternalCollectionsUtilities UnsafeMutableBufferPointer+Extras.swift
[125/362] Compiling InternalCollectionsUtilities UnsafeMutableRawBufferPointer+Extras.swift
[126/362] Compiling InternalCollectionsUtilities UnsafeRawBufferPointer+Extras.swift
[127/364] Compiling SwiftSyntax Keyword.swift
[128/364] Compiling SwiftSyntax RenamedChildrenCompatibility.swift
[130/365] Emitting module InternalCollectionsUtilities
[131/364] Compiling InternalCollectionsUtilities _SortedCollection.swift
[132/364] Compiling InternalCollectionsUtilities _UniqueCollection.swift
[135/364] Emitting module PropertyBased
[141/364] Compiling InternalCollectionsUtilities String+Padding.swift
[142/364] Compiling InternalCollectionsUtilities _UnsafeBitSet+Index.swift
[143/364] Compiling InternalCollectionsUtilities _UnsafeBitSet+_Word.swift
[144/364] Compiling InternalCollectionsUtilities _UnsafeBitSet.swift
[146/364] Compiling SwiftSyntax SyntaxAnyVisitor.swift
[147/364] Compiling SwiftSyntax SyntaxBaseNodes.swift
[148/364] Compiling SwiftSyntax SyntaxCollections.swift
[149/364] Compiling SwiftSyntax SyntaxEnum.swift
[153/364] Compiling SwiftSyntax RenamedNodesCompatibility.swift
[164/364] Emitting module InternalCollectionsUtilities
[179/376] Emitting module PropertyBased
[180/376] Compiling ComplexModule Complex+IntegerLiteral.swift
[190/375] Compiling ComplexModule Polar.swift
[191/376] Compiling ComplexModule Complex+Hashable.swift
[193/376] Compiling ComplexModule Complex+Numeric.swift
[194/376] Compiling ComplexModule Complex+StringConvertible.swift
[195/376] Compiling ComplexModule Complex.swift
[207/377] Compiling ComplexModule Complex+ElementaryFunctions.swift
[215/389] Compiling ComplexModule Scale.swift
[216/389] Compiling PropertyBased Shrink+Tuple.swift
[217/389] Compiling PropertyBased Shrink.swift
[218/389] Compiling PropertyBased Xoshiro.swift
[219/389] Compiling PropertyBased Zip.swift
[220/390] Compiling ComplexModule Complex+Hashable.swift
[221/390] Compiling ComplexModule Complex+IntegerLiteral.swift
[222/391] Compiling ComplexModule Polar.swift
[223/391] Compiling ComplexModule Complex.swift
[224/391] Compiling ComplexModule Complex+StringConvertible.swift
[225/391] Compiling ComplexModule Complex+Numeric.swift
[230/392] Compiling ComplexModule Complex+AdditiveArithmetic.swift
[231/392] Compiling ComplexModule Complex+AlgebraicField.swift
[232/392] Compiling ComplexModule Complex+Codable.swift
[233/392] Compiling ComplexModule Complex+ElementaryFunctions.swift
[240/405] Compiling OrderedCollections _HashTable+Bucket.swift
[241/405] Compiling OrderedCollections _HashTable+BucketIterator.swift
[243/521] Compiling ComplexModule Scale.swift
[244/521] Emitting module ComplexModule
[245/521] Compiling OrderedCollections _HashTable+Constants.swift
[246/521] Compiling OrderedCollections _HashTable+CustomStringConvertible.swift
[247/521] Compiling OrderedCollections _HashTable+Bucket.swift
[248/521] Compiling OrderedCollections _HashTable+BucketIterator.swift
[250/573] Compiling HeapModule _HeapNode.swift
[251/581] Compiling HeapModule Heap.swift
[252/623] Compiling HeapModule Heap+UnsafeHandle.swift
[253/623] Compiling HeapModule Heap+ExpressibleByArrayLiteral.swift
[254/623] Compiling HeapModule Heap+Invariants.swift
[255/706] Compiling HeapModule Heap+Descriptions.swift
[256/706] Emitting module HeapModule
[257/706] Compiling PropertyLawKit DefensiveCopyLaws.swift
[258/706] Compiling PropertyLawKit Enumeration.swift
[259/706] Compiling PropertyLawKit EnumerationCombinators.swift
[260/706] Compiling PropertyLawKit EnumerationProduct.swift
[261/706] Compiling PropertyLawKit EquatableLaws.swift
[262/706] Compiling PropertyLawKit EveryCarrierLaws.swift
[263/706] Compiling PropertyLawKit EveryCaseLaws.swift
[264/706] Compiling PropertyLawKit FixedWidthIntegerLaws.swift
[265/714] Compiling PropertyLawKit CheckPreflight.swift
[266/714] Compiling PropertyLawKit CoverageAccumulator.swift
[267/714] Compiling PropertyLawKit CaseIterableLaws.swift
[268/714] Compiling PropertyLawKit CodableLaws.swift
[269/714] Compiling PropertyLawKit CollectionLaws.swift
[270/714] Compiling PropertyLawKit CommutativeMonoid.swift
[271/714] Compiling PropertyLawKit CommutativeMonoidLaws.swift
[272/714] Compiling PropertyLawKit ComparableLaws.swift
[273/714] Compiling PropertyLawKit CoverageClassifier.swift
[274/714] Compiling PropertyLawKit DefensiveCopy.swift
[275/714] Emitting module ComplexModule
[276/715] Compiling PropertyLawKit LawCheckBuilders.swift
[277/715] Compiling PropertyLawKit LawSuppressionPolicy.swift
[278/715] Compiling PropertyLawKit NearMissCollector.swift
[279/715] Compiling PropertyLawKit PerLawDriver.swift
[280/715] Compiling PropertyLawKit PropertyLawSuiteRunner.swift
[281/715] Compiling PropertyLawKit LawSelection.swift
[282/715] Compiling PropertyLawKit LawSuppression.swift
[283/715] Compiling PropertyLawKit PropertyLawViolation.swift
[284/722] Compiling PropertyLawKit CodableRoundTripMode.swift
[285/722] Compiling PropertyLawKit EnforcementMode.swift
[286/722] Compiling PropertyLawKit Environment.swift
[287/722] Compiling PropertyLawKit EqualValuePairing.swift
[288/722] Compiling PropertyLawKit InputSource.swift
[289/722] Compiling PropertyLawKit LawCheckOptions.swift
[290/722] Compiling PropertyLawKit LawIdentifier.swift
[291/722] Compiling PropertyLawKit BinaryIntegerLaws.swift
[302/722] Compiling PropertyLawKit Seed.swift
[303/722] Compiling PropertyLawKit SequenceLawOptions.swift
[304/722] Compiling PropertyLawKit SpaceCoverage.swift
[305/722] Compiling PropertyLawKit StrictnessTier.swift
[306/722] Compiling PropertyLawKit TrialBudget.swift
[307/722] Compiling PropertyLawKit PropertyLawKit.swift
[308/722] Compiling PropertyLawKit ActionSequenceFactory.swift
[309/722] Compiling PropertyLawKit AdditiveArithmeticLaws.swift
[318/731] Compiling HeapModule Heap+ExpressibleByArrayLiteral.swift
[328/731] Compiling PropertyLawKit AggregateDriver.swift
[329/731] Compiling PropertyLawKit SwiftPropertyBasedBackend.swift
[332/731] Compiling PropertyLawKit DrawPoolDriver.swift
[333/731] Compiling PropertyLawKit EnumerationDriver.swift
[334/731] Compiling PropertyLawKit EqualValueLawBuilders.swift
[335/731] Compiling PropertyLawKit InheritedLawCollector.swift
[337/739] Emitting module PropertyLawComplex
[338/739] Compiling PropertyLawComplex EdgeCaseBiasedGenerators.swift
[339/740] Emitting module HeapModule
[348/740] Compiling HeapModule _HeapNode.swift
[357/740] Compiling PropertyLawKit BidirectionalCollectionLaws.swift
[358/740] Compiling PropertyLawKit BinaryFloatingPointLaws.swift
[359/740] Compiling PropertyLawKit ReplayEnvironmentValidator.swift
[360/740] Compiling PropertyLawKit SpaceSampling.swift
[361/740] Compiling PropertyLawKit ViolationFormatter.swift
[362/740] Compiling PropertyLawKit CheckResult.swift
[363/740] Compiling PropertyLawKit CodableCodec.swift
[364/740] Compiling PropertyLawKit CodableLawConfig.swift
[365/740] Compiling HeapModule Heap.swift
[367/742] Compiling HeapModule Heap+Invariants.swift
[368/742] Compiling HeapModule Heap+Descriptions.swift
[369/742] Compiling HeapModule Heap+UnsafeHandle.swift
[370/743] Emitting module PropertyLawComplex
[413/743] Compiling PropertyLawKit ReplayEnvironmentMismatch.swift
[414/743] Compiling PropertyLawKit Ring.swift
[415/743] Compiling PropertyLawKit RingLaws.swift
[416/743] Compiling PropertyLawKit SameResult.swift
[417/743] Compiling PropertyLawKit Semigroup.swift
[418/743] Compiling PropertyLawKit SemigroupLaws.swift
[419/743] Compiling PropertyLawKit Semilattice.swift
[420/743] Compiling PropertyLawKit SemilatticeLaws.swift
[421/743] Compiling PropertyLawKit SequenceLaws.swift
[422/743] Compiling PropertyLawKit SetAlgebraLaws.swift
[423/743] Compiling PropertyLawKit SignedIntegerLaws.swift
[424/743] Compiling PropertyLawKit SignedNumericLaws.swift
[425/743] Compiling PropertyLawKit StableIdentity.swift
[426/755] Compiling PropertyLawComplex EdgeCaseBiasedGenerators.swift
[427/832] Compiling HashTreeCollections TreeSet+Codable.swift
[428/832] Compiling HashTreeCollections TreeSet+Collection.swift
[429/832] Compiling HashTreeCollections TreeSet+CustomReflectable.swift
[430/832] Compiling HashTreeCollections TreeSet+Debugging.swift
[431/832] Compiling HashTreeCollections TreeSet+Descriptions.swift
[432/832] Compiling HashTreeCollections TreeSet+Equatable.swift
[433/832] Compiling HashTreeCollections TreeSet+ExpressibleByArrayLiteral.swift
[442/832] Emitting module PropertyLawKit
[456/844] Compiling HashTreeCollections TreeDictionary+CustomReflectable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[457/844] Compiling HashTreeCollections TreeDictionary+Debugging.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[458/844] Compiling HashTreeCollections TreeDictionary+Descriptions.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[459/844] Compiling HashTreeCollections TreeDictionary.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[467/844] Compiling HashTreeCollections TreeSet+Extras.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[468/844] Compiling HashTreeCollections TreeSet+Filter.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[469/844] Compiling HashTreeCollections TreeSet+Hashable.swift
[470/844] Compiling HashTreeCollections TreeSet+Sendable.swift
[471/844] Compiling HashTreeCollections TreeSet+Sequence.swift
[472/844] Compiling HashTreeCollections TreeSet+SetAlgebra Initializers.swift
[473/844] Compiling HashTreeCollections TreeSet+SetAlgebra basics.swift
[474/844] Compiling HashTreeCollections TreeSet+SetAlgebra formIntersection.swift
[475/844] Compiling HashTreeCollections TreeSet+SetAlgebra formSymmetricDifference.swift
[476/844] Compiling HashTreeCollections TreeSet+SetAlgebra formUnion.swift
[477/844] Compiling HashTreeCollections TreeSet+SetAlgebra intersection.swift
[478/844] Compiling HashTreeCollections TreeSet+SetAlgebra isDisjoint.swift
[479/844] Compiling PropertyLawKit RandomAccessCollectionLaws.swift
[480/844] Compiling PropertyLawKit RangeReplaceableCollectionLaws.swift
[481/844] Compiling PropertyLawKit RawRepresentableLaws.swift
[482/844] Emitting module PropertyLawKit
[483/844] Compiling HashTreeCollections _AncestorHashSlots.swift
[484/844] Compiling HashTreeCollections _Bitmap.swift
[485/844] Compiling HashTreeCollections _Bucket.swift
[486/844] Compiling HashTreeCollections _Hash.swift
[487/844] Compiling HashTreeCollections _HashLevel.swift
[488/844] Compiling HashTreeCollections _HashNode+Builder.swift
[489/844] Compiling HashTreeCollections _HashNode+Debugging.swift
[490/844] Compiling HashTreeCollections _HashNode+Initializers.swift
[491/844] Compiling HashTreeCollections _HashNode+Invariants.swift
[492/844] Compiling HashTreeCollections _HashNode+Lookups.swift
[493/844] Compiling HashTreeCollections _HashNode+Primitive Insertions.swift
[494/844] Compiling HashTreeCollections TreeDictionary+Equatable.swift
[495/844] Compiling HashTreeCollections TreeDictionary+ExpressibleByDictionaryLiteral.swift
[496/844] Compiling HashTreeCollections TreeDictionary+Filter.swift
[497/844] Compiling HashTreeCollections TreeDictionary+Hashable.swift
[498/844] Compiling HashTreeCollections TreeDictionary+Initializers.swift
[499/844] Compiling HashTreeCollections TreeDictionary+Keys.swift
[500/844] Compiling HashTreeCollections TreeDictionary+MapValues.swift
[501/844] Compiling HashTreeCollections TreeDictionary+Merge.swift
[502/844] Compiling HashTreeCollections TreeDictionary+Sendable.swift
[503/844] Compiling HashTreeCollections TreeDictionary+Sequence.swift
[504/844] Compiling HashTreeCollections TreeDictionary+Values.swift
[505/844] Compiling HashTreeCollections _HashNode+Structural subtracting.swift
[506/844] Compiling HashTreeCollections _HashNode+Structural symmetricDifference.swift
[507/844] Compiling HashTreeCollections _HashNode+Structural union.swift
[508/844] Compiling HashTreeCollections _HashNode+Subtree Insertions.swift
[522/920] Compiling HashTreeCollections TreeSet+Hashable.swift
[523/920] Compiling HashTreeCollections TreeSet+Sendable.swift
[524/920] Compiling HashTreeCollections TreeSet+Sequence.swift
[525/920] Compiling HashTreeCollections TreeSet+SetAlgebra Initializers.swift
[526/920] Compiling HashTreeCollections TreeSet+SetAlgebra basics.swift
[527/920] Compiling HashTreeCollections TreeSet+SetAlgebra formIntersection.swift
[528/920] Compiling HashTreeCollections TreeSet+SetAlgebra formSymmetricDifference.swift
[529/920] Compiling HashTreeCollections TreeSet+SetAlgebra formUnion.swift
[530/920] Compiling HashTreeCollections TreeSet+SetAlgebra intersection.swift
[531/920] Compiling HashTreeCollections TreeSet+SetAlgebra isDisjoint.swift
[535/920] Compiling HashTreeCollections TreeDictionary+CustomReflectable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[536/920] Compiling HashTreeCollections TreeDictionary+Debugging.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[537/920] Compiling HashTreeCollections TreeDictionary+Descriptions.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[538/920] Compiling HashTreeCollections TreeDictionary.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[539/920] Compiling HashTreeCollections TreeSet+Codable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[540/920] Compiling HashTreeCollections TreeSet+Collection.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[541/920] Compiling HashTreeCollections TreeSet+CustomReflectable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[542/920] Compiling HashTreeCollections TreeSet+Debugging.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[543/920] Compiling HashTreeCollections TreeSet+Descriptions.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[544/920] Compiling HashTreeCollections TreeSet+Equatable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[545/920] Compiling HashTreeCollections TreeSet+ExpressibleByArrayLiteral.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[546/920] Compiling HashTreeCollections TreeSet+Extras.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[547/920] Compiling HashTreeCollections TreeSet+Filter.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/EquatableLaws.swift:132:12: warning: no 'async' operations occur within 'await' expression
130 | ) async -> CheckResult {
131 |     let applications = Applications()
132 |     return await reportingApplications(applications, of: await runEqualityChainLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
133 |         "Equatable.transitivity",
134 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/HashableLaws.swift:87:12: warning: no 'async' operations occur within 'await' expression
 85 | ) async -> CheckResult {
 86 |     let applications = Applications()
 87 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
 88 |         "Hashable.equalityConsistency",
 89 |         source: source,
[568/930] Compiling HashTreeCollections _HashNode+Primitive Removals.swift
[569/930] Compiling HashTreeCollections _HashNode+Primitive Replacement.swift
[570/930] Compiling HashTreeCollections _HashNode+Storage.swift
[571/930] Compiling HashTreeCollections _HashNode+Structural compactMapValues.swift
[572/930] Compiling HashTreeCollections _HashNode+Structural filter.swift
[573/930] Compiling HashTreeCollections _HashNode+Structural intersection.swift
[574/930] Compiling HashTreeCollections _HashNode+Structural isDisjoint.swift
[575/930] Compiling HashTreeCollections _HashNode+Structural isEqualSet.swift
[576/930] Compiling HashTreeCollections _HashNode+Structural isSubset.swift
[577/930] Compiling HashTreeCollections _HashNode+Structural mapValues.swift
[578/930] Compiling HashTreeCollections _HashNode+Structural merge.swift
[579/930] Compiling PropertyLawKit StableIdentityLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[580/930] Compiling PropertyLawKit StatefulGuard.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[581/930] Compiling PropertyLawKit StdlibGenerators.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[582/930] Compiling PropertyLawKit StrictWeakOrderingLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[583/930] Compiling PropertyLawKit StrictWeakOrderingVacuity.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[584/930] Compiling PropertyLawKit StrideableLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[585/930] Compiling PropertyLawKit StringProtocolLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[586/930] Compiling PropertyLawKit TransformationFunctionLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[587/930] Compiling PropertyLawKit TransformationLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[588/930] Compiling PropertyLawKit UnsignedIntegerLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[589/930] Compiling PropertyLawKit ValueSemantic.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[590/930] Compiling PropertyLawKit ValueSemanticLaws.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[601/940] Emitting module OrderedCollections
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:30:21: error: 'frequency' is unavailable
 28 |     /// the engine's RNG.
 29 |     public static func unicodeScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
 30 |         Gen<UInt32>.frequency(
    |                     `- error: 'frequency' is unavailable
 31 |             // ASCII — what most code is written and tested against.
 32 |             (4.0, Gen<UInt32>.uint32(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:100:20: error: 'frequency' is unavailable
 98 |
 99 |     public static func asciiScalar() -> Generator<Unicode.Scalar, some SendableSequenceType> {
100 |         Gen<UInt8>.frequency(
    |                    `- error: 'frequency' is unavailable
101 |             // Printable ASCII — space through `~`. What most code is written against.
102 |             (6.0, Gen<UInt8>.uint8(in: 0x20 ... 0x7E)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:107:30: error: 'frequency' is unavailable
105 |             // `compactMap` back to non-optional would be three lines saying what
106 |             // three equal-weight `always`es say plainly.
107 |             (2.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
108 |                 (1.0, Gen<UInt8>.always(0x09)),
109 |                 (1.0, Gen<UInt8>.always(0x0A)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StdlibGenerators.swift:114:30: error: 'frequency' is unavailable
112 |             // The rest of the control range, plus DEL. NUL is in here, which is what
113 |             // makes this generator able to find a C-string truncation bug.
114 |             (1.0, Gen<UInt8>.frequency(
    |                              `- error: 'frequency' is unavailable
115 |                 (1.0, Gen<UInt8>.uint8(in: 0x00 ... 0x08)),
116 |                 (1.0, Gen<UInt8>.uint8(in: 0x0B ... 0x1F)),
/host/spi-builder-workspace/.build/checkouts/swift-property-based/Sources/PropertyBased/Gen+Frequency.swift:172:24: note: 'frequency' was introduced in Swift 6.2
170 |     @available(swift 6.2)
171 |     @_disfavoredOverload
172 |     public static func frequency<each Seq: Sequence>(
    |                        `- note: 'frequency' was introduced in Swift 6.2
173 |         _ generators: repeat (weight: FloatLiteralType, gen: Generator<Value, each Seq>)
174 |     )
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:176:13: warning: no 'async' operations occur within 'await' expression
174 |     return try await runPropertyLawSuite(options: options) {
175 |         [
176 |             await requiringApplicableCases(await runBinaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
177 |                 "StrictWeakOrdering.discrimination",
178 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:271:13: warning: no 'async' operations occur within 'await' expression
269 |     return try await runPropertyLawSuite(options: options) {
270 |         [
271 |             await requiringApplicableCases(await runTernaryLaw(
    |             `- warning: no 'async' operations occur within 'await' expression
272 |                 "StrictWeakOrdering.congruence",
273 |                 tier: .conventional,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/StrictWeakOrderingLaws.swift:334:12: warning: no 'async' operations occur within 'await' expression
332 | ) async -> CheckResult {
333 |     let applications = Applications()
334 |     return await requiringApplicableCases(await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
335 |         "StrictWeakOrdering.transitivity",
336 |         source: source,
[614/941] Compiling HashTreeCollections TreeDictionary+MapValues.swift
[615/941] Compiling HashTreeCollections TreeDictionary+Merge.swift
[616/941] Compiling HashTreeCollections TreeDictionary+Sendable.swift
[617/941] Compiling HashTreeCollections TreeDictionary+Sequence.swift
[618/941] Compiling HashTreeCollections TreeDictionary+Values.swift
[619/941] Compiling HashTreeCollections _HashTreeIterator.swift
[620/941] Compiling HashTreeCollections _HashTreeStatistics.swift
[621/941] Compiling HashTreeCollections _RawHashNode+UnsafeHandle.swift
[622/941] Compiling HashTreeCollections _RawHashNode.swift
[623/941] Compiling HashTreeCollections _UnmanagedHashNode.swift
[624/941] Compiling HashTreeCollections _UnsafePath.swift
[625/941] Compiling HashTreeCollections TreeDictionary+Codable.swift
[626/941] Compiling HashTreeCollections TreeDictionary+Collection.swift
[627/941] Compiling HashTreeCollections _HashNode+Subtree Modify.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[628/941] Compiling HashTreeCollections _HashNode+Subtree Removals.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[629/941] Compiling HashTreeCollections _HashNode+UnsafeHandle.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[630/941] Compiling HashTreeCollections _HashNode.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[631/941] Compiling HashTreeCollections _HashNodeHeader.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[632/941] Compiling HashTreeCollections _HashSlot.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[633/941] Compiling HashTreeCollections _HashStack.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[634/941] Compiling HashTreeCollections TreeDictionary+Equatable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[635/941] Compiling HashTreeCollections TreeDictionary+ExpressibleByDictionaryLiteral.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[636/941] Compiling HashTreeCollections TreeDictionary+Filter.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[637/941] Compiling HashTreeCollections TreeDictionary+Hashable.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[638/941] Compiling HashTreeCollections TreeDictionary+Initializers.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[639/941] Compiling HashTreeCollections TreeDictionary+Keys.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:124:12: warning: no 'async' operations occur within 'await' expression
122 | ) async -> CheckResult {
123 |     let applications = Applications()
124 |     return await reportingApplications(applications, of: await runTernaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
125 |         "Comparable.transitivity",
126 |         source: source,
[640/941] Compiling HashTreeCollections TreeSet+SetAlgebra isEqualSet.swift
[641/941] Compiling HashTreeCollections TreeSet+SetAlgebra isStrictSubset.swift
[642/941] Compiling HashTreeCollections TreeSet+SetAlgebra isStrictSuperset.swift
[643/941] Compiling HashTreeCollections TreeSet+SetAlgebra isSubset.swift
[644/941] Compiling HashTreeCollections TreeSet+SetAlgebra isSuperset.swift
[645/941] Compiling HashTreeCollections TreeSet+SetAlgebra subtract.swift
[646/941] Compiling HashTreeCollections TreeSet+SetAlgebra subtracting.swift
[647/941] Compiling HashTreeCollections TreeSet+SetAlgebra symmetricDifference.swift
[648/941] Compiling HashTreeCollections TreeSet+SetAlgebra union.swift
[649/941] Compiling HashTreeCollections TreeSet.swift
/host/spi-builder-workspace/Sources/PropertyLawKit/Public/ComparableLaws.swift:104:12: warning: no 'async' operations occur within 'await' expression
102 | ) async -> CheckResult {
103 |     let applications = Applications()
104 |     return await reportingApplications(applications, of: await runEqualValueBinaryLaw(
    |            `- warning: no 'async' operations occur within 'await' expression
105 |         "Comparable.antisymmetry",
106 |         source: source,
BUILD FAILURE 6.1 linux