A modern programming language that makes developers happier.

kotlinlang

hi - I'm upgrading the dependencies in my project and migrating to a newer version of Kotlin is requiring I move away from `BroadcastChannel`. The translation seems pretty simple but I'm having trouble getting it to work in my MVIKotlin-based project (and I believe this chunk of code is based closely on an older version of an MVIKotlin example). More details in the thread.

in a Component class, I'm moving from this:
```private val inputChannel = BroadcastChannel&lt;Input&gt;(Channel.BUFFERED)
val input: (Input) -&gt; Unit = { inputChannel.trySend(it) }
init {
    bind(dependencies.lifecycle, BinderLifecycleMode.CREATE_DESTROY, mainContext) {
        inputChannel.asFlow().mapNotNull(inputToDetailIntent) bindTo recipeDetailStore
    }
}```
to:
```private val inputFlow = MutableSharedFlow&lt;Input&gt;()
val input: (Input) -&gt; Unit = { inputFlow.tryEmit(it) }
init {
    bind(dependencies.lifecycle, BinderLifecycleMode.CREATE_DESTROY, mainContext) {
        inputFlow.mapNotNull(inputToDetailIntent) bindTo recipeDetailStore
    }
}```
With the former version, calls to `input()` get passed along as expected to the `recipeDetailStore` and handled in its executor. In the latter version, I confirmed they get passed to `inputFlow.tryEmit()` but they never reach the executor

any idea what I might be missing? It seems like `bindTo` would be unaffected by the change from `BroadcastChannel` to `MutableSharedFlow` and every tutorial I've found about this migration is pretty simple and just recommends the API translation I did

This looks like an issue with buffering. Try specifying `MutableSharedFlow&lt;Input&gt;(extraBufferCapacity = Int.MAX_VALUE)`.

I guess I misunderstood the way buffering would be treated in this case

I guess my approach could have only worked if the observer was set up before the initial call to `input()`