General: Stabilize multi-select with a per-id SelectionState holder

Replace rememberSelection<T>() (MutableState<Set<T>>) with a @stable
SelectionState<T> holder exposing per-id membership via @composable
isSelected(id) backed by derivedStateOf, plus isActive/count as
derivedStateOf. Toggling one row now recomposes only that row instead of
the whole visible window: previously every visible item subscribed to the
single Set state and re-ran its leaf work (thumbnails, file-size/date
formatting, plurals) on every toggle.

Migrated all 13 call sites across corpsefinder, systemcleaner,
deduplicator, analyzer, squeezer, appcontrol, appcleaner, exclusion and
swiper. Screen-scope aggregate reads (Squeezer savings, Analyzer
selected-items/none-inaccessible) moved into their top-bar composables so
they no longer re-invalidate the list. Container composables
(CorpseContent, AppJunkPage, FilterContentPage, ClusterContent) now take
the holder. AppControl pendingExportIds migrated too, so the old helper
could be deleted.

Deduplicator details: preserved the keep-one delete cap on
toggle/long-press/select-all, and additionally re-apply it after the prune
so a cluster shrinking under a held selection (or a restored selection
against a smaller cluster) can no longer let a delete take the whole
cluster.

Adds SelectionState unit tests plus a Robolectric recomposition-isolation
test proving a steady-active toggle recomposes only the toggled row.

Author: d4rken

app-common-exclusion/src/main/java/eu/darken/sdmse/exclusion/ui/list/ExclusionListScreen.kt

@@ -58,7 +58,7 @@ import eu.darken.sdmse.common.compose.layout.SdmTooltipIconButton
 import eu.darken.sdmse.common.compose.layout.SdmTopAppBar
 import eu.darken.sdmse.common.compose.preview.Preview2
 import eu.darken.sdmse.common.compose.preview.PreviewWrapper
-import eu.darken.sdmse.common.compose.selection.rememberSelection
+import eu.darken.sdmse.common.compose.selection.rememberSelectionState
 import eu.darken.sdmse.common.error.ErrorEventHandler
 import eu.darken.sdmse.common.exclusion.R
 import eu.darken.sdmse.common.navigation.NavigationEventHandler
@@ -196,19 +196,20 @@ internal fun ExclusionListScreen(
     // back via the Undo snackbar or "Reset defaults". So "Select all" covers every row.
     val selectableIds = currentIds
 
-    var selection by rememberSelection<ExclusionId>()
+    val selection = rememberSelectionState<ExclusionId>()
     // Prune stale IDs when the underlying list changes.
-    LaunchedEffect(currentIds) { selection = selection intersect currentIds }
+    LaunchedEffect(currentIds) { selection.retainAll(currentIds) }
+    val selectionActive = selection.isActive
 
     var overflowExpanded by remember { mutableStateOf(false) }
     var infoOpen by rememberSaveable { mutableStateOf(false) }
 
-    BackHandler(enabled = selection.isNotEmpty()) { selection = emptySet() }
+    BackHandler(enabled = selectionActive) { selection.clear() }
 
     SdmScaffold(
         snackbarHost = { SnackbarHost(snackbarHostState) },
         topBar = {
-            if (selection.isEmpty()) {
+            if (!selectionActive) {
                 SdmTopAppBar(
                     title = stringResource(R.string.exclusion_manager_title),
                     onNavigateUp = onNavigateUp,
@@ -264,31 +265,33 @@ internal fun ExclusionListScreen(
                 )
             } else {
                 SdmSelectionTopAppBar(
-                    selectedCount = selection.size,
-                    onClearSelection = { selection = emptySet() },
+                    selectedCount = selection.count,
+                    onClearSelection = { selection.clear() },
                     actions = {
                         SdmTooltipIconButton(
                             icon = Icons.TwoTone.FileUpload,
                             label = stringResource(R.string.exclusion_export_action),
                             onClick = {
-                                onExportSelected(selection.toSet())
-                                selection = emptySet()
+                                val ids = selection.selected
+                                selection.clear()
+                                onExportSelected(ids)
                             },
                         )
                         SdmDeleteAction(onClick = {
-                            onRemoveSelected(selection.toSet())
-                            selection = emptySet()
+                            val ids = selection.selected
+                            selection.clear()
+                            onRemoveSelected(ids)
                         })
                         SdmSelectAllAction(
-                            visible = selection.size < selectableIds.size,
-                            onClick = { selection = selectableIds },
+                            visible = selection.count < selectableIds.size,
+                            onClick = { selection.setSelection(selectableIds) },
                         )
                     },
                 )
             }
         },
         floatingActionButton = {
-            if (selection.isEmpty()) {
+            if (!selectionActive) {
                 FloatingActionButton(onClick = onAddExclusion) {
                     Icon(Icons.TwoTone.Add, contentDescription = stringResource(R.string.exclusion_create_action))
                 }
@@ -309,16 +312,16 @@ internal fun ExclusionListScreen(
 
                 else -> LazyColumn(modifier = Modifier.fillMaxSize()) {
                     items(rows, key = { it.stableId }) { row ->
-                        val isSelected = selection.contains(row.stableId)
+                        val isSelected = selection.isSelected(row.stableId)
                         val onRowTap = {
-                            if (selection.isNotEmpty()) {
-                                selection = selection.toggle(row.stableId)
+                            if (selection.isActive) {
+                                selection.toggle(row.stableId)
                             } else {
                                 onRowClick(row)
                             }
                         }
                         val onRowLongPress = {
-                            selection = selection.toggle(row.stableId)
+                            selection.toggle(row.stableId)
                         }
                         when (row) {
                             is ExclusionListViewModel.Row.Pkg -> PkgExclusionRow(
@@ -406,9 +409,6 @@ private fun ExclusionEmptyState(
     )
 }
 
-private fun Set<ExclusionId>.toggle(id: ExclusionId): Set<ExclusionId> =
-    if (contains(id)) this - id else this + id
-
 @Preview2
 @Composable
 private fun ExclusionListScreenEmptyPreview() {

app-common-ui/src/main/java/eu/darken/sdmse/common/compose/selection/RememberSelection.kt

@@ -0,0 +1,104 @@
+package eu.darken.sdmse.common.compose.selection
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.listSaver
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+
+/**
+ * Multi-selection state for tool list/detail screens, designed so that toggling a single row only
+ * recomposes that row instead of the whole visible window.
+ *
+ * The previous helper handed out a raw `MutableState<Set<T>>`, and screens read `selection.contains(id)`
+ * and `selection.isNotEmpty()` directly inside their `items {}` lambda. Every visible item then subscribed
+ * to the one set state, so a single toggle invalidated every item and re-ran its expensive leaf work
+ * (thumbnails, file-size/date formatting, plurals). This holder replaces that pattern:
+ *
+ * - [isSelected] exposes per-id membership as a `derivedStateOf`, so only rows whose membership actually
+ *   flips recompose. This isolation holds while selection is already active; entering selection mode
+ *   (first item) or clearing the last item flips [isActive] and legitimately recomposes every row that
+ *   reacts to selection mode.
+ * - [isActive] and [count] are `derivedStateOf`, so a container or top bar reading them only recomposes on
+ *   the empty<->non-empty transition / count change, not on every toggle.
+ *
+ * Backed by [rememberSelectionState] / [rememberSaveable] so it survives configuration changes and process
+ * death (every selection id type is Bundle-saveable, as with the prior helper).
+ */
+@Stable
+class SelectionState<T : Any>(initial: Set<T> = emptySet()) {
+
+    // Defensive copy: never alias a caller's (possibly mutable) set into snapshot state.
+    private var _selected by mutableStateOf(initial.toSet())
+
+    /**
+     * Snapshot of the current selection. Reading this subscribes to ANY selection change, so use it at
+     * event time (action callbacks, click handlers) — not to derive per-row UI during composition, which
+     * would reintroduce the whole-list invalidation this holder exists to avoid.
+     */
+    val selected: Set<T> get() = _selected
+
+    /** `true` while anything is selected. Notifies only on the empty <-> non-empty transition. */
+    val isActive: Boolean by derivedStateOf { _selected.isNotEmpty() }
+
+    /** Number of selected items. Notifies only when the count changes (e.g. top-bar "N selected"). */
+    val count: Int by derivedStateOf { _selected.size }
+
+    /**
+     * Per-id membership as a Compose-isolated read. Only rows whose membership flips recompose.
+     * Must be called from composable scope (e.g. inside a Lazy item).
+     */
+    @Composable
+    fun isSelected(id: T): Boolean {
+        val state = remember(this, id) { derivedStateOf { id in _selected } }
+        return state.value
+    }
+
+    /**
+     * Event-time membership check (click handlers). Does NOT create a composition subscription — do not
+     * call this in composition to derive per-row state; use [isSelected] there.
+     */
+    fun contains(id: T): Boolean = id in _selected
+
+    fun toggle(id: T) {
+        _selected = if (id in _selected) _selected - id else _selected + id
+    }
+
+    fun select(id: T) {
+        _selected = _selected + id
+    }
+
+    fun deselect(id: T) {
+        _selected = _selected - id
+    }
+
+    fun setSelection(ids: Set<T>) {
+        _selected = ids.toSet()
+    }
+
+    fun clear() {
+        _selected = emptySet()
+    }
+
+    /** Drop ids that are no longer present (replaces the prune `intersect`); skips a no-op write. */
+    fun retainAll(ids: Set<T>) {
+        val next = _selected intersect ids
+        if (next.size != _selected.size) _selected = next
+    }
+
+    companion object {
+        fun <T : Any> saver() = listSaver<SelectionState<T>, T>(
+            save = { it._selected.toList() },
+            restore = { SelectionState(it.toSet()) },
+        )
+    }
+}
+
+@Composable
+fun <T : Any> rememberSelectionState(): SelectionState<T> = rememberSaveable(
+    saver = SelectionState.saver(),
+) { SelectionState() }

app-common-ui/src/main/java/eu/darken/sdmse/common/compose/selection/SelectionState.kt

@@ -0,0 +1,143 @@
+package eu.darken.sdmse.common.compose.selection
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import eu.darken.sdmse.common.compose.preview.PreviewWrapper
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import testhelpers.compose.BaseComposeRobolectricTest
+
+/**
+ * Verifies the recomposition-isolation contract of [SelectionState] — the whole point of the holder.
+ *
+ * Each probe row bumps a per-id counter in a [SideEffect]; a [SideEffect] only runs for a row that
+ * actually (re)composed, so counter deltas measure recompositions.
+ */
+class SelectionStateIsolationTest : BaseComposeRobolectricTest() {
+
+    @Composable
+    private fun ProbeRow(id: Int, holder: SelectionState<Int>, counters: MutableMap<Int, Int>) {
+        val selected = holder.isSelected(id)
+        SideEffect { counters[id] = (counters[id] ?: 0) + 1 }
+        Text("row$id=$selected")
+    }
+
+    @Composable
+    private fun ModeAwareRow(id: Int, holder: SelectionState<Int>, counters: MutableMap<Int, Int>) {
+        val selected = holder.isSelected(id)
+        val active = holder.isActive
+        SideEffect { counters[id] = (counters[id] ?: 0) + 1 }
+        Text("row$id=$selected active=$active")
+    }
+
+    @Test
+    fun `steady-active toggle recomposes only the toggled row`() {
+        val holder = SelectionState<Int>()
+        val counters = mutableMapOf<Int, Int>()
+        // Pre-select a row so selection is already active — isolate the steady-state behavior from the
+        // empty<->non-empty transition.
+        holder.select(0)
+
+        composeRule.setContent {
+            PreviewWrapper {
+                Column {
+                    (0..4).forEach { ProbeRow(it, holder, counters) }
+                }
+            }
+        }
+        composeRule.waitForIdle()
+        val baseline = counters.toMap()
+
+        composeRule.runOnIdle { holder.toggle(2) }
+        composeRule.waitForIdle()
+
+        (0..4).forEach { id ->
+            val delta = (counters[id] ?: 0) - (baseline[id] ?: 0)
+            assertEquals("row $id recompositions after toggling row 2", if (id == 2) 1 else 0, delta)
+        }
+    }
+
+    @Test
+    fun `entering selection mode recomposes all mode-aware rows`() {
+        val holder = SelectionState<Int>()
+        val counters = mutableMapOf<Int, Int>()
+
+        composeRule.setContent {
+            PreviewWrapper {
+                Column {
+                    (0..4).forEach { ModeAwareRow(it, holder, counters) }
+                }
+            }
+        }
+        composeRule.waitForIdle()
+        val baseline = counters.toMap()
+
+        // empty -> active flips isActive, which every mode-aware row reads: all recompose once (expected).
+        composeRule.runOnIdle { holder.select(0) }
+        composeRule.waitForIdle()
+
+        (0..4).forEach { id ->
+            val delta = (counters[id] ?: 0) - (baseline[id] ?: 0)
+            assertEquals("row $id recompositions when entering selection mode", 1, delta)
+        }
+    }
+
+    @Test
+    fun `isActive notifies only on the empty to non-empty transition`() {
+        val holder = SelectionState<Int>()
+        var bannerCompositions = 0
+
+        composeRule.setContent {
+            PreviewWrapper {
+                val active = holder.isActive
+                SideEffect { bannerCompositions++ }
+                Text("active=$active")
+            }
+        }
+        composeRule.waitForIdle()
+        val afterInitial = bannerCompositions
+
+        composeRule.runOnIdle { holder.select(1) } // empty -> active: notifies
+        composeRule.waitForIdle()
+        assertEquals(1, bannerCompositions - afterInitial)
+        val afterFirst = bannerCompositions
+
+        composeRule.runOnIdle { holder.select(2) } // active -> active: no notify
+        composeRule.waitForIdle()
+        assertEquals(0, bannerCompositions - afterFirst)
+
+        composeRule.runOnIdle { holder.clear() } // active -> empty: notifies
+        composeRule.waitForIdle()
+        assertEquals(1, bannerCompositions - afterFirst)
+    }
+
+    @Test
+    fun `isSelected re-evaluates when the id argument changes`() {
+        val holder = SelectionState(setOf(10))
+        val idState = mutableStateOf(10)
+        var lastSelected = false
+
+        composeRule.setContent {
+            PreviewWrapper {
+                val id by idState
+                val selected = holder.isSelected(id)
+                SideEffect { lastSelected = selected }
+                Text("sel=$selected")
+            }
+        }
+        composeRule.waitForIdle()
+        assertEquals(true, lastSelected)
+
+        composeRule.runOnIdle { idState.value = 11 }
+        composeRule.waitForIdle()
+        assertEquals(false, lastSelected)
+
+        composeRule.runOnIdle { idState.value = 10 }
+        composeRule.waitForIdle()
+        assertEquals(true, lastSelected)
+    }
+}