import ComposableArchitecture
import SwiftUI

@Reducer
struct Root {
    @Reducer
    enum Path {
        case account(Account)
        case analyze(Analyze)
        case settings(Settings)
    }

    @ObservableState
    struct State: Equatable {
        var path = StackState<Path.State>()
        var main = Main.State()
    }

    enum Action {
        case path(StackActionOf<Path>)
        case main(Main.Action)
    }

    var body: some ReducerOf<Self> {
        Scope(state: \.main, action: \.main) {
            Main()
        }
        Reduce { _, action in
            switch action {
            case .path:
                return .none

            case .main:
                return .none
            }
        }
        .forEach(\.path, action: \.path)
    }
}

extension Root.Path.State: Equatable {}

struct RootView: View {
    @Bindable var store: StoreOf<Root>

    var body: some View {
        NavigationStack(
            path: $store.scope(state: \.path, action: \.path)
        ) {
            MainView(store: store.scope(state: \.main, action: \.main))
        } destination: { store in
            switch store.case {
            case let .account(store):
                AccountView(store: store)
            case let .analyze(meeting, syncUp):
                AnalyzeView(meeting: meeting, syncUp: syncUp)
            case let .settings(store):
                SettingsView(store: store)
            }
        }
    }
}

Cannot convert value of type 'Binding<Store<StackState<Root.Path.State>, ChildAction>?>' to expected argument type 'Binding<Store<StackState<State>, StackAction<State, Action>>>'