Reverse Lookups break transactions of deeply nested maps

In deeply nested maps, datascript can successfully build relationships with both the lookup ref, and reverse lookup ref, however, it seems like when you combine them, it does not create a connection

for example
A -> B -> C ;; works
C <- B <- A ;; works
A -> C <- B ;; does not work

(deftest test-resolve-eid-refs-deep-map
  (let [conn (d/create-conn {:name {:db/unique :db.unique/identity}
                             :friend {:db/valueType :db.type/ref
                                      :db/cardinality :db.cardinality/many}})
        tx   (d/transact! conn [{:name "Sergey"
                                 :friend [{:name "Ivan"}
                                          {:name "Petr"}]}
                                {:name "Oleg"
                                 :friend [{:name "Dmitri"
                                           :friend [{:name "Sven"
                                                     :friend [{:name "John"
                                                               :friend [
                                                                        {:name "Sergey"}
                                                                        ]
                                                               :_friend [
                                                                         {:name "Dmitri"}]}
                                                              {:name "Petr"}]
                                                     }]}]
                                 :_friend [{:name "Boris"}]}]
                          )
        q '[:find ?fn
            :in $ ?n
            :where [?e :name ?n]
            [?e :friend ?fe]
            [?fe :name ?fn]]]
    (is (= (d/q q @conn "Sergey") #{["Ivan"] ["Petr"]}))
    ;; true
    (is (= (d/q q @conn "Boris") #{["Oleg"]}))
    ;; true
    ;; this shows that :_ does build relationship on reverse lookups  
    ;;  and can create the new entity at the same time
    (is (= (d/q q @conn "Oleg") #{["Dmitri"]}))
    ;; true
    (is (= (d/q q @conn "Sven") #{["John"][ "Petr"]} ))
    ;; true
    (is (= (d/pull @conn '[:name {:_friend 1}] [:name "Petr"])
           {:name "Petr"
            :_friend [{:name "Sergey"}
                      {:name "Sven"}]}))
    ;; true - shows that you can create relationships on a deep add, even to existing ents
    (is (= (d/q q @conn "Dmitri") #{["Sven"] ["John"]}))
    ;; fails, only Sven is a friend of Dmitri
    ;; shows that if you are going to be doing a deep map transaction, each path
    ;; needs to only go in one direction
    (is (= (d/q q @conn "John") #{["Sergey"]}))
    ;; true, shows that the deep add works when moving in one direction
    ))

Am I missing something?

Reproduce the issue with the test-resolve-eid-refs-deep-map example, starting at d/transact! and checking the resulting relationships with d/q and d/pull. Trace how deeply nested lookup refs and reverse lookup refs are handled together, then verify that the failing John query returns Sergey while the existing assertions remain valid.