Swift Package IndexBuild Information
Successful build of garuda, reference 1.1.0 (8fbb0f), with Swift 6.2 for Linux on 3 Oct 2026 09:24:29 UTC.
Swift 6 data race errors: 0
Build Command
bash -c docker run --pull=always --rm -v "checkouts-54344843-2":/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.2-latest swift build --triple x86_64-unknown-linux-gnu 2>&1Build Log
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[570/672] Compiling Garuda AsyncOps.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[571/672] Compiling Garuda Authentication.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[572/672] Compiling Garuda Authorization.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[573/672] Compiling Garuda Balancing.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[574/672] Compiling Garuda BlockingPool.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[575/672] Compiling Garuda Broadcast.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[576/672] Compiling Garuda CLI.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[577/672] Compiling Garuda CORS.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[578/672] Compiling Garuda CSRF.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[579/672] Compiling Garuda Cancellation.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[580/672] Compiling Garuda Compression.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[581/672] Compiling Garuda Config.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[582/672] Compiling Garuda Conformance.swift
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:119:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:157:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:185:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:208:30: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:148:46: warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- warning: capture of non-Sendable type 'Key.Type' in an isolated closure [#SendableMetatypes]
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:222:48: warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
220 | /// A token carrying an OAuth 2.0 scope.
221 | public static func scope(_ wanted: String) -> Policy<Value> where Value: ScopedClaims {
222 | Policy(needs: "the scope " + wanted) { $0.hasScope(wanted) }
| `- warning: capture of non-Sendable type 'Value.Type' in an isolated closure [#SendableMetatypes]
223 | }
224 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:114:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
112 | nonisolated(unsafe) let verify = verify
113 | describeBearerScope()
114 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
115 | guard let header = request.header("authorization"), let token = parseBearer(header),
116 | let who = try await verify(token) else {
117 | return Challenge("Bearer")
118 | }
119 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
120 | return nil
121 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:152:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
150 | nonisolated(unsafe) let verify = verify
151 | describeBasicScope()
152 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
153 | guard let header = request.header("authorization"), let credentials = parseBasic(header),
154 | let who = try await verify(credentials.username, credentials.password) else {
155 | return Challenge(challenge)
156 | }
157 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
158 | return nil
159 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:178:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
176 | nonisolated(unsafe) let verify = verify
177 | describeBearerScope()
178 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
179 | let state = try request.state(Service.self)
180 | guard let header = request.header("authorization"), let token = parseBearer(header) else {
:
183 | nonisolated(unsafe) let unsafeState = state
184 | guard let who = try await verify(token, unsafeState) else { return Challenge("Bearer") }
185 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
186 | return nil
187 | }
/host/spi-builder-workspace/Sources/Garuda/Authentication.swift:199:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
197 | nonisolated(unsafe) let verify = verify
198 | describeBasicScope()
199 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
200 | let state = try request.state(Service.self)
201 | guard let header = request.header("authorization"), let credentials = parseBasic(header) else {
:
206 | return Challenge(challenge)
207 | }
208 | request[context: key] = who
| `- note: closure captures 'key' which is accessible to code in the current task
209 | return nil
210 | }
/host/spi-builder-workspace/Sources/Garuda/Authorization.swift:147:9: warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
145 | nonisolated(unsafe) let allows = allows
146 | describeForbidden(needs)
147 | use { request, _ async throws -> (any ResponseConvertible)? in
| `- warning: passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure
148 | guard let who = request[context: key] else { throw HTTPError.unauthorized }
| `- note: closure captures 'key' which is accessible to code in the current task
149 | guard try await allows(who) else { throw AuthorizationError(needs: needs) }
150 | return nil
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[583/672] Compiling Garuda PostgresURL.swift
[584/672] Compiling Garuda QUICListener.swift
[585/672] Compiling Garuda QUICWorker.swift
[586/672] Compiling Garuda QueryDecoding.swift
[587/672] Compiling Garuda RateLimit.swift
[588/672] Compiling Garuda Redis.swift
[589/672] Compiling Garuda RedisCluster.swift
[590/672] Compiling Garuda RedisPool.swift
[591/672] Compiling Garuda RedisSentinel.swift
[592/672] Compiling Garuda Reexec.swift
[593/672] Compiling Garuda RefreshTokens.swift
[594/672] Compiling Garuda ReloadWatcher.swift
[595/672] Compiling Garuda RequestBody.swift
[596/672] Compiling Garuda RequestContext.swift
[597/672] Compiling Garuda RequestDecompression.swift
[598/672] Compiling Garuda RequestID.swift
[599/672] Compiling Garuda MetricsListener.swift
[600/672] Compiling Garuda Multipart.swift
[601/672] Compiling Garuda OpenAPI.swift
[602/672] Compiling Garuda OpenAPISchema.swift
[603/672] Compiling Garuda Outbound.swift
[604/672] Compiling Garuda Passwords.swift
[605/672] Compiling Garuda PoolWaiters.swift
[606/672] Compiling Garuda Postgres.swift
[607/672] Compiling Garuda PostgresArrays.swift
[608/672] Compiling Garuda PostgresCopyPool.swift
[609/672] Compiling Garuda PostgresListen.swift
[610/672] Compiling Garuda PostgresMigrations.swift
[611/672] Compiling Garuda PostgresPool.swift
[612/672] Compiling Garuda PostgresReading.swift
[613/672] Compiling Garuda PostgresRecord.swift
[614/672] Compiling Garuda PostgresTypes.swift
[615/672] Compiling Garuda Connection.swift
[616/672] Compiling Garuda Cookies.swift
[617/672] Compiling Garuda CustomExtractors.swift
[618/672] Compiling Garuda DNSMessage.swift
[619/672] Compiling Garuda Digest.swift
[620/672] Compiling Garuda EventStream.swift
[621/672] Compiling Garuda Extraction.swift
[622/672] Compiling Garuda Form.swift
[623/672] Compiling Garuda ForwardedApply.swift
[624/672] Compiling Garuda HTTP2.swift
[625/672] Compiling Garuda HTTP2Client.swift
[626/672] Compiling Garuda HTTP2Response.swift
[627/672] Compiling Garuda HTTP3.swift
[628/672] Compiling Garuda HTTP3Response.swift
[629/672] Compiling Garuda HTTPClient.swift
[630/672] Compiling Garuda HTTPClientRedirects.swift
[631/672] Compiling Garuda Router.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[632/672] Compiling Garuda RunOnce.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[633/672] Compiling Garuda Runtime.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[634/672] Compiling Garuda SQLite.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[635/672] Compiling Garuda SQLiteDatabase.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[636/672] Compiling Garuda SQLiteDecoding.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[637/672] Compiling Garuda Scheduled.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[638/672] Compiling Garuda SecurityHeaders.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[639/672] Compiling Garuda Sessions.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[640/672] Compiling Garuda State.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[641/672] Compiling Garuda StaticDirectories.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[642/672] Compiling Garuda StaticFiles.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[643/672] Compiling Garuda StreamingResponse.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[644/672] Compiling Garuda TLS.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[645/672] Compiling Garuda TestClient.swift
/host/spi-builder-workspace/Sources/Garuda/Runtime.swift:284:62: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
282 | // ones over both.
283 | var certKeys: [OpaquePointer] = []
284 | for pair in [(cert, key)] + config.tlsExtraCerts.map { ($0.cert, $0.key) } {
| `- warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning
285 | var error = [CChar](repeating: 0, count: 256)
286 | let loaded: OpaquePointer? = error.withUnsafeMutableBufferPointer {
[646/672] Compiling Garuda TestWebSocket.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[647/672] Compiling Garuda TimedWait.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[648/672] Compiling Garuda Timestamp.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[649/672] Compiling Garuda TraceContext.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[650/672] Compiling Garuda TrailingSlash.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[651/672] Compiling Garuda TypedRoutes.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[652/672] Compiling Garuda UUID.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[653/672] Compiling Garuda Unsafely.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[654/672] Compiling Garuda Validation.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[655/672] Compiling Garuda WebSocket.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[656/672] Compiling Garuda WebSocketAPI.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[657/672] Compiling Garuda WebSocketStreams.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[658/672] Compiling Garuda WebTransport.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[659/672] Compiling Garuda WebTransportAPI.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[660/672] Compiling Garuda Worker.swift
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:30: warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type 'R.Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/TypedRoutes.swift:105:36: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
103 | // through the async function it would be an async frame and a
104 | // task switch per extractor, per request.
105 | let answer = try await handler(
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
106 | repeat (each E).awaitsExtraction
107 | ? try await extractForAsyncRoute((each E).self, request, ¶meter, response)
/host/spi-builder-workspace/Sources/Garuda/WebSocketAPI.swift:303:48: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
301 | }
302 | var parameter = 0
303 | let run = Carried(value: WebSocket.bind(handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
304 | repeat try (each E).extract(from: request, parameter: ¶meter)))
305 | let chosen = subprotocols.first { offer.subprotocols.contains($0) }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:347:13: warning: no calls to throwing functions occur within 'try' expression
345 | onAsync(.connect, pattern) { request, _ in
346 | try WebTransportSession.refuseUnlessSession(request)
347 | try await WebTransportSession.serve(request) { session in try await handler(request, session) }
| `- warning: no calls to throwing functions occur within 'try' expression
348 | }
349 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:43: warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: capture of non-Sendable type '(each E).Type' in an isolated closure [#SendableMetatypes]
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
/host/spi-builder-workspace/Sources/Garuda/WebTransportAPI.swift:368:13: warning: no calls to throwing functions occur within 'try' expression
366 | try WebTransportSession.refuseUnlessSession(request)
367 | var parameter = 0
368 | try await WebTransportSession.serve(request, handler,
| `- warning: no calls to throwing functions occur within 'try' expression
369 | repeat try (each E).extract(from: request, parameter: ¶meter))
370 | }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[661/681] Wrapping AST for Garuda for debugging
[663/687] Emitting module GarudaSQL
Internal Error: dataCorrupted(Swift.DecodingError.Context(codingPath: [], debugDescription: "Corrupted JSON", underlyingError: Optional(unexpected end of file)))
[664/687] Emitting module GarudaJSON
[665/687] Compiling GarudaSQL PostgresRow.swift
[666/687] Compiling GarudaJSON JSON.swift
Internal Error: dataCorrupted(Swift.DecodingError.Context(codingPath: [], debugDescription: "Corrupted JSON", underlyingError: Optional(unexpected end of file)))
[668/689] Compiling GarudaFuzzTargets Seeds.swift
[669/689] Emitting module GarudaUploads
[671/689] Emitting module garuda_server
[672/689] Compiling garuda_server main.swift
[673/690] Wrapping AST for garuda-server for debugging
[674/690] Write Objects.LinkFileList
[676/690] Emitting module GarudaFuzzTargets
[677/690] Compiling GarudaFuzzTargets FuzzTargets.swift
[678/690] Compiling GarudaFuzzTargets FuzzCorpus.swift
[679/691] Wrapping AST for GarudaFuzzTargets for debugging
[681/693] Compiling GarudaUploads ResumableUploads.swift
[682/693] Compiling GarudaUploads StructuredFields.swift
[683/693] Compiling GarudaUploads UploadStore.swift
[684/694] Linking garuda
[685/694] Wrapping AST for GarudaUploads for debugging
[687/698] Emitting module pgfuzz
[688/698] Compiling pgfuzz main.swift
[689/699] Wrapping AST for pgfuzz for debugging
[690/699] Write Objects.LinkFileList
[691/699] Linking pgfuzz
[693/699] Compiling garuda_conformance CompressionAndCacheRoutes.swift
[694/699] Emitting module garuda_conformance
[695/699] Compiling garuda_conformance BroadcastRoutes.swift
[696/699] Compiling garuda_conformance main.swift
[697/700] Wrapping AST for garuda-conformance for debugging
[698/700] Write Objects.LinkFileList
[699/700] Linking garuda-conformance
Build complete! (50.48s)
Build complete.
{
"c_language_standard" : "gnu11",
"dependencies" : [
{
"identity" : "aviancore",
"requirement" : {
"range" : [
{
"lower_bound" : "0.7.1",
"upper_bound" : "0.8.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/grepjava/aviancore"
},
{
"identity" : "swift-distributed-tracing",
"requirement" : {
"range" : [
{
"lower_bound" : "1.3.0",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-distributed-tracing"
},
{
"identity" : "swift-syntax",
"requirement" : {
"range" : [
{
"lower_bound" : "602.0.0",
"upper_bound" : "603.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/swiftlang/swift-syntax"
}
],
"manifest_display_name" : "garuda",
"name" : "garuda",
"path" : "/host/spi-builder-workspace",
"platforms" : [
{
"name" : "macos",
"version" : "15.0"
}
],
"products" : [
{
"name" : "garuda",
"targets" : [
"garuda-server"
],
"type" : {
"executable" : null
}
},
{
"name" : "garuda-conformance",
"targets" : [
"garuda-conformance"
],
"type" : {
"executable" : null
}
},
{
"name" : "Garuda",
"targets" : [
"Garuda"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "GarudaUploads",
"targets" : [
"GarudaUploads"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "GarudaJSON",
"targets" : [
"GarudaJSON"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "GarudaSQL",
"targets" : [
"GarudaSQL"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "pgfuzz",
"targets" : [
"pgfuzz"
],
"type" : {
"executable" : null
}
},
{
"name" : "GarudaMacros",
"targets" : [
"GarudaMacros"
],
"type" : {
"macro" : null
}
}
],
"targets" : [
{
"c99name" : "pgfuzz",
"module_type" : "SwiftTarget",
"name" : "pgfuzz",
"path" : "Sources/pgfuzz",
"product_dependencies" : [
"CAvian"
],
"product_memberships" : [
"pgfuzz"
],
"sources" : [
"main.swift"
],
"target_dependencies" : [
"GarudaFuzzTargets"
],
"type" : "executable"
},
{
"c99name" : "garuda_server",
"module_type" : "SwiftTarget",
"name" : "garuda-server",
"path" : "Sources/garuda-server",
"product_memberships" : [
"garuda"
],
"sources" : [
"main.swift"
],
"target_dependencies" : [
"Garuda"
],
"type" : "executable"
},
{
"c99name" : "garuda_conformance",
"module_type" : "SwiftTarget",
"name" : "garuda-conformance",
"path" : "Sources/GarudaConformance",
"product_dependencies" : [
"AvianCore",
"AvianHTTP"
],
"product_memberships" : [
"garuda-conformance"
],
"sources" : [
"BroadcastRoutes.swift",
"CompressionAndCacheRoutes.swift",
"main.swift"
],
"target_dependencies" : [
"Garuda",
"GarudaUploads"
],
"type" : "executable"
},
{
"c99name" : "GarudaUploadsTests",
"module_type" : "SwiftTarget",
"name" : "GarudaUploadsTests",
"path" : "Tests/GarudaUploadsTests",
"product_dependencies" : [
"CAvian",
"AvianHTTP"
],
"sources" : [
"ResumableUploadTests.swift"
],
"target_dependencies" : [
"Garuda",
"GarudaUploads"
],
"type" : "test"
},
{
"c99name" : "GarudaUploads",
"module_type" : "SwiftTarget",
"name" : "GarudaUploads",
"path" : "Sources/GarudaUploads",
"product_dependencies" : [
"AvianHTTP"
],
"product_memberships" : [
"garuda-conformance",
"GarudaUploads"
],
"sources" : [
"ResumableUploads.swift",
"StructuredFields.swift",
"UploadStore.swift"
],
"target_dependencies" : [
"Garuda"
],
"type" : "library"
},
{
"c99name" : "GarudaTests",
"module_type" : "SwiftTarget",
"name" : "GarudaTests",
"path" : "Tests/GarudaTests",
"product_dependencies" : [
"CAvian",
"AvianCore",
"AvianHTTP",
"AvianQUIC",
"Tracing",
"InMemoryTracing"
],
"sources" : [
"AppEnvironmentTests.swift",
"ApplicationTests.swift",
"AsyncOpsTests.swift",
"AsyncRouteTests.swift",
"AuthenticationTests.swift",
"AuthorizationTests.swift",
"BalancingTests.swift",
"BlockingPoolTests.swift",
"BroadcastTests.swift",
"ByteRangeTests.swift",
"CORSTests.swift",
"CSRFTests.swift",
"CancellationTests.swift",
"ConnectionTableTests.swift",
"CookiesTests.swift",
"CustomExtractorTests.swift",
"DNSMessageTests.swift",
"DatabaseTracingTests.swift",
"DeadlineTests.swift",
"DigestTests.swift",
"ExtractionTests.swift",
"FakeRedisNode.swift",
"FormTests.swift",
"FuzzCorpusTests.swift",
"HTTP2ClientTests.swift",
"HTTPClientRedirectTests.swift",
"HTTPClientStreamTests.swift",
"HTTPClientTests.swift",
"HTTPSClientTests.swift",
"HandlerTaskTests.swift",
"HandlerThreadTests.swift",
"HostAndAddressFilterTests.swift",
"JSONFastPathTests.swift",
"JSONTests.swift",
"JWKSTests.swift",
"JWTTests.swift",
"JWTVectors.swift",
"KernelTLSHandoffTests.swift",
"LargeBodyTests.swift",
"LoggingTests.swift",
"LoopbackAlias.swift",
"MainActorRouteTests.swift",
"MiddlewareTests.swift",
"OpenAPITests.swift",
"OutboundTLSTests.swift",
"OutboundTests.swift",
"PasswordsTests.swift",
"PostgresArrayTests.swift",
"PostgresCopyTests.swift",
"PostgresIntegrationTests.swift",
"PostgresListenIntegrationTests.swift",
"PostgresListenScriptedTests.swift",
"PostgresListenTests.swift",
"PostgresMigrationTests.swift",
"PostgresPoolTests.swift",
"PostgresRecordTests.swift",
"PostgresSaslPrepTests.swift",
"PostgresSessionTests.swift",
"PostgresTypesRoundTripTests.swift",
"PostgresTypesTests.swift",
"PostgresURLTests.swift",
"PostgresWireTests.swift",
"PrepareTests.swift",
"RedisClusterIntegrationTests.swift",
"RedisClusterScriptedTests.swift",
"RedisIncompleteTests.swift",
"RedisIntegrationTests.swift",
"RedisProtocolTests.swift",
"RedisReplayTests.swift",
"RedisScriptedTests.swift",
"RedisSentinelTests.swift",
"RedisSlotTests.swift",
"RefreshTokensTests.swift",
"RequestBodyTests.swift",
"RequestDecompressionTests.swift",
"RequestLimitsTests.swift",
"ResolverCacheTests.swift",
"ResolverConfigTests.swift",
"ResolverTests.swift",
"ResponseHookTests.swift",
"ResponseObserverTests.swift",
"ResponseTests.swift",
"RouteMetricsTests.swift",
"RouteTableTests.swift",
"RouterTests.swift",
"RunOnceTests.swift",
"SPAFallbackTests.swift",
"SQLiteTests.swift",
"ScheduledTests.swift",
"SchedulerSliceTests.swift",
"ScramTests.swift",
"SecurityHeadersTests.swift",
"SessionsTests.swift",
"StartupChecksTests.swift",
"StateTests.swift",
"StreamingResponseTests.swift",
"TestWire.swift",
"TimeAndUUIDTests.swift",
"TimedWaitTests.swift",
"TracingTests.swift",
"TrailingSlashTests.swift",
"ValidationTests.swift",
"WebSocketHandlerTests.swift"
],
"target_dependencies" : [
"GarudaPostgres",
"GarudaRedis",
"CGarudaSQLite",
"CGarudaJWT",
"Garuda",
"GarudaSQL",
"GarudaFuzzTargets",
"CAllocationCounter"
],
"type" : "test"
},
{
"c99name" : "GarudaSQL",
"module_type" : "SwiftTarget",
"name" : "GarudaSQL",
"path" : "Sources/GarudaSQL",
"product_memberships" : [
"GarudaSQL"
],
"sources" : [
"PostgresRow.swift"
],
"target_dependencies" : [
"Garuda",
"GarudaMacros"
],
"type" : "library"
},
{
"c99name" : "GarudaRedis",
"module_type" : "SwiftTarget",
"name" : "GarudaRedis",
"path" : "Sources/GarudaRedis",
"product_dependencies" : [
"AvianCore"
],
"product_memberships" : [
"garuda",
"garuda-conformance",
"Garuda",
"GarudaUploads",
"GarudaJSON",
"GarudaSQL",
"pgfuzz"
],
"sources" : [
"RedisCommand.swift",
"RedisParser.swift",
"RedisReads.swift",
"RedisSlots.swift",
"RedisValue.swift"
],
"type" : "library"
},
{
"c99name" : "GarudaPostgres",
"module_type" : "SwiftTarget",
"name" : "GarudaPostgres",
"path" : "Sources/GarudaPostgres",
"product_dependencies" : [
"CAvian",
"AvianCore"
],
"product_memberships" : [
"garuda",
"garuda-conformance",
"Garuda",
"GarudaUploads",
"GarudaJSON",
"GarudaSQL",
"pgfuzz"
],
"sources" : [
"PostgresArrayText.swift",
"PostgresBinary.swift",
"PostgresCopy.swift",
"PostgresSession.swift",
"PostgresWire.swift",
"SaslPrep.swift",
"ScramSHA256.swift"
],
"type" : "library"
},
{
"c99name" : "GarudaMacros",
"module_type" : "SwiftTarget",
"name" : "GarudaMacros",
"path" : "Sources/GarudaMacros",
"product_dependencies" : [
"SwiftSyntax",
"SwiftSyntaxBuilder",
"SwiftSyntaxMacros",
"SwiftDiagnostics",
"SwiftCompilerPlugin"
],
"product_memberships" : [
"GarudaJSON",
"GarudaSQL",
"GarudaMacros"
],
"sources" : [
"JSONMacro.swift",
"Plugin.swift",
"PostgresRowMacro.swift"
],
"type" : "macro"
},
{
"c99name" : "GarudaJSONTests",
"module_type" : "SwiftTarget",
"name" : "GarudaJSONTests",
"path" : "Tests/GarudaJSONTests",
"sources" : [
"JSONMacroTests.swift"
],
"target_dependencies" : [
"Garuda",
"GarudaJSON"
],
"type" : "test"
},
{
"c99name" : "GarudaJSON",
"module_type" : "SwiftTarget",
"name" : "GarudaJSON",
"path" : "Sources/GarudaJSON",
"product_memberships" : [
"GarudaJSON"
],
"sources" : [
"JSON.swift"
],
"target_dependencies" : [
"Garuda",
"GarudaMacros"
],
"type" : "library"
},
{
"c99name" : "GarudaFuzzTargets",
"module_type" : "SwiftTarget",
"name" : "GarudaFuzzTargets",
"path" : "Sources/GarudaFuzzTargets",
"product_dependencies" : [
"AvianCore",
"AvianHTTP",
"AvianQUIC"
],
"product_memberships" : [
"pgfuzz"
],
"sources" : [
"FuzzCorpus.swift",
"FuzzTargets.swift",
"Seeds.swift"
],
"target_dependencies" : [
"Garuda"
],
"type" : "library"
},
{
"c99name" : "Garuda",
"module_type" : "SwiftTarget",
"name" : "Garuda",
"path" : "Sources/Garuda",
"product_dependencies" : [
"CAvian",
"AvianCore",
"AvianHTTP",
"AvianQUIC",
"Tracing"
],
"product_memberships" : [
"garuda",
"garuda-conformance",
"Garuda",
"GarudaUploads",
"GarudaJSON",
"GarudaSQL",
"pgfuzz"
],
"sources" : [
"ACME.swift",
"AppEnvironment.swift",
"Application.swift",
"AsyncOps.swift",
"Authentication.swift",
"Authorization.swift",
"Balancing.swift",
"BlockingPool.swift",
"Broadcast.swift",
"CLI.swift",
"CORS.swift",
"CSRF.swift",
"Cancellation.swift",
"Compression.swift",
"Config.swift",
"Conformance.swift",
"Connection.swift",
"Cookies.swift",
"CustomExtractors.swift",
"DNSMessage.swift",
"Digest.swift",
"EventStream.swift",
"Extraction.swift",
"Form.swift",
"ForwardedApply.swift",
"HTTP2.swift",
"HTTP2Client.swift",
"HTTP2Response.swift",
"HTTP3.swift",
"HTTP3Response.swift",
"HTTPClient.swift",
"HTTPClientRedirects.swift",
"HTTPClientStream.swift",
"HTTPS.swift",
"HTTPStatus.swift",
"Handler.swift",
"HandlerTasks.swift",
"HostAndAddressFilters.swift",
"JSON.swift",
"JSONDecoding.swift",
"JSONEncoding.swift",
"JSONFastPath.swift",
"JSONReading.swift",
"JSONWriting.swift",
"JWKS.swift",
"JWT.swift",
"Logging.swift",
"Metrics.swift",
"MetricsListener.swift",
"Multipart.swift",
"OpenAPI.swift",
"OpenAPISchema.swift",
"Outbound.swift",
"Passwords.swift",
"PoolWaiters.swift",
"Postgres.swift",
"PostgresArrays.swift",
"PostgresCopyPool.swift",
"PostgresListen.swift",
"PostgresMigrations.swift",
"PostgresPool.swift",
"PostgresReading.swift",
"PostgresRecord.swift",
"PostgresTypes.swift",
"PostgresURL.swift",
"QUICListener.swift",
"QUICWorker.swift",
"QueryDecoding.swift",
"RateLimit.swift",
"Redis.swift",
"RedisCluster.swift",
"RedisPool.swift",
"RedisSentinel.swift",
"Reexec.swift",
"RefreshTokens.swift",
"ReloadWatcher.swift",
"RequestBody.swift",
"RequestContext.swift",
"RequestDecompression.swift",
"RequestID.swift",
"RequestLimits.swift",
"RequestStart.swift",
"RequestTracing.swift",
"Resolver.swift",
"ResolverCache.swift",
"ResolverConfig.swift",
"Respond.swift",
"ResponseCache.swift",
"ResponseConvertible.swift",
"ResponseError.swift",
"ResponseHooks.swift",
"ResponseKinds.swift",
"ResponseObservers.swift",
"RouteMetrics.swift",
"RouteTable.swift",
"Router.swift",
"RunOnce.swift",
"Runtime.swift",
"SQLite.swift",
"SQLiteDatabase.swift",
"SQLiteDecoding.swift",
"Scheduled.swift",
"SecurityHeaders.swift",
"Sessions.swift",
"State.swift",
"StaticDirectories.swift",
"StaticFiles.swift",
"StreamingResponse.swift",
"TLS.swift",
"TestClient.swift",
"TestWebSocket.swift",
"TimedWait.swift",
"Timestamp.swift",
"TraceContext.swift",
"TrailingSlash.swift",
"TypedRoutes.swift",
"UUID.swift",
"Unsafely.swift",
"Validation.swift",
"WebSocket.swift",
"WebSocketAPI.swift",
"WebSocketStreams.swift",
"WebTransport.swift",
"WebTransportAPI.swift",
"Worker.swift"
],
"target_dependencies" : [
"GarudaPostgres",
"GarudaRedis",
"CGarudaSQLite",
"CGarudaJWT"
],
"type" : "library"
},
{
"c99name" : "CGarudaSQLite",
"module_type" : "ClangTarget",
"name" : "CGarudaSQLite",
"path" : "Sources/CGarudaSQLite",
"product_memberships" : [
"garuda",
"garuda-conformance",
"Garuda",
"GarudaUploads",
"GarudaJSON",
"GarudaSQL",
"pgfuzz"
],
"sources" : [
"garuda_sqlite.c"
],
"type" : "library"
},
{
"c99name" : "CGarudaJWT",
"module_type" : "ClangTarget",
"name" : "CGarudaJWT",
"path" : "Sources/CGarudaJWT",
"product_memberships" : [
"garuda",
"garuda-conformance",
"Garuda",
"GarudaUploads",
"GarudaJSON",
"GarudaSQL",
"pgfuzz"
],
"sources" : [
"garuda_jwt.c"
],
"type" : "library"
},
{
"c99name" : "CAllocationCounter",
"module_type" : "ClangTarget",
"name" : "CAllocationCounter",
"path" : "Tests/CAllocationCounter",
"sources" : [
"allocations.c",
"global_enqueues.c"
],
"type" : "library"
}
],
"tools_version" : "6.2"
}
basic-6.2-latest: Pulling from saguaro1/spi-images
Digest: sha256:813c8e8a77634154d7d247705cb89167ff1c866446abbe321f542129dc4cf5a7
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:basic-6.2-latest
Done.