data class BTypeEntry(
  var identifier: BTypeIdentifier,
  var lookAndFeel: String = "",
  var durationInMinutes: Int = 0,
  var previousBEvent: BTypeIdentifier? = null,
  var associatedAEvent: ATypeIdentifier? = null,
  var lastIEvent: ITypeIdentifier? = null,

//like 10 more fields here, but stuff like strings, ints.
):EventLogEntry() {}

"Deeper view when saved"

findNavController().previousBackStackEntry?.savedStateHandle?.set("key", data)
findNavController().popBackStack()

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    findNavController().currentBackStackEntry?.savedStateHandle?.getLiveData<String>("key")?.observe(viewLifecycleOwner) { data ->
        // Do something with the data.
    }
}

navigation(startDestination = "/EntryEditor/BTypeEditor?entryId=${logEntryId}&parentId={parentId}", route="creation_flow") {
  composable ("/EntryEditor/BTypeEditor?entryId=${logEntryId}&parentId={parentId}") {
    val existing = it.arguments?.getString(logEntryIdentifierName)
    val parentId = it.arguments?.getString("parentId")
    // This is how each destination gains access to the parent navigation graph entry
    val parentEntry = remember {
      navController.getBackStackEntry("creation_flow")
    }
    // And this ViewModel would be the same one from each destination
    // You'd use viewModel instead of hiltViewModel if you weren't using Hilt
    val creationFlowViewModel = hiltViewModel<CreationFlowViewModel>(
      parentEntry
    )
    // Gets the existing entry using existing or creates a new one that has a parentId
    // If both are null, we're on the root of a brand new BType
    val bType = creationFlowViewModel.getOrCreateBType(exiting, parentId)
    EventEditorBType(navController = navController, bType,
      onSaved = { updatedBType ->
        creationFlowViewModel.save(updatedBType)
      },
      onCreateNestedAType = {
        // Navigate to the ATypeEditor, passing in this BType's ID as the parentId
        navController.navigate("/EntryEditor/ATypeEditor?parentId={bType.id}")
    )
}

CreationFlowViewModel

@HiltViewModel
class CreationFlowViewModel @Inject constructor(
    private val eventStoreModel: EventStoreModel
) : ViewModel() {
  // You probably want a better data type than this :)
  val tempBTypeStore = mapOf<String, BType>()
  val tempBTypeParentMap = mapOf<String, String>()

  fun getOrCreateBType(existing: String?, parentid: String?): BType {
    if (existing != null) {
      val existingBType = eventStoreModel.getBType(existing)
      if (existingBType != null) {
        return existingBType;
      }
    }
    val newBType = BType(UUID.randomUUID())
    if (parentId != null) {
      tempBTypeParentMap[newBType.id] = parentId
    }
    tempBTypeStore[newBType.id] = newBType
    return newBType
  }

  fun save(bType: BType) {
    val existing = eventStoreModel.getBType(existing)
    if (existing != null) {
      // This is an edit case, we can directly save it
      eventStoreModel.update(bType)
    } else {
      if (tempBTypeParent[bType.id] == null) {
        // This is the root item being saved, so we
        // can save the BType - ideally, your better data
        // structure can do this efficiently
        eventStoreModel.add(bType)
      } else {
        // This isn't the root node, so we just update
        // our temp copy
        tempBTypeStore[bType.id] = bType
      }
    }
  }
}