derivedStateOf dependency tracking under concurrent state mutations

Answer to the core questions

1. Recomputation per frame: When several coroutines mutate the same source State object inside a single frame, Compose collapses all those changes into one state snapshot. The derivedStateOf block is executed only once in the next recomposition pass, regardless of how many intermediate values were produced.

2. Dependency scope: The set of state reads that derivedStateOf tracks is captured for each individual recomposition. Concurrent recompositions are independent; each one sees the current snapshot of the source state at the moment the block runs. Dependencies are not shared across parallel recomposition passes.

Why this happens

Jetpack Compose’s scheduler batches state changes that occur before the next frame. When an update happens, the framework marks the affected State as “dirty” and schedules a recomposition. If more changes to the same State happen before that recomposition runs, the scheduler keeps only the last value. Consequently, the derivedStateOf block sees a single value and is recomputed once per frame.

Practical test you can run

1. Define a mutable state:

   val count = remember { mutableStateOf(0) }

2. Create a derived state that doubles the count:

   val doubled = derivedStateOf { count.value * 2 }

3. Launch two coroutines that increment count five times each with delay(0) so all updates happen in the same frame.
4. Observe the number of times the derived value changes by logging inside a LaunchedEffect(doubled) block.
5. Repeat the experiment with a delay(16) between some increments to force a frame boundary; you should see two recompositions instead of one.

Missing diagnostic detail

Does your workload sometimes have coroutines that suspend and resume after a frame? If so, the derived state may be recomputed more than once per logical “round” of updates. Knowing whether updates cross frame boundaries will help you decide if you need additional throttling or memoization.