Substate's should_exist() method does not run even though sources have changed

[gwafotapa]

I'm having this issue where the should_exist method of a sub-state is not run despite its sources having changed.
Here is a minimal working example of my problem:

use bevy::{
    prelude::*,
    state::{app::StatesPlugin, state::FreelyMutableState},
};

#[derive(States, Eq, PartialEq, Hash, Copy, Clone, Debug, Default)]
pub enum Stage {
    #[default]
    Setup,
    Main,
}

#[derive(SubStates, Eq, PartialEq, Hash, Copy, Clone, Debug, Default)]
#[source(Stage = Stage::Main)]
pub enum Main {
    #[default]
    Phase1,
    Phase2,
}

#[derive(Eq, PartialEq, Hash, Copy, Clone, Debug, Default)]
pub enum Menu {
    #[default]
    Paused,
}

impl SubStates for Menu {
    type SourceStates = (Stage, Option<Main>);

    fn should_exist((stage, main): Self::SourceStates) -> Option<Self> {
        println!("Computing from {:?} / {:?}", stage, main);
        match stage {
            Stage::Main => match main.unwrap() {
                Main::Phase1 => None,
                Main::Phase2 => Some(Self::Paused),
            },
            _ => None,
        }
    }
}

impl States for Menu {
    const DEPENDENCY_DEPTH: usize = <Self as SubStates>::SourceStates::SET_DEPENDENCY_DEPTH + 1;
}

impl FreelyMutableState for Menu {}

fn print_entered_state<S: States + Copy>(mut evr: EventReader<StateTransitionEvent<S>>) {
    for entered in evr.read().filter_map(|ev| ev.entered) {
        println!("{:?}", entered);
    }
}

fn enter_stage_main(mut stage: ResMut<NextState<Stage>>) {
    stage.set(Stage::Main)
}

fn enter_main_phase_2(mut main: ResMut<NextState<Main>>) {
    main.set(Main::Phase2)
}

fn main() {
    let mut app = App::new();
    app.add_plugins((MinimalPlugins, StatesPlugin));

    app.init_state::<Stage>()
        .add_sub_state::<Main>()
        .add_sub_state::<Menu>();

    app.add_systems(
        Update,
        (
            print_entered_state::<Stage>,
            print_entered_state::<Main>,
            print_entered_state::<Menu>,
        )
            .chain(),
    );

    app.add_systems(OnEnter(Stage::Setup), enter_stage_main)
        .add_systems(OnEnter(Main::Phase1), enter_main_phase_2);

    app.run();
}

If you run this code, you can see that the sub-state Main enters its variant Main::Phase2. But event though Main was modified and is a source of Menu, the should_exist method of Menu is not called (otherwise we would have a print). What am I missing ?