How to get a single Reducer from IdentifiedArrayOf

[Kyome22]

When holding reducers in an IdentifiedArrayOf, how can I obtain the reducer for a specific item when I want to perform detailed settings for it in an inspector?

import ComposableArchitecture
import SwiftUI

@Reducer
struct Content {
    @ObservableState
    struct State: Equatable {
        var items = IdentifiedArrayOf<Item.State>()
        var itemSelection: Item.State.ID?
        var isPresentedInspector: Bool {
            get { itemSelection != nil }
            set {
                if !newValue {
                    itemSelection = nil
                }
            }
        }
    }

    enum Action: BindableAction {
        case binding(BindingAction<State>)
        case items(IdentifiedActionOf<Item>)
        case onAppear
    }

    var body: some ReducerOf<Self> {
        BindingReducer()

        Reduce { state, action in
            switch action {
            case .binding:
                return .none

            case let .items(.element(id: id, action: .openInspectorButtonTapped)):
                state.itemSelection = id
                return .none

            case .items(.element(id: _, action: .closeInspectorButtonTapped)):
                state.itemSelection = nil
                return .none

            case .items:
                return .none

            case .onAppear:
                state.items = .init(uniqueElements: "ABCDE".map({ Item.State(title: $0.description) }))
                return .none
            }
        }
        .forEach(\.items, action: \.items) {
            Item()
        }
    }
}

struct ContentView: View {
    @Bindable var store = StoreOf<Content>(initialState: Content.State()) {
        Content()
    }

    var body: some View {
        VStack {
            ForEach(store.scope(state: \.items, action: \.items)) { store in
                ItemView(store: store)
            }
        }
        .inspector(isPresented: $store.isPresentedInspector) {
            // 🛑 This is not a good implementation.
            ForEach(store.scope(state: \.items, action: \.items)) { store in
                if store.id == self.store.itemSelection {
                    ItemSettingsView(store: store)
                }
            }
        }
        .onAppear {
            store.send(.onAppear)
        }
    }
}

@Reducer
struct Item {
    @ObservableState
    struct State: Equatable, Identifiable {
        var id: UUID = .init()
        var title: String
        var flag = false
    }

    enum Action: BindableAction {
        case binding(BindingAction<State>)
        case openInspectorButtonTapped
        case closeInspectorButtonTapped
    }

    var body: some ReducerOf<Self> {
        BindingReducer()
    }
}

struct ItemView: View {
    var store: StoreOf<Item>

    var body: some View {
        HStack {
            Text(store.title)
            Button {
                store.send(.openInspectorButtonTapped)
            } label: {
                Image(systemName: "gearshape.fill")
            }
            .buttonStyle(.bordered)
        }
    }
}

struct ItemSettingsView: View {
    @Bindable var store: StoreOf<Item>

    var body: some View {
        VStack {
            Button {
                store.send(.closeInspectorButtonTapped)
            } label: {
                Image(systemName: "xmark")
            }
            .buttonStyle(.borderless)
            TextField("Title", text: $store.title)
                .textFieldStyle(.roundedBorder)
            Spacer()
        }
    }
}