Adopt Sendable throughout API to support -strict-concurrency=complete

Sources/OpenAPIRuntime/Interface/ClientTransport.swift

@@ -229,10 +229,11 @@ public protocol ClientMiddleware: Sendable {
     ///   - operationID: The identifier of the OpenAPI operation.
     ///   - next: A closure that calls the next middleware, or the transport.
     /// - Returns: An HTTP response.
+    @preconcurrency
     func intercept(
         _ request: Request,
         baseURL: URL,
         operationID: String,
-        next: (Request, URL) async throws -> Response
+        next: @Sendable (Request, URL) async throws -> Response
     ) async throws -> Response
 }

Sources/OpenAPIRuntime/Interface/ServerTransport.swift

@@ -111,10 +111,9 @@ public protocol ServerTransport {
     ///   - path: The URL path components, for example `["pets", ":petId"]`.
     ///   - queryItemNames: The names of query items to be extracted
     ///   from the request URL that matches the provided HTTP operation.
+    @preconcurrency
     func register(
-        _ handler: @Sendable @escaping (
-            Request, ServerRequestMetadata
-        ) async throws -> Response,
+        _ handler: @Sendable @escaping (Request, ServerRequestMetadata) async throws -> Response,
         method: HTTPMethod,
         path: [RouterPathComponent],
         queryItemNames: Set<String>
@@ -215,10 +214,11 @@ public protocol ServerMiddleware: Sendable {
     ///   - operationID: The identifier of the OpenAPI operation.
     ///   - next: A closure that calls the next middleware, or the transport.
     /// - Returns: An HTTP response.
+    @preconcurrency
     func intercept(
         _ request: Request,
         metadata: ServerRequestMetadata,
         operationID: String,
-        next: (Request, ServerRequestMetadata) async throws -> Response
+        next: @Sendable (Request, ServerRequestMetadata) async throws -> Response
     ) async throws -> Response
 }

Sources/OpenAPIRuntime/Interface/UniversalClient.swift

@@ -83,12 +83,14 @@ public struct UniversalClient: Sendable {
     ///   - serializer: Creates an HTTP request from the provided Input value.
     ///   - deserializer: Creates an Output value from the provided HTTP response.
     /// - Returns: The Output value produced by `deserializer`.
+    @preconcurrency
     public func send<OperationInput, OperationOutput>(
         input: OperationInput,
         forOperation operationID: String,
-        serializer: (OperationInput) throws -> Request,
-        deserializer: (Response) throws -> OperationOutput
+        serializer: @Sendable (OperationInput) throws -> Request,
+        deserializer: @Sendable (Response) throws -> OperationOutput
     ) async throws -> OperationOutput {
+        @Sendable
         func wrappingErrors<R>(
             work: () async throws -> R,
             mapError: (Error) -> Error
@@ -121,7 +123,7 @@ public struct UniversalClient: Sendable {
             makeError(error: error)
         }
         let response: Response = try await wrappingErrors {
-            var next: (Request, URL) async throws -> Response = { (_request, _url) in
+            var next: @Sendable (Request, URL) async throws -> Response = { (_request, _url) in
                 try await wrappingErrors {
                     try await transport.send(
                         _request,

Sources/OpenAPIRuntime/Interface/UniversalServer.swift

@@ -84,14 +84,16 @@ public struct UniversalServer<APIHandler: Sendable>: Sendable {
     ///   - deserializer: Creates an Input value from the provided HTTP request.
     ///   - serializer: Creates an HTTP response from the provided Output value.
     /// - Returns: The HTTP response produced by `serializer`.
+    @preconcurrency
     public func handle<OperationInput, OperationOutput>(
         request: Request,
         with metadata: ServerRequestMetadata,
         forOperation operationID: String,
-        using handlerMethod: @escaping (APIHandler) -> ((OperationInput) async throws -> OperationOutput),
-        deserializer: @escaping (Request, ServerRequestMetadata) throws -> OperationInput,
-        serializer: @escaping (OperationOutput, Request) throws -> Response
+        using handlerMethod: @Sendable @escaping (APIHandler) -> ((OperationInput) async throws -> OperationOutput),
+        deserializer: @Sendable @escaping (Request, ServerRequestMetadata) throws -> OperationInput,
+        serializer: @Sendable @escaping (OperationOutput, Request) throws -> Response
     ) async throws -> Response {
+        @Sendable
         func wrappingErrors<R>(
             work: () async throws -> R,
             mapError: (Error) -> Error
@@ -102,6 +104,7 @@ public struct UniversalServer<APIHandler: Sendable>: Sendable {
                 throw mapError(error)
             }
         }
+        @Sendable
         func makeError(
             input: OperationInput? = nil,
             output: OperationOutput? = nil,
@@ -116,7 +119,7 @@ public struct UniversalServer<APIHandler: Sendable>: Sendable {
                 underlyingError: error
             )
         }
-        var next: (Request, ServerRequestMetadata) async throws -> Response = { _request, _metadata in
+        var next: @Sendable (Request, ServerRequestMetadata) async throws -> Response = { _request, _metadata in
             let input: OperationInput = try await wrappingErrors {
                 try deserializer(_request, _metadata)
             } mapError: { error in