feat: NativeConcurrency package trait — NIO/AsyncKit-free SQLiteKit

Package@swift-6.1.swift

@@ -0,0 +1,86 @@
+// swift-tools-version:6.1
+import PackageDescription
+
+let package = Package(
+    name: "sqlite-kit",
+    platforms: [
+        .macOS(.v10_15),
+        .iOS(.v13),
+        .watchOS(.v6),
+        .tvOS(.v13),
+    ],
+    products: [
+        .library(name: "SQLiteKit", targets: ["SQLiteKit"]),
+    ],
+    traits: [
+        .default(enabledTraits: ["NIO"]),
+        .trait(
+            name: "NIO",
+            description: "Default backend: SwiftNIO + AsyncKit (EventLoopFuture surface and the connection-pool source)."
+        ),
+        .trait(
+            name: "NativeConcurrency",
+            description: "NIO-free build on Swift concurrency: no AsyncKit connection pool, async-only query surface over sqlite-nio's NativeConcurrency driver. Build with `--traits NativeConcurrency` (replaces the default NIO trait)."
+        ),
+        .trait(
+            name: "Freestanding",
+            description: "Embedded/freestanding flavor (implies NativeConcurrency). No additional source effect in this package beyond NativeConcurrency; declared so a root's `--traits Freestanding` configuration names a known trait when this package is wired by path.",
+            enabledTraits: ["NativeConcurrency"]
+        ),
+    ],
+    dependencies: [
+        // TODO: SM: Update swift-nio version once NIOAsyncRuntime is available from swift-nio
+        // .package(url: "https://github.com/apple/swift-nio.git", from: "2.89.0"),
+        .package(url: "https://github.com/PassiveLogic/swift-nio.git", branch: "feat/khasmPAL-2026"),
+
+        // TODO: SM: Update below once everything is merged and release to the proper repositories
+//        .package(url: "https://github.com/vapor/sqlite-nio.git", from: "1.9.0"),
+        .package(url: "https://github.com/PassiveLogic/sqlite-nio.git", branch: "feat/native-concurrency-trait", traits: [
+            .trait(name: "default", condition: .when(traits: ["NIO"])),
+            .trait(name: "NativeConcurrency", condition: .when(traits: ["NativeConcurrency"])),
+        ]),
+//        .package(url: "https://github.com/vapor/sql-kit.git", from: "3.33.1"),
+        .package(url: "https://github.com/PassiveLogic/sql-kit.git", branch: "feat/native-concurrency-trait", traits: [
+            .trait(name: "default", condition: .when(traits: ["NIO"])),
+            .trait(name: "NativeConcurrency", condition: .when(traits: ["NativeConcurrency"])),
+        ]),
+//        .package(url: "https://github.com/vapor/async-kit.git", from: "1.19.0"),
+        .package(url: "https://github.com/PassiveLogic/async-kit.git", branch: "feat/khasmPAL-2026"),
+    ],
+    targets: [
+        .target(
+            name: "SQLiteKit",
+            dependencies: [
+                .product(name: "SQLiteNIO", package: "sqlite-nio"),
+                .product(name: "SQLKit", package: "sql-kit"),
+                // The SwiftNIO/AsyncKit stack rides the default `NIO` trait; with
+                // `NativeConcurrency` enabled instead, SQLiteKit is NIO-free (no pool),
+                // gated in source with `#if NativeConcurrency`.
+                .product(name: "NIOFoundationCompat", package: "swift-nio", condition: .when(traits: ["NIO"])),
+                .product(name: "NIOAsyncRuntime", package: "swift-nio", condition: .when(platforms: [.wasi], traits: ["NIO"])),
+                .product(name: "NIOPosix", package: "swift-nio", condition: .when(traits: ["NIO"])),
+                .product(name: "AsyncKit", package: "async-kit", condition: .when(traits: ["NIO"])),
+            ],
+            swiftSettings: swiftSettings
+        ),
+        .testTarget(
+            name: "SQLiteKitTests",
+            dependencies: [
+                .product(name: "SQLKitBenchmark", package: "sql-kit"),
+                .target(name: "SQLiteKit"),
+            ],
+            swiftSettings: swiftSettings
+        ),
+    ]
+)
+
+var swiftSettings: [SwiftSetting] { [
+    // This manifest raises the tools-version to 6.1 (for package traits); the package sources
+    // stay in the Swift 5 language mode of the earlier manifests.
+    .swiftLanguageMode(.v5),
+    .enableUpcomingFeature("ExistentialAny"),
+    .enableUpcomingFeature("ConciseMagicFile"),
+    .enableUpcomingFeature("ForwardTrailingClosures"),
+    .enableUpcomingFeature("DisableOutwardActorInference"),
+    .enableExperimentalFeature("StrictConcurrency=complete"),
+] }

Sources/SQLiteKit/Exports.swift

@@ -1,4 +1,6 @@
 @_documentation(visibility: internal) @_exported import SQLKit
 @_documentation(visibility: internal) @_exported import SQLiteNIO
+#if !NativeConcurrency // AsyncKit (connection pool) is elided on the NIO-free NativeConcurrency build.
 @_documentation(visibility: internal) @_exported import AsyncKit
+#endif
 @_documentation(visibility: internal) @_exported import struct Logging.Logger

Sources/SQLiteKit/SQLiteConfiguration.swift

@@ -1,4 +1,6 @@
+#if !hasFeature(Embedded)
 import struct Foundation.UUID
+#endif
 
 /// Describes a configuration for an SQLite database connection.
 public struct SQLiteConfiguration: Sendable {
@@ -8,7 +10,11 @@ public struct SQLiteConfiguration: Sendable {
         ///
         /// See ``memory(identifier:)``.
         public static var memory: Self {
+            #if hasFeature(Embedded) // Foundation.UUID is unavailable; derive a unique identifier from system randomness.
+            .memory(identifier: "memory-\(UInt64.random(in: .min ... .max))")
+            #else
             .memory(identifier: UUID().uuidString)
+            #endif
         }
 
         /// Specify an SQLite database stored in memory, using a given identifier string.

Sources/SQLiteKit/SQLiteConnection+SQLKit.swift

@@ -143,11 +143,15 @@ struct SQLiteDatabaseVersion: SQLDatabaseReportedVersion {
         Self.components(of: self.intValue).patch
     }
 
+    #if !hasFeature(Embedded)
+    // `as? Self` is a cast to a generic type, which Embedded Swift forbids. On embedded we fall back to
+    // the `SQLDatabaseReportedVersion` protocol's default `stringValue`-based comparison implementations.
+
     // See `SQLDatabaseReportedVersion.isEqual(to:)`.
     func isEqual(to otherVersion: any SQLDatabaseReportedVersion) -> Bool {
         (otherVersion as? Self).map { $0.intValue == self.intValue } ?? false
     }
-    
+
     // See `SQLDatabaseReportedVersion.isOlder(than:)`.
     func isOlder(than otherVersion: any SQLDatabaseReportedVersion) -> Bool {
         (otherVersion as? Self).map {
@@ -156,6 +160,7 @@ struct SQLiteDatabaseVersion: SQLDatabaseReportedVersion {
             (self.patchVersion < $0.patchVersion)))
         } ?? false
     }
+    #endif
 }
 
 /// Wraps a `SQLiteDatabase` with the `SQLDatabase` protocol.
@@ -173,12 +178,14 @@ struct SQLiteDatabaseVersion: SQLDatabaseReportedVersion {
     @usableFromInline
     let decoder: SQLiteDataDecoder
 
+    #if !NativeConcurrency
     // See `SQLDatabase.eventLoop`.
     @usableFromInline
     var eventLoop: any EventLoop {
         self.database.eventLoop
     }
-
+    #endif
+
     // See `SQLDatabase.version`.
     @usableFromInline
     var version: (any SQLDatabaseReportedVersion)? {
@@ -209,14 +216,15 @@ struct SQLiteDatabaseVersion: SQLDatabaseReportedVersion {
         self.queryLogLevel = queryLogLevel
     }
 
+    #if !NativeConcurrency
     // See `SQLDatabase.execute(sql:_:)`.
     @usableFromInline
     func execute(
         sql query: any SQLExpression,
         _ onRow: @escaping @Sendable (any SQLRow) -> ()
     ) -> EventLoopFuture<Void> {
         let (sql, rawBinds) = self.serialize(query)
-        
+
         if let queryLogLevel = self.queryLogLevel {
             self.logger.log(level: queryLogLevel, "Executing query", metadata: ["sql": .string(sql), "binds": .array(rawBinds.map { .string("\($0)") })])
         }
@@ -227,13 +235,14 @@ struct SQLiteDatabaseVersion: SQLDatabaseReportedVersion {
         } catch {
             return self.eventLoop.makeFailedFuture(error)
         }
-        
+
         return self.database.query(
             sql,
             binds,
             { onRow($0.sql(decoder: self.decoder)) }
         )
     }
+    #endif
 
     // See `SQLDatabase.execute(sql:_:)`.
     @usableFromInline
@@ -242,9 +251,14 @@ struct SQLiteDatabaseVersion: SQLDatabaseReportedVersion {
         _ onRow: @escaping @Sendable (any SQLRow) -> ()
     ) async throws {
         let (sql, rawBinds) = self.serialize(query)
-        
+
         if let queryLogLevel = self.queryLogLevel {
+            // Embedded Swift has no reflection, so bound values cannot be string-interpolated for logging.
+            #if hasFeature(Embedded)
+            self.logger.log(level: queryLogLevel, "Executing query", metadata: ["sql": .string(sql)])
+            #else
             self.logger.log(level: queryLogLevel, "Executing query", metadata: ["sql": .string(sql), "binds": .array(rawBinds.map { .string("\($0)") })])
+            #endif
         }
 
         try await self.database.query(
@@ -253,12 +267,16 @@ struct SQLiteDatabaseVersion: SQLDatabaseReportedVersion {
             { onRow($0.sql(decoder: self.decoder)) }
         )
     }
-
+
+    #if !NativeConcurrency
+    // `withSession(_:)` rides sqlite-nio's protocol-level `withConnection`, which is concrete-only
+    // on the NativeConcurrency build (SQLKit's default `withSession` applies there instead).
     // See `SQLDatabase.withSession(_:)`.
     @usableFromInline
     func withSession<R>(_ closure: @escaping @Sendable (any SQLDatabase) async throws -> R) async throws -> R {
         try await self.database.withConnection {
             try await closure($0.sql(encoder: self.encoder, decoder: self.decoder, queryLogLevel: self.queryLogLevel))
         }
     }
+    #endif
 }

Sources/SQLiteKit/SQLiteConnectionSource.swift

@@ -1,3 +1,7 @@
+// The connection-pool source is built on AsyncKit/SwiftNIO, which are not part of the NIO-free
+// NativeConcurrency build. That build uses sqlite-nio's concrete async `SQLiteConnection`
+// directly (no pool).
+#if !NativeConcurrency
 #if canImport(Darwin)
 import Foundation
 #else
@@ -117,3 +121,4 @@ fileprivate extension SQLiteConfiguration.Storage {
         }
     }
 }
+#endif // !NativeConcurrency

Sources/SQLiteKit/SQLiteDataDecoder.swift

@@ -1,7 +1,23 @@
+#if hasFeature(Embedded)
+import SQLiteNIO
+
+/// Placeholder ``SQLiteDataDecoder`` for the Embedded Swift build.
+///
+/// `Decodable`-based row decoding (the only thing this type does on normal platforms) is unavailable in
+/// Embedded Swift, where ``SQLKit/SQLRow`` exposes no generic `decode(column:as:)`. Typed access on
+/// embedded is performed directly against the concrete `SQLiteRow` via `SQLiteDataConvertible`. This
+/// stub exists only so the `SQLiteDataDecoder` API surface (e.g. `sql(decoder:)`) remains uniform.
+public struct SQLiteDataDecoder: Sendable {
+    /// Initialize a ``SQLiteDataDecoder``.
+    public init() {}
+}
+#else
 import Foundation
 import SQLiteNIO
 @_spi(CodableUtilities) import SQLKit
+#if !NativeConcurrency
 import NIOFoundationCompat
+#endif
 
 /// Translates `SQLiteData` values received from the database into `Decodable` values.
 ///
@@ -51,7 +67,11 @@ public struct SQLiteDataDecoder: Sendable {
 
                 switch data {
                 case .text(let str):  buf = .init(str.utf8)
+                #if NativeConcurrency
+                case .blob(let blob): buf = .init(blob)
+                #else
                 case .blob(let blob): buf = .init(buffer: blob, byteTransferStrategy: .noCopy)
+                #endif
                 // The remaining cases should never happen, but we implement them anyway just in case.
                 case .integer(let n): buf = .init(String(n).utf8)
                 case .float(let n):   buf = .init(String(n).utf8)
@@ -109,3 +129,4 @@ public struct SQLiteDataDecoder: Sendable {
         }
     }
 }
+#endif // hasFeature(Embedded)

Sources/SQLiteKit/SQLiteDataEncoder.swift

@@ -1,4 +1,34 @@
+#if hasFeature(Embedded)
+import SQLKit
+import SQLiteNIO
+
+/// Translates a bound query parameter (a ``SQLKit/SQLBindValue``) into an `SQLiteData` value.
+///
+/// The Codable/JSON path used on normal platforms is unavailable in Embedded Swift, so on that target
+/// values are mapped directly from their driver-neutral ``SQLKit/SQLDataValue`` representation.
+public struct SQLiteDataEncoder: Sendable {
+    /// Initialize a ``SQLiteDataEncoder``.
+    public init() {}
+
+    /// Convert the given bound value to an `SQLiteData` value.
+    ///
+    /// - Parameter value: The value to convert.
+    /// - Returns: The converted `SQLiteData` value.
+    public func encode(_ value: any SQLBindValue & Sendable) throws -> SQLiteData {
+        switch value.sqlDataValue {
+        case .integer(let int): return .integer(SQLiteInt64(int))
+        case .double(let double): return .float(double)
+        case .string(let string): return .text(string)
+        case .blob(let bytes): return .blob(bytes)
+        case .bool(let bool): return .integer(bool ? 1 : 0)
+        case .null: return .null
+        }
+    }
+}
+#else
+#if !NativeConcurrency
 import NIOCore
+#endif
 import Foundation
 @_spi(CodableUtilities) import SQLKit
 import SQLiteNIO
@@ -175,3 +205,4 @@ public struct SQLiteDataEncoder: Sendable {
         }
     }
 }
+#endif // hasFeature(Embedded)