         (merge-node-input collapse-node-id node)
         (merge-nodes-run-next env collapse-node-id node)
         (remove-node node)
-        (propagate-provides {::node-id collapse-node-id})
+        #_(propagate-provides {::node-id collapse-node-id})
         (transfer-node-source-attrs collapse-node-id node)
         #_
         (simplify-branch env))))

                      (assoc graph ::root run-next)
                      env
                      {::node-id (::run-next node)})
          next-node (or (get-in new-graph [::nodes run-next])
                        (get-in graph [::nodes run-next]))]
      (-> graph
          (assoc
            ::nodes (::nodes new-graph)

  (if run-next
    (assoc-in graph [::nodes node-id ::run-next] run-next)
    (update-in graph [::nodes node-id] dissoc ::run-next)))

(defn propagate-provides
  "This function is used to propagate back new provides after extending a node."
  [graph {::keys [node-id]}]
  graph #_(loop [graph'   graph
                 node-id' node-id
                 visited  #{}]
            (if (contains? visited node-id')
              (do
                ; TODO double check if need this detection here once unreachable is properly implemented
                (println "Cycle detected" visited node-id')
                graph)
              (let [{::keys [after-node provides]} (get-in graph' [::nodes node-id'])]
                (if after-node
                  (recur
                    (merge-node-provides graph' after-node {::provides (or provides {})})
                    after-node
                    (conj visited node-id'))
                  graph')))))

(defn merge-nodes-run-next
  "Updates node-id run-next with the run-next of the last element. This will do an AND
