 MongoInternals.Connection::_observeChanges = (cursorDescription, ordered, callbacks) ->
   initializing = true
 
+  # If observeChanges is called inside a reactive context we have to make extra effort to pass the computation to the
+  # observeChanges callbacks so that the computation is available to the "added" publish method, if it is called. We use
+  # fiber object for that. observeChanges callbacks are not called in a reactive context. Additionally, we want this to
+  # be passed only during the observeChanges initialization (when it is calling "added" callbacks in a blocking manner).
   if Tracker.active
     Meteor._nodeCodeMustBeInFiber()
     currentComputation = Tracker.currentComputation

    documents = {}

    publish._setAfterFlush = (computation) ->
      unless computation._publishAfterFlushSet
        computation._publishAfterFlushSet = true

        computation._trackerInstance.afterFlushCallbacks.push =>
          # We remove those which are not published anymore.
          for collectionName of @_documents
            currentlyPublishedDocumentIds = _.keys(@_documents[collectionName] or {})
            currentComputationAddedDocumentIds = _.keys(documents[computation._id]?[collectionName] or {})
            # If afterFlush for other autoruns in the publish function have not yet run, we have to look in "documents" as well.
            otherComputationsAddedDocumentsIds = _.union (_.keys(docs[collectionName] or {}) for computationId, docs of documents when computationId isnt "#{computation._id}")...
            # But after afterFlush, "documents" is empty to be ready for next rerun of the computation, so we look into "oldDocuments".
            otherComputationsPreviouslyAddedDocumentsIds = _.union (_.keys(docs[collectionName] or {}) for computationId, docs of oldDocuments when computationId isnt "#{computation._id}")...

            # We ignore IDs found in both otherComputationsAddedDocumentsIds and otherComputationsPreviouslyAddedDocumentsIds
            # which might ignore more IDs then necessary (an ID might be previously added which has not been added in this
            # iteration) but this is OK because in afterFlush of other computations this will be corrected and documents
            # with those IDs removed.
            for id in _.difference currentlyPublishedDocumentIds, currentComputationAddedDocumentIds, otherComputationsAddedDocumentsIds, otherComputationsPreviouslyAddedDocumentsIds
              @removed collectionName, id

          oldDocuments[computation._id] = documents[computation._id] or {}
          documents[computation._id] = {}
          computation._publishAfterFlushSet = false

        computation._trackerInstance.requireFlush()

    originalAdded = publish.added
    publish.added = (collectionName, id, fields) ->

      if Tracker.active
        currentComputation = Tracker.currentComputation
      else
        # Computation can also be passed through current fiber in the case this "added" method is called
        # from the observeChanges callback from an observeChanges called inside a reactive context.
        currentComputation = Fiber.current._publishComputation
      if currentComputation
        @_setAfterFlush currentComputation
        Meteor._ensure(documents, currentComputation._id, collectionName)[stringId] = true

      # If document as already present in publish then we call changed to send updated fields (Meteor sends only a diff).
      # This can hide some errors in publish functions if they one calls "added" on an existing document and we could
      # make it so that this behavior works only inside reactive computation (if "currentComputation" is set), but we
      # can also make it so that publish function tries to do something smarter (sending a diff) in all cases, as we do.
      if @_documents[collectionName]?[stringId]
        oldFields = {}
        # If some field existed before, but does not exist anymore, we have to remove it by calling "changed"
