Changes from test app

Author: stagg

backstack/src/commonMain/kotlin/com/slack/circuit/backstack/BackStack.kt

@@ -35,6 +35,9 @@ public interface BackStack<R : Record> : Iterable<R> {
   /** The top-most record in the [BackStack], or `null` if the [BackStack] is empty. */
   public val topRecord: R?
 
+  /** The bottom-most record in the [BackStack], or `null` if the [BackStack] is empty. */
+  public val rootRecord: R?
+
   /**
    * Push a new [Record] onto the back stack. The new record will become the top of the stack.
    *
@@ -103,6 +106,20 @@ public interface BackStack<R : Record> : Iterable<R> {
    */
   public fun containsRecord(record: R, includeSaved: Boolean): Boolean
 
+  /**
+   * Whether a record with the given [key] is reachable within the back stack or saved state.
+   * Reachable means that it is either currently in the visible back stack or if we popped `depth`
+   * times, it would be found.
+   *
+   * @param key The record's key to look for.
+   * @param depth How many records to consider popping from the top of the stack before considering
+   *   the key unreachable. A depth of zero means only check the current visible stack. A depth of 1
+   *   means check the current visible stack plus one record popped off the top, and so on.
+   * @param includeSaved Whether to also check if the record is contained by any saved back stack
+   *   state. See [saveState].
+   */
+  public fun isRecordReachable(key: String, depth: Int, includeSaved: Boolean): Boolean
+
   @Stable
   public interface Record {
     /**

backstack/src/commonMain/kotlin/com/slack/circuit/backstack/SaveableBackStack.kt

@@ -24,6 +24,7 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.snapshots.Snapshot
 import com.slack.circuit.runtime.screen.PopResult
 import com.slack.circuit.runtime.screen.Screen
+import kotlin.math.min
 import kotlin.uuid.ExperimentalUuidApi
 import kotlin.uuid.Uuid
 import kotlinx.coroutines.CompletableDeferred
@@ -92,6 +93,9 @@ internal constructor(
   public override val topRecord: Record?
     get() = entryList.firstOrNull()
 
+  override val rootRecord: Record?
+    get() = entryList.lastOrNull()
+
   public override fun push(screen: Screen, resultKey: String?): Boolean {
     return push(screen, emptyMap(), resultKey)
   }
@@ -154,6 +158,24 @@ internal constructor(
     return false
   }
 
+  override fun isRecordReachable(key: String, depth: Int, includeSaved: Boolean): Boolean {
+    if (depth < 0) return false
+    // Check in the current entry list
+    for (i in 0 until min(depth, entryList.size)) {
+      if (entryList[i].key == key) return true
+    }
+    // If includeSaved, check saved backstack states too
+    if (includeSaved && stateStore.isNotEmpty()) {
+      val storedValues = stateStore.values
+      for ((i, stored) in storedValues.withIndex()) {
+        if (i >= depth) break
+        // stored can mutate, so safely get the record.
+        if (stored.getOrNull(i)?.key == key) return true
+      }
+    }
+    return false
+  }
+
   public data class Record(
     override val screen: Screen,
     val args: Map<String, Any?> = emptyMap(),

circuit-foundation/src/commonMain/kotlin/com/slack/circuit/foundation/NavigableCircuitContent.kt

@@ -32,6 +32,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.movableContentOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.saveable.SaveableStateHolder
 import androidx.compose.runtime.saveable.rememberSaveableStateHolder
 import androidx.compose.runtime.setValue
@@ -193,14 +194,22 @@ private fun <R : Record> buildCircuitContentProviders(
   val recordKeys by
     remember { mutableStateOf(persistentSetOf<String>()) }
       .apply { value = backStack.map { it.key }.toPersistentSet() }
+  val latestBackStack by rememberUpdatedState(backStack)
   DisposableEffect(recordKeys) {
     // Delay cleanup until the next backstack change.
-    val contentNotInBackStack = previousContentProviders.keys.toSet() - recordKeys
+    val contentNotInBackStack =
+      previousContentProviders.keys.filterNot {
+        latestBackStack.isRecordReachable(key = it, depth = 1, includeSaved = true) ||
+          it in activeRecordKeys
+      }
     onDispose {
       // Only remove the keys that are no longer in the backstack or composition.
-      (contentNotInBackStack - recordKeys - activeRecordKeys).forEach {
-        previousContentProviders.remove(it)
-      }
+      contentNotInBackStack
+        .filterNot {
+          latestBackStack.isRecordReachable(key = it, depth = 1, includeSaved = true) ||
+            it in activeRecordKeys
+        }
+        .forEach { previousContentProviders.remove(it) }
     }
   }
   return backStack