@devo-bmad-custom/agent-orchestration 1.0.0

package/src/.agents/skills/ui-ux-pro-custom/data/jetpack-compose-expert-skill/references/source-code/navigation-source.md

@@ -0,0 +1,2947 @@
+# Navigation Compose Source Reference
+
+## File: navigation/navigation-compose/src/androidMain/kotlin/androidx/navigation/compose/NavHostController.android.kt
+```kotlin
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:JvmName("NavHostControllerKt")
+@file:JvmMultifileClass
+
+package androidx.navigation.compose
+
+import android.content.Context
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.saveable.Saver
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.platform.LocalContext
+import androidx.navigation.NavDestination
+import androidx.navigation.NavHostController
+import androidx.navigation.Navigator
+
+@Composable
+public actual fun rememberNavController(
+    vararg navigators: Navigator<out NavDestination>
+): NavHostController {
+    val context = LocalContext.current
+    return rememberSaveable(inputs = navigators, saver = NavControllerSaver(context)) {
+            createNavController(context)
+        }
+        .apply {
+            for (navigator in navigators) {
+                navigatorProvider.addNavigator(navigator)
+            }
+        }
+}
+
+private fun createNavController(context: Context) =
+    NavHostController(context).apply {
+        navigatorProvider.addNavigator(ComposeNavGraphNavigator(navigatorProvider))
+        navigatorProvider.addNavigator(ComposeNavigator())
+        navigatorProvider.addNavigator(DialogNavigator())
+    }
+
+/** Saver to save and restore the NavController across config change and process death. */
+private fun NavControllerSaver(context: Context): Saver<NavHostController, *> =
+    Saver(
+        save = { it.saveState() },
+        restore = { createNavController(context).apply { restoreState(it) } },
+    )
+```
+
+## File: navigation/navigation-compose/src/androidMain/kotlin/androidx/navigation/compose/internal/NavComposeUtils.android.kt
+```kotlin
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose.internal
+
+import androidx.activity.compose.PredictiveBackHandler
+import androidx.compose.runtime.Composable
+import java.lang.ref.WeakReference
+import java.util.UUID
+import kotlinx.coroutines.flow.Flow
+
+internal actual typealias BackEventCompat = androidx.activity.BackEventCompat
+
+@Composable
+internal actual fun PredictiveBackHandler(
+    enabled: Boolean,
+    onBack: suspend (progress: Flow<BackEventCompat>) -> Unit,
+) {
+    PredictiveBackHandler(enabled, onBack)
+}
+
+internal actual fun randomUUID(): String = UUID.randomUUID().toString()
+
+/**
+ * Class WeakReference encapsulates weak reference to an object, which could be used to either
+ * retrieve a strong reference to an object, or return null, if object was already destroyed by the
+ * memory manager.
+ */
+internal actual class WeakReference<T : Any> actual constructor(reference: T) {
+    private val weakReference = WeakReference(reference)
+
+    actual fun get(): T? = weakReference.get()
+
+    actual fun clear() = weakReference.clear()
+}
+
+internal actual typealias DefaultNavTransitions = StandardDefaultNavTransitions
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/ComposeNavGraphNavigator.kt
+```kotlin
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose
+
+import androidx.compose.animation.AnimatedContentTransitionScope
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
+import androidx.compose.animation.SizeTransform
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavGraph
+import androidx.navigation.NavGraphNavigator
+import androidx.navigation.Navigator
+import androidx.navigation.NavigatorProvider
+import kotlin.jvm.JvmSuppressWildcards
+
+/**
+ * Custom subclass of [NavGraphNavigator] that adds support for defining transitions at the
+ * navigation graph level.
+ */
+@Navigator.Name("navigation")
+internal class ComposeNavGraphNavigator(navigatorProvider: NavigatorProvider) :
+    NavGraphNavigator(navigatorProvider) {
+    override fun createDestination(): NavGraph {
+        return ComposeNavGraph(this)
+    }
+
+    internal class ComposeNavGraph(navGraphNavigator: Navigator<out NavGraph>) :
+        NavGraph(navGraphNavigator) {
+        internal var enterTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+            null
+
+        internal var exitTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+            null
+
+        internal var popEnterTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+            null
+
+        internal var popExitTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+            null
+
+        internal var predictivePopEnterTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> EnterTransition?)? =
+            null
+
+        internal var predictivePopExitTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> ExitTransition?)? =
+            null
+
+        internal var sizeTransform:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+            null
+    }
+}
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/ComposeNavigator.kt
+```kotlin
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose
+
+import androidx.compose.animation.AnimatedContentScope
+import androidx.compose.animation.AnimatedContentTransitionScope
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
+import androidx.compose.animation.SizeTransform
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavDestination
+import androidx.navigation.NavOptions
+import androidx.navigation.Navigator
+import androidx.navigation.compose.ComposeNavigator.Destination
+import kotlin.jvm.JvmSuppressWildcards
+import kotlinx.coroutines.flow.StateFlow
+
+/**
+ * Navigator that navigates through [Composable]s. Every destination using this Navigator must set a
+ * valid [Composable] by setting it directly on an instantiated [Destination] or calling
+ * [composable].
+ */
+@Navigator.Name("composable")
+public class ComposeNavigator constructor() : Navigator<Destination>(NAME) {
+
+    /** Get the map of transitions currently in progress from the [state]. */
+    internal val transitionsInProgress
+        get() = state.transitionsInProgress
+
+    /** Get the back stack from the [state]. */
+    public val backStack: StateFlow<List<NavBackStackEntry>>
+        get() = state.backStack
+
+    internal val isPop = mutableStateOf(false)
+
+    override fun navigate(
+        entries: List<NavBackStackEntry>,
+        navOptions: NavOptions?,
+        navigatorExtras: Extras?,
+    ) {
+        entries.forEach { entry -> state.pushWithTransition(entry) }
+        isPop.value = false
+    }
+
+    override fun createDestination(): Destination {
+        return Destination(this) {}
+    }
+
+    override fun popBackStack(popUpTo: NavBackStackEntry, savedState: Boolean) {
+        state.popWithTransition(popUpTo, savedState)
+        isPop.value = true
+    }
+
+    /**
+     * Function to prepare the entry for transition.
+     *
+     * This should be called when the entry needs to move the [androidx.lifecycle.Lifecycle.State]
+     * in preparation for a transition such as when using predictive back.
+     */
+    public fun prepareForTransition(entry: NavBackStackEntry) {
+        state.prepareForTransition(entry)
+    }
+
+    /**
+     * Callback to mark a navigation in transition as complete.
+     *
+     * This should be called in conjunction with [navigate] and [popBackStack] as those calls merely
+     * start a transition to the target destination, and requires manually marking the transition as
+     * complete by calling this method.
+     *
+     * Failing to call this method could result in entries being prevented from reaching their final
+     * [androidx.lifecycle.Lifecycle.State].
+     */
+    public fun onTransitionComplete(entry: NavBackStackEntry) {
+        state.markTransitionComplete(entry)
+    }
+
+    /** NavDestination specific to [ComposeNavigator] */
+    @NavDestination.ClassType(Composable::class)
+    public class Destination(
+        navigator: ComposeNavigator,
+        internal val content:
+            @Composable
+            AnimatedContentScope.(@JvmSuppressWildcards NavBackStackEntry) -> Unit,
+    ) : NavDestination(navigator) {
+
+        @Deprecated(
+            message = "Deprecated in favor of Destination that supports AnimatedContent",
+            level = DeprecationLevel.HIDDEN,
+        )
+        public constructor(
+            navigator: ComposeNavigator,
+            content: @Composable (NavBackStackEntry) -> @JvmSuppressWildcards Unit,
+        ) : this(navigator, content = { entry -> content(entry) })
+
+        internal var enterTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+            null
+
+        internal var exitTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+            null
+
+        internal var popEnterTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+            null
+
+        internal var popExitTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+            null
+
+        internal var predictivePopEnterTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> EnterTransition?)? =
+            null
+
+        internal var predictivePopExitTransition:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> ExitTransition?)? =
+            null
+
+        internal var sizeTransform:
+            (@JvmSuppressWildcards
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+            null
+    }
+
+    internal companion object {
+        internal const val NAME = "composable"
+    }
+}
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/ComposeNavigatorDestinationBuilder.kt
+```kotlin
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose
+
+import androidx.compose.animation.AnimatedContentScope
+import androidx.compose.animation.AnimatedContentTransitionScope
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
+import androidx.compose.animation.SizeTransform
+import androidx.compose.runtime.Composable
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavDestinationBuilder
+import androidx.navigation.NavDestinationDsl
+import androidx.navigation.NavType
+import kotlin.jvm.JvmSuppressWildcards
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+/** DSL for constructing a new [ComposeNavigator.Destination] */
+@NavDestinationDsl
+public class ComposeNavigatorDestinationBuilder :
+    NavDestinationBuilder<ComposeNavigator.Destination> {
+
+    private val composeNavigator: ComposeNavigator
+    private val content: @Composable (AnimatedContentScope.(NavBackStackEntry) -> Unit)
+
+    public var enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        null
+
+    public var exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        null
+
+    public var popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        null
+
+    public var popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        null
+
+    public var sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        null
+
+    /**
+     * DSL for constructing a new [ComposeNavigator.Destination]
+     *
+     * @param navigator navigator used to create the destination
+     * @param route the destination's unique route
+     * @param content composable for the destination
+     */
+    public constructor(
+        navigator: ComposeNavigator,
+        route: String,
+        content: @Composable AnimatedContentScope.(NavBackStackEntry) -> Unit,
+    ) : super(navigator, route) {
+        this.composeNavigator = navigator
+        this.content = content
+    }
+
+    /**
+     * DSL for constructing a new [ComposeNavigator.Destination]
+     *
+     * @param navigator navigator used to create the destination
+     * @param route the destination's unique route from a [KClass]
+     * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+     *   [NavType]. May be empty if [route] does not use custom NavTypes.
+     * @param content composable for the destination
+     */
+    public constructor(
+        navigator: ComposeNavigator,
+        route: KClass<*>,
+        typeMap: Map<KType, @JvmSuppressWildcards NavType<*>>,
+        content: @Composable AnimatedContentScope.(NavBackStackEntry) -> Unit,
+    ) : super(navigator, route, typeMap) {
+        this.composeNavigator = navigator
+        this.content = content
+    }
+
+    override fun instantiateDestination(): ComposeNavigator.Destination {
+        return ComposeNavigator.Destination(composeNavigator, content)
+    }
+
+    override fun build(): ComposeNavigator.Destination {
+        return super.build().also { destination ->
+            destination.enterTransition = enterTransition
+            destination.exitTransition = exitTransition
+            destination.popEnterTransition = popEnterTransition
+            destination.popExitTransition = popExitTransition
+            destination.sizeTransform = sizeTransform
+        }
+    }
+}
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/DialogHost.kt
+```kotlin
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveableStateHolder
+import androidx.compose.runtime.snapshots.SnapshotStateList
+import androidx.compose.ui.platform.LocalInspectionMode
+import androidx.compose.ui.window.Dialog
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.compose.DialogNavigator.Destination
+
+/**
+ * Show each [Destination] on the [DialogNavigator]'s back stack as a [Dialog].
+ *
+ * Note that [NavHost] will call this for you; you do not need to call it manually.
+ */
+@Composable
+public fun DialogHost(dialogNavigator: DialogNavigator) {
+    val saveableStateHolder = rememberSaveableStateHolder()
+    val dialogBackStack by dialogNavigator.backStack.collectAsState()
+    val visibleBackStack = rememberVisibleList(dialogBackStack)
+    visibleBackStack.PopulateVisibleList(dialogBackStack)
+
+    val transitionInProgress by dialogNavigator.transitionInProgress.collectAsState()
+    val dialogsToDispose = remember { mutableStateListOf<NavBackStackEntry>() }
+
+    visibleBackStack.forEach { backStackEntry ->
+        val destination = backStackEntry.destination as Destination
+        Dialog(
+            onDismissRequest = { dialogNavigator.dismiss(backStackEntry) },
+            properties = destination.dialogProperties,
+        ) {
+            DisposableEffect(backStackEntry) {
+                dialogsToDispose.add(backStackEntry)
+                onDispose {
+                    dialogNavigator.onTransitionComplete(backStackEntry)
+                    dialogsToDispose.remove(backStackEntry)
+                }
+            }
+
+            // while in the scope of the composable, we provide the navBackStackEntry as the
+            // ViewModelStoreOwner and LifecycleOwner
+            backStackEntry.LocalOwnersProvider(saveableStateHolder) {
+                destination.content(backStackEntry)
+            }
+        }
+    }
+    // Dialogs may have been popped before it was composed. To prevent leakage, we need to
+    // mark popped entries as complete here. Check that we don't accidentally complete popped
+    // entries that were composed, unless they were disposed of already.
+    LaunchedEffect(transitionInProgress, dialogsToDispose) {
+        transitionInProgress.forEach { entry ->
+            if (
+                !dialogNavigator.backStack.value.contains(entry) &&
+                    !dialogsToDispose.contains(entry)
+            ) {
+                dialogNavigator.onTransitionComplete(entry)
+            }
+        }
+    }
+}
+
+@Composable
+internal fun MutableList<NavBackStackEntry>.PopulateVisibleList(
+    backStack: Collection<NavBackStackEntry>
+) {
+    val isInspecting = LocalInspectionMode.current
+    backStack.forEach { entry ->
+        DisposableEffect(entry.lifecycle) {
+            val observer = LifecycleEventObserver { _, event ->
+                // show dialog in preview
+                if (isInspecting && !contains(entry)) {
+                    add(entry)
+                }
+                // ON_START -> add to visibleBackStack, ON_STOP -> remove from visibleBackStack
+                if (event == Lifecycle.Event.ON_START) {
+                    // We want to treat the visible lists as Sets but we want to keep
+                    // the functionality of mutableStateListOf() so that we recompose in response
+                    // to adds and removes.
+                    if (!contains(entry)) {
+                        add(entry)
+                    }
+                }
+                if (event == Lifecycle.Event.ON_STOP) {
+                    remove(entry)
+                }
+            }
+            entry.lifecycle.addObserver(observer)
+            onDispose { entry.lifecycle.removeObserver(observer) }
+        }
+    }
+}
+
+@Composable
+internal fun rememberVisibleList(
+    backStack: Collection<NavBackStackEntry>
+): SnapshotStateList<NavBackStackEntry> {
+    // show dialog in preview
+    val isInspecting = LocalInspectionMode.current
+    return remember(backStack) {
+        mutableStateListOf<NavBackStackEntry>().also {
+            it.addAll(
+                backStack.filter { entry ->
+                    if (isInspecting) {
+                        true
+                    } else {
+                        entry.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
+                    }
+                }
+            )
+        }
+    }
+}
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/DialogNavigator.kt
+```kotlin
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import androidx.navigation.FloatingWindow
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavDestination
+import androidx.navigation.NavOptions
+import androidx.navigation.Navigator
+import androidx.navigation.compose.DialogNavigator.Destination
+
+/**
+ * Navigator that navigates through [Composable]s that will be hosted within a [Dialog]. Every
+ * destination using this Navigator must set a valid [Composable] by setting it directly on an
+ * instantiated [Destination] or calling [dialog].
+ */
+@Navigator.Name("dialog")
+public class DialogNavigator() : Navigator<Destination>(NAME) {
+
+    /** Get the back stack from the [state]. */
+    internal val backStack
+        get() = state.backStack
+
+    /** Get the transitioning dialogs from the [state]. */
+    internal val transitionInProgress
+        get() = state.transitionsInProgress
+
+    /** Dismiss the dialog destination associated with the given [backStackEntry]. */
+    internal fun dismiss(backStackEntry: NavBackStackEntry) {
+        popBackStack(backStackEntry, false)
+    }
+
+    override fun navigate(
+        entries: List<NavBackStackEntry>,
+        navOptions: NavOptions?,
+        navigatorExtras: Extras?,
+    ) {
+        entries.forEach { entry -> state.push(entry) }
+    }
+
+    override fun createDestination(): Destination {
+        return Destination(this) {}
+    }
+
+    override fun popBackStack(popUpTo: NavBackStackEntry, savedState: Boolean) {
+        state.popWithTransition(popUpTo, savedState)
+        // When popping, the incoming dialog is marked transitioning to hold it in
+        // STARTED. With pop complete, we can remove it from transition so it can move to RESUMED.
+        val popIndex = state.transitionsInProgress.value.indexOf(popUpTo)
+        // do not mark complete for entries up to and including popUpTo
+        state.transitionsInProgress.value.forEachIndexed { index, entry ->
+            if (index > popIndex) onTransitionComplete(entry)
+        }
+    }
+
+    internal fun onTransitionComplete(entry: NavBackStackEntry) {
+        state.markTransitionComplete(entry)
+    }
+
+    /** NavDestination specific to [DialogNavigator] */
+    @NavDestination.ClassType(Composable::class)
+    public class Destination(
+        navigator: DialogNavigator,
+        internal val dialogProperties: DialogProperties = DialogProperties(),
+        internal val content: @Composable (NavBackStackEntry) -> Unit,
+    ) : NavDestination(navigator), FloatingWindow
+
+    internal companion object {
+        internal const val NAME = "dialog"
+    }
+}
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/DialogNavigatorDestinationBuilder.kt
+```kotlin
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.window.DialogProperties
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavDestinationBuilder
+import androidx.navigation.NavDestinationDsl
+import androidx.navigation.NavType
+import kotlin.jvm.JvmSuppressWildcards
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+/** DSL for constructing a new [DialogNavigator.Destination] */
+@NavDestinationDsl
+public class DialogNavigatorDestinationBuilder :
+    NavDestinationBuilder<DialogNavigator.Destination> {
+
+    private val dialogNavigator: DialogNavigator
+    private val dialogProperties: DialogProperties
+    private val content: @Composable (NavBackStackEntry) -> Unit
+
+    /**
+     * DSL for constructing a new [DialogNavigator.Destination]
+     *
+     * @param navigator navigator used to create the destination
+     * @param route the destination's unique route
+     * @param dialogProperties properties that should be passed to
+     *   [androidx.compose.ui.window.Dialog].
+     * @param content composable for the destination
+     */
+    public constructor(
+        navigator: DialogNavigator,
+        route: String,
+        dialogProperties: DialogProperties,
+        content: @Composable (NavBackStackEntry) -> Unit,
+    ) : super(navigator, route) {
+        this.dialogNavigator = navigator
+        this.dialogProperties = dialogProperties
+        this.content = content
+    }
+
+    /**
+     * DSL for constructing a new [DialogNavigator.Destination]
+     *
+     * @param navigator navigator used to create the destination
+     * @param route the destination's unique route from a [KClass]
+     * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+     *   [NavType]. May be empty if [route] does not use custom NavTypes.
+     * @param dialogProperties properties that should be passed to
+     *   [androidx.compose.ui.window.Dialog].
+     * @param content composable for the destination
+     */
+    public constructor(
+        navigator: DialogNavigator,
+        route: KClass<*>,
+        typeMap: Map<KType, @JvmSuppressWildcards NavType<*>>,
+        dialogProperties: DialogProperties,
+        content: @Composable (NavBackStackEntry) -> Unit,
+    ) : super(navigator, route, typeMap) {
+        this.dialogNavigator = navigator
+        this.dialogProperties = dialogProperties
+        this.content = content
+    }
+
+    override fun instantiateDestination(): DialogNavigator.Destination {
+        return DialogNavigator.Destination(dialogNavigator, dialogProperties, content)
+    }
+}
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/NavBackStackEntryProvider.kt
+```kotlin
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:JvmName("NavBackStackEntryProviderKt")
+
+package androidx.navigation.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.saveable.SaveableStateHolder
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.createSavedStateHandle
+import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
+import androidx.lifecycle.viewmodel.compose.viewModel
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.compose.internal.WeakReference
+import androidx.navigation.compose.internal.randomUUID
+import androidx.savedstate.compose.LocalSavedStateRegistryOwner
+import kotlin.jvm.JvmName
+
+/**
+ * Provides [this] [NavBackStackEntry] as [LocalViewModelStoreOwner], [LocalLifecycleOwner] and
+ * [LocalSavedStateRegistryOwner] to the [content] and saves the [content]'s saveable states with
+ * the given [saveableStateHolder].
+ *
+ * @param saveableStateHolder The [SaveableStateHolder] that holds the saved states. The same holder
+ *   should be used for all [NavBackStackEntry]s in the encapsulating [Composable] and the holder
+ *   should be hoisted.
+ * @param content The content [Composable]
+ */
+@Composable
+public fun NavBackStackEntry.LocalOwnersProvider(
+    saveableStateHolder: SaveableStateHolder,
+    content: @Composable () -> Unit,
+) {
+    // This outer `CompositionLocalProvider` explicitly provides the owners from this
+    // `NavBackStackEntry` directly to the `SaveableStateProvider`. This prevents potential issues,
+    // such as in testing scenarios, where these owners might not be set.
+    CompositionLocalProvider(
+        LocalViewModelStoreOwner provides this,
+        LocalLifecycleOwner provides this,
+        LocalSavedStateRegistryOwner provides this,
+    ) {
+        saveableStateHolder.SaveableStateProvider {
+            // This inner `CompositionLocalProvider`, located inside the `SaveableStateProvider`
+            // lambda, ensures that the `content` composable receives the correct owners
+            // from this `NavBackStackEntry`. This layering prevents unintended owner overrides
+            // by `SaveableStateProvider` and ensures the destination content correctly interacts
+            // with its navigation-scoped owners.
+            CompositionLocalProvider(
+                LocalViewModelStoreOwner provides this,
+                LocalLifecycleOwner provides this,
+                LocalSavedStateRegistryOwner provides this,
+                content = content,
+            )
+        }
+    }
+}
+
+@Composable
+private fun SaveableStateHolder.SaveableStateProvider(content: @Composable () -> Unit) {
+    val viewModel = viewModel { BackStackEntryIdViewModel(createSavedStateHandle()) }
+    // Stash a reference to the SaveableStateHolder in the ViewModel so that
+    // it is available when the ViewModel is cleared, marking the permanent removal of this
+    // NavBackStackEntry from the back stack. Which, because of animations,
+    // only happens after this leaves composition. Which means we can't rely on
+    // DisposableEffect to clean up this reference (as it'll be cleaned up too early)
+    viewModel.saveableStateHolderRef = WeakReference(this)
+    SaveableStateProvider(viewModel.id, content)
+}
+
+internal class BackStackEntryIdViewModel(handle: SavedStateHandle) : ViewModel() {
+
+    private val IdKey = "SaveableStateHolder_BackStackEntryKey"
+
+    // we create our own id for each back stack entry to support multiple entries of the same
+    // destination. this id will be restored by SavedStateHandle
+    val id: String = (handle.get<String>(IdKey) ?: randomUUID().also { handle.set(IdKey, it) })
+
+    lateinit var saveableStateHolderRef: WeakReference<SaveableStateHolder>
+
+    // onCleared will be called on the entries removed from the back stack. here we notify
+    // SaveableStateProvider that we should remove any state is had associated with this
+    // destination as it is no longer needed.
+    override fun onCleared() {
+        super.onCleared()
+        saveableStateHolderRef.get()?.removeState(id)
+        saveableStateHolderRef.clear()
+    }
+}
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/NavGraphBuilder.kt
+```kotlin
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose
+
+import androidx.compose.animation.AnimatedContentScope
+import androidx.compose.animation.AnimatedContentTransitionScope
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
+import androidx.compose.animation.SizeTransform
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.window.DialogProperties
+import androidx.navigation.NamedNavArgument
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavDeepLink
+import androidx.navigation.NavGraph
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.NavType
+import androidx.navigation.get
+import kotlin.jvm.JvmSuppressWildcards
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+/**
+ * Add the [Composable] to the [NavGraphBuilder]
+ *
+ * @param route route for the destination
+ * @param arguments list of arguments to associate with destination
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param content composable for the destination
+ */
+@Deprecated(
+    message = "Deprecated in favor of composable builder that supports AnimatedContent",
+    level = DeprecationLevel.HIDDEN,
+)
+public fun NavGraphBuilder.composable(
+    route: String,
+    arguments: List<NamedNavArgument> = emptyList(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    content: @Composable (NavBackStackEntry) -> Unit,
+) {
+    addDestination(
+        ComposeNavigator.Destination(provider[ComposeNavigator::class]) { entry -> content(entry) }
+            .apply {
+                this.route = route
+                arguments.forEach { (argumentName, argument) ->
+                    addArgument(argumentName, argument)
+                }
+                deepLinks.forEach { deepLink -> addDeepLink(deepLink) }
+            }
+    )
+}
+
+/**
+ * Add the [Composable] to the [NavGraphBuilder]
+ *
+ * @param route route for the destination
+ * @param arguments list of arguments to associate with destination
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to determine the destination's enter transition
+ * @param exitTransition callback to determine the destination's exit transition
+ * @param popEnterTransition callback to determine the destination's popEnter transition
+ * @param popExitTransition callback to determine the destination's popExit transition
+ * @param content composable for the destination
+ */
+@Deprecated(
+    message = "Deprecated in favor of composable builder that supports sizeTransform",
+    level = DeprecationLevel.HIDDEN,
+)
+public fun NavGraphBuilder.composable(
+    route: String,
+    arguments: List<NamedNavArgument> = emptyList(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        null,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        null,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        exitTransition,
+    content: @Composable AnimatedContentScope.(NavBackStackEntry) -> Unit,
+) {
+    destination(
+        ComposeNavigatorDestinationBuilder(provider[ComposeNavigator::class], route, content)
+            .apply {
+                arguments.forEach { (argumentName, argument) -> argument(argumentName, argument) }
+                deepLinks.forEach { deepLink -> deepLink(deepLink) }
+                this.enterTransition = enterTransition
+                this.exitTransition = exitTransition
+                this.popEnterTransition = popEnterTransition
+                this.popExitTransition = popExitTransition
+            }
+    )
+}
+
+/**
+ * Add the [Composable] to the [NavGraphBuilder]
+ *
+ * @param route route for the destination
+ * @param arguments list of arguments to associate with destination
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to determine the destination's enter transition
+ * @param exitTransition callback to determine the destination's exit transition
+ * @param popEnterTransition callback to determine the destination's popEnter transition
+ * @param popExitTransition callback to determine the destination's popExit transition
+ * @param sizeTransform callback to determine the destination's sizeTransform.
+ * @param content composable for the destination
+ * @sample androidx.navigation.compose.samples.SizeTransformComposable
+ */
+public fun NavGraphBuilder.composable(
+    route: String,
+    arguments: List<NamedNavArgument> = emptyList(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        null,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        null,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        exitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        null,
+    content: @Composable AnimatedContentScope.(NavBackStackEntry) -> Unit,
+) {
+    destination(
+        ComposeNavigatorDestinationBuilder(provider[ComposeNavigator::class], route, content)
+            .apply {
+                arguments.forEach { (argumentName, argument) -> argument(argumentName, argument) }
+                deepLinks.forEach { deepLink -> deepLink(deepLink) }
+                this.enterTransition = enterTransition
+                this.exitTransition = exitTransition
+                this.popEnterTransition = popEnterTransition
+                this.popExitTransition = popExitTransition
+                this.sizeTransform = sizeTransform
+            }
+    )
+}
+
+/**
+ * Add the [Composable] to the [NavGraphBuilder]
+ *
+ * @param T route from a [KClass] for the destination
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [T] does not use custom NavTypes.
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to determine the destination's enter transition
+ * @param exitTransition callback to determine the destination's exit transition
+ * @param popEnterTransition callback to determine the destination's popEnter transition
+ * @param popExitTransition callback to determine the destination's popExit transition
+ * @param sizeTransform callback to determine the destination's sizeTransform.
+ * @param content composable for the destination
+ */
+public inline fun <reified T : Any> NavGraphBuilder.composable(
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    noinline enterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        null,
+    noinline exitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        null,
+    noinline popEnterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        enterTransition,
+    noinline popExitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        exitTransition,
+    noinline sizeTransform:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            SizeTransform?)? =
+        null,
+    noinline content: @Composable AnimatedContentScope.(NavBackStackEntry) -> Unit,
+) {
+    composable(
+        T::class,
+        typeMap,
+        deepLinks,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        sizeTransform,
+        content,
+    )
+}
+
+/**
+ * Add the [Composable] to the [NavGraphBuilder]
+ *
+ * @param route route from a [KClass] for the destination
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [route] does not use custom NavTypes.
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to determine the destination's enter transition
+ * @param exitTransition callback to determine the destination's exit transition
+ * @param popEnterTransition callback to determine the destination's popEnter transition
+ * @param popExitTransition callback to determine the destination's popExit transition
+ * @param sizeTransform callback to determine the destination's sizeTransform.
+ * @param content composable for the destination
+ */
+public fun <T : Any> NavGraphBuilder.composable(
+    route: KClass<T>,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    enterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        null,
+    exitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        null,
+    popEnterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        enterTransition,
+    popExitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        exitTransition,
+    sizeTransform:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            SizeTransform?)? =
+        null,
+    content: @Composable AnimatedContentScope.(NavBackStackEntry) -> Unit,
+) {
+    destination(
+        ComposeNavigatorDestinationBuilder(
+                provider[ComposeNavigator::class],
+                route,
+                typeMap,
+                content,
+            )
+            .apply {
+                deepLinks.forEach { deepLink -> deepLink(deepLink) }
+                this.enterTransition = enterTransition
+                this.exitTransition = exitTransition
+                this.popEnterTransition = popEnterTransition
+                this.popExitTransition = popExitTransition
+                this.sizeTransform = sizeTransform
+            }
+    )
+}
+
+/**
+ * Construct a nested [NavGraph]
+ *
+ * @sample androidx.navigation.compose.samples.NavWithArgsInNestedGraph
+ * @param startDestination the starting destination's route for this NavGraph
+ * @param route the destination's unique route
+ * @param arguments list of arguments to associate with destination
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param builder the builder used to construct the graph
+ */
+@Deprecated(
+    message = "Deprecated in favor of navigation builder that supports AnimatedContent",
+    level = DeprecationLevel.HIDDEN,
+)
+public fun NavGraphBuilder.navigation(
+    startDestination: String,
+    route: String,
+    arguments: List<NamedNavArgument> = emptyList(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    navigation(startDestination, route, arguments, deepLinks, null, null, null, null, null, builder)
+}
+
+/**
+ * Construct a nested [NavGraph]
+ *
+ * @param startDestination the starting destination's route for this NavGraph
+ * @param route the destination's unique route
+ * @param arguments list of arguments to associate with destination
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to define enter transitions for destination in this NavGraph
+ * @param exitTransition callback to define exit transitions for destination in this NavGraph
+ * @param popEnterTransition callback to define pop enter transitions for destination in this
+ *   NavGraph
+ * @param popExitTransition callback to define pop exit transitions for destination in this NavGraph
+ * @param builder the builder used to construct the graph
+ * @return the newly constructed nested NavGraph
+ */
+@Deprecated(
+    message = "Deprecated in favor of navigation builder that supports sizeTransform",
+    level = DeprecationLevel.HIDDEN,
+)
+public fun NavGraphBuilder.navigation(
+    startDestination: String,
+    route: String,
+    arguments: List<NamedNavArgument> = emptyList(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    enterTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        null,
+    exitTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        null,
+    popEnterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        enterTransition,
+    popExitTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        exitTransition,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    navigation(
+        startDestination,
+        route,
+        arguments,
+        deepLinks,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        null,
+        builder,
+    )
+}
+
+/**
+ * Construct a nested [NavGraph]
+ *
+ * @param startDestination the starting destination's route for this NavGraph
+ * @param route the destination's unique route
+ * @param arguments list of arguments to associate with destination
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to define enter transitions for destination in this NavGraph
+ * @param exitTransition callback to define exit transitions for destination in this NavGraph
+ * @param popEnterTransition callback to define pop enter transitions for destination in this
+ *   NavGraph
+ * @param popExitTransition callback to define pop exit transitions for destination in this NavGraph
+ * @param sizeTransform callback to define the size transform for destinations in this NavGraph
+ * @param builder the builder used to construct the graph
+ * @return the newly constructed nested NavGraph
+ */
+public fun NavGraphBuilder.navigation(
+    startDestination: String,
+    route: String,
+    arguments: List<NamedNavArgument> = emptyList(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        null,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        null,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition?)? =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition?)? =
+        exitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        null,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    addDestination(
+        NavGraphBuilder(provider, startDestination, route).apply(builder).build().apply {
+            arguments.forEach { (argumentName, argument) -> addArgument(argumentName, argument) }
+            deepLinks.forEach { deepLink -> addDeepLink(deepLink) }
+            if (this is ComposeNavGraphNavigator.ComposeNavGraph) {
+                this.enterTransition = enterTransition
+                this.exitTransition = exitTransition
+                this.popEnterTransition = popEnterTransition
+                this.popExitTransition = popExitTransition
+                this.sizeTransform = sizeTransform
+            }
+        }
+    )
+}
+
+/**
+ * Construct a nested [NavGraph]
+ *
+ * @param T the destination's unique route from a KClass
+ * @param startDestination the starting destination's route from [KClass] for this NavGraph
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [T] does not use custom NavTypes.
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to define enter transitions for destination in this NavGraph
+ * @param exitTransition callback to define exit transitions for destination in this NavGraph
+ * @param popEnterTransition callback to define pop enter transitions for destination in this
+ *   NavGraph
+ * @param popExitTransition callback to define pop exit transitions for destination in this NavGraph
+ * @param sizeTransform callback to define the size transform for destinations in this NavGraph
+ * @param builder the builder used to construct the graph
+ * @return the newly constructed nested NavGraph
+ * @sample androidx.navigation.compose.samples.SizeTransformNav
+ */
+public inline fun <reified T : Any> NavGraphBuilder.navigation(
+    startDestination: KClass<*>,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    noinline enterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        null,
+    noinline exitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        null,
+    noinline popEnterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        enterTransition,
+    noinline popExitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        exitTransition,
+    noinline sizeTransform:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            SizeTransform?)? =
+        null,
+    noinline builder: NavGraphBuilder.() -> Unit,
+) {
+    navigation(
+        startDestination,
+        T::class,
+        typeMap,
+        deepLinks,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        sizeTransform,
+        builder,
+    )
+}
+
+/**
+ * Construct a nested [NavGraph]
+ *
+ * @param route the destination's unique route from a KClass
+ * @param startDestination the starting destination's route from [KClass] for this NavGraph
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [route] does not use custom NavTypes.
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to define enter transitions for destination in this NavGraph
+ * @param exitTransition callback to define exit transitions for destination in this NavGraph
+ * @param popEnterTransition callback to define pop enter transitions for destination in this
+ *   NavGraph
+ * @param popExitTransition callback to define pop exit transitions for destination in this NavGraph
+ * @param sizeTransform callback to define the size transform for destinations in this NavGraph
+ * @param builder the builder used to construct the graph
+ * @return the newly constructed nested NavGraph
+ */
+public fun <T : Any> NavGraphBuilder.navigation(
+    startDestination: KClass<*>,
+    route: KClass<T>,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    enterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        null,
+    exitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        null,
+    popEnterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        enterTransition,
+    popExitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        exitTransition,
+    sizeTransform:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            SizeTransform?)? =
+        null,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    addDestination(
+        NavGraphBuilder(provider, startDestination, route, typeMap).apply(builder).build().apply {
+            deepLinks.forEach { deepLink -> addDeepLink(deepLink) }
+            if (this is ComposeNavGraphNavigator.ComposeNavGraph) {
+                this.enterTransition = enterTransition
+                this.exitTransition = exitTransition
+                this.popEnterTransition = popEnterTransition
+                this.popExitTransition = popExitTransition
+                this.sizeTransform = sizeTransform
+            }
+        }
+    )
+}
+
+/**
+ * Construct a nested [NavGraph]
+ *
+ * @param T the destination's unique route from a KClass
+ * @param startDestination the starting destination's route from an Object for this NavGraph
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [T] does not use custom NavTypes.
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to define enter transitions for destination in this NavGraph
+ * @param exitTransition callback to define exit transitions for destination in this NavGraph
+ * @param popEnterTransition callback to define pop enter transitions for destination in this
+ *   NavGraph
+ * @param popExitTransition callback to define pop exit transitions for destination in this NavGraph
+ * @param sizeTransform callback to define the size transform for destinations in this NavGraph
+ * @param builder the builder used to construct the graph
+ * @return the newly constructed nested NavGraph
+ */
+public inline fun <reified T : Any> NavGraphBuilder.navigation(
+    startDestination: Any,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    noinline enterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        null,
+    noinline exitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        null,
+    noinline popEnterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        enterTransition,
+    noinline popExitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        exitTransition,
+    noinline sizeTransform:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            SizeTransform?)? =
+        null,
+    noinline builder: NavGraphBuilder.() -> Unit,
+) {
+    navigation(
+        startDestination,
+        T::class,
+        typeMap,
+        deepLinks,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        sizeTransform,
+        builder,
+    )
+}
+
+/**
+ * Construct a nested [NavGraph]
+ *
+ * @param route the destination's unique route from a KClass
+ * @param startDestination the starting destination's route from an Object for this NavGraph
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [route] does not use custom NavTypes.
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param enterTransition callback to define enter transitions for destination in this NavGraph
+ * @param exitTransition callback to define exit transitions for destination in this NavGraph
+ * @param popEnterTransition callback to define pop enter transitions for destination in this
+ *   NavGraph
+ * @param popExitTransition callback to define pop exit transitions for destination in this NavGraph
+ * @param sizeTransform callback to define the size transform for destinations in this NavGraph
+ * @param builder the builder used to construct the graph
+ * @return the newly constructed nested NavGraph
+ */
+public fun <T : Any> NavGraphBuilder.navigation(
+    startDestination: Any,
+    route: KClass<T>,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    enterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        null,
+    exitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        null,
+    popEnterTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            EnterTransition?)? =
+        enterTransition,
+    popExitTransition:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            ExitTransition?)? =
+        exitTransition,
+    sizeTransform:
+        (AnimatedContentTransitionScope<NavBackStackEntry>.() -> @JvmSuppressWildcards
+            SizeTransform?)? =
+        null,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    addDestination(
+        NavGraphBuilder(provider, startDestination, route, typeMap).apply(builder).build().apply {
+            deepLinks.forEach { deepLink -> addDeepLink(deepLink) }
+            if (this is ComposeNavGraphNavigator.ComposeNavGraph) {
+                this.enterTransition = enterTransition
+                this.exitTransition = exitTransition
+                this.popEnterTransition = popEnterTransition
+                this.popExitTransition = popExitTransition
+                this.sizeTransform = sizeTransform
+            }
+        }
+    )
+}
+
+/**
+ * Add the [Composable] to the [NavGraphBuilder] that will be hosted within a
+ * [androidx.compose.ui.window.Dialog]. This is suitable only when this dialog represents a separate
+ * screen in your app that needs its own lifecycle and saved state, independent of any other
+ * destination in your navigation graph. For use cases such as `AlertDialog`, you should use those
+ * APIs directly in the [composable] destination that wants to show that dialog.
+ *
+ * @param route route for the destination
+ * @param arguments list of arguments to associate with destination
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param dialogProperties properties that should be passed to [androidx.compose.ui.window.Dialog].
+ * @param content composable content for the destination that will be hosted within the Dialog
+ */
+public fun NavGraphBuilder.dialog(
+    route: String,
+    arguments: List<NamedNavArgument> = emptyList(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    dialogProperties: DialogProperties = DialogProperties(),
+    content: @Composable (NavBackStackEntry) -> Unit,
+) {
+    destination(
+        DialogNavigatorDestinationBuilder(
+                provider[DialogNavigator::class],
+                route,
+                dialogProperties,
+                content,
+            )
+            .apply {
+                arguments.forEach { (argumentName, argument) -> argument(argumentName, argument) }
+                deepLinks.forEach { deepLink -> deepLink(deepLink) }
+            }
+    )
+}
+
+/**
+ * Add the [Composable] to the [NavGraphBuilder] that will be hosted within a
+ * [androidx.compose.ui.window.Dialog]. This is suitable only when this dialog represents a separate
+ * screen in your app that needs its own lifecycle and saved state, independent of any other
+ * destination in your navigation graph. For use cases such as `AlertDialog`, you should use those
+ * APIs directly in the [composable] destination that wants to show that dialog.
+ *
+ * @param T route from a KClass for the destination
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [T] does not use custom NavTypes.
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param dialogProperties properties that should be passed to [androidx.compose.ui.window.Dialog].
+ * @param content composable content for the destination that will be hosted within the Dialog
+ */
+public inline fun <reified T : Any> NavGraphBuilder.dialog(
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    dialogProperties: DialogProperties = DialogProperties(),
+    noinline content: @Composable (NavBackStackEntry) -> Unit,
+) {
+    dialog(T::class, typeMap, deepLinks, dialogProperties, content)
+}
+
+/**
+ * Add the [Composable] to the [NavGraphBuilder] that will be hosted within a
+ * [androidx.compose.ui.window.Dialog]. This is suitable only when this dialog represents a separate
+ * screen in your app that needs its own lifecycle and saved state, independent of any other
+ * destination in your navigation graph. For use cases such as `AlertDialog`, you should use those
+ * APIs directly in the [composable] destination that wants to show that dialog.
+ *
+ * @param route route from [KClass] of [T] for the destination
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [route] does not use custom NavTypes.
+ * @param deepLinks list of deep links to associate with the destinations
+ * @param dialogProperties properties that should be passed to [androidx.compose.ui.window.Dialog].
+ * @param content composable content for the destination that will be hosted within the Dialog
+ */
+public fun <T : Any> NavGraphBuilder.dialog(
+    route: KClass<T>,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    deepLinks: List<NavDeepLink> = emptyList(),
+    dialogProperties: DialogProperties = DialogProperties(),
+    content: @Composable (NavBackStackEntry) -> Unit,
+) {
+    destination(
+        DialogNavigatorDestinationBuilder(
+                provider[DialogNavigator::class],
+                route,
+                typeMap,
+                dialogProperties,
+                content,
+            )
+            .apply { deepLinks.forEach { deepLink -> deepLink(deepLink) } }
+    )
+}
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/NavHost.kt
+```kotlin
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose
+
+import androidx.collection.mutableObjectFloatMapOf
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.AnimatedContentTransitionScope
+import androidx.compose.animation.ContentTransform
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
+import androidx.compose.animation.SizeTransform
+import androidx.compose.animation.core.SeekableTransitionState
+import androidx.compose.animation.core.animate
+import androidx.compose.animation.core.rememberTransition
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.togetherWith
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveableStateHolder
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavDestination
+import androidx.navigation.NavDestination.Companion.hierarchy
+import androidx.navigation.NavGraph
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.NavHostController
+import androidx.navigation.NavType
+import androidx.navigation.Navigator
+import androidx.navigation.compose.internal.DefaultNavTransitions
+import androidx.navigation.compose.internal.PredictiveBackHandler
+import androidx.navigation.createGraph
+import androidx.navigation.get
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.jvm.JvmSuppressWildcards
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlinx.coroutines.launch
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The builder passed into this method is [remember]ed. This means that for this NavHost, the
+ * contents of the builder cannot be changed.
+ *
+ * @sample androidx.navigation.compose.samples.NavScaffold
+ * @param navController the navController for this host
+ * @param startDestination the route for the start destination
+ * @param modifier The modifier to be applied to the layout.
+ * @param route the route for the graph
+ * @param builder the builder used to construct the graph
+ */
+@Deprecated(
+    message = "Deprecated in favor of NavHost that supports AnimatedContent",
+    level = DeprecationLevel.HIDDEN,
+)
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    startDestination: String,
+    modifier: Modifier = Modifier,
+    route: String? = null,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    NavHost(
+        navController,
+        remember(route, startDestination, builder) {
+            navController.createGraph(startDestination, route, builder)
+        },
+        modifier,
+    )
+}
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The builder passed into this method is [remember]ed. This means that for this NavHost, the
+ * contents of the builder cannot be changed.
+ *
+ * @param navController the navController for this host
+ * @param startDestination the route for the start destination
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param route the route for the graph
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param builder the builder used to construct the graph
+ */
+@Deprecated(
+    message = "Deprecated in favor of NavHost that supports sizeTransform",
+    level = DeprecationLevel.HIDDEN,
+)
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    startDestination: String,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    route: String? = null,
+    enterTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    NavHost(
+        navController,
+        remember(route, startDestination, builder) {
+            navController.createGraph(startDestination, route, builder)
+        },
+        modifier,
+        contentAlignment,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+    )
+}
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The builder passed into this method is [remember]ed. This means that for this NavHost, the
+ * contents of the builder cannot be changed.
+ *
+ * @param navController the navController for this host
+ * @param startDestination the route for the start destination
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param route the route for the graph
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param sizeTransform callback to define the size transform for destinations in this host
+ * @param builder the builder used to construct the graph
+ */
+@Deprecated(
+    message =
+        "Deprecated in favor of NavHost that supports predictivePopEnterTransition and predictivePopExitTransition",
+    level = DeprecationLevel.HIDDEN,
+)
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    startDestination: String,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    route: String? = null,
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        DefaultNavTransitions.sizeTransform,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    NavHost(
+        navController,
+        startDestination,
+        modifier,
+        contentAlignment,
+        route,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        sizeTransform = sizeTransform,
+        builder = builder,
+    )
+}
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The builder passed into this method is [remember]ed. This means that for this NavHost, the
+ * contents of the builder cannot be changed.
+ *
+ * @param navController the navController for this host
+ * @param startDestination the route for the start destination
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param route the route for the graph
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param predictivePopEnterTransition callback to define predictivePopEnter transitions for
+ *   destination in this host
+ * @param predictivePopExitTransition callback to define predictivePopExit transitions for
+ *   destination in this host
+ * @param sizeTransform callback to define the size transform for destinations in this host
+ * @param builder the builder used to construct the graph
+ */
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    startDestination: String,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    route: String? = null,
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    predictivePopEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> EnterTransition) =
+        DefaultNavTransitions.predictivePopEnterTransition,
+    predictivePopExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> ExitTransition) =
+        DefaultNavTransitions.predictivePopExitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        DefaultNavTransitions.sizeTransform,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    NavHost(
+        navController,
+        remember(route, startDestination, builder) {
+            navController.createGraph(startDestination, route, builder)
+        },
+        modifier,
+        contentAlignment,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        predictivePopEnterTransition,
+        predictivePopExitTransition,
+        sizeTransform,
+    )
+}
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The builder passed into this method is [remember]ed. This means that for this NavHost, the
+ * contents of the builder cannot be changed.
+ *
+ * @param navController the navController for this host
+ * @param startDestination the route from a [KClass] for the start destination
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param route the route from a [KClass] for the graph
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [route] does not use custom NavTypes.
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param sizeTransform callback to define the size transform for destinations in this host
+ * @param builder the builder used to construct the graph
+ */
+@Deprecated(
+    message =
+        "Deprecated in favor of NavHost that supports predictivePopEnterTransition and predictivePopExitTransition",
+    level = DeprecationLevel.HIDDEN,
+)
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    startDestination: KClass<*>,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    route: KClass<*>? = null,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        DefaultNavTransitions.sizeTransform,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    NavHost(
+        navController,
+        startDestination,
+        modifier,
+        contentAlignment,
+        route,
+        typeMap,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        DefaultNavTransitions.predictivePopEnterTransition,
+        DefaultNavTransitions.predictivePopExitTransition,
+        sizeTransform,
+        builder,
+    )
+}
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The builder passed into this method is [remember]ed. This means that for this NavHost, the
+ * contents of the builder cannot be changed.
+ *
+ * @param navController the navController for this host
+ * @param startDestination the route from a [KClass] for the start destination
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param route the route from a [KClass] for the graph
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [route] does not use custom NavTypes.
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param predictivePopEnterTransition callback to define predictivePopEnter transitions for
+ *   destination in this host
+ * @param predictivePopExitTransition callback to define predictivePopExit transitions for
+ *   destination in this host
+ * @param sizeTransform callback to define the size transform for destinations in this host
+ * @param builder the builder used to construct the graph
+ */
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    startDestination: KClass<*>,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    route: KClass<*>? = null,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    predictivePopEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> EnterTransition) =
+        DefaultNavTransitions.predictivePopEnterTransition,
+    predictivePopExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> ExitTransition) =
+        DefaultNavTransitions.predictivePopExitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        DefaultNavTransitions.sizeTransform,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    NavHost(
+        navController,
+        remember(route, startDestination, builder) {
+            navController.createGraph(startDestination, route, typeMap, builder)
+        },
+        modifier,
+        contentAlignment,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        predictivePopEnterTransition,
+        predictivePopExitTransition,
+        sizeTransform,
+    )
+}
+
+/**
+ * Provides in place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The builder passed into this method is [remember]ed. This means that for this NavHost, the
+ * contents of the builder cannot be changed.
+ *
+ * @param navController the navController for this host
+ * @param startDestination the route from a an Object for the start destination
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param route the route from a [KClass] for the graph
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [route] does not use custom NavTypes.
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param sizeTransform callback to define the size transform for destinations in this host
+ * @param builder the builder used to construct the graph
+ */
+@Deprecated(
+    message =
+        "Deprecated in favor of NavHost that supports predictivePopEnterTransition and predictivePopExitTransition",
+    level = DeprecationLevel.HIDDEN,
+)
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    startDestination: Any,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    route: KClass<*>? = null,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        DefaultNavTransitions.sizeTransform,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    NavHost(
+        navController,
+        startDestination,
+        modifier,
+        contentAlignment,
+        route,
+        typeMap,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        DefaultNavTransitions.predictivePopEnterTransition,
+        DefaultNavTransitions.predictivePopExitTransition,
+        sizeTransform,
+        builder,
+    )
+}
+
+/**
+ * Provides in place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The builder passed into this method is [remember]ed. This means that for this NavHost, the
+ * contents of the builder cannot be changed.
+ *
+ * @param navController the navController for this host
+ * @param startDestination the route from a an Object for the start destination
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param route the route from a [KClass] for the graph
+ * @param typeMap map of destination arguments' kotlin type [KType] to its respective custom
+ *   [NavType]. May be empty if [route] does not use custom NavTypes.
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param predictivePopEnterTransition callback to define predictivePopEnter transitions for
+ *   destination in this host
+ * @param predictivePopExitTransition callback to define predictivePopExit transitions for
+ *   destination in this host
+ * @param sizeTransform callback to define the size transform for destinations in this host
+ * @param builder the builder used to construct the graph
+ */
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    startDestination: Any,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    route: KClass<*>? = null,
+    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    predictivePopEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> EnterTransition) =
+        DefaultNavTransitions.predictivePopEnterTransition,
+    predictivePopExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> ExitTransition) =
+        DefaultNavTransitions.predictivePopExitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        DefaultNavTransitions.sizeTransform,
+    builder: NavGraphBuilder.() -> Unit,
+) {
+    NavHost(
+        navController,
+        remember(route, startDestination, builder) {
+            navController.createGraph(startDestination, route, typeMap, builder)
+        },
+        modifier,
+        contentAlignment,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        predictivePopEnterTransition,
+        predictivePopExitTransition,
+        sizeTransform,
+    )
+}
+
+/**
+ * Provides in place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * The graph passed into this method is [remember]ed. This means that for this NavHost, the graph
+ * cannot be changed.
+ *
+ * @param navController the navController for this host
+ * @param graph the graph for this host
+ * @param modifier The modifier to be applied to the layout.
+ */
+@Deprecated(
+    message = "Deprecated in favor of NavHost that supports AnimatedContent",
+    level = DeprecationLevel.HIDDEN,
+)
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    graph: NavGraph,
+    modifier: Modifier = Modifier,
+): Unit = NavHost(navController, graph, modifier)
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * @param navController the navController for this host
+ * @param graph the graph for this host
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ */
+@Deprecated(
+    message = "Deprecated in favor of NavHost that supports sizeTransform",
+    level = DeprecationLevel.HIDDEN,
+)
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    graph: NavGraph,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    enterTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+) {
+    NavHost(
+        navController,
+        graph,
+        modifier,
+        contentAlignment,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        sizeTransform = null, // sizeTransform
+    )
+}
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * @param navController the navController for this host
+ * @param graph the graph for this host
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param sizeTransform callback to define the size transform for destinations in this host
+ */
+@Deprecated(
+    message =
+        "Deprecated in favor of NavHost that supports predictivePopEnterTransition and predictivePopExitTransition",
+    level = DeprecationLevel.HIDDEN,
+)
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    graph: NavGraph,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        DefaultNavTransitions.sizeTransform,
+) {
+    NavHost(
+        navController,
+        graph,
+        modifier,
+        contentAlignment,
+        enterTransition,
+        exitTransition,
+        popEnterTransition,
+        popExitTransition,
+        DefaultNavTransitions.predictivePopEnterTransition,
+        DefaultNavTransitions.predictivePopExitTransition,
+        sizeTransform,
+    )
+}
+
+/**
+ * Provides a place in the Compose hierarchy for self contained navigation to occur.
+ *
+ * Once this is called, any Composable within the given [NavGraphBuilder] can be navigated to from
+ * the provided [navController].
+ *
+ * @param navController the navController for this host
+ * @param graph the graph for this host
+ * @param modifier The modifier to be applied to the layout.
+ * @param contentAlignment The [Alignment] of the [AnimatedContent]
+ * @param enterTransition callback to define enter transitions for destination in this host
+ * @param exitTransition callback to define exit transitions for destination in this host
+ * @param popEnterTransition callback to define popEnter transitions for destination in this host
+ * @param popExitTransition callback to define popExit transitions for destination in this host
+ * @param predictivePopEnterTransition callback to define predictivePopEnter transitions for
+ *   destination in this host
+ * @param predictivePopExitTransition callback to define predictivePopExit transitions for
+ *   destination in this host
+ * @param sizeTransform callback to define the size transform for destinations in this host
+ */
+@Composable
+public fun NavHost(
+    navController: NavHostController,
+    graph: NavGraph,
+    modifier: Modifier = Modifier,
+    contentAlignment: Alignment = Alignment.TopStart,
+    enterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        DefaultNavTransitions.enterTransition,
+    exitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        DefaultNavTransitions.exitTransition,
+    popEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition) =
+        enterTransition,
+    popExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition) =
+        exitTransition,
+    predictivePopEnterTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> EnterTransition) =
+        DefaultNavTransitions.predictivePopEnterTransition,
+    predictivePopExitTransition:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> ExitTransition) =
+        DefaultNavTransitions.predictivePopExitTransition,
+    sizeTransform:
+        (@JvmSuppressWildcards
+        AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        DefaultNavTransitions.sizeTransform,
+) {
+
+    val lifecycleOwner = LocalLifecycleOwner.current
+    val viewModelStoreOwner =
+        checkNotNull(LocalViewModelStoreOwner.current) {
+            "NavHost requires a ViewModelStoreOwner to be provided via LocalViewModelStoreOwner"
+        }
+
+    navController.setViewModelStore(viewModelStoreOwner.viewModelStore)
+
+    // Then set the graph
+    navController.graph = graph
+
+    // Find the ComposeNavigator, returning early if it isn't found
+    // (such as is the case when using TestNavHostController)
+    val composeNavigator =
+        navController.navigatorProvider.get<Navigator<out NavDestination>>(ComposeNavigator.NAME)
+            as? ComposeNavigator ?: return
+
+    val currentBackStack by composeNavigator.backStack.collectAsState()
+
+    var progress by remember { mutableFloatStateOf(0f) }
+    var inPredictiveBack by remember { mutableStateOf(false) }
+    var swipeEdge by remember { mutableIntStateOf(0) }
+    PredictiveBackHandler(currentBackStack.size > 1) { backEvent ->
+        // This block handles the three phases of a predictive back gesture:
+        // 1. OnStarted: When the gesture begins.
+        // 2. OnProgressed: As the user drags their finger.
+        // 3. OnCompleted or OnCancelled: When the gesture finishes or is cancelled.
+        //
+        // Always guard with `currentBackStack.size > 1`:
+        // If `enabled` becomes stale (set false mid-frame while a gesture is in-flight),
+        // these checks prevent IndexOutOfBounds when accessing the stack.
+
+        var currentBackStackEntry: NavBackStackEntry? = null
+
+        // --- OnStarted ---
+        if (currentBackStack.size > 1) {
+            progress = 0f
+            currentBackStackEntry = currentBackStack.lastOrNull()
+            composeNavigator.prepareForTransition(currentBackStackEntry!!)
+            val previousEntry = currentBackStack[currentBackStack.size - 2]
+            composeNavigator.prepareForTransition(previousEntry)
+        }
+        try {
+            backEvent.collect {
+                // --- OnProgressed ---
+                if (currentBackStack.size > 1) {
+                    inPredictiveBack = true
+                    progress = it.progress
+                    swipeEdge = it.swipeEdge
+                }
+            }
+            // --- OnCompleted ---
+            if (currentBackStack.size > 1) {
+                inPredictiveBack = false
+                composeNavigator.popBackStack(currentBackStackEntry!!, false)
+            }
+        } catch (_: CancellationException) {
+            // --- OnCancelled ---
+            if (currentBackStack.size > 1) {
+                inPredictiveBack = false
+            }
+        }
+    }
+
+    DisposableEffect(lifecycleOwner) {
+        // Setup the navController with proper owners
+        navController.setLifecycleOwner(lifecycleOwner)
+        onDispose {}
+    }
+
+    val saveableStateHolder = rememberSaveableStateHolder()
+
+    val allVisibleEntries by navController.visibleEntries.collectAsState()
+
+    // Intercept back only when there's a destination to pop
+    val visibleEntries by remember {
+        derivedStateOf {
+            allVisibleEntries.filter { entry ->
+                entry.destination.navigatorName == ComposeNavigator.NAME
+            }
+        }
+    }
+
+    val backStackEntry: NavBackStackEntry? = visibleEntries.lastOrNull()
+
+    val zIndices = remember { mutableObjectFloatMapOf<String>() }
+
+    if (backStackEntry != null) {
+        val finalEnter: AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition = {
+            val targetDestination = targetState.destination as ComposeNavigator.Destination
+
+            if (inPredictiveBack) {
+                targetDestination.hierarchy.firstNotNullOfOrNull { destination ->
+                    destination.createPredictivePopEnterTransition(this, swipeEdge)
+                } ?: predictivePopEnterTransition.invoke(this, swipeEdge)
+            } else if (composeNavigator.isPop.value) {
+                targetDestination.hierarchy.firstNotNullOfOrNull { destination ->
+                    destination.createPopEnterTransition(this)
+                } ?: popEnterTransition.invoke(this)
+            } else {
+                targetDestination.hierarchy.firstNotNullOfOrNull { destination ->
+                    destination.createEnterTransition(this)
+                } ?: enterTransition.invoke(this)
+            }
+        }
+
+        val finalExit: AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition = {
+            val initialDestination = initialState.destination as ComposeNavigator.Destination
+
+            if (inPredictiveBack) {
+                initialDestination.hierarchy.firstNotNullOfOrNull { destination ->
+                    destination.createPredictivePopExitTransition(this, swipeEdge)
+                } ?: predictivePopExitTransition.invoke(this, swipeEdge)
+            } else if (composeNavigator.isPop.value) {
+                initialDestination.hierarchy.firstNotNullOfOrNull { destination ->
+                    destination.createPopExitTransition(this)
+                } ?: popExitTransition.invoke(this)
+            } else {
+                initialDestination.hierarchy.firstNotNullOfOrNull { destination ->
+                    destination.createExitTransition(this)
+                } ?: exitTransition.invoke(this)
+            }
+        }
+
+        val finalSizeTransform:
+            AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform? =
+            {
+                val targetDestination = targetState.destination as ComposeNavigator.Destination
+
+                targetDestination.hierarchy.firstNotNullOfOrNull { destination ->
+                    destination.createSizeTransform(this)
+                } ?: sizeTransform?.invoke(this)
+            }
+
+        DisposableEffect(true) {
+            onDispose {
+                visibleEntries.forEach { entry -> composeNavigator.onTransitionComplete(entry) }
+            }
+        }
+
+        val transitionState = remember {
+            // The state returned here cannot be nullable cause it produces the input of the
+            // transitionSpec passed into the AnimatedContent and that must match the non-nullable
+            // scope exposed by the transitions on the NavHost and composable APIs.
+            SeekableTransitionState(backStackEntry)
+        }
+
+        val transition = rememberTransition(transitionState, label = "entry")
+
+        if (inPredictiveBack) {
+            LaunchedEffect(progress) {
+                // Update transition progress safely (same guard against stale enabled state).
+                if (currentBackStack.size > 1) {
+                    val previousEntry = currentBackStack[currentBackStack.size - 2]
+                    transitionState.seekTo(progress, previousEntry)
+                }
+            }
+        } else {
+            LaunchedEffect(backStackEntry) {
+                // This ensures we don't animate after the back gesture is cancelled and we
+                // are already on the current state
+                if (transitionState.currentState != backStackEntry) {
+                    transitionState.animateTo(backStackEntry)
+                } else {
+                    // convert from nanoseconds to milliseconds
+                    val totalDuration = transition.totalDurationNanos / 1000000
+                    // When the predictive back gesture is cancel, we need to manually animate
+                    // the SeekableTransitionState from where it left off, to zero and then
+                    // snapTo the final position.
+                    animate(
+                        transitionState.fraction,
+                        0f,
+                        animationSpec = tween((transitionState.fraction * totalDuration).toInt()),
+                    ) { value, _ ->
+                        this@LaunchedEffect.launch {
+                            if (value > 0) {
+                                // Seek the original transition back to the currentState
+                                transitionState.seekTo(value)
+                            }
+                            if (value == 0f) {
+                                // Once we animate to the start, we need to snap to the right state.
+                                transitionState.snapTo(backStackEntry)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        transition.AnimatedContent(
+            modifier,
+            transitionSpec = {
+                // If the initialState of the AnimatedContent is not in visibleEntries, we are in
+                // a case where visible has cleared the old state for some reason, so instead of
+                // attempting to animate away from the initialState, we skip the animation.
+                if (initialState in visibleEntries) {
+                    val initialZIndex = zIndices.getOrPut(initialState.id) { 0f }
+                    val targetZIndex =
+                        when {
+                            targetState.id == initialState.id -> initialZIndex
+                            composeNavigator.isPop.value || inPredictiveBack -> initialZIndex - 1f
+                            else -> initialZIndex + 1f
+                        }
+                    zIndices[targetState.id] = targetZIndex
+
+                    ContentTransform(
+                        finalEnter(this),
+                        finalExit(this),
+                        targetZIndex,
+                        finalSizeTransform(this),
+                    )
+                } else {
+                    EnterTransition.None togetherWith ExitTransition.None
+                }
+            },
+            contentAlignment,
+            contentKey = { it.id },
+        ) {
+            // In some specific cases, such as clearing your back stack by changing your
+            // start destination, AnimatedContent can contain an entry that is no longer
+            // part of visible entries since it was cleared from the back stack and is not
+            // animating. In these cases the currentEntry will be null, and in those cases,
+            // AnimatedContent will just skip attempting to transition the old entry.
+            // See https://issuetracker.google.com/238686802
+            val isPredictiveBackCancelAnimation = transitionState.currentState == backStackEntry
+            val currentEntry =
+                if (inPredictiveBack || isPredictiveBackCancelAnimation) {
+                    // We have to do this because the previous entry does not show up in
+                    // visibleEntries
+                    // even if we prepare it above as part of onBackStackChangeStarted
+                    it
+                } else {
+                    visibleEntries.lastOrNull { entry -> it == entry }
+                }
+
+            // while in the scope of the composable, we provide the navBackStackEntry as the
+            // ViewModelStoreOwner and LifecycleOwner
+            currentEntry?.LocalOwnersProvider(saveableStateHolder) {
+                (currentEntry.destination as ComposeNavigator.Destination).content(
+                    this,
+                    currentEntry,
+                )
+            }
+        }
+        LaunchedEffect(transition.currentState, transition.targetState) {
+            if (
+                transition.currentState == transition.targetState &&
+                    // There is a race condition where previous animation has completed the new
+                    // animation has yet to start and there is a navigate call before this effect.
+                    // We need to make sure we are completing only when the start is settled on the
+                    // actual entry.
+                    (navController.currentBackStackEntry == null ||
+                        transition.targetState == backStackEntry)
+            ) {
+                visibleEntries.forEach { entry -> composeNavigator.onTransitionComplete(entry) }
+                zIndices.removeIf { key, _ -> key != transition.targetState.id }
+            }
+        }
+    }
+
+    val dialogNavigator =
+        navController.navigatorProvider.get<Navigator<out NavDestination>>(DialogNavigator.NAME)
+            as? DialogNavigator ?: return
+
+    // Show any dialog destinations
+    DialogHost(dialogNavigator)
+}
+
+private fun NavDestination.createEnterTransition(
+    scope: AnimatedContentTransitionScope<NavBackStackEntry>
+): EnterTransition? =
+    when (this) {
+        is ComposeNavigator.Destination -> this.enterTransition?.invoke(scope)
+        is ComposeNavGraphNavigator.ComposeNavGraph -> this.enterTransition?.invoke(scope)
+        else -> null
+    }
+
+private fun NavDestination.createExitTransition(
+    scope: AnimatedContentTransitionScope<NavBackStackEntry>
+): ExitTransition? =
+    when (this) {
+        is ComposeNavigator.Destination -> this.exitTransition?.invoke(scope)
+        is ComposeNavGraphNavigator.ComposeNavGraph -> this.exitTransition?.invoke(scope)
+        else -> null
+    }
+
+private fun NavDestination.createPopEnterTransition(
+    scope: AnimatedContentTransitionScope<NavBackStackEntry>
+): EnterTransition? =
+    when (this) {
+        is ComposeNavigator.Destination -> this.popEnterTransition?.invoke(scope)
+        is ComposeNavGraphNavigator.ComposeNavGraph -> this.popEnterTransition?.invoke(scope)
+        else -> null
+    }
+
+private fun NavDestination.createPopExitTransition(
+    scope: AnimatedContentTransitionScope<NavBackStackEntry>
+): ExitTransition? =
+    when (this) {
+        is ComposeNavigator.Destination -> this.popExitTransition?.invoke(scope)
+        is ComposeNavGraphNavigator.ComposeNavGraph -> this.popExitTransition?.invoke(scope)
+        else -> null
+    }
+
+private fun NavDestination.createPredictivePopEnterTransition(
+    scope: AnimatedContentTransitionScope<NavBackStackEntry>,
+    swipeEdge: Int,
+): EnterTransition? =
+    when (this) {
+        is ComposeNavigator.Destination ->
+            this.predictivePopEnterTransition?.invoke(scope, swipeEdge)
+        is ComposeNavGraphNavigator.ComposeNavGraph ->
+            this.predictivePopEnterTransition?.invoke(scope, swipeEdge)
+        else -> null
+    }
+
+private fun NavDestination.createPredictivePopExitTransition(
+    scope: AnimatedContentTransitionScope<NavBackStackEntry>,
+    swipeEdge: Int,
+): ExitTransition? =
+    when (this) {
+        is ComposeNavigator.Destination ->
+            this.predictivePopExitTransition?.invoke(scope, swipeEdge)
+        is ComposeNavGraphNavigator.ComposeNavGraph ->
+            this.predictivePopExitTransition?.invoke(scope, swipeEdge)
+        else -> null
+    }
+
+private fun NavDestination.createSizeTransform(
+    scope: AnimatedContentTransitionScope<NavBackStackEntry>
+): SizeTransform? =
+    when (this) {
+        is ComposeNavigator.Destination -> this.sizeTransform?.invoke(scope)
+        is ComposeNavGraphNavigator.ComposeNavGraph -> this.sizeTransform?.invoke(scope)
+        else -> null
+    }
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/NavHostController.kt
+```kotlin
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:JvmName("NavHostControllerKt")
+@file:JvmMultifileClass
+
+package androidx.navigation.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.State
+import androidx.compose.runtime.collectAsState
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavController
+import androidx.navigation.NavDestination
+import androidx.navigation.NavHostController
+import androidx.navigation.Navigator
+import kotlin.jvm.JvmMultifileClass
+import kotlin.jvm.JvmName
+
+/**
+ * Gets the current navigation back stack entry as a [MutableState]. When the given navController
+ * changes the back stack due to a [NavController.navigate] or [NavController.popBackStack] this
+ * will trigger a recompose and return the top entry on the back stack.
+ *
+ * @return a mutable state of the current back stack entry
+ */
+@Composable
+public fun NavController.currentBackStackEntryAsState(): State<NavBackStackEntry?> {
+    return currentBackStackEntryFlow.collectAsState(null)
+}
+
+/**
+ * Creates a NavHostController that handles the adding of the [ComposeNavigator] and
+ * [DialogNavigator]. Additional [Navigator] instances can be passed through [navigators] to be
+ * applied to the returned NavController. Note that each [Navigator] must be separately remembered
+ * before being passed in here: any changes to those inputs will cause the NavController to be
+ * recreated.
+ *
+ * @see NavHost
+ */
+@Composable
+public expect fun rememberNavController(
+    vararg navigators: Navigator<out NavDestination>
+): NavHostController
+```
+
+## File: navigation/navigation-compose/src/commonMain/kotlin/androidx/navigation/compose/internal/NavComposeUtils.kt
+```kotlin
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigation.compose.internal
+
+import androidx.compose.animation.AnimatedContentTransitionScope
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
+import androidx.compose.animation.SizeTransform
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.scaleOut
+import androidx.compose.runtime.Composable
+import androidx.navigation.NavBackStackEntry
+import kotlinx.coroutines.flow.Flow
+
+internal expect class BackEventCompat {
+    val touchX: Float
+    val touchY: Float
+    val progress: Float
+    val swipeEdge: Int
+}
+
+@Composable
+internal expect fun PredictiveBackHandler(
+    enabled: Boolean = true,
+    onBack: suspend (progress: Flow<BackEventCompat>) -> Unit,
+)
+
+internal expect fun randomUUID(): String
+
+/**
+ * Class WeakReference encapsulates weak reference to an object, which could be used to either
+ * retrieve a strong reference to an object, or return null, if object was already destroyed by the
+ * memory manager.
+ */
+internal expect class WeakReference<T : Any>(reference: T) {
+    fun get(): T?
+
+    fun clear()
+}
+
+internal expect object DefaultNavTransitions {
+    val enterTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition
+    val exitTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition
+    val predictivePopEnterTransition:
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> EnterTransition
+    val predictivePopExitTransition:
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> ExitTransition
+    val sizeTransform: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)?
+}
+
+internal object StandardDefaultNavTransitions {
+    val enterTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition = {
+        fadeIn(animationSpec = tween(700))
+    }
+    val exitTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition = {
+        fadeOut(animationSpec = tween(700))
+    }
+    val predictivePopEnterTransition:
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> EnterTransition =
+        {
+            fadeIn(
+                spring(
+                    dampingRatio = 1.0f, // reflects material3 motionScheme.defaultEffectsSpec()
+                    stiffness = 1600.0f, // reflects material3 motionScheme.defaultEffectsSpec()
+                )
+            )
+        }
+    val predictivePopExitTransition:
+        AnimatedContentTransitionScope<NavBackStackEntry>.(Int) -> ExitTransition =
+        {
+            scaleOut(targetScale = 0.7f) // reflects material3 motionScheme.defaultEffectsSpec()
+        }
+    val sizeTransform: (AnimatedContentTransitionScope<NavBackStackEntry>.() -> SizeTransform?)? =
+        null
+}
+```
+