                             ::pc/output [:c]}]
               ::eql/query [:c]})
            '#::pcrg{:unreachable #{}
-                    :nodes       {1 {::pcrg/node-id 1
-                               ::pcrg/provides {:c {}}
-                               ::pcrg/requires {:c {}}
-                               ::pc/sym        c}
-                            2 {::pcrg/node-id  2
-                               ::pcrg/provides {:b {}
-                                                :c {}}
-                               ::pcrg/requires {:b {}
-                                                :c {}}
-                               ::pcrg/run-next 1
-                               ::pc/sym        b}
-                            3 {::pcrg/node-id  3
-                               ::pcrg/provides {:a {}
-                                                :b {}
-                                                :c {}}
-                               ::pcrg/requires {:a {}
-                                                :b {}
-                                                :c {}}
-                               ::pcrg/run-next 2
-                               ::pc/sym        a}}
-                    :root        3})))
-
-  (testing "broken chain"
-    (is (= (compute-run-graph*
-             {::resolvers [{::pc/sym    'b
-                            ::pc/input  #{:a}
-                            ::pc/output [:b]}
-                           {::pc/sym    'c
-                            ::pc/input  #{:b}
-                            ::pc/output [:c]}]
-              ::eql/query [:c]})
-           '#::pcrg{:nodes       {}
-                    :unreachable #{:a}}))))
+                    :nodes       {1 {::pcrg/node-id  1
+                                     ::pcrg/provides {:c {}}
+                                     ::pcrg/requires {:c {}}
+                                     ::pc/sym        c}
+                                  2 {::pcrg/node-id  2
+                                     ::pcrg/provides {:b {}
+                                                      :c {}}
+                                     ::pcrg/requires {:b {}
+                                                      :c {}}
+                                     ::pcrg/run-next 1
+                                     ::pc/sym        b}
+                                  3 {::pcrg/node-id  3
+                                     ::pcrg/provides {:a {}
+                                                      :b {}
+                                                      :c {}}
+                                     ::pcrg/requires {:a {}
+                                                      :b {}
+                                                      :c {}}
+                                     ::pcrg/run-next 2
+                                     ::pc/sym        a}}
+                    :root        3}))))

           {::pcrg/unreachable #{}
            ::pcrg/root        1
            ::pcrg/nodes       {1 {::pcrg/node-id  1
                             ::pc/sym        'a
                             ::pcrg/requires {:a {}
                                              :b {}}
                             ::pcrg/provides {:a {}
                                              :b {}}}}})))

  (testing "single dependency"
    (is (= (compute-run-graph*

                            ::pc/output [:a]}]
              ::eql/query [:a]})
           '#::pcrg{:unreachable #{}
                    :nodes       {1 {::pcrg/node-id  1
                                     ::pcrg/provides {:a {}}
                                     ::pcrg/requires {:a {}}
                                     ::pc/sym        a}
                                  2 {::pcrg/node-id  2
                                     ::pcrg/provides {:a {}}
                                     ::pcrg/requires {:a {}}
                                     ::pc/sym        a2}
                                  3 #::pcrg{:node-id  3
                                            :requires {:a {}}
                                            :run-or   [1
                                                       2]}}
                    :root        3})))

  (testing "multiple attribute request"
