                             []))
 
                         (let [next-children (remove (comp (set (keys res)) :key) (:children (query->ast (focus-subquery tx (vec provides)))))]
-                          (pt/trace env {::pt/event ::reset-loop
+                          (pt/trace env {::pt/event  ::reset-loop
                                          ::loop-keys (mapv :key next-children)})
                           (recur res
                             (into #{} (remove provides) waiting)

        (async/close! ch)))
    ch))

(defn parallel-parser [{:keys [read mutate]}]
  (fn self [{::keys [waiting key-watchers max-key-iterations]
             :or    {max-key-iterations 5}

                    (recur res waiting processing key-iterations tail))

                  :else
                  (let [[res waiting processing key-iterations tail]
                        (parallel-process-value
                          env tx ast
                          key-watchers
                          res waiting processing
                          read mutate key-iterations tail)]
                    (recur res waiting processing key-iterations tail))))

              (if (seq processing)
                (let [[{::keys [response-value provides merge-result?] :as msg} p] (async/alts! (vec processing))]
                  (if msg

                    (do
                      (trace env {::pt/event       ::process-pending
                                  ::provides       provides
                                  ::response-value response-value
                                  ::merge-result?  (boolean merge-result?)})
                      (swap! (:com.wsscode.pathom.core/entity env) #(merge response-value %))

                      (parallel-flush-watchers env key-watchers provides)

                      (if merge-result?
                        (do
                          (pt/trace env {::pt/event ::merge-result ::response-value response-value})
