refactor: Add type constraints to ActionHandler and ActionProcessor

Sources/Flow/ActionHandler/ActionHandler.swift

@@ -119,7 +119,17 @@ import Foundation
 ///
 /// The Facade pattern here is a feature, not a code smell. It provides clean abstraction
 /// and hides implementation complexity from users while maintaining full testability.
-public final class ActionHandler<Action, State, ActionResult: Sendable> {
+///
+/// ## Type Constraints
+///
+/// Type parameters are constrained to match Feature protocol requirements:
+/// - `Action: Sendable` ensures safe concurrent action dispatching
+/// - `State: AnyObject` ensures reference semantics for direct state mutation
+/// - `ActionResult: Sendable` ensures safe concurrent result handling
+///
+/// These constraints prevent common errors like using value-type State (which wouldn't
+/// support mutation) or non-Sendable actions (which could cause data races).
+public final class ActionHandler<Action: Sendable, State: AnyObject, ActionResult: Sendable> {
   private let processor: ActionProcessor<Action, State, ActionResult>
 
   /// Creates a ActionHandler with the given action processing logic.

Sources/Flow/ActionHandler/ActionProcessor.swift

@@ -1,7 +1,9 @@
 import Foundation
 
 /// Action execution closure that mutates state and returns a task.
-public typealias ActionExecution<Action, State, ActionResult> =
+///
+/// - Note: Type constraints match Feature protocol requirements to ensure consistency.
+public typealias ActionExecution<Action: Sendable, State: AnyObject, ActionResult: Sendable> =
   @MainActor (Action, State) async ->
   ActionTask<Action, State, ActionResult>
 
@@ -25,7 +27,12 @@ public typealias StateErrorHandler<State> = (Error, State) -> Void
 /// .use(LoggingMiddleware())
 /// .onError { error, state in state.errorMessage = "\(error)" }
 /// ```
-public final class ActionProcessor<Action, State, ActionResult: Sendable> {
+///
+/// - Note: Type constraints match Feature protocol requirements:
+///   - `Action: Sendable` for safe concurrency across tasks
+///   - `State: AnyObject` ensures reference semantics for state mutation
+///   - `ActionResult: Sendable` for safe concurrency of operation results
+public final class ActionProcessor<Action: Sendable, State: AnyObject, ActionResult: Sendable> {
   private let baseExecution: ActionExecution<Action, State, ActionResult>
   private let errorHandler: StateErrorHandler<State>?
   private let middlewareManager: MiddlewareManager<Action, State>