Any idea why the require in awaitClose would fail? According to docs the channel is closed before the block passed into awaitClose is invoked

fun flowFrom(api: CallbackBasedApi): Flow<T> = callbackFlow {
    val callback = object : Callback { // Implementation of some callback interface
        override fun onNextValue(value: T) {
            // To avoid blocking you can configure channel capacity using
            // either buffer(Channel.CONFLATED) or buffer(Channel.UNLIMITED) to avoid overfill
            trySendBlocking(value)
                .onFailure { throwable ->
                    // Downstream has been cancelled or failed, can log here
                }
        }
        override fun onApiError(cause: Throwable) {
            cancel(CancellationException("API Error", cause))
        }
        override fun onCompleted() = channel.close()
    }
    api.register(callback)
    /*
     * Suspends until either 'onCompleted'/'onApiError' from the callback is invoked
     * or flow collector is cancelled (e.g. by 'take(1)' or because a collector's coroutine was cancelled).
     * In both cases, callback will be properly unregistered.
     */
        awaitClose { 
            require(isClosedForSend) // <--- THIS FAILS
            api.unregister(callback) 
        }
    }

where in the docs does it say that? https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.channels/await-close.html

Suspends the current coroutine until the channel is either closed or cancelled and invokes the given block before resuming the coroutine.

in this case you're getting cancelled before closed

in which case?

didn't even think about that, it seems like a documentation bug because it's clearly scope cancellation that invokes the lambda, not channel cancellation

Ok well the code I pasted in was the example from the documentation (apart from the require statement) and you can see if make no attempt to handle closing of the channel if scope is cancelled meaning it would suffer from: _java.lang.IllegalStateException: 'awaitClose { yourCallbackOrListener.cancel() }' should be used in the end of callbackFlow block. Otherwise, a callback/listener may leak in case of external cancellation._

the channel does get closed once the scope is canceled, it just hasn't happened yet at that callback. any reason you need the require?

Well I'm getting the ISE above

can't reproduce here, is it coming from the API you're using?

its coming from here: https://github.com/GitLiveApp/firebase-kotlin-sdk/blob/fbef5f403cbc88879a4a94f7fca[…]rc/androidMain/kotlin/dev/gitlive/firebase/database/database.kt