                                      check-ast-opt?
                                      (reduce
                                        (fn [ent {:keys [key]}]
-                                         (if (contains? ent key)
-                                           ent
+                                         (if-let [[_ v] (find entity key)]
+                                           (assoc ent key v)
                                            (reduced nil)))
-                                       entity
+                                       {}
                                        (:children ast)))
                                    (join entity env)))
               env            (assoc env ::processing-sequence coll)

            out-chan
            (fn join-seq-pipeline [[ent i] res-ch]
              (go
                (let [res (<!maybe (join-item (update env ::path conj (inc i)) ent))]
                  (>! res-ch res)
                  (async/close! res-ch))))
            from-chan)

       :else
       (parser env' query)))))

(defn join-seq-parallel [{:keys  [query]
                          ::keys [entity-path-cache]
                          :as    env} coll]
  (if (seq coll)
    (go-catch
      (pt/tracing env {::pt/event ::parallel-sequence-loop
