Merge "[kairos] Use lazy endSignal in LocalNetwork" into main

internal class LocalNetwork(

    private val network: Network,

    private val scope: CoroutineScope,

    private val endSignal: Events<Any>,

    private val endSignalLazy: Lazy<Events<Any>>,

) : KairosNetwork {

    override suspend fun <R> transact(block: TransactionScope.() -> R): R =

        network.transaction("KairosNetwork.transact") { block() }.awaitOrCancel()

                                stateScope =

                                    StateScopeImpl(

                                        evalScope = this,

                                        endSignalLazy = lazy { mergeLeft(stopEmitter, endSignal) },

                                        endSignalLazy =

                                            lazy { mergeLeft(stopEmitter, endSignalLazy.value) },

                                    ),

                                coroutineScope = this@coroutineScope,

                            )

@ExperimentalKairosApi

class RootKairosNetwork

internal constructor(private val network: Network, private val scope: CoroutineScope, job: Job) :

    Job by job, KairosNetwork by LocalNetwork(network, scope, emptyEvents)

    Job by job, KairosNetwork by LocalNetwork(network, scope, lazyOf(emptyEvents))

/** Constructs a new [RootKairosNetwork] in the given [CoroutineScope]. */

@ExperimentalKairosApi

    private val job: Job

        get() = coroutineScope.coroutineContext.job

    override val kairosNetwork: KairosNetwork by lazy {

        LocalNetwork(network, coroutineScope, endSignal)

    override val kairosNetwork: LocalNetwork by lazy {

        LocalNetwork(network, coroutineScope, stateScope.endSignalLazy)

    }

    override fun <T> events(builder: suspend EventProducerScope<T>.() -> Unit): Events<T> =

        }

        // When our scope is cancelled, deactivate this observer.

        cancelHandle = childScope.coroutineContext.job.invokeOnCompletion { handle.dispose() }

        val localNetwork = LocalNetwork(network, childScope, endSignal)

        val localNetwork = LocalNetwork(network, childScope, stateScope.endSignalLazy)

        val outputNode =

            Output<A>(

                interceptor =