         (dissoc out ::root)
         ; resolvers loop
         (reduce
-          (fn [{::keys [unreachable-syms index-syms] :as out} resolver]
+          (fn [{::keys [unreachable-syms] :as out} resolver]
             (if (contains? unreachable-syms resolver)
               out
               (let [env (assoc env pc-sym resolver)]
-                (if (and (contains? (::index-syms out) resolver)
-                         (not (dynamic-resolver? env resolver)))
-                  (let [sym-node-id (first (get index-syms resolver))]
-                    (cond-> (extend-node-run-next out env)
-                      sym-node-id
-                      (-> (update-in [::nodes sym-node-id ::requires] merge-io {(pc-attr env) {}})
-                          (update-in [::nodes sym-node-id ::provides] merge-io {(pc-attr env) {}}))))
+                (if-let [sym-node-id (get-resolver-extension-node-id out env)]
+                  (-> (extend-node-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-sym-node out env)]
                     (-> out
                         (include-node node)

      (set/subset? (all-attribute-resolvers env (pc-attr env)) syms)
      (update ::unreachable-attrs conj (pc-attr env)))))

(defn compute-missing [out {::keys [previous-out] :as env} missing]
  (if (seq missing)
    (let [root-node (get-root-node out)


                unreachable-attrs (filter #(set/subset? (all-attribute-resolvers env %) unreachable-syms) still-missing)]
            (update out' ::unreachable-attrs into unreachable-attrs)))))
    out))

(defn get-resolver-extension-node-id
  [{::keys [index-syms] :as out} env]
  (let [resolver (pc-sym env)]
    (and (contains? (::index-syms out) resolver)
         (not (dynamic-resolver? env resolver))
         (first (get index-syms resolver)))))

(defn resolver-input-paths
  [out
