diff --git a/src/fs/chunk_iterator.cpp b/src/fs/chunk_iterator.cpp
index 26cff1ea..a7393531 100644
--- a/src/fs/chunk_iterator.cpp
+++ b/src/fs/chunk_iterator.cpp
@@ -6,10 +6,9 @@
 using namespace syncspirit::fs;
 
 chunk_iterator_t::chunk_iterator_t(scan_task_ptr_t task_, model::file_info_ptr_t file_,
-                                   const model::folder_info_t& peer_folder_,
-                                   file_ptr_t backend_) noexcept
-    : task{std::move(task_)}, peer_folder{peer_folder_}, peer_file{std::move(file_)}, backend{std::move(backend_)}, last_queued_block{0},
-      valid_blocks_count{0}, abandoned{false} {
+                                   const model::folder_info_t &peer_folder_, file_ptr_t backend_) noexcept
+    : task{std::move(task_)}, peer_folder{peer_folder_}, peer_file{std::move(file_)}, backend{std::move(backend_)},
+      last_queued_block{0}, valid_blocks_count{0}, abandoned{false} {
     unhashed_blocks = peer_file->get_blocks().size();
     valid_blocks_map.resize(unhashed_blocks);
 }
diff --git a/src/fs/chunk_iterator.h b/src/fs/chunk_iterator.h
index 3ad8a54e..19233949 100644
--- a/src/fs/chunk_iterator.h
+++ b/src/fs/chunk_iterator.h
@@ -21,9 +21,7 @@ namespace bfs = std::filesystem;
 struct SYNCSPIRIT_API chunk_iterator_t {
     using valid_blocks_map_t = std::vector<bool>;
 
-    chunk_iterator_t(scan_task_ptr_t task,
-                     model::file_info_ptr_t file,
-                     const model::folder_info_t& peer_folder,
+    chunk_iterator_t(scan_task_ptr_t task, model::file_info_ptr_t file, const model::folder_info_t &peer_folder,
                      file_ptr_t backend) noexcept;
 
     bool has_more_chunks() const noexcept;
@@ -36,7 +34,7 @@ struct SYNCSPIRIT_API chunk_iterator_t {
     outcome::result<details::chunk_t> read() noexcept;
 
     inline model::file_info_ptr_t get_file() { return peer_file; }
-    inline const model::folder_info_t& get_folder() { return peer_folder; }
+    inline const model::folder_info_t &get_folder() { return peer_folder; }
 
     inline bfs::path get_path() noexcept { return backend->get_path(); }
     inline outcome::result<void> remove() noexcept { return backend->remove(); }
@@ -45,7 +43,7 @@ struct SYNCSPIRIT_API chunk_iterator_t {
 
   private:
     scan_task_ptr_t task;
-    const model::folder_info_t& peer_folder;
+    const model::folder_info_t &peer_folder;
     model::file_info_ptr_t peer_file;
     file_ptr_t backend;
     int64_t last_queued_block;
diff --git a/src/fs/file.cpp b/src/fs/file.cpp
index 3c8865e9..720cd8e2 100644
--- a/src/fs/file.cpp
+++ b/src/fs/file.cpp
@@ -26,7 +26,8 @@ using namespace syncspirit::fs;
 #define SS_STAT_BUFF struct stat
 #endif
 
-auto file_t::open_write(model::file_info_ptr_t model, const model::folder_info_t& folder_info) noexcept -> outcome::result<file_t> {
+auto file_t::open_write(model::file_info_ptr_t model, const model::folder_info_t &folder_info) noexcept
+    -> outcome::result<file_t> {
     using mode_t = utils::fstream_t;
     auto tmp = model->get_size() > 0;
     auto model_path = model->get_path(folder_info);
@@ -72,8 +73,8 @@ auto file_t::open_read(const bfs::path &path) noexcept -> outcome::result<file_t
 
 file_t::file_t() noexcept {};
 
-file_t::file_t(utils::fstream_t backend_, model::file_info_ptr_t model_, bfs::path path_,
-               bfs::path model_path_, bool temporal_) noexcept
+file_t::file_t(utils::fstream_t backend_, model::file_info_ptr_t model_, bfs::path path_, bfs::path model_path_,
+               bool temporal_) noexcept
     : backend{new utils::fstream_t(std::move(backend_))}, model{std::move(model_)}, path{std::move(path_)},
       temporal{temporal_} {
     model_path = std::move(model_path_);
diff --git a/src/fs/file.h b/src/fs/file.h
index 3f334019..53b401bd 100644
--- a/src/fs/file.h
+++ b/src/fs/file.h
@@ -42,12 +42,14 @@ struct SYNCSPIRIT_API file_t : model::arc_base_t<file_t> {
     outcome::result<void> copy(size_t my_offset, const file_t &from, size_t source_offset, size_t size) noexcept;
     outcome::result<utils::bytes_t> read(size_t offset, size_t size) const noexcept;
 
-    static outcome::result<file_t> open_write(model::file_info_ptr_t model, const model::folder_info_t& folder_info) noexcept;
+    static outcome::result<file_t> open_write(model::file_info_ptr_t model,
+                                              const model::folder_info_t &folder_info) noexcept;
     static outcome::result<file_t> open_read(const bfs::path &path) noexcept;
 
   private:
     using backend_ptr_t = std::unique_ptr<utils::fstream_t>;
-    file_t(utils::fstream_t backend, model::file_info_ptr_t model, bfs::path path, bfs::path model_path, bool temporal) noexcept;
+    file_t(utils::fstream_t backend, model::file_info_ptr_t model, bfs::path path, bfs::path model_path,
+           bool temporal) noexcept;
     file_t(utils::fstream_t backend, bfs::path path) noexcept;
 
     backend_ptr_t backend;
diff --git a/src/fs/file_actor.cpp b/src/fs/file_actor.cpp
index e46628cc..5588313e 100644
--- a/src/fs/file_actor.cpp
+++ b/src/fs/file_actor.cpp
@@ -390,8 +390,8 @@ auto file_actor_t::operator()(const model::diff::modify::append_block_t &diff, v
     return r ? diff.visit_next(*this, custom) : r;
 }
 
-auto file_actor_t::get_source_for_cloning(model::file_info_ptr_t &source, const model::folder_info_t& source_fi, const file_ptr_t &target_backend) noexcept
-    -> outcome::result<file_ptr_t> {
+auto file_actor_t::get_source_for_cloning(model::file_info_ptr_t &source, const model::folder_info_t &source_fi,
+                                          const file_ptr_t &target_backend) noexcept -> outcome::result<file_ptr_t> {
     auto source_path = source->get_path(source_fi);
     if (source_path == target_backend->get_path()) {
         return target_backend;
@@ -448,15 +448,14 @@ auto file_actor_t::operator()(const model::diff::modify::clone_block_t &diff, vo
     return r ? diff.visit_next(*this, custom) : r;
 }
 
-auto file_actor_t::open_file_rw(const std::filesystem::path &path, model::file_info_ptr_t info, const model::folder_info_t &folder_info) noexcept
-    -> outcome::result<file_ptr_t> {
+auto file_actor_t::open_file_rw(const std::filesystem::path &path, model::file_info_ptr_t info,
+                                const model::folder_info_t &folder_info) noexcept -> outcome::result<file_ptr_t> {
     auto augmentation = info.get()->get_augmentation();
     auto presence = static_cast<presentation::presence_t *>(augmentation.get());
     if (!presence->is_unique()) {
         return utils::make_error_code(utils::error_code_t::nonunique_filename);
     }
 
-
     LOG_TRACE(log, "open_file (r/w, by path), path = {}", path.string());
     auto item = rw_cache->get(path);
     if (item) {
diff --git a/src/fs/file_actor.h b/src/fs/file_actor.h
index cf992b63..829e48b3 100644
--- a/src/fs/file_actor.h
+++ b/src/fs/file_actor.h
@@ -75,10 +75,11 @@ struct SYNCSPIRIT_API file_actor_t : public r::actor_base_t, private model::diff
     void on_controller_predown(net::message::controller_predown_t &message) noexcept;
 
     outcome::result<file_ptr_t> get_source_for_cloning(model::file_info_ptr_t &source,
-                                                       const model::folder_info_t& source_fi,
+                                                       const model::folder_info_t &source_fi,
                                                        const file_ptr_t &target_backend) noexcept;
 
-    outcome::result<file_ptr_t> open_file_rw(const bfs::path &path, model::file_info_ptr_t info, const model::folder_info_t &folder_info) noexcept;
+    outcome::result<file_ptr_t> open_file_rw(const bfs::path &path, model::file_info_ptr_t info,
+                                             const model::folder_info_t &folder_info) noexcept;
     outcome::result<file_ptr_t> open_file_ro(const bfs::path &path, bool use_cache = false) noexcept;
 
     outcome::result<void> operator()(const model::diff::advance::remote_copy_t &, void *) noexcept override;
diff --git a/src/fs/scan_actor.cpp b/src/fs/scan_actor.cpp
index a1209650..ec7981e4 100644
--- a/src/fs/scan_actor.cpp
+++ b/src/fs/scan_actor.cpp
@@ -262,7 +262,7 @@ void scan_actor_t::on_hash(hasher::message::digest_response_t &res) noexcept {
         return do_shutdown(ee);
     }
 
-    auto& fi = info.get_folder();
+    auto &fi = info.get_folder();
     bool queued_next = false;
     auto &digest = res.payload.res.digest;
     auto block_index = rp.block_index;
diff --git a/src/fs/scan_task.cpp b/src/fs/scan_task.cpp
index 7f2f5b93..62a88640 100644
--- a/src/fs/scan_task.cpp
+++ b/src/fs/scan_task.cpp
@@ -41,7 +41,7 @@ scan_task_t::scan_task_t(model::cluster_ptr_t cluster_, std::string_view folder_
     }
 
     folder_info = folder->get_folder_infos().by_device(*cluster->get_device()).get();
-    if (!folder_info ) {
+    if (!folder_info) {
         return;
     }
 
diff --git a/src/fs/scan_task.h b/src/fs/scan_task.h
index 84eb3ab7..93ed4083 100644
--- a/src/fs/scan_task.h
+++ b/src/fs/scan_task.h
@@ -128,7 +128,7 @@ struct SYNCSPIRIT_API scan_task_t : boost::intrusive_ref_counter<scan_task_t, bo
 
     std::string folder_id;
     model::folder_ptr_t folder;
-    model::folder_info_t* folder_info;
+    model::folder_info_t *folder_info;
     model::cluster_ptr_t cluster;
     file_cache_ptr_t rw_cache;
     model::file_infos_map_t files;
diff --git a/src/model/diff/advance/advance.cpp b/src/model/diff/advance/advance.cpp
index 6df81d87..9616547f 100644
--- a/src/model/diff/advance/advance.cpp
+++ b/src/model/diff/advance/advance.cpp
@@ -26,9 +26,8 @@ static std::string_view stringify(advance_action_t action) {
     return "ignore";
 }
 
-auto advance_t::create(advance_action_t action, const model::file_info_t &source,
-                       const model::folder_info_t& source_fi,  sequencer_t &sequencer) noexcept
-    -> cluster_diff_ptr_t {
+auto advance_t::create(advance_action_t action, const model::file_info_t &source, const model::folder_info_t &source_fi,
+                       sequencer_t &sequencer) noexcept -> cluster_diff_ptr_t {
     auto folder = source_fi.get_folder();
     auto &cluster = *folder->get_cluster();
     auto proto_file = source.as_proto(true);
diff --git a/src/model/diff/advance/advance.h b/src/model/diff/advance/advance.h
index d93fa2b6..20143d6e 100644
--- a/src/model/diff/advance/advance.h
+++ b/src/model/diff/advance/advance.h
@@ -13,7 +13,7 @@ namespace syncspirit::model::diff::advance {
 
 struct SYNCSPIRIT_API advance_t : cluster_diff_t {
     static cluster_diff_ptr_t create(advance_action_t action, const model::file_info_t &source,
-                                     const model::folder_info_t& source_fi, sequencer_t &sequencer) noexcept;
+                                     const model::folder_info_t &source_fi, sequencer_t &sequencer) noexcept;
 
     outcome::result<void> apply_impl(apply_controller_t &, void *) const noexcept override;
     outcome::result<void> apply_forward(apply_controller_t &, void *) const noexcept override;
diff --git a/src/model/diff/local/blocks_availability.cpp b/src/model/diff/local/blocks_availability.cpp
index 35b726f0..dd01f1bb 100644
--- a/src/model/diff/local/blocks_availability.cpp
+++ b/src/model/diff/local/blocks_availability.cpp
@@ -9,7 +9,8 @@
 
 using namespace syncspirit::model::diff::local;
 
-blocks_availability_t::blocks_availability_t(const file_info_t &file, const folder_info_t &fi, valid_blocks_map_t valid_blocks_map_) noexcept
+blocks_availability_t::blocks_availability_t(const file_info_t &file, const folder_info_t &fi,
+                                             valid_blocks_map_t valid_blocks_map_) noexcept
     : block_diff_t{file, fi}, valid_blocks_map{std::move(valid_blocks_map_)} {
     LOG_DEBUG(log, "blocks_availability_t, file: '{}', valid blocks: {}", file, valid_blocks_map.size());
     assert(!file.is_locally_available());
diff --git a/src/model/diff/local/blocks_availability.h b/src/model/diff/local/blocks_availability.h
index e8049a11..d8586e80 100644
--- a/src/model/diff/local/blocks_availability.h
+++ b/src/model/diff/local/blocks_availability.h
@@ -12,7 +12,8 @@ namespace syncspirit::model::diff::local {
 struct SYNCSPIRIT_API blocks_availability_t final : block_diff_t {
     using valid_blocks_map_t = std::vector<bool>;
 
-    blocks_availability_t(const file_info_t &file, const folder_info_t &fi, valid_blocks_map_t valid_blocks_map) noexcept;
+    blocks_availability_t(const file_info_t &file, const folder_info_t &fi,
+                          valid_blocks_map_t valid_blocks_map) noexcept;
 
     outcome::result<void> apply_impl(apply_controller_t &, void *) const noexcept override;
     outcome::result<void> visit(cluster_visitor_t &, void *) const noexcept override;
diff --git a/src/model/diff/local/file_availability.cpp b/src/model/diff/local/file_availability.cpp
index 375edbaa..5248a473 100644
--- a/src/model/diff/local/file_availability.cpp
+++ b/src/model/diff/local/file_availability.cpp
@@ -19,7 +19,7 @@ auto file_availability_t::apply_impl(apply_controller_t &controller, void *custo
     auto &cluster = controller.get_cluster();
     auto folder = cluster.get_folders().by_id(folder_id);
     if (folder) {
-        auto& folder_info = *folder->get_folder_infos().by_device(*cluster.get_device());
+        auto &folder_info = *folder->get_folder_infos().by_device(*cluster.get_device());
         auto f = folder_info.get_file_infos().by_name(file->get_name()->get_full_name());
         if (f->get_version().identical_to(version)) {
             f->mark_local(true, folder_info);
diff --git a/src/model/diff/modify/append_block.cpp b/src/model/diff/modify/append_block.cpp
index 56489046..c5523338 100644
--- a/src/model/diff/modify/append_block.cpp
+++ b/src/model/diff/modify/append_block.cpp
@@ -7,7 +7,8 @@
 
 using namespace syncspirit::model::diff::modify;
 
-append_block_t::append_block_t(const file_info_t &file, const folder_info_t &fi, size_t block_index_, utils::bytes_t data_) noexcept
+append_block_t::append_block_t(const file_info_t &file, const folder_info_t &fi, size_t block_index_,
+                               utils::bytes_t data_) noexcept
     : block_transaction_t{file, fi, block_index_}, data{std::move(data_)} {
     LOG_DEBUG(log, "append_block_t, file: '{}', block: {}", file, block_index);
 }
diff --git a/src/model/diff/modify/block_transaction.cpp b/src/model/diff/modify/block_transaction.cpp
index a195c352..61c81eb7 100644
--- a/src/model/diff/modify/block_transaction.cpp
+++ b/src/model/diff/modify/block_transaction.cpp
@@ -7,8 +7,8 @@
 
 using namespace syncspirit::model::diff::modify;
 
-block_transaction_t::block_transaction_t(const file_info_t &file, const folder_info_t& fi, size_t block_index) :
-    parent_t(file,  fi, block_index) {}
+block_transaction_t::block_transaction_t(const file_info_t &file, const folder_info_t &fi, size_t block_index)
+    : parent_t(file, fi, block_index) {}
 
 auto block_transaction_t::ack() const -> cluster_diff_ptr_t { return new block_ack_t(*this); }
 
diff --git a/src/model/diff/modify/block_transaction.h b/src/model/diff/modify/block_transaction.h
index 541f8c25..5f20bb70 100644
--- a/src/model/diff/modify/block_transaction.h
+++ b/src/model/diff/modify/block_transaction.h
@@ -10,7 +10,7 @@ namespace syncspirit::model::diff::modify {
 struct SYNCSPIRIT_API block_transaction_t : block_diff_t {
     using parent_t = block_diff_t;
 
-    block_transaction_t(const file_info_t &file, const folder_info_t& fi, size_t block_index);
+    block_transaction_t(const file_info_t &file, const folder_info_t &fi, size_t block_index);
 
     cluster_diff_ptr_t ack() const;
     cluster_diff_ptr_t rej() const;
diff --git a/src/model/diff/modify/clone_block.cpp b/src/model/diff/modify/clone_block.cpp
index 90223d5a..0f31c1e0 100644
--- a/src/model/diff/modify/clone_block.cpp
+++ b/src/model/diff/modify/clone_block.cpp
@@ -8,7 +8,8 @@
 
 using namespace syncspirit::model::diff::modify;
 
-clone_block_t::clone_block_t(const file_block_t &file_block, const folder_info_t &target_fi, const folder_info_t &source_fi) noexcept
+clone_block_t::clone_block_t(const file_block_t &file_block, const folder_info_t &target_fi,
+                             const folder_info_t &source_fi) noexcept
     : block_transaction_t{*file_block.file(), target_fi, file_block.block_index()} {
     const file_info_t *source_file = nullptr;
     auto &block_pieces = file_block.block()->get_file_blocks();
@@ -26,8 +27,7 @@ clone_block_t::clone_block_t(const file_block_t &file_block, const folder_info_t
     source_folder_id = folder->get_id();
     source_file_name = source_file->get_name()->get_full_name();
 
-    assert(file_block.file()->get_blocks().at(block_index)->get_hash() == folder
-                                                                              ->get_cluster()
+    assert(file_block.file()->get_blocks().at(block_index)->get_hash() == folder->get_cluster()
                                                                               ->get_folders()
                                                                               .by_id(source_folder_id)
                                                                               ->get_folder_infos()
diff --git a/src/model/diff/modify/clone_block.h b/src/model/diff/modify/clone_block.h
index 9bc4f209..8d13e97e 100644
--- a/src/model/diff/modify/clone_block.h
+++ b/src/model/diff/modify/clone_block.h
@@ -9,7 +9,8 @@
 namespace syncspirit::model::diff::modify {
 
 struct SYNCSPIRIT_API clone_block_t final : block_transaction_t {
-    clone_block_t(const file_block_t &file_block, const folder_info_t &target_fi, const folder_info_t &source_fi) noexcept;
+    clone_block_t(const file_block_t &file_block, const folder_info_t &target_fi,
+                  const folder_info_t &source_fi) noexcept;
 
     outcome::result<void> visit(cluster_visitor_t &, void *) const noexcept override;
 
diff --git a/src/model/diff/modify/finish_file.cpp b/src/model/diff/modify/finish_file.cpp
index 0dbc14df..6b44609a 100644
--- a/src/model/diff/modify/finish_file.cpp
+++ b/src/model/diff/modify/finish_file.cpp
@@ -10,7 +10,7 @@
 
 using namespace syncspirit::model::diff::modify;
 
-finish_file_t::finish_file_t(const model::file_info_t &file, const folder_info_t& fi) noexcept {
+finish_file_t::finish_file_t(const model::file_info_t &file, const folder_info_t &fi) noexcept {
     auto folder = fi.get_folder();
     auto &device_id = fi.get_device()->device_id();
     folder_id = folder->get_id();
diff --git a/src/model/diff/modify/finish_file.h b/src/model/diff/modify/finish_file.h
index aea4abc6..b02a756a 100644
--- a/src/model/diff/modify/finish_file.h
+++ b/src/model/diff/modify/finish_file.h
@@ -10,7 +10,7 @@
 namespace syncspirit::model::diff::modify {
 
 struct SYNCSPIRIT_API finish_file_t final : cluster_diff_t {
-    finish_file_t(const model::file_info_t &file, const folder_info_t& fi) noexcept;
+    finish_file_t(const model::file_info_t &file, const folder_info_t &fi) noexcept;
 
     outcome::result<void> visit(cluster_visitor_t &, void *) const noexcept override;
 
diff --git a/src/model/diff/modify/mark_reachable.cpp b/src/model/diff/modify/mark_reachable.cpp
index 9191db00..fb412b9a 100644
--- a/src/model/diff/modify/mark_reachable.cpp
+++ b/src/model/diff/modify/mark_reachable.cpp
@@ -9,9 +9,8 @@
 
 using namespace syncspirit::model::diff::modify;
 
-mark_reachable_t::mark_reachable_t(const model::file_info_t &file, const folder_info_t& fi, bool reachable_) noexcept
-    : folder_id{fi.get_folder()->get_id()}, file_name{file.get_name()->get_full_name()},
-      reachable{reachable_} {
+mark_reachable_t::mark_reachable_t(const model::file_info_t &file, const folder_info_t &fi, bool reachable_) noexcept
+    : folder_id{fi.get_folder()->get_id()}, file_name{file.get_name()->get_full_name()}, reachable{reachable_} {
     auto &peer = fi.get_device()->device_id();
     device_id = peer.get_sha256();
     LOG_DEBUG(log, "mark_reachable_t, file: '{}', device: {}, value: {}", file, peer, reachable);
diff --git a/src/model/diff/modify/mark_reachable.h b/src/model/diff/modify/mark_reachable.h
index 3d609daa..bcfc3de1 100644
--- a/src/model/diff/modify/mark_reachable.h
+++ b/src/model/diff/modify/mark_reachable.h
@@ -10,7 +10,7 @@ namespace syncspirit::model::diff::modify {
 
 struct SYNCSPIRIT_API mark_reachable_t final : cluster_diff_t {
 
-    mark_reachable_t(const model::file_info_t &file, const folder_info_t& fi, bool reachable) noexcept;
+    mark_reachable_t(const model::file_info_t &file, const folder_info_t &fi, bool reachable) noexcept;
 
     outcome::result<void> apply_impl(apply_controller_t &, void *) const noexcept override;
     outcome::result<void> visit(cluster_visitor_t &, void *) const noexcept override;
diff --git a/src/model/diff/modify/remove_files.cpp b/src/model/diff/modify/remove_files.cpp
index 410c5e83..a086ee42 100644
--- a/src/model/diff/modify/remove_files.cpp
+++ b/src/model/diff/modify/remove_files.cpp
@@ -10,9 +10,9 @@
 
 using namespace syncspirit::model::diff::modify;
 
-remove_files_t::remove_files_t(const folder_info_t& fi, const file_infos_map_t &files,
+remove_files_t::remove_files_t(const folder_info_t &fi, const file_infos_map_t &files,
                                orphaned_blocks_t *orphaned_blocks_) noexcept {
-    auto& device = *fi.get_device();
+    auto &device = *fi.get_device();
     folder_id = fi.get_folder()->get_id();
     device_id = device.device_id().get_sha256();
     keys.reserve(files.size());
diff --git a/src/model/diff/modify/remove_files.h b/src/model/diff/modify/remove_files.h
index e388938c..5f31f104 100644
--- a/src/model/diff/modify/remove_files.h
+++ b/src/model/diff/modify/remove_files.h
@@ -12,7 +12,7 @@ namespace syncspirit::model::diff::modify {
 struct SYNCSPIRIT_API remove_files_t final : generic_remove_t {
     using generic_remove_t::generic_remove_t;
 
-    remove_files_t(const folder_info_t& fi, const file_infos_map_t &files,
+    remove_files_t(const folder_info_t &fi, const file_infos_map_t &files,
                    orphaned_blocks_t *orphaned_blocks = nullptr) noexcept;
 
     outcome::result<void> apply_impl(apply_controller_t &, void *) const noexcept override;
diff --git a/src/model/file_info.cpp b/src/model/file_info.cpp
index 4e16c493..8ee4a2e6 100644
--- a/src/model/file_info.cpp
+++ b/src/model/file_info.cpp
@@ -58,7 +58,7 @@ outcome::result<file_info_ptr_t> file_info_t::create(utils::bytes_view_t key, co
     auto ptr = file_info_ptr_t();
     ptr = new file_info_t(key, folder_info);
 
-    auto& path_cache = folder_info->get_folder()->get_cluster()->get_path_cache();
+    auto &path_cache = folder_info->get_folder()->get_cluster()->get_path_cache();
     auto r = ptr->fields_update(data, path_cache);
     if (!r) {
         return r.assume_error();
@@ -72,7 +72,7 @@ auto file_info_t::create(const bu::uuid &uuid_, const proto::FileInfo &info_,
     auto ptr = file_info_ptr_t();
     ptr = new file_info_t(uuid_, folder_info);
 
-    auto& path_cache = folder_info->get_folder()->get_cluster()->get_path_cache();
+    auto &path_cache = folder_info->get_folder()->get_cluster()->get_path_cache();
     auto r = ptr->fields_update(info_, path_cache);
     if (!r) {
         return r.assume_error();
@@ -88,8 +88,10 @@ static void fill(unsigned char *key, const bu::uuid &uuid, const folder_info_ptr
     std::copy(uuid.begin(), uuid.end(), key + 1 + fi_uuid.size());
 }
 
-file_info_t::guard_t::guard_t(file_info_t &file_, const folder_info_t* folder_info_) noexcept :
-    file{&file_}, folder_info{folder_info_} { file_.synchronizing_lock(); }
+file_info_t::guard_t::guard_t(file_info_t &file_, const folder_info_t *folder_info_) noexcept
+    : file{&file_}, folder_info{folder_info_} {
+    file_.synchronizing_lock();
+}
 
 file_info_t::guard_t::~guard_t() {
     if (file) {
@@ -97,14 +99,12 @@ file_info_t::guard_t::~guard_t() {
     }
 }
 
-file_info_t::file_info_t(utils::bytes_view_t key_, const folder_info_ptr_t &folder_info) noexcept
-    {
+file_info_t::file_info_t(utils::bytes_view_t key_, const folder_info_ptr_t &folder_info) noexcept {
     assert(key_.subspan(1, uuid_length) == folder_info->get_uuid());
     std::copy(key_.begin(), key_.end(), key);
 }
 
-file_info_t::file_info_t(const bu::uuid &uuid, const folder_info_ptr_t &folder_info_) noexcept
-    {
+file_info_t::file_info_t(const bu::uuid &uuid, const folder_info_ptr_t &folder_info_) noexcept {
     fill(key, uuid, folder_info_);
 }
 
@@ -134,13 +134,13 @@ utils::bytes_view_t file_info_t::get_folder_uuid() const noexcept {
     return utils::bytes_view_t(key + 1, key + 1 + uuid_length);
 }
 
-
 std::uint64_t file_info_t::get_block_offset(size_t block_index) const noexcept {
     assert(!blocks.empty());
     return block_size * block_index;
 }
 
-auto file_info_t::fields_update(const db::FileInfo &source, model::path_cache_t& path_cache) noexcept -> outcome::result<void> {
+auto file_info_t::fields_update(const db::FileInfo &source, model::path_cache_t &path_cache) noexcept
+    -> outcome::result<void> {
     flags = (flags & ~0b111111) | as_flags(db::get_type(source));
     name = path_cache.get_path(db::get_name(source));
     sequence = db::get_sequence(source);
@@ -170,7 +170,8 @@ auto file_info_t::fields_update(const db::FileInfo &source, model::path_cache_t&
     return reserve_blocks(has_content ? db::get_blocks_size(source) : 0);
 }
 
-auto file_info_t::fields_update(const proto::FileInfo &source, model::path_cache_t& path_cache) noexcept -> outcome::result<void> {
+auto file_info_t::fields_update(const proto::FileInfo &source, model::path_cache_t &path_cache) noexcept
+    -> outcome::result<void> {
     name = path_cache.get_path(proto::get_name(source));
     sequence = proto::get_sequence(source);
     flags = (flags & ~0b111111) | as_flags(proto::get_type(source));
@@ -295,7 +296,7 @@ void file_info_t::mark_unreachable(bool value) noexcept {
     }
 }
 
-void file_info_t::mark_local(bool available, const folder_info_t& folder_info) noexcept {
+void file_info_t::mark_local(bool available, const folder_info_t &folder_info) noexcept {
     if (available) {
         flags = flags | f_local;
     } else {
@@ -338,7 +339,7 @@ bool file_info_t::is_locally_available() const noexcept { return missing_blocks
 
 bool file_info_t::is_partly_available() const noexcept { return missing_blocks < blocks.size(); }
 
-const std::filesystem::path file_info_t::get_path(const folder_info_t& folder_info) const noexcept {
+const std::filesystem::path file_info_t::get_path(const folder_info_t &folder_info) const noexcept {
     auto own_name = boost::nowide::widen(name->get_full_name());
     auto path = folder_info.get_folder()->get_path() / own_name;
     path.make_preferred();
@@ -475,7 +476,9 @@ std::string file_info_t::make_conflicting_name() const noexcept {
     return full_name.string();
 }
 
-auto file_info_t::guard(const model::folder_info_t& folder_info) noexcept -> guard_t { return guard_t(*this, &folder_info); }
+auto file_info_t::guard(const model::folder_info_t &folder_info) noexcept -> guard_t {
+    return guard_t(*this, &folder_info);
+}
 
 bool file_info_t::identical_to(const proto::FileInfo &file) const noexcept {
     auto &v = proto::get_version(file);
diff --git a/src/model/file_info.h b/src/model/file_info.h
index 3cfabdf2..003303ef 100644
--- a/src/model/file_info.h
+++ b/src/model/file_info.h
@@ -60,7 +60,7 @@ struct SYNCSPIRIT_API file_info_t final : augmentable_t {
 
     struct guard_t {
         guard_t() noexcept = default;
-        guard_t(file_info_t &file, const folder_info_t* folder_info) noexcept;
+        guard_t(file_info_t &file, const folder_info_t *folder_info) noexcept;
         guard_t(const guard_t &) = delete;
         guard_t(guard_t &&) = default;
         ~guard_t();
@@ -68,7 +68,7 @@ struct SYNCSPIRIT_API file_info_t final : augmentable_t {
         guard_t &operator=(guard_t &&) noexcept = default;
 
         file_info_ptr_t file;
-        const folder_info_t* folder_info;
+        const folder_info_t *folder_info;
     };
 
     static outcome::result<file_info_ptr_t> create(utils::bytes_view_t key, const db::FileInfo &data,
@@ -127,14 +127,14 @@ struct SYNCSPIRIT_API file_info_t final : augmentable_t {
 
     void mark_unreachable(bool value) noexcept;
     void mark_local_available(size_t block_index) noexcept;
-    void mark_local(bool available, const folder_info_t&) noexcept;
+    void mark_local(bool available, const folder_info_t &) noexcept;
     bool is_locally_available(size_t block_index) const noexcept;
     bool is_locally_available() const noexcept;
     bool is_partly_available() const noexcept;
 
     const std::string &get_link_target() const noexcept { return symlink_target; }
 
-    const bfs::path get_path(const folder_info_t& folder_info) const noexcept;
+    const bfs::path get_path(const folder_info_t &folder_info) const noexcept;
 
     inline std::int64_t get_modified_s() const noexcept { return modified_s; }
     inline std::int32_t get_modified_ns() const noexcept { return modified_ns; }
@@ -152,8 +152,8 @@ struct SYNCSPIRIT_API file_info_t final : augmentable_t {
 
     static const constexpr auto data_length = 1 + uuid_length * 2;
 
-    outcome::result<void> fields_update(const db::FileInfo &, model::path_cache_t&) noexcept;
-    outcome::result<void> fields_update(const proto::FileInfo &, model::path_cache_t&) noexcept;
+    outcome::result<void> fields_update(const db::FileInfo &, model::path_cache_t &) noexcept;
+    outcome::result<void> fields_update(const proto::FileInfo &, model::path_cache_t &) noexcept;
 
     proto::Index generate() noexcept;
     std::size_t expected_meta_size() const noexcept;
@@ -161,7 +161,7 @@ struct SYNCSPIRIT_API file_info_t final : augmentable_t {
     std::uint32_t get_permissions() const noexcept;
     bool has_no_permissions() const noexcept;
 
-    guard_t guard(const model::folder_info_t& folder_info) noexcept;
+    guard_t guard(const model::folder_info_t &folder_info) noexcept;
 
     std::string make_conflicting_name() const noexcept;
 
diff --git a/src/model/misc/block_iterator.cpp b/src/model/misc/block_iterator.cpp
index ef85e91b..07d098b0 100644
--- a/src/model/misc/block_iterator.cpp
+++ b/src/model/misc/block_iterator.cpp
@@ -9,9 +9,8 @@ using namespace syncspirit::model;
 
 static constexpr auto wrong_index = std::numeric_limits<size_t>::max();
 
-blocks_iterator_t::blocks_iterator_t(file_info_t &source_, const folder_info_t &source_folder_) noexcept :
-    source_folder{source_folder_}, source{&source_},
-    i{0} {
+blocks_iterator_t::blocks_iterator_t(file_info_t &source_, const folder_info_t &source_folder_) noexcept
+    : source_folder{source_folder_}, source{&source_}, i{0} {
     auto &sb = source->get_blocks();
     if (i == sb.size()) {
         i = wrong_index;
diff --git a/src/model/misc/block_iterator.h b/src/model/misc/block_iterator.h
index be6f7652..12c5b9ac 100644
--- a/src/model/misc/block_iterator.h
+++ b/src/model/misc/block_iterator.h
@@ -16,18 +16,18 @@ struct file_info_t;
 struct SYNCSPIRIT_API blocks_iterator_t : arc_base_t<blocks_iterator_t> {
     using blocks_t = std::vector<block_info_ptr_t>;
 
-    blocks_iterator_t(file_info_t &source, const folder_info_t& source_folder) noexcept;
+    blocks_iterator_t(file_info_t &source, const folder_info_t &source_folder) noexcept;
     operator bool() const noexcept;
 
     file_block_t next() noexcept;
     file_info_t *get_source() noexcept;
-    inline const folder_info_t& get_source_folder() const noexcept { return source_folder; }
+    inline const folder_info_t &get_source_folder() const noexcept { return source_folder; }
 
   private:
     void prepare() noexcept;
     void advance() noexcept;
 
-    const folder_info_t& source_folder;
+    const folder_info_t &source_folder;
     file_info_ptr_t source;
     size_t i = 0;
     std::int64_t sequence;
diff --git a/src/model/misc/file_iterator.cpp b/src/model/misc/file_iterator.cpp
index c92be1ab..031fa1b1 100644
--- a/src/model/misc/file_iterator.cpp
+++ b/src/model/misc/file_iterator.cpp
@@ -70,8 +70,8 @@ auto file_iterator_t::find_folder(folder_t *folder) noexcept -> folder_iterator_
 auto file_iterator_t::prepare_folder(folder_info_ptr_t peer_folder) noexcept -> folder_iterator_t & {
     auto &files = peer_folder->get_file_infos();
     auto folder = peer_folder->get_folder();
-    auto& local_folder = *folder->get_folder_infos().by_device(*folder->get_cluster()->get_device());
-    auto& local_files = local_folder.get_file_infos();
+    auto &local_folder = *folder->get_folder_infos().by_device(*folder->get_cluster()->get_device());
+    auto &local_files = local_folder.get_file_infos();
     auto order = folder->get_pull_order();
     auto set = std::make_unique<queue_t>(file_comparator_t{order});
     auto seen_index = std::uint64_t{0};
@@ -102,8 +102,8 @@ auto file_iterator_t::next() noexcept -> result_t {
 
     while (folder_scans < folders_count) {
         auto &fi = folders_list[folder_index];
-        auto& peer_folder = *fi.peer_folder;
-        auto folder = peer_folder .get_folder();
+        auto &peer_folder = *fi.peer_folder;
+        auto folder = peer_folder.get_folder();
         auto &folders = folder->get_folder_infos();
         auto &local_folder = *folders.by_device(*cluster.get_device());
         auto &local_files = local_folder.get_file_infos();
@@ -149,8 +149,8 @@ void file_iterator_t::populate(folder_iterator_t &it) noexcept {
     }
     auto &files_map = peer_folder->get_file_infos();
     auto folder = peer_folder->get_folder();
-    auto& local_folder = *folder->get_folder_infos().by_device(*folder->get_cluster()->get_device());
-    auto& local_files = local_folder.get_file_infos();
+    auto &local_folder = *folder->get_folder_infos().by_device(*folder->get_cluster()->get_device());
+    auto &local_files = local_folder.get_file_infos();
     auto max_sequence = peer_folder->get_max_sequence();
     auto [from, to] = files_map.range(seen_sequence + 1, max_sequence);
     for (auto fit = from; fit != to; ++fit) {
@@ -209,8 +209,8 @@ void file_iterator_t::recheck(const folder_info_t &remote_fi, file_info_t &remot
         if (fi.peer_folder.get() == &remote_fi) {
             if (fi.can_receive) {
                 auto folder = fi.peer_folder->get_folder();
-                auto& local_folder = *folder->get_folder_infos().by_device(*folder->get_cluster()->get_device());
-                auto& local_files = local_folder.get_file_infos();
+                auto &local_folder = *folder->get_folder_infos().by_device(*folder->get_cluster()->get_device());
+                auto &local_files = local_folder.get_file_infos();
                 auto local_file = local_files.by_name(remote.get_name()->get_full_name());
                 if (resolve(remote, local_file.get(), local_folder) != advance_action_t::ignore) {
                     fi.files_queue->emplace(&remote);
diff --git a/src/model/misc/file_iterator.h b/src/model/misc/file_iterator.h
index e21740cc..2df7ba76 100644
--- a/src/model/misc/file_iterator.h
+++ b/src/model/misc/file_iterator.h
@@ -20,7 +20,7 @@ using compare_fn_t = bool(const file_info_t *l, const file_info_t *r);
 
 struct SYNCSPIRIT_API file_iterator_t : arc_base_t<file_iterator_t> {
     using files_list_t = std::vector<file_info_ptr_t>;
-    using result_t = std::tuple<file_info_t *, const folder_info_t*, advance_action_t>;
+    using result_t = std::tuple<file_info_t *, const folder_info_t *, advance_action_t>;
 
     file_iterator_t(cluster_t &cluster, const device_ptr_t &peer) noexcept;
     file_iterator_t(const file_iterator_t &) = delete;
@@ -30,7 +30,7 @@ struct SYNCSPIRIT_API file_iterator_t : arc_base_t<file_iterator_t> {
     void on_upsert(folder_t &folder) noexcept;
     void on_upsert(folder_info_ptr_t peer_folder) noexcept;
     void on_remove(folder_info_ptr_t peer_folder) noexcept;
-    void recheck(const folder_info_t& fi, file_info_t &file) noexcept;
+    void recheck(const folder_info_t &fi, file_info_t &file) noexcept;
 
   private:
     struct file_comparator_t {
diff --git a/src/model/misc/resolver.cpp b/src/model/misc/resolver.cpp
index 8ab00e25..580df13e 100644
--- a/src/model/misc/resolver.cpp
+++ b/src/model/misc/resolver.cpp
@@ -72,7 +72,8 @@ int compare(const file_info_t &file_1, const file_info_t &file_2) noexcept {
     return -1;
 }
 
-static advance_action_t _resolve(const file_info_t &remote, const file_info_t *local, const folder_info_t& local_folder) noexcept {
+static advance_action_t _resolve(const file_info_t &remote, const file_info_t *local,
+                                 const folder_info_t &local_folder) noexcept {
     if (remote.is_unreachable()) {
         return advance_action_t::ignore;
     }
@@ -115,7 +116,8 @@ static advance_action_t _resolve(const file_info_t &remote, const file_info_t *l
     return compare_by_version(remote, *local);
 }
 
-advance_action_t resolve(const file_info_t &remote, const file_info_t* local, const folder_info_t& local_folder) noexcept {
+advance_action_t resolve(const file_info_t &remote, const file_info_t *local,
+                         const folder_info_t &local_folder) noexcept {
     using P = utils::platform_t;
     if (remote.is_link() && !remote.is_deleted() && !P::symlinks_supported()) {
         return advance_action_t::ignore;
diff --git a/src/model/misc/resolver.h b/src/model/misc/resolver.h
index db24959f..9813b947 100644
--- a/src/model/misc/resolver.h
+++ b/src/model/misc/resolver.h
@@ -17,6 +17,7 @@ enum class advance_action_t {
 
 int SYNCSPIRIT_API compare(const file_info_t &file_1, const file_info_t &file_2) noexcept;
 
-advance_action_t SYNCSPIRIT_API resolve(const file_info_t &remote, const file_info_t* local, const folder_info_t& local_folder) noexcept;
+advance_action_t SYNCSPIRIT_API resolve(const file_info_t &remote, const file_info_t *local,
+                                        const folder_info_t &local_folder) noexcept;
 
 } // namespace syncspirit::model
diff --git a/src/model/misc/updates_streamer.cpp b/src/model/misc/updates_streamer.cpp
index c1fa6453..cc36561b 100644
--- a/src/model/misc/updates_streamer.cpp
+++ b/src/model/misc/updates_streamer.cpp
@@ -51,7 +51,7 @@ void updates_streamer_t::refresh_remote() noexcept {
     }
 }
 
-bool updates_streamer_t::on_update(file_info_t &file, const folder_info_t& fi) noexcept {
+bool updates_streamer_t::on_update(file_info_t &file, const folder_info_t &fi) noexcept {
     assert(fi.get_device() == self);
     bool r = false;
     if (!streaming) {
@@ -91,7 +91,7 @@ auto updates_streamer_t::next() noexcept -> update_t {
             auto &seen_sequence = seen_info[streaming->folder_info];
             auto initial = seen_sequence == 0;
             seen_sequence = file->get_sequence();
-            return {file,  streaming->folder_info.get(), initial};
+            return {file, streaming->folder_info.get(), initial};
         }
         streaming.reset();
     }
diff --git a/src/model/misc/updates_streamer.h b/src/model/misc/updates_streamer.h
index 4796acb9..3dec0a40 100644
--- a/src/model/misc/updates_streamer.h
+++ b/src/model/misc/updates_streamer.h
@@ -16,7 +16,7 @@
 namespace syncspirit::model {
 
 struct SYNCSPIRIT_API updates_streamer_t {
-    using update_t = std::tuple<file_info_ptr_t, folder_info_t*, bool>;
+    using update_t = std::tuple<file_info_ptr_t, folder_info_t *, bool>;
 
     updates_streamer_t(cluster_t &, device_t &) noexcept;
     updates_streamer_t(const updates_streamer_t &) noexcept = delete;
@@ -24,7 +24,7 @@ struct SYNCSPIRIT_API updates_streamer_t {
 
     update_t next() noexcept;
 
-    bool on_update(file_info_t &, const folder_info_t&) noexcept;
+    bool on_update(file_info_t &, const folder_info_t &) noexcept;
     void on_remote_refresh() noexcept;
     void on_upsert(const folder_info_t &) noexcept;
 
diff --git a/src/net/controller_actor.cpp b/src/net/controller_actor.cpp
index 813491b8..47d8c095 100644
--- a/src/net/controller_actor.cpp
+++ b/src/net/controller_actor.cpp
@@ -241,7 +241,7 @@ void controller_actor_t::push_pending() noexcept {
     }
 
     auto updates = updates_t{};
-    auto get_update = [&](model::file_info_t &file, model::folder_info_t& folder_info) -> update_t & {
+    auto get_update = [&](model::file_info_t &file, model::folder_info_t &folder_info) -> update_t & {
         for (auto &p : updates) {
             if (p.folder == &folder_info) {
                 return p;
@@ -389,7 +389,8 @@ OUTER:
     }
 }
 
-void controller_actor_t::preprocess_block(model::file_block_t &file_block, const model::folder_info_t &source_folder) noexcept {
+void controller_actor_t::preprocess_block(model::file_block_t &file_block,
+                                          const model::folder_info_t &source_folder) noexcept {
     using namespace model::diff;
     if (!peer_address) {
         LOG_TRACE(log, "ignoring block, as there is no peer");
@@ -414,7 +415,8 @@ void controller_actor_t::preprocess_block(model::file_block_t &file_block, const
         auto sz = block->get_size();
         LOG_TRACE(log, "request_block '{}' on file '{}'; block index = {} / {}, sz = {}, request pool sz = {}", hash,
                   *file, file_block.block_index(), file->get_blocks().size() - 1, sz, request_pool);
-        request<payload::block_request_t>(peer_address, file, source_folder, file_block.block_index()).send(request_timeout);
+        request<payload::block_request_t>(peer_address, file, source_folder, file_block.block_index())
+            .send(request_timeout);
         ++rx_blocks_requested;
         request_pool -= (int64_t)sz;
     }
@@ -618,7 +620,7 @@ auto controller_actor_t::operator()(const model::diff::modify::block_ack_t &diff
         }
         auto folder = cluster->get_folders().by_id(diff.folder_id);
         if (folder) {
-            auto& folder_infos = folder->get_folder_infos();
+            auto &folder_infos = folder->get_folder_infos();
             auto folder_info = folder_infos.by_device_id(diff.device_id);
             if (folder_info) {
                 auto file = folder_info->get_file_infos().by_name(diff.file_name);
@@ -829,7 +831,7 @@ void controller_actor_t::on_block(message::block_response_t &message) noexcept {
     auto &ee = message.payload.ee;
     auto &payload = message.payload.req->payload.request_payload;
     auto [file_block, folder_info] = payload.get_block(*cluster, *peer);
-    auto file = file_block ? file_block->file() : (model::file_info_t*)(nullptr);
+    auto file = file_block ? file_block->file() : (model::file_info_t *)(nullptr);
     bool do_release_block = false;
     bool try_next = true;
     if (state != r::state_t::OPERATIONAL) {
@@ -885,7 +887,7 @@ void controller_actor_t::on_validation(hasher::message::validation_response_t &r
     auto block_res = (message::block_response_t *)res.payload.req->payload.request_payload->custom.get();
     auto &payload = block_res->payload.req->payload.request_payload;
     auto [file_block, folder_info] = payload.get_block(*cluster, *peer);
-    auto file = file_block ? file_block->file() : (model::file_info_t*)(nullptr);
+    auto file = file_block ? file_block->file() : (model::file_info_t *)(nullptr);
     bool do_release_block = false;
     bool try_next = false;
     if (state != r::state_t::OPERATIONAL) {
@@ -933,7 +935,8 @@ void controller_actor_t::on_validation(hasher::message::validation_response_t &r
                     try_next = true;
                     do_release_block = true;
                 } else {
-                    auto diff = cluster_diff_ptr_t(new modify::append_block_t(*file, *folder_info, index, std::move(data)));
+                    auto diff =
+                        cluster_diff_ptr_t(new modify::append_block_t(*file, *folder_info, index, std::move(data)));
                     push_block_write(std::move(diff));
                 }
             }
@@ -1013,7 +1016,8 @@ auto controller_actor_t::get_sync_info(std::string_view folder_id) noexcept -> f
     return it->second;
 }
 
-void controller_actor_t::acquire_block(const model::file_block_t &file_block, const model::folder_info_t &folder_info) noexcept {
+void controller_actor_t::acquire_block(const model::file_block_t &file_block,
+                                       const model::folder_info_t &folder_info) noexcept {
     auto block = file_block.block();
     auto folder = folder_info.get_folder();
     LOG_TRACE(log, "acquire block '{}', {}", block->get_hash(), (const void *)block);
diff --git a/src/net/controller_actor.h b/src/net/controller_actor.h
index 1eee4044..b8e60a4a 100644
--- a/src/net/controller_actor.h
+++ b/src/net/controller_actor.h
@@ -155,7 +155,7 @@ struct SYNCSPIRIT_API controller_actor_t : public r::actor_base_t, private model
     void on_forward(message::forwarded_message_t &message) noexcept;
     void on_block(message::block_response_t &message) noexcept;
     void on_validation(hasher::message::validation_response_t &res) noexcept;
-    void preprocess_block(model::file_block_t &block, const model::folder_info_t& source_folder) noexcept;
+    void preprocess_block(model::file_block_t &block, const model::folder_info_t &source_folder) noexcept;
     void on_model_update(model::message::model_update_t &message) noexcept;
     void on_tx_signal(net::message::tx_signal_t &message) noexcept;
     void on_block_response(fs::message::block_response_t &message) noexcept;
diff --git a/src/net/messages.cpp b/src/net/messages.cpp
index f8fa3a34..eaab14b8 100644
--- a/src/net/messages.cpp
+++ b/src/net/messages.cpp
@@ -6,7 +6,8 @@
 
 using namespace syncspirit::net::payload;
 
-block_request_t::block_request_t(const model::file_info_ptr_t &file_, const model::folder_info_t &fi, size_t block_index_) noexcept {
+block_request_t::block_request_t(const model::file_info_ptr_t &file_, const model::folder_info_t &fi,
+                                 size_t block_index_) noexcept {
     folder_id = fi.get_folder()->get_id();
     file_name = file_->get_name()->get_full_name();
     sequence = file_->get_sequence();
diff --git a/src/net/messages.h b/src/net/messages.h
index 22050e06..32da2745 100644
--- a/src/net/messages.h
+++ b/src/net/messages.h
@@ -150,7 +150,7 @@ struct block_response_t {
 
 struct SYNCSPIRIT_API block_request_t {
     using response_t = block_response_t;
-    using block_info_t = std::pair<model::file_block_t*, model::folder_info_t*>;
+    using block_info_t = std::pair<model::file_block_t *, model::folder_info_t *>;
     std::string folder_id;
     std::string file_name;
     std::int64_t sequence;
@@ -158,7 +158,8 @@ struct SYNCSPIRIT_API block_request_t {
     std::int64_t block_offset;
     std::uint32_t block_size;
     utils::bytes_t block_hash;
-    block_request_t(const model::file_info_ptr_t &file, const model::folder_info_t &folder, size_t block_index) noexcept;
+    block_request_t(const model::file_info_ptr_t &file, const model::folder_info_t &folder,
+                    size_t block_index) noexcept;
 
     block_info_t get_block(model::cluster_t &, model::device_t &peer) noexcept;
 };
diff --git a/src/presentation/cluster_file_presence.cpp b/src/presentation/cluster_file_presence.cpp
index 43f4d152..7744ccb9 100644
--- a/src/presentation/cluster_file_presence.cpp
+++ b/src/presentation/cluster_file_presence.cpp
@@ -14,9 +14,9 @@ using namespace syncspirit::presentation;
 using F = presence_t::features_t;
 
 cluster_file_presence_t::cluster_file_presence_t(std::uint32_t default_features_, file_entity_t &entity,
-                                                 model::file_info_t &file_info_, const model::folder_info_t &folder_info) noexcept
-    : file_presence_t(&entity, folder_info.get_device()), file_info{file_info_},
-      default_features{default_features_} {
+                                                 model::file_info_t &file_info_,
+                                                 const model::folder_info_t &folder_info) noexcept
+    : file_presence_t(&entity, folder_info.get_device()), file_info{file_info_}, default_features{default_features_} {
     link(&file_info);
     refresh_features();
     statistics = own_statistics = refresh_own_stats();
diff --git a/src/presentation/cluster_file_presence.h b/src/presentation/cluster_file_presence.h
index 5ba47398..0ef373ec 100644
--- a/src/presentation/cluster_file_presence.h
+++ b/src/presentation/cluster_file_presence.h
@@ -12,8 +12,8 @@ namespace syncspirit::presentation {
 struct file_entity_t;
 
 struct SYNCSPIRIT_API cluster_file_presence_t : file_presence_t {
-    cluster_file_presence_t(std::uint32_t default_features, file_entity_t &entity,
-                            model::file_info_t &file_info, const model::folder_info_t &folder_info) noexcept;
+    cluster_file_presence_t(std::uint32_t default_features, file_entity_t &entity, model::file_info_t &file_info,
+                            const model::folder_info_t &folder_info) noexcept;
 
     const model::file_info_t &get_file_info() const noexcept;
     const presence_t *determine_best(const presence_t *) const override;
diff --git a/src/presentation/file_entity.cpp b/src/presentation/file_entity.cpp
index aa6aaead..461ef538 100644
--- a/src/presentation/file_entity.cpp
+++ b/src/presentation/file_entity.cpp
@@ -17,9 +17,9 @@ using namespace syncspirit::presentation;
 
 using F = presence_t::features_t;
 
-file_entity_t::file_entity_t(model::path_ptr_t path_, const model::folder_infos_map_t& fi_map) noexcept
+file_entity_t::file_entity_t(model::path_ptr_t path_, const model::folder_infos_map_t &fi_map) noexcept
     : entity_t(std::move(path_)) {
-    using pair_t = std::pair<model::file_info_t *, model::folder_info_t*>;
+    using pair_t = std::pair<model::file_info_t *, model::folder_info_t *>;
     using presence_files_t = std::pmr::vector<pair_t>;
 
     auto buffer = std::array<std::byte, 32 * sizeof(model::file_info_t *)>();
@@ -43,7 +43,8 @@ file_entity_t::file_entity_t(model::path_ptr_t path_, const model::folder_infos_
     }
 }
 
-auto file_entity_t::on_insert(model::file_info_t &file_info, const model::folder_info_t& fi) noexcept -> file_presence_t * {
+auto file_entity_t::on_insert(model::file_info_t &file_info, const model::folder_info_t &fi) noexcept
+    -> file_presence_t * {
     auto device = fi.get_device();
     for (auto p : presences) {
         if (p->device == device) {
diff --git a/src/presentation/file_entity.h b/src/presentation/file_entity.h
index 01d9957f..592369d5 100644
--- a/src/presentation/file_entity.h
+++ b/src/presentation/file_entity.h
@@ -13,9 +13,9 @@ namespace syncspirit::presentation {
 struct file_presence_t;
 
 struct SYNCSPIRIT_API file_entity_t : entity_t {
-    file_entity_t(model::path_ptr_t path, const model::folder_infos_map_t& fi_map) noexcept;
+    file_entity_t(model::path_ptr_t path, const model::folder_infos_map_t &fi_map) noexcept;
     void set_parent(entity_t *entity) noexcept;
-    auto on_insert(model::file_info_t &, const model::folder_info_t&) noexcept -> file_presence_t *;
+    auto on_insert(model::file_info_t &, const model::folder_info_t &) noexcept -> file_presence_t *;
 
   private:
     presence_ptr_t missing_file;
diff --git a/src/presentation/folder_entity.cpp b/src/presentation/folder_entity.cpp
index 8ab2f534..dfa28323 100644
--- a/src/presentation/folder_entity.cpp
+++ b/src/presentation/folder_entity.cpp
@@ -27,7 +27,7 @@ static void process(model::folder_info_t *folder_info, entity_t::children_t &fil
         if (new_files.count(name.get())) {
             continue;
         }
-        auto& folders_map = folder_info->get_folder()->get_folder_infos();
+        auto &folders_map = folder_info->get_folder()->get_folder_infos();
         auto child = file_entity_ptr_t(new file_entity_t(name, folders_map));
         new_files.emplace(name.get(), std::move(child));
     }
@@ -109,7 +109,7 @@ auto folder_entity_t::on_insert(model::folder_info_t &folder_info) noexcept -> f
     return p;
 }
 
-entity_t *folder_entity_t::on_insert(model::file_info_t &file_info, const model::folder_info_t& folder_info) noexcept {
+entity_t *folder_entity_t::on_insert(model::file_info_t &file_info, const model::folder_info_t &folder_info) noexcept {
     auto &path = file_info.get_name();
     auto device = folder_info.get_device();
 
diff --git a/src/presentation/folder_entity.h b/src/presentation/folder_entity.h
index c7128e54..8eaa4993 100644
--- a/src/presentation/folder_entity.h
+++ b/src/presentation/folder_entity.h
@@ -15,7 +15,7 @@ struct SYNCSPIRIT_API folder_entity_t final : entity_t, model::augmentation_t {
     folder_entity_t(model::folder_ptr_t folder) noexcept;
     model::folder_t &get_folder() noexcept;
     folder_presence_t *on_insert(model::folder_info_t &folder_info) noexcept;
-    entity_t *on_insert(model::file_info_t &file_info, const model::folder_info_t& folder_info) noexcept;
+    entity_t *on_insert(model::file_info_t &file_info, const model::folder_info_t &folder_info) noexcept;
     void on_update() noexcept override;
     void on_delete() noexcept override;
 
diff --git a/src/presentation/local_file_presence.h b/src/presentation/local_file_presence.h
index 8fe5de2f..63c0eff6 100644
--- a/src/presentation/local_file_presence.h
+++ b/src/presentation/local_file_presence.h
@@ -8,7 +8,8 @@
 namespace syncspirit::presentation {
 
 struct SYNCSPIRIT_API local_file_presence_t : cluster_file_presence_t {
-    local_file_presence_t(file_entity_t &entity, model::file_info_t &file_info, const model::folder_info_t &folder_info) noexcept;
+    local_file_presence_t(file_entity_t &entity, model::file_info_t &file_info,
+                          const model::folder_info_t &folder_info) noexcept;
 };
 
 } // namespace syncspirit::presentation
diff --git a/src/presentation/peer_file_presence.h b/src/presentation/peer_file_presence.h
index 2f492fc2..749a0a9d 100644
--- a/src/presentation/peer_file_presence.h
+++ b/src/presentation/peer_file_presence.h
@@ -8,7 +8,8 @@
 namespace syncspirit::presentation {
 
 struct SYNCSPIRIT_API peer_file_presence_t : cluster_file_presence_t {
-    peer_file_presence_t(file_entity_t &entity, model::file_info_t &file_info, const model::folder_info_t &folder_info) noexcept;
+    peer_file_presence_t(file_entity_t &entity, model::file_info_t &file_info,
+                         const model::folder_info_t &folder_info) noexcept;
 };
 
 } // namespace syncspirit::presentation
diff --git a/tests/050-file_iterator.cpp b/tests/050-file_iterator.cpp
index 4000e3e5..cd8ec9f4 100644
--- a/tests/050-file_iterator.cpp
+++ b/tests/050-file_iterator.cpp
@@ -220,7 +220,8 @@ TEST_CASE("file iterator, single folder", "[model]") {
             SECTION("0 files are missing on my side") {
                 auto peer_file_1 = peer_files.by_name("a.txt");
                 auto peer_file_2 = peer_files.by_name("b.txt");
-                REQUIRE(builder.remote_copy(*peer_file_1, *peer_folder).remote_copy(*peer_file_2, *peer_folder).apply());
+                REQUIRE(
+                    builder.remote_copy(*peer_file_1, *peer_folder).remote_copy(*peer_file_2, *peer_folder).apply());
                 CHECK(file_iterator->next() == R{{}, {}, A::ignore});
             }
             SECTION("new file in new peer update") {
diff --git a/tests/051-block_iterator.cpp b/tests/051-block_iterator.cpp
index 42f209bd..ca501dda 100644
--- a/tests/051-block_iterator.cpp
+++ b/tests/051-block_iterator.cpp
@@ -20,7 +20,7 @@ TEST_CASE("block iterator", "[model]") {
     cluster->get_devices().put(my_device);
 
     auto block_iterator = block_iterator_ptr_t();
-    auto next = [&](file_info_ptr_t source, const folder_info_t& source_fi, bool reset = false) -> file_block_t {
+    auto next = [&](file_info_ptr_t source, const folder_info_t &source_fi, bool reset = false) -> file_block_t {
         if (source && source->is_file() && !source->is_deleted()) {
             if (reset) {
                 block_iterator = new blocks_iterator_t(*source, source_fi);
diff --git a/tests/070-db.cpp b/tests/070-db.cpp
index 51317962..c3361418 100644
--- a/tests/070-db.cpp
+++ b/tests/070-db.cpp
@@ -1092,7 +1092,9 @@ void test_peer_3_folders_6_files() {
             // clang-format on
 
             {
-                auto get_peer_file = [&](std::string_view folder_id, std::string_view name) -> std::pair<model::file_info_ptr_t, model::folder_info_t*> {
+                auto get_peer_file =
+                    [&](std::string_view folder_id,
+                        std::string_view name) -> std::pair<model::file_info_ptr_t, model::folder_info_t *> {
                     auto folder = cluster->get_folders().by_id(folder_id);
                     auto folder_info = folder->get_folder_infos().by_device(*peer_device);
                     auto file = folder_info->get_file_infos().by_name(name);
diff --git a/tests/071-fs_actor.cpp b/tests/071-fs_actor.cpp
index fe7814f0..d3065ee5 100644
--- a/tests/071-fs_actor.cpp
+++ b/tests/071-fs_actor.cpp
@@ -482,7 +482,10 @@ void test_clone_block() {
                     auto target_file = folder_peer->get_file_infos().by_name(proto::get_name(pr_target));
                     auto block = source_file->get_blocks()[0];
                     auto file_block = model::file_block_t(block.get(), target_file.get(), 0);
-                    builder.clone_block(file_block, *folder_peer, *folder_peer).apply(*sup).finish_file(*target, *folder_peer).apply(*sup);
+                    builder.clone_block(file_block, *folder_peer, *folder_peer)
+                        .apply(*sup)
+                        .finish_file(*target, *folder_peer)
+                        .apply(*sup);
 
                     auto path = root_path / std::string(target_file->get_name()->get_full_name());
                     REQUIRE(bfs::exists(path));
@@ -516,7 +519,10 @@ void test_clone_block() {
                     auto target_file = folder_peer->get_file_infos().by_name(proto::get_name(pr_target));
                     auto block = source->get_blocks()[0];
                     auto file_block = model::file_block_t(block.get(), target_file.get(), 0);
-                    builder.clone_block(file_block, *folder_peer, *fi_2_my).apply(*sup).finish_file(*target, *folder_peer).apply(*sup);
+                    builder.clone_block(file_block, *folder_peer, *fi_2_my)
+                        .apply(*sup)
+                        .finish_file(*target, *folder_peer)
+                        .apply(*sup);
 
                     auto path = root_path / std::string(target_file->get_name()->get_full_name());
                     REQUIRE(bfs::exists(path));
@@ -542,8 +548,11 @@ void test_clone_block() {
                     auto blocks = source_file->get_blocks();
                     auto fb_1 = model::file_block_t(blocks[0].get(), target_file.get(), 0);
                     auto fb_2 = model::file_block_t(blocks[1].get(), target_file.get(), 1);
-                    builder.clone_block(fb_1, *folder_peer, *folder_peer).clone_block(fb_2, *folder_peer, *folder_peer).apply(*sup)
-                            .finish_file(*target, *folder_peer).apply(*sup);
+                    builder.clone_block(fb_1, *folder_peer, *folder_peer)
+                        .clone_block(fb_2, *folder_peer, *folder_peer)
+                        .apply(*sup)
+                        .finish_file(*target, *folder_peer)
+                        .apply(*sup);
 
                     auto filename = std::string(target_file->get_name()->get_full_name());
                     auto path = root_path / filename;
@@ -570,7 +579,10 @@ void test_clone_block() {
 
                     auto blocks = source_file->get_blocks();
                     auto fb = model::file_block_t(blocks[0].get(), target_file.get(), 1);
-                    builder.clone_block(fb, *folder_peer, *folder_peer).apply(*sup).finish_file(*target, *folder_peer).apply(*sup);
+                    builder.clone_block(fb, *folder_peer, *folder_peer)
+                        .apply(*sup)
+                        .finish_file(*target, *folder_peer)
+                        .apply(*sup);
 
                     auto filename = std::string(target_file->get_name()->get_full_name());
                     auto path = root_path / filename;
@@ -595,7 +607,10 @@ void test_clone_block() {
 
                 auto block = source_file->get_blocks()[0];
                 auto file_block = model::file_block_t(block.get(), target_file.get(), 1);
-                builder.clone_block(file_block, *folder_peer, *folder_peer).apply(*sup).finish_file(*source, *folder_peer).apply(*sup);
+                builder.clone_block(file_block, *folder_peer, *folder_peer)
+                    .apply(*sup)
+                    .finish_file(*source, *folder_peer)
+                    .apply(*sup);
 
                 auto path = root_path / std::string(target_file->get_name()->get_full_name());
                 REQUIRE(bfs::exists(path));
diff --git a/tests/075-controller.cpp b/tests/075-controller.cpp
index bf8c5804..4e3d6675 100644
--- a/tests/075-controller.cpp
+++ b/tests/075-controller.cpp
@@ -1257,7 +1257,6 @@ void test_downloading_errors() {
             CHECK(f->is_unreachable());
             CHECK(!f->is_synchronizing());
 
-
             auto f_local = folder_my->get_file_infos().by_name(f->get_name()->get_full_name());
             CHECK(!f_local);
             CHECK(!folder_my->get_folder()->is_synchronizing());
diff --git a/tests/diff-builder.cpp b/tests/diff-builder.cpp
index 5bb79a51..9d94ad4a 100644
--- a/tests/diff-builder.cpp
+++ b/tests/diff-builder.cpp
@@ -251,13 +251,15 @@ diff_builder_t &diff_builder_t::unshare_folder(model::folder_info_t &fi) noexcep
     return assign(new diff::modify::unshare_folder_t(*cluster, fi));
 }
 
-diff_builder_t &diff_builder_t::remote_copy(const model::file_info_t &source, const model::folder_info_t& source_fi) noexcept {
+diff_builder_t &diff_builder_t::remote_copy(const model::file_info_t &source,
+                                            const model::folder_info_t &source_fi) noexcept {
     auto action = model::advance_action_t::remote_copy;
     auto diff = diff::advance::remote_copy_t::create(action, source, source_fi, *sequencer);
     return assign(diff.get());
 }
 
-diff_builder_t &diff_builder_t::advance(const model::file_info_t &source, const model::folder_info_t& source_fi) noexcept {
+diff_builder_t &diff_builder_t::advance(const model::file_info_t &source,
+                                        const model::folder_info_t &source_fi) noexcept {
     auto folder = source_fi.get_folder();
     auto local_fi = folder->get_folder_infos().by_device(*folder->get_cluster()->get_device());
     auto local_file = local_fi->get_file_infos().by_name(source.get_name()->get_full_name());
@@ -266,7 +268,8 @@ diff_builder_t &diff_builder_t::advance(const model::file_info_t &source, const
     return assign(diff.get());
 }
 
-diff_builder_t &diff_builder_t::finish_file(const model::file_info_t &file, const model::folder_info_t& folder_info) noexcept {
+diff_builder_t &diff_builder_t::finish_file(const model::file_info_t &file,
+                                            const model::folder_info_t &folder_info) noexcept {
     return assign(new diff::modify::finish_file_t(file, folder_info));
 }
 
@@ -296,14 +299,14 @@ diff_builder_t &diff_builder_t::update_contact(const model::device_id_t &device,
     return assign(new model::diff::contact::update_contact_t(*cluster, device, uris));
 }
 
-diff_builder_t &diff_builder_t::append_block(const model::file_info_t &target,
-                                              const model::folder_info_t& target_fi,
-                                             size_t block_index,
-                                             utils::bytes_t data) noexcept {
+diff_builder_t &diff_builder_t::append_block(const model::file_info_t &target, const model::folder_info_t &target_fi,
+                                             size_t block_index, utils::bytes_t data) noexcept {
     return assign(new diff::modify::append_block_t(target, target_fi, block_index, std::move(data)));
 }
 
-diff_builder_t &diff_builder_t::clone_block(const model::file_block_t &file_block,  const model::folder_info_t& target_fi, const model::folder_info_t& source_fi) noexcept {
+diff_builder_t &diff_builder_t::clone_block(const model::file_block_t &file_block,
+                                            const model::folder_info_t &target_fi,
+                                            const model::folder_info_t &source_fi) noexcept {
     return assign(new diff::modify::clone_block_t(file_block, target_fi, source_fi));
 }
 
@@ -352,7 +355,8 @@ diff_builder_t &diff_builder_t::synchronization_finish(std::string_view id) noex
     return assign(new model::diff::local::synchronization_finish_t(std::string(id)));
 }
 
-diff_builder_t &diff_builder_t::mark_reacheable(model::file_info_ptr_t peer_file, const model::folder_info_t& peer_fi, bool value) noexcept {
+diff_builder_t &diff_builder_t::mark_reacheable(model::file_info_ptr_t peer_file, const model::folder_info_t &peer_fi,
+                                                bool value) noexcept {
     return assign(new model::diff::modify::mark_reachable_t(*peer_file, peer_fi, value));
 }
 
diff --git a/tests/diff-builder.h b/tests/diff-builder.h
index 5ea4b206..243eff6a 100644
--- a/tests/diff-builder.h
+++ b/tests/diff-builder.h
@@ -78,12 +78,14 @@ struct SYNCSPIRIT_TEST_API diff_builder_t : private model::diff::apply_controlle
     diff_builder_t &share_folder(utils::bytes_view_t sha256, std::string_view folder_id,
                                  utils::bytes_view_t introducer_sha256 = {}) noexcept;
     diff_builder_t &unshare_folder(model::folder_info_t &fi) noexcept;
-    diff_builder_t &remote_copy(const model::file_info_t &source, const model::folder_info_t& source_fi) noexcept;
-    diff_builder_t &advance(const model::file_info_t &source, const model::folder_info_t& source_fi) noexcept;
-    diff_builder_t &finish_file(const model::file_info_t &file, const model::folder_info_t& source_fi) noexcept;
+    diff_builder_t &remote_copy(const model::file_info_t &source, const model::folder_info_t &source_fi) noexcept;
+    diff_builder_t &advance(const model::file_info_t &source, const model::folder_info_t &source_fi) noexcept;
+    diff_builder_t &finish_file(const model::file_info_t &file, const model::folder_info_t &source_fi) noexcept;
     diff_builder_t &local_update(std::string_view folder_id, const proto::FileInfo &file_) noexcept;
-    diff_builder_t &append_block(const model::file_info_t &target, const model::folder_info_t& target_fi, size_t block_index, utils::bytes_t data) noexcept;
-    diff_builder_t &clone_block(const model::file_block_t &, const model::folder_info_t& target_fi, const model::folder_info_t& source_fi) noexcept;
+    diff_builder_t &append_block(const model::file_info_t &target, const model::folder_info_t &target_fi,
+                                 size_t block_index, utils::bytes_t data) noexcept;
+    diff_builder_t &clone_block(const model::file_block_t &, const model::folder_info_t &target_fi,
+                                const model::folder_info_t &source_fi) noexcept;
     diff_builder_t &ack_block(const model::diff::modify::block_transaction_t &) noexcept;
     diff_builder_t &remove_folder(const model::folder_t &folder) noexcept;
     diff_builder_t &remove_peer(const model::device_t &peer) noexcept;
@@ -99,7 +101,8 @@ struct SYNCSPIRIT_TEST_API diff_builder_t : private model::diff::apply_controlle
     diff_builder_t &scan_request(std::string_view id) noexcept;
     diff_builder_t &synchronization_start(std::string_view id) noexcept;
     diff_builder_t &synchronization_finish(std::string_view id) noexcept;
-    diff_builder_t &mark_reacheable(model::file_info_ptr_t peer_file, const model::folder_info_t& peer_fi, bool value) noexcept;
+    diff_builder_t &mark_reacheable(model::file_info_ptr_t peer_file, const model::folder_info_t &peer_fi,
+                                    bool value) noexcept;
     diff_builder_t &suspend(const model::folder_t &folder) noexcept;
     diff_builder_t &interrupt() noexcept;