Reverse Lookups break transactions of deeply nested maps

Tái hiện vấn đề bằng ví dụ test-resolve-eid-refs-deep-map, bắt đầu từ d/transact! và kiểm tra các mối quan hệ thu được bằng d/q và d/pull. Theo dõi cách các lookup refs lồng nhau sâu và các lookup refs ngược được xử lý cùng nhau, sau đó xác minh rằng truy vấn John đang thất bại trả về Sergey, trong khi các assertion hiện có vẫn hợp lệ.

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?