Confusion about State & NextState when adding a State resource in a system

[danielmckinnonanderson]

Hello! I'm confused about the usage of State / NextState and how they fit into the timings of the app when the state is initialized manually rather than while building the app.

I have declared some state to use in my game that should only exist during specific timings of my app. This state should only exist in the world when we're in turn-based combat:

#[derive(States, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug, Default)]
pub enum TurnBasedCombatState {
    /// Initializing the turn-related resources & components prior to starting
    #[default]
    Setup,

    /// Combatants are taking their turns
    Fighting,

    /// A win or loss condition has been achieved, combat is over
    End,
}

Since the game starts at a menu, and only proceeds to this turn based combat vertical slice after selecting that option from the menu, it makes sense that I would not call app.init_state in my plugin for this capability.
Instead, the state is initialized at the top of the system which fires on this triggering event like so:

fn setup_new_combat_sys(
    mut commands: Commands,
    mut init_combat_er: EventReader<InitializeNewCombatReq>,
    mut spawn_map_ew: EventWriter<SpawnMapReq>,
    mut spawn_sprite_ew: EventWriter<SpawnSpriteReq>,
    mut spawn_camera_ew: EventWriter<SpawnCameraReq>,
) {
    for &InitializeNewCombatReq in init_combat_er.read() {
        commands.insert_resource(State::new(TurnBasedCombatState::Setup));
        // Rest elided, no other State resources are manipulated

So far so good. My understanding of the way this works in Bevy is that at the end of the frame, these commands are executed and my State will be added. I would expect that at that same point is when the NextState resource is added, in sync with this declared state if no other State of this type existed before.

Where I'm getting confused then, is why a system I intend to run after this to change the variant of the state from Setup to Fighting never triggers, because move_to_fighting_state_sys did not run because it requested inaccessible system parameter ResMut<NextState<TurnBasedCombatState>>.
I have tried a few orderings of these systems to try and fulfill the condition where the NextState is setup, including running this system before the setup_new_combat_sys so that it would be run first after the updates on this frame complete, which is when I assumed that the NextState would be ready. Currently I have the scheduling as this, in my plugin:

pub struct TurnBasedCombatPlugin;

impl Plugin for TurnBasedCombatPlugin {
    fn build(&self, app: &mut App) {
        app.add_event::<InitializeNewCombatReq>()
            .add_systems(Update, setup_new_combat_sys)
            .add_systems(Update, move_to_fighting_state_sys
                .run_if(in_state(TurnBasedCombatState::Setup)))
        ;
    }
}

fn move_to_fighting_state_sys(
    mut next_state: ResMut<NextState<TurnBasedCombatState>>,
) {
    next_state.set(TurnBasedCombatState::Fighting);
    info!("Moving to next state `TurnBasedCombat::Fighting`");
}

Am I doing something wrong with the initialization of my state resource? Is there a different pattern I need to use to achieve this behavior?
Per this discussion, is the best choice for implementing what I'm describing to manually add both the State and NextState to the world prior to either of the systems described here running? Is my mental model of these state transitions & resource initializations incorrect?