NavigationStack error

[captadoh]

I am following the SyncUps example and have landed on this

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

but for this line

path: $store.scope(state: \.path, action: \.path)

I get the following error

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

I am not able to determine why this error is happening. I believe I am following the SyncUps to a T but this error won't go away.

[mbrandonw]

Hi @captadoh, Swift is just pointing to the wrong line. Your problem is here:

case let .analyze(meeting, syncUp):

That is not the proper way to destructure the .analyze case.