Understanding using NavigableCircuitContent for nested flows

[shaharKeisarApps]

I want to make sure I understand Circuit's perspective on navigation.
Let's assume I have a home screen as my root screen.
Inside that, I will be able to navigate to a new flow. mail flow

Should I set for that flow a new Circuit + NavigableCircuitContent?

Here is a code example (based on the Circuit Tutorial example):

fun MainActivity.tutorialOnCreate() {
    val circuit: Circuit =
        Circuit.Builder()
            .addPresenterFactory(HomePresenter.Factory())
            .addPresenterFactory(MailFlowPresenter.Factory())
            .addUi<HomeScreen, HomeScreen.State> { state, modifier -> HomeUi(state, modifier) }
            .addUi<MailFlowScreen, MailFlowScreen.State> { _, _ -> MailFlow() }
            .build()


    setContent {
        MaterialTheme {
            val backStack = rememberSaveableBackStack { push(HomeScreen) }
            val navigator = rememberCircuitNavigator(backStack)

            CircuitCompositionLocals(circuit) {
                NavigableCircuitContent(
                    navigator = navigator,
                    backStack = backStack,
                )
            }

        }
    }
}

My Home screen

@Parcelize
data object HomeScreen : Screen {
    data class State(
        val eventSink: (Event) -> Unit
    ) : CircuitUiState

    sealed class Event : CircuitUiEvent {
        data object GoToMailFlow : Event()
    }
}

class HomePresenter(
    private val navigator: Navigator,
) : Presenter<HomeScreen.State> {
    @Composable
    override fun present(): HomeScreen.State {
        return HomeScreen.State() { event ->
            when (event) {
                HomeScreen.Event.GoToMailFlow -> navigator.goTo(MailFlowScreen)
            }
        }
    }

    class Factory : Presenter.Factory {
        override fun create(
            screen: Screen,
            navigator: Navigator,
            context: CircuitContext,
        ): Presenter<*>? {
            return when (screen) {
                HomeScreen -> return HomePresenter(navigator)
                else -> null
            }
        }
    }
}

@Composable
fun HomeUi(state: HomeScreen.State, modifier: Modifier = Modifier) {
    Scaffold(
        modifier = modifier,
        topBar = { TopAppBar(title = { Text("Home") }) }) { innerPadding ->
        LazyColumn(modifier = Modifier.padding(innerPadding)) {
            item {
                Text(text = "Hello Home Screen")
                Button(onClick = { state.eventSink(HomeScreen.Event.GoToMailFlow) }) {}
            }
        }
    }
}

@Parcelize
data object MailFlowScreen : Screen {
    object State : CircuitUiState
}

class MailFlowPresenter(
    private val navigator: Navigator,
) : Presenter<MailFlowScreen.State> {
    @Composable
    override fun present(): MailFlowScreen.State = MailFlowScreen.State

    class Factory : Presenter.Factory {
        override fun create(
            screen: Screen,
            navigator: Navigator,
            context: CircuitContext,
        ): Presenter<*>? {
            return when (screen) {
                MailFlowScreen -> return MailFlowPresenter(navigator)
                else -> null
            }
        }
    }
}

@Composable
fun MailFlow(modifier: Modifier = Modifier) {
    val emailRepository = EmailRepository()

    val circuit: Circuit =
        Circuit.Builder()
            .addPresenterFactory(InboxPresenter.Factory(emailRepository))
            .addPresenterFactory(DetailPresenter.Factory(emailRepository))
            .addUi<InboxScreen, InboxScreen.State> { state, _modifier -> Inbox(state, _modifier) }
            .addUi<DetailScreen, DetailScreen.State> { state, _modifier ->
                EmailDetail(
                    state,
                    _modifier
                )
            }
            .build()

    val backStack = rememberSaveableBackStack { push(InboxScreen) }
    val navigator = rememberCircuitNavigator(backStack)
    Scaffold(
        modifier = modifier,
        topBar = { TopAppBar(title = { Text("MailFlow") }) }) { innerPadding ->
        NavigableCircuitContent(
            circuit = circuit,
            backStack = backStack,
            navigator = navigator,
            modifier = Modifier.padding(innerPadding),
        )
    }
}

The inbox screen and details remain the same.
Note: This way of setting flows creates a problem where I can't do navigator.resetRoot(HomeScreen) from MailFlow screens.
(There is no screen if MailFlow has its own circuit; if the circuit is global for the app, HomeScreen will be shown as a nested screen inside MailFlow.)