             (dissoc <> ::root)
             (reduce-kv
               (fn [out inputs resolvers]
-                (resolver-input-paths out env inputs resolvers))
+                (compute-input-resolvers-graph out env inputs resolvers))
               <>
               (get index-oir attribute)))]
       (if (::root new-out)

        (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)))))))
          <>
          resolvers)


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

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