Is it possible to save the NavBackStackEntry's ViewModels?

Question

I've been trying to create a custom saver for my app state in Jetpack Compose such:

object MainAppSaver:Saver<AppState, Map<String, Any>>
{

     override fun restore(value: Map<String, Any>): AppState?
  {
     val snackBarHostState = value["snackBarHostState"] as SnackbarHostState
     val navHostController = value["navHostController"] as NavHostController
     val snackBarManage = value["snackBarManage"] as ManageSnackBar
     val resources = value["resources"] as Resources
     val coroutineScope = value["coroutineScope"] as CoroutineScope
    return AppState(snackbarHostState = snackBarHostState, navHostController = navHostController, manageSnackBar = snackBarManage, resources = resources,
 coroutineScope = coroutineScope)
  }

    override fun SaverScope.save(value: AppState): Map<String, Any>?
  {
      return mapOf(
      "snackBarHostState" to value.snackbarHostState,
      "navHostController" to value.navHostController,
      "snackBarManage" to value.manageSnackBar,
      "resources" to value.resources,
      "coroutineScope" to value.coroutineScope)
  }
}

to be used for rememberSaveable{} that survives configuration changes. After creating the saver, I created a composable called rememberState as follows:

@Composable
fun rememberState(snackBarHostState: SnackbarHostState = remember{ SnackbarHostState()}, navHostController: NavHostController = rememberNavController(), snackBarManage:ManageSnackBar = ManageSnackBar, resources: Resources = resources(), coroutineScope: CoroutineScope = rememberCoroutineScope()):AppState
 {
    return rememberSaveable(saver = MainAppSaver)
    {
      AppState(snackBarHostState, navHostController, snackBarManage, resources, coroutineScope)
    }
 }

I define AppState in a class

class AppState(val snackbarHostState: SnackbarHostState, val navHostController: NavHostController,
val manageSnackBar: ManageSnackBar, val resources: Resources, val coroutineScope: CoroutineScope)
 {
init
{
coroutineScope.launch()
    {
 manageSnackBar.snackBarFlow.collect()
        {
snackBar->
snackBar?.let()
            {
snackBarMessage ->
   val text = snackBarMessage.toMessage(resources)
   val actionText = when(snackBarMessage)
                {
     is SnackBarMessage.StringSnackBarAction -> snackBarMessage.actionText
     is SnackBarMessage.ResourceSnackBarAction -> snackBarMessage.actionText
                }
   val onClick = when(snackBarMessage)
                {
    is SnackBarMessage.StringSnackBarAction -> snackBarMessage.onClick
    is SnackBarMessage.ResourceSnackBarAction -> snackBarMessage.onClick
                }
   val snackBarResult = snackbarHostState.showSnackbar(message = text, actionLabel = actionText,
 duration = SnackbarDuration.Short)
 when(snackBarResult)
                {
   SnackbarResult.ActionPerformed -> if(onClick != null) onClick()
    SnackbarResult.Dismissed -> {}
                }
            }

        }
    }
  navHostController.addOnDestinationChangedListener()
    {
   _ ->
   manageSnackBar.clearMessages()
        }
    }
fun navigateTo(route:String)
  {
   navHostController.navigate(route)
      {
     launchSingleTop = true
    }
   }
 }

}

In my main composable, I use rememberState:

 @Composable
  fun MainApp()
   {
 val appState = rememberState()
Scaffold(bottomBar =
        {
 BottomNavigationBar(navHostController = 
appState.navHostController, showBottomBar = showBottomBar, 
haptic = haptic,
 themeOption = selectedTheme, selectedItem = selectedItem)

 snackbarHost =
        {
 SnackbarHost(hostState = appState.snackbarHostState, 
 Modifier.padding(bottom = 20.dp),
 snackbar =
                    {
 snackData ->
 Snackbar(snackData, shape = MaterialTheme.shapes.medium,
 actionColor = MaterialTheme.colorScheme.primary,
  containerColor = containerColor, contentColor = contentColor)
                    })
            })
            {
 inner->
 Box(modifier = Modifier
                        .fillMaxSize()
                        .padding(inner))
                {
 AppNavigation(appState = appState, showBottomBar = 
  showBottomBar, haptic = haptic, themeOption = selectedTheme)
                }
            }
 }

This is my AppNavigation composable:

  @Composable
 fun AppNavigation(appState: AppState, 
showBottomBar:MutableState<Boolean>, haptic: HapticFeedback, 
themeOption: ThemeOption)
  {
    val startDestination = if(isUserLoggedIn()) 
    NavigateRoute.NotesScreen.route else 
    NavigateRoute.OnBoardingScreen.route
    NavHost(navController = appState.navHostController, 
    startDestination = startDestination)
    {
    // Composables
      }
  }

The issue, after creating the saver and rotating, the app crashes and throws

java.lang.IllegalStateException: You cannot access the NavBackStackEntry's ViewModels after the NavBackStackEntry is destroyed.

How can I fix it? What I want is when rotating, the snackbar and navigation to retain their states. I would appreciate the reply.

What I expect is when the device is being rotating(activity is being destroyed and recreated), I expect the Snackbar and the navigation state to be retained. I am using Firebase for my database and storage, when the content has been added to the server, I expect the current screen(Add screen) to navigate back to the previous screen (list of contents) while popping the back stack. While it works on one orientation, it doesn't navigate when rotating.