anchor.diff:  
       let updateTransition1 transitionModel_ =
           let transition_ = get transitionModel_ transitionLens
  +        let started = transition_.Ticks = 0
           let (transition_, finished) =
               if transition_.Ticks >= transition_.Lifetime then ({ transition_ with Ticks = 0 }, true)
               else ({ transition_ with Ticks = transition_.Ticks + 1 }, false)
           let transitionModel_ = set transition_ transitionModel_ transitionLens
  -        (transitionModel_, finished)
  +        (transitionModel_, started, finished)
   
       let updateTransition update world_ : bool * World =
           let (keepRunning, world_) =
  
positive.code:                 match selectedScreen_.State with
                  | IncomingState ->
                      let incomingModel_ = get selectedScreenModel_ incomingModelLens
                      let (incomingModel_, finished) = updateTransition1 incomingModel_
                      let selectedScreen_ = { selectedScreen_ with State = if finished then IdlingState else IncomingState
                                                                   IncomingModel = incomingModel_ }
                      let selectedScreenModel_ = set selectedScreen_ selectedScreenModel_ screenLens
                      let world_ = set (Some selectedScreenModel_) world_ <| worldOptSelectedScreenModelLens
                      publish [Lun.make "finished"; Lun.make "incoming"] { Handled = false; Data = NoData } world_
                  | OutgoingState ->
                      let outgoingModel_ = get selectedScreenModel_ outgoingModelLens
                      let (outgoingModel_, finished) = updateTransition1 outgoingModel_
                      let selectedScreen_ = { selectedScreen_ with State = if finished then IdlingState else OutgoingState
                                                                   OutgoingModel = outgoingModel_ }
                      let screenModel_ = set outgoingModel_ selectedScreenModel_ outgoingModelLens
                      let world_ = set (Some screenModel_) world_ <| worldOptSelectedScreenModelLens
                      publish [Lun.make "finished"; Lun.make "outgoing"] { Handled = false; Data = NoData } world_
                  | IdlingState -> (true, world_)
          if keepRunning then update world_
  
negative.code:     let getAudioDescriptors world : AudioDescriptor rQueue =
          let componentDescriptors = getComponentAudioDescriptors world
          let worldDescriptors = [] // TODO: get audio descriptors when there are some
          componentDescriptors @ worldDescriptors // NOTE: pretty inefficient
  
      /// Play the world's audio.
      let play world_ =
  