From 0765168ff24d1a63ac25daae64932e4e04457c21 Mon Sep 17 00:00:00 2001
From: Max Rozdobudko <max.rozdobudko@gmail.com>
Date: Fri, 14 Aug 2026 19:58:09 +0300
Subject: [PATCH] fix: remove blanket retroactive KeyPath: Sendable conformance
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ThemeKit shipped `extension KeyPath: @retroactive @unchecked Sendable`,
a global conformance on a std-lib type ThemeKit does not own. It leaks
into every consumer and collides with libraries that manage key-path
sendability themselves — notably TCA, which deliberately avoids such a
conformance and uses scoped `_Sendable*KeyPath` existentials instead.
The collision surfaces as a build failure in TCA-using code:

    Type 'WritableKeyPath<Root, BindingState<Value>>' does not conform
    to the 'Sendable' protocol

The conformance only existed to let the generated ThemeShadowedStyle /
ThemeShapeStyle structs (which store a KeyPath<Theme, ...> and conform
to ShapeStyle: Sendable) synthesize Sendable. Make those generated
structs `@unchecked Sendable` instead — sendability is asserted locally
and self-contained, since the stored key path is read-only over the
Sendable Theme type. Drop the now-redundant per-property `nonisolated`
on the key-path storage so it builds under MainActor default isolation.

Removes KeyPath+Sendable.swift and its test. The deleted test verified
sendability at the std-lib layer; replace it with coverage where it now
matters: generator assertions on the emitted declarations, plus
compile-time Sendable and cross-actor checks against the generated
styles in all four language-mode/isolation fixture targets.

Co-Authored-By: Foti Dim <foti.dimanidis@numan.com>
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 IMPLEMENTATION_DETAILS.md                     |  2 +-
 Sources/ThemeKit/KeyPath+Sendable.swift       |  1 -
 .../ThemeShadowedStyleGenerator.swift         | 11 +++-
 .../ThemeShapeStyleGenerator.swift            |  9 ++-
 .../GeneratedCodeCompilationTests.swift       | 34 ++++++++++
 .../ThemeFileGeneratorTests.swift             | 20 ++++++
 .../ThemeKitTests/KeyPathSendableTests.swift  | 66 -------------------
 7 files changed, 70 insertions(+), 73 deletions(-)
 delete mode 100644 Sources/ThemeKit/KeyPath+Sendable.swift
 delete mode 100644 Tests/ThemeKitTests/KeyPathSendableTests.swift

diff --git a/IMPLEMENTATION_DETAILS.md b/IMPLEMENTATION_DETAILS.md
index 00ff41e..2525ee8 100644
--- a/IMPLEMENTATION_DETAILS.md
+++ b/IMPLEMENTATION_DETAILS.md
@@ -99,7 +99,7 @@ RoundedRectangle(cornerRadius: 12)
 Theme tokens are resolved lazily through SwiftUI's `ShapeStyle` protocol. Under the hood, `ThemeShapeStyle<Style>` holds a key path into the `Theme` and resolves the correct light/dark variant at render time using the environment's color scheme:
 
 ```swift
-struct ThemeShapeStyle<Style: ShapeStyle>: ShapeStyle, Sendable {
+struct ThemeShapeStyle<Style: ShapeStyle>: ShapeStyle, @unchecked Sendable {
     let keyPath: KeyPath<Theme, ThemeAdaptiveStyle<Style>>
 
     func resolve(in environment: EnvironmentValues) -> some ShapeStyle {
diff --git a/Sources/ThemeKit/KeyPath+Sendable.swift b/Sources/ThemeKit/KeyPath+Sendable.swift
deleted file mode 100644
index 7404f22..0000000
--- a/Sources/ThemeKit/KeyPath+Sendable.swift
+++ /dev/null
@@ -1 +0,0 @@
-extension KeyPath: @retroactive @unchecked Sendable where Root: Sendable, Value: Sendable {}
diff --git a/Sources/ThemeKitGenerator/ThemeShadowedStyleGenerator.swift b/Sources/ThemeKitGenerator/ThemeShadowedStyleGenerator.swift
index 9310361..00896a2 100644
--- a/Sources/ThemeKitGenerator/ThemeShadowedStyleGenerator.swift
+++ b/Sources/ThemeKitGenerator/ThemeShadowedStyleGenerator.swift
@@ -9,9 +9,14 @@ nonisolated public struct ThemeShadowedStyleGenerator: Sendable {
         import SwiftUI
         import ThemeKit
 
-        nonisolated public struct ThemeShadowedStyle<Base: ShapeStyle>: ShapeStyle {
-            nonisolated let base: Base
-            nonisolated let shadowKeyPath: KeyPath<Theme, ThemeAdaptiveStyle<Shadow>>
+        // `@unchecked Sendable` because the stored `shadowKeyPath` is a read-only
+        // `KeyPath` over the `Sendable` `Theme` type. Sendability is asserted
+        // here rather than through a blanket retroactive `KeyPath: Sendable`
+        // conformance, which would leak into every consumer and conflict with
+        // libraries (e.g. TCA) that manage key-path sendability themselves.
+        nonisolated public struct ThemeShadowedStyle<Base: ShapeStyle>: ShapeStyle, @unchecked Sendable {
+            let base: Base
+            let shadowKeyPath: KeyPath<Theme, ThemeAdaptiveStyle<Shadow>>
 
             nonisolated public init(base: Base, shadowKeyPath: KeyPath<Theme, ThemeAdaptiveStyle<Shadow>>) {
                 self.base = base
diff --git a/Sources/ThemeKitGenerator/ThemeShapeStyleGenerator.swift b/Sources/ThemeKitGenerator/ThemeShapeStyleGenerator.swift
index ee7aeb4..0c760ca 100644
--- a/Sources/ThemeKitGenerator/ThemeShapeStyleGenerator.swift
+++ b/Sources/ThemeKitGenerator/ThemeShapeStyleGenerator.swift
@@ -9,8 +9,13 @@ nonisolated public struct ThemeShapeStyleGenerator: Sendable {
         import SwiftUI
         import ThemeKit
 
-        nonisolated public struct ThemeShapeStyle<Style: ShapeStyle & Sendable & Codable & Equatable>: ShapeStyle, Equatable {
-            nonisolated let keyPath: KeyPath<Theme, ThemeAdaptiveStyle<Style>>
+        // `@unchecked Sendable` because the stored `keyPath` is a read-only
+        // `KeyPath` over the `Sendable` `Theme` type. Sendability is asserted
+        // here rather than through a blanket retroactive `KeyPath: Sendable`
+        // conformance, which would leak into every consumer and conflict with
+        // libraries (e.g. TCA) that manage key-path sendability themselves.
+        nonisolated public struct ThemeShapeStyle<Style: ShapeStyle & Sendable & Codable & Equatable>: ShapeStyle, Equatable, @unchecked Sendable {
+            let keyPath: KeyPath<Theme, ThemeAdaptiveStyle<Style>>
 
             nonisolated public init(keyPath: KeyPath<Theme, ThemeAdaptiveStyle<Style>>) {
                 self.keyPath = keyPath
diff --git a/Tests/GeneratedCodeCompilationTests/GeneratedCodeCompilationTests.swift b/Tests/GeneratedCodeCompilationTests/GeneratedCodeCompilationTests.swift
index 3c55993..32d801a 100644
--- a/Tests/GeneratedCodeCompilationTests/GeneratedCodeCompilationTests.swift
+++ b/Tests/GeneratedCodeCompilationTests/GeneratedCodeCompilationTests.swift
@@ -1,4 +1,5 @@
 import Testing
+import SwiftUI
 import GeneratedCodeSwift5
 import GeneratedCodeSwift5MainActor
 import GeneratedCodeSwift6
@@ -44,4 +45,37 @@ struct GeneratedCodeCompilationTests {
         _ = theme.meshGradients.aurora
         _ = theme.shadows.card
     }
+
+    // MARK: - Sendability
+
+    /// Requires its argument to be `Sendable`. Calls fail to compile if the
+    /// generated style types lose their `Sendable` conformance.
+    private func requireSendable<T: Sendable>(_ value: T) -> T { value }
+
+    /// The generated style types store a `KeyPath` into `Theme` and must be
+    /// `Sendable` on their own — ThemeKit intentionally ships no retroactive
+    /// `KeyPath: Sendable` conformance, which would leak into every consumer
+    /// and conflict with libraries that manage key-path sendability themselves.
+    @Test func generatedStyles_areSendable() {
+        _ = requireSendable(GeneratedCodeSwift5.ThemeShapeStyle(keyPath: \.colors.surface))
+        _ = requireSendable(GeneratedCodeSwift5MainActor.ThemeShapeStyle(keyPath: \.colors.surface))
+        _ = requireSendable(GeneratedCodeSwift6.ThemeShapeStyle(keyPath: \.colors.surface))
+        _ = requireSendable(GeneratedCodeSwift6MainActor.ThemeShapeStyle(keyPath: \.colors.surface))
+
+        _ = requireSendable(GeneratedCodeSwift5.ThemeShadowedStyle(base: Color.red, shadowKeyPath: \.shadows.card))
+        _ = requireSendable(GeneratedCodeSwift5MainActor.ThemeShadowedStyle(base: Color.red, shadowKeyPath: \.shadows.card))
+        _ = requireSendable(GeneratedCodeSwift6.ThemeShadowedStyle(base: Color.red, shadowKeyPath: \.shadows.card))
+        _ = requireSendable(GeneratedCodeSwift6MainActor.ThemeShadowedStyle(base: Color.red, shadowKeyPath: \.shadows.card))
+    }
+
+    /// Generated styles must survive a hop across an actor boundary.
+    @Test func generatedStyles_canCrossActorBoundary() async {
+        let style = GeneratedCodeSwift6.ThemeShapeStyle(keyPath: \.colors.surface)
+        let shadowed = GeneratedCodeSwift6MainActor.ThemeShadowedStyle(base: Color.red, shadowKeyPath: \.shadows.card)
+
+        await Task { @Sendable in
+            _ = style
+            _ = shadowed
+        }.value
+    }
 }
diff --git a/Tests/ThemeKitGeneratorTests/ThemeFileGeneratorTests.swift b/Tests/ThemeKitGeneratorTests/ThemeFileGeneratorTests.swift
index ceb4401..79d4fa7 100644
--- a/Tests/ThemeKitGeneratorTests/ThemeFileGeneratorTests.swift
+++ b/Tests/ThemeKitGeneratorTests/ThemeFileGeneratorTests.swift
@@ -265,6 +265,17 @@ struct ThemeFileGeneratorTests {
         #expect(shapeStyle.content.contains("Style: ShapeStyle & Sendable & Codable"))
     }
 
+    @Test func themeShapeStyle_declaresUncheckedSendable() throws {
+        let files = try ThemeFileGenerator().generate(fromJSON: fullJSON).files
+        let shapeStyle = try #require(files.first { $0.name == "ThemeShapeStyle.swift" })
+
+        // Sendability must be asserted on the struct itself — ThemeKit deliberately
+        // ships no retroactive `KeyPath: Sendable` conformance.
+        #expect(shapeStyle.content.contains("ShapeStyle, Equatable, @unchecked Sendable"))
+        #expect(shapeStyle.content.contains("let keyPath: KeyPath<Theme, ThemeAdaptiveStyle<Style>>"))
+        #expect(!shapeStyle.content.contains("nonisolated let keyPath"))
+    }
+
     // MARK: - Config Section
 
     @Test func configSection_providesOutputPath() throws {
@@ -315,6 +326,15 @@ struct ThemeFileGeneratorTests {
         #expect(file.content.contains("ThemeShadowedStyle: Equatable where Base: Equatable"))
     }
 
+    @Test func themeShadowedStyle_declaresUncheckedSendable() throws {
+        let files = try ThemeFileGenerator().generate(fromJSON: shadowsOnlyJSON).files
+        let file = try #require(files.first { $0.name == "ThemeShadowedStyle.swift" })
+
+        #expect(file.content.contains("ShapeStyle, @unchecked Sendable"))
+        #expect(file.content.contains("let shadowKeyPath: KeyPath<Theme, ThemeAdaptiveStyle<Shadow>>"))
+        #expect(!file.content.contains("nonisolated let"))
+    }
+
     @Test func shadowShapeStyle_containsBothStaticAndInstanceProperties() throws {
         let files = try ThemeFileGenerator().generate(fromJSON: shadowsOnlyJSON).files
         let shadowExt = try #require(files.first { $0.name == "ShapeStyle+ThemeShadows.swift" })
diff --git a/Tests/ThemeKitTests/KeyPathSendableTests.swift b/Tests/ThemeKitTests/KeyPathSendableTests.swift
deleted file mode 100644
index 5c16ed4..0000000
--- a/Tests/ThemeKitTests/KeyPathSendableTests.swift
+++ /dev/null
@@ -1,66 +0,0 @@
-import Testing
-@testable import ThemeKit
-
-@Suite("KeyPath+Sendable")
-struct KeyPathSendableTests {
-
-    // MARK: - Compile-time Sendable conformance
-
-    /// Helper that requires its argument to be Sendable.
-    /// If KeyPath did not conform to Sendable, calls to this function
-    /// with KeyPath arguments would fail to compile.
-    private func requireSendable<T: Sendable>(_ value: T) -> T { value }
-
-    @Test func keyPath_withSendableRootAndValue_conformsToSendable() {
-        // SendableRoot and SendableValue are both Sendable,
-        // so KeyPath<SendableRoot, String> should satisfy Sendable.
-        let kp = requireSendable(\SendableRoot.name)
-        #expect(kp == \SendableRoot.name)
-    }
-
-    @Test func keyPath_nestedProperty_conformsToSendable() {
-        let kp = requireSendable(\SendableRoot.count)
-        #expect(kp == \SendableRoot.count)
-    }
-
-    // MARK: - Cross-actor sending
-
-    private actor Collector {
-        func read<Root: Sendable, Value: Sendable>(
-            _ keyPath: KeyPath<Root, Value>, from root: Root
-        ) -> Value {
-            root[keyPath: keyPath]
-        }
-    }
-
-    @Test func keyPath_canBeSentAcrossActorBoundary() async {
-        let collector = Collector()
-        let root = SendableRoot(name: "theme", count: 42)
-
-        let name = await collector.read(\.name, from: root)
-        let count = await collector.read(\.count, from: root)
-
-        #expect(name == "theme")
-        #expect(count == 42)
-    }
-
-    // MARK: - Sendable closure capture
-
-    @Test func keyPath_canBeCapturedInSendableClosure() async {
-        let kp: KeyPath<SendableRoot, String> = \.name
-        let root = SendableRoot(name: "captured", count: 0)
-
-        let result = await Task { @Sendable in
-            root[keyPath: kp]
-        }.value
-
-        #expect(result == "captured")
-    }
-}
-
-// MARK: - Test helpers
-
-private struct SendableRoot: Sendable {
-    let name: String
-    let count: Int
-}