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
-}