 
     indexes = []
     sourceFields = {}
-
+    sourceFieldsLimitedToPrefix = {}
+
+    # We use isModifiableCollection to optimize so that we do not even setup observers
+    # for fields which deal with unmodifiable collections.
     sourceFieldsWalker = (obj) ->
       for name, field of obj
         if field instanceof globals.Document._ObservingField
           if field instanceof globals.Document._ReferenceField
-            # Optimization. So that we do not even setup observers for fields which deal with unmodifiable collections.
-            if isModifiableCollection(field.sourceCollection) or (field.reverseName and isModifiableCollection(field.targetCollection))
-              sourceFields[field.sourcePath] = 1
-
-              index = {}
-              index["#{ field.sourcePath }._id"] = 1
-              indexes.push index
+            if field.reverseName
+              if isModifiableCollection(field.sourceCollection) or isModifiableCollection(field.targetCollection)
+                # Limit to PREFIX only when both collections are server side. Otherwise there is a collection
+                # which is local only to this instance and we want to process all documents for it. Alternatively,
+                # there is a collection through a connection, in which case we are conservative and also process
+                # all documents for it. We do not necessary know if connections are shared between instances.
+                if isServerCollection(field.sourceCollection) and isServerCollection(field.targetCollection)
+                  sourceFieldsLimitedToPrefix[field.sourcePath] = 1
+                else
+                  sourceFields[field.sourcePath] = 1
+
+                index = {}
+                index["#{ field.sourcePath }._id"] = 1
+                indexes.push index
+            else
+              if isModifiableCollection field.sourceCollection
+                if isServerCollection field.sourceCollection
+                  sourceFieldsLimitedToPrefix[field.sourcePath] = 1
+                else
+                  sourceFields[field.sourcePath] = 1
+
+                index = {}
+                index["#{ field.sourcePath }._id"] = 1
+                indexes.push index
           else
             if isModifiableCollection field.sourceCollection
-              sourceFields[field.sourcePath] = 1
+              if isServerCollection field.sourceCollection
+                sourceFieldsLimitedToPrefix[field.sourcePath] = 1
+              else
+                sourceFields[field.sourcePath] = 1
         else if field not instanceof globals.Document._Field
           sourceFieldsWalker field
 
     sourceFieldsWalker @Meta.fields
-
-    # Source and target collections were not modifiable collections.
-    return if _.isEmpty sourceFields
 
     unless updateAll
       for index in indexes
         @Meta.collection._ensureIndex index if Meteor.isServer and @Meta.collection._connection is Meteor.server
 
-    initializing = true
-
-    observers =
-      added: globals.Document._observerCallback @Meta.collection, (id, fields) =>
-        @_sourceUpdated id, fields if updateAll or not initializing
-
-    unless updateAll
-      observers.changed = globals.Document._observerCallback @Meta.collection, (id, fields) =>
-        @_sourceUpdated id, fields
-
-    handle = @Meta.collection.find({}, fields: sourceFields).observeChanges observers
-
-    initializing = false
-
-    handle.stop() if updateAll
+    # Source or target collections are modifiable collections.
+    unless _.isEmpty sourceFields
+      initializing = true
+
+      observers =
+        added: globals.Document._observerCallback false, (id, fields) =>
+          @_sourceUpdated id, fields if updateAll or not initializing
+
+      unless updateAll
+        observers.changed = globals.Document._observerCallback false, (id, fields) =>
+          @_sourceUpdated id, fields
+
+      handle = @Meta.collection.find({}, fields: sourceFields).observeChanges observers
+
+      initializing = false
+
+      handle.stop() if updateAll
+
+    # Source or target collections are modifiable collections.
+    unless _.isEmpty sourceFieldsLimitedToPrefix
+      initializingLimitedToPrefix = true
+
+      observers =
+        added: globals.Document._observerCallback true, (id, fields) =>
+          @_sourceUpdated id, fields if updateAll or not initializingLimitedToPrefix
+
+      unless updateAll
+        observers.changed = globals.Document._observerCallback true, (id, fields) =>
+          @_sourceUpdated id, fields
+
+      handle = @Meta.collection.find({}, fields: sourceFieldsLimitedToPrefix).observeChanges observers
+
+      initializingLimitedToPrefix = false
+
+      handle.stop() if updateAll
 
   @_updateAll: ->
     # It is only reasonable to run anything if this instance


      initializing = true

      queryFields = fieldsToProjection @fields
      @collection.find({}, fields: queryFields).observe
        added: globals.Document._observerCallback @collection, (document) =>
          @trigger document, null unless initializing

        changed: globals.Document._observerCallback @collection, (newDocument, oldDocument) =>
          @trigger newDocument, oldDocument

        removed: globals.Document._observerCallback @collection, (oldDocument) =>
          @trigger null, oldDocument

      initializing = false


      initializing = true

      # Limit to PREFIX only when both collections are server side. Otherwise there is a collection
      # which is local only to this instance and we want to process all documents for it. Alternatively,
      # there is a collection through a connection, in which case we are conservative and also process
      # all documents for it. We do not necessary know if connections are shared between instances.
      limitToPrefix = isServerCollection(@targetCollection) and isServerCollection(@sourceCollection)

      observers =
        added: globals.Document._observerCallback limitToPrefix, (id, fields) =>
          @updateSource id, fields if updateAll or not initializing

      unless updateAll
        observers.changed = globals.Document._observerCallback limitToPrefix, (id, fields) =>
          @updateSource id, fields

        observers.removed = globals.Document._observerCallback limitToPrefix, (id) =>
          @removeSource id

      referenceFields = fieldsToProjection @fields
