         (dissoc out ::root)
         ; resolvers loop
         (reduce
-          (fn [{::keys [unreachable-syms] :as out} resolver]
-            (if (contains? unreachable-syms resolver)
-              out
-              (let [env (assoc env pc-sym resolver)]
-                (if-let [sym-node-id (get-resolver-extension-node-id out env)]
-                  (-> (extend-resolver-run-next out env)
-                      (update-in [::nodes sym-node-id ::requires] merge-io {(pc-attr env) {}})
-                      (update-in [::nodes sym-node-id ::provides] merge-io {(pc-attr env) {}}))
-                  (let [node (create-resolver-node out env)]
-                    (-> out
-                        (include-node node)
-                        (cond-> (and run-next (not= run-next (::node-id node)))
-                                (assoc-in [::nodes run-next ::after-node] (::node-id node)))
-                        (compute-root-or env node)))))))
+          (fn [out resolver] (compute-resolver-graph out env resolver))
           <>
           resolvers)
 

                  (remove #(contains? entity (:key %)))
                  children))))))

(defn compute-attribute-graph-item
  [{::keys [root] :as out}
   {:com.wsscode.pathom.connect/keys [index-oir attribute]
    :as                              env}]

        run-next
        (assoc ::run-next run-next)))))

(defn extend-node-run-next
  "Extend node run next, adding the current run-next from env to it. If the node don't
  have a run-next, it will be set for the one informed by the env. In case
  there is already something to run next the node, a wrap AND branch node will be
  inserted containing the previous node and the new one."
  [out
   {::keys [run-next run-next-trail] :as env}
   node-id]
  (if (or (not run-next)
          (contains? run-next-trail node-id))
    out
    (let [node      (get-in out [::nodes node-id])
          new-out   (compute-root-and
                      (assoc out ::root (::run-next node))
                      env
                      {::node-id run-next})
          next-node (or (get-in new-out [::nodes run-next])
                        (get-in out [::nodes run-next]))]
      (-> out
          (assoc
            ::nodes (::nodes new-out)
            ::index-syms (::index-syms new-out))
          (assoc-in [::nodes node-id ::run-next] (::root new-out))
          (assoc-in [::nodes (::root new-out) ::after-node] node-id)
          (merge-node-provides node-id next-node)
          (propagate-provides node)
          (update ::extended-nodes p.misc/sconj node-id)))))

(defn include-node [out {::keys [node-id] :as node}]
  (let [sym (pc-sym node)]
