diff --git a/.clang-format b/.clang-format
index 65e5851..f9891bb 100644
--- a/.clang-format
+++ b/.clang-format
@@ -57,7 +57,7 @@ BreakConstructorInitializersBeforeComma: false
 BreakConstructorInitializers: BeforeColon
 BreakAfterJavaFieldAnnotations: false
 BreakStringLiterals: true
-ColumnLimit:     80
+ColumnLimit:     120
 CommentPragmas:  '^ IWYU pragma:'
 QualifierAlignment: Leave
 CompactNamespaces: false
diff --git a/src/error.hpp b/src/error.hpp
index adb4e85..18aa178 100644
--- a/src/error.hpp
+++ b/src/error.hpp
@@ -5,10 +5,10 @@
 
 #include <tl/expected.hpp>
 
-#define TRY(expr)                                                              \
-    ({                                                                         \
-        auto && t_expect = (expr);                                             \
-        if (not t_expect)                                                      \
-            return tl::unexpected(std::move(t_expect.error()));                \
-        std::move(t_expect.value());                                           \
+#define TRY(expr)                                                                                                      \
+    ({                                                                                                                 \
+        auto && t_expect = (expr);                                                                                     \
+        if (not t_expect)                                                                                              \
+            return tl::unexpected(std::move(t_expect.error()));                                                        \
+        std::move(t_expect.value());                                                                                   \
     })
diff --git a/src/loader.cpp b/src/loader.cpp
index 86acc23..02dab58 100644
--- a/src/loader.cpp
+++ b/src/loader.cpp
@@ -19,8 +19,7 @@ namespace loader {
 
         template <typename T>
         tl::expected<std::optional<T>, std::string>
-        get_optional(const Json::Value & parent, std::string_view parent_name,
-                     const std::string & name) {
+        get_optional(const Json::Value & parent, std::string_view parent_name, const std::string & name) {
             // It's okay for a member to be missing from an optional value
             if (!parent.isMember(name)) {
                 return std::nullopt;
@@ -43,26 +42,22 @@ namespace loader {
             }
 
             return tl::unexpected(
-                fmt::format("Optional field {} in {} is not of type {}!", name,
-                            parent_name, typeid(T).name()));
+                fmt::format("Optional field {} in {} is not of type {}!", name, parent_name, typeid(T).name()));
         };
 
         template <typename T>
-        tl::expected<T, std::string> get_required(const Json::Value & parent,
-                                                  std::string_view parent_name,
+        tl::expected<T, std::string> get_required(const Json::Value & parent, std::string_view parent_name,
                                                   const std::string & name) {
             if (!parent.isMember(name)) {
                 // TODO: it would be nice to have the parent name…
-                return tl::unexpected(fmt::format(
-                    "Required field {} in {} is missing!", name, parent_name));
+                return tl::unexpected(fmt::format("Required field {} in {} is missing!", name, parent_name));
             }
 
-            return get_optional<T>(parent, parent_name, name)
-                .and_then([](auto && v) -> tl::expected<T, std::string> {
-                    if (v)
-                        return v.value();
-                    return "bad";
-                });
+            return get_optional<T>(parent, parent_name, name).and_then([](auto && v) -> tl::expected<T, std::string> {
+                if (v)
+                    return v.value();
+                return "bad";
+            });
             // TODO: also need to fixup error message for "Optional type ..."
         }
 
@@ -104,10 +99,8 @@ namespace loader {
             unreachable(fmt::format("Unknown version schema: {}", str).c_str());
         }
 
-        tl::expected<LangValues, std::string>
-        get_lang_values(const Json::Value & parent,
-                        std::string_view parent_name,
-                        const std::string & name) {
+        tl::expected<LangValues, std::string> get_lang_values(const Json::Value & parent, std::string_view parent_name,
+                                                              const std::string & name) {
             LangValues ret{};
             if (!parent.isMember(name)) {
                 return ret;
@@ -116,49 +109,36 @@ namespace loader {
             Json::Value value = parent[name];
             if (value.isObject()) {
                 // TODO: simplify this further, maybe with a loop?
-                auto && cb = [](auto && r) {
-                    return r.value_or(std::vector<std::string>{});
-                };
-                ret[KnownLanguages::C] =
-                    TRY(get_optional<std::vector<std::string>>(value, name, "C")
-                            .map(cb));
-                ret[KnownLanguages::CPP] = TRY(
-                    get_optional<std::vector<std::string>>(value, name, "C++")
-                        .map(cb));
+                auto && cb = [](auto && r) { return r.value_or(std::vector<std::string>{}); };
+                ret[KnownLanguages::C] = TRY(get_optional<std::vector<std::string>>(value, name, "C").map(cb));
+                ret[KnownLanguages::CPP] = TRY(get_optional<std::vector<std::string>>(value, name, "C++").map(cb));
                 ret[KnownLanguages::FORTRAN] =
-                    TRY(get_optional<std::vector<std::string>>(value, name,
-                                                               "Fortran")
-                            .map(cb));
+                    TRY(get_optional<std::vector<std::string>>(value, name, "Fortran").map(cb));
             } else if (value.isArray()) {
                 std::vector<std::string> fin;
                 for (auto && v : value) {
                     fin.emplace_back(v.asString());
                 }
-                for (auto && v : {KnownLanguages::C, KnownLanguages::CPP,
-                                  KnownLanguages::FORTRAN}) {
+                for (auto && v : {KnownLanguages::C, KnownLanguages::CPP, KnownLanguages::FORTRAN}) {
                     ret.emplace(v, fin);
                 }
             } else {
-                return tl::unexpected(fmt::format(
-                    "Section {} of {} is neither an object nor an array!",
-                    parent_name, name));
+                return tl::unexpected(
+                    fmt::format("Section {} of {} is neither an object nor an array!", parent_name, name));
             }
             return ret;
         }
 
-        tl::expected<Defines, std::string>
-        get_defines(const Json::Value & parent, std::string_view parent_name,
-                    const std::string & name) {
-            LangValues && lang =
-                TRY(get_lang_values(parent, parent_name, name));
+        tl::expected<Defines, std::string> get_defines(const Json::Value & parent, std::string_view parent_name,
+                                                       const std::string & name) {
+            LangValues && lang = TRY(get_lang_values(parent, parent_name, name));
             Defines ret;
             for (auto && [k, values] : lang) {
                 ret[k] = {};
                 for (auto && value : values) {
                     if (value.front() == '!') {
                         ret[k].emplace_back(Define{value.substr(1), false});
-                    } else if (const size_t sep = value.find("=");
-                               sep != value.npos) {
+                    } else if (const size_t sep = value.find("="); sep != value.npos) {
                         std::string dkey = value.substr(0, sep);
                         std::string dvalue = value.substr(sep + 1);
                         ret[k].emplace_back(Define{dkey, dvalue});
@@ -170,18 +150,16 @@ namespace loader {
             return ret;
         };
 
-        tl::expected<Requires, std::string>
-        get_requires(const Json::Value & parent, std::string_view parent_name,
-                     const std::string & name) {
+        tl::expected<Requires, std::string> get_requires(const Json::Value & parent, std::string_view parent_name,
+                                                         const std::string & name) {
             Requires ret{};
             if (!parent.isMember(name)) {
                 return ret;
             }
 
-            Json::Value require = parent["name"];
+            Json::Value require = parent[name];
             if (!require.isObject()) {
-                return tl::unexpected(fmt::format(
-                    "{} field of {} is not an object", name, parent_name));
+                return tl::unexpected(fmt::format("{} field of {} is not an object", name, parent_name));
             }
 
             for (auto && itr = require.begin(); itr != require.end(); ++itr) {
@@ -190,8 +168,7 @@ namespace loader {
                 const Json::Value obj = *itr;
 
                 ret.emplace(key, Requirement{
-                                     TRY(get_optional<std::vector<std::string>>(
-                                             require, name, "Components"))
+                                     TRY(get_optional<std::vector<std::string>>(require, name, "Components"))
                                          .value_or(std::vector<std::string>{}),
                                  });
             }
@@ -200,13 +177,10 @@ namespace loader {
         };
 
         tl::expected<std::unordered_map<std::string, Component>, std::string>
-        get_components(const Json::Value & parent, std::string_view parent_name,
-                       const std::string & name) {
+        get_components(const Json::Value & parent, std::string_view parent_name, const std::string & name) {
             Json::Value compmap;
             if (!parent.isMember(name)) {
-                return tl::unexpected(
-                    fmt::format("Required field Components of {} is missing!",
-                                parent_name));
+                return tl::unexpected(fmt::format("Required field Components of {} is missing!", parent_name));
             }
 
             std::unordered_map<std::string, Component> components{};
@@ -214,14 +188,12 @@ namespace loader {
             // TODO: error handling for not an object
             compmap = parent[name];
             if (!compmap.isObject()) {
-                return tl::unexpected(fmt::format(
-                    "{} field of {} is not an object", name, parent_name));
+                return tl::unexpected(fmt::format("{} field of {} is not an object", name, parent_name));
             }
             if (compmap.empty()) {
-                return tl::unexpected(
-                    fmt::format("Components field of {} is empty, but must "
-                                "have at least one component",
-                                parent_name));
+                return tl::unexpected(fmt::format("Components field of {} is empty, but must "
+                                                  "have at least one component",
+                                                  parent_name));
             }
 
             for (auto && itr = compmap.begin(); itr != compmap.end(); ++itr) {
@@ -230,28 +202,21 @@ namespace loader {
                 const Json::Value comp = *itr;
 
                 if (!comp.isObject()) {
-                    return tl::unexpected(
-                        fmt::format("{} {} is not an object", name, key));
+                    return tl::unexpected(fmt::format("{} {} is not an object", name, key));
                 }
 
-                components[key] = Component{
-                    TRY(get_required<std::string>(comp, name, "Type")
-                            .map(string_to_type)),
-                    TRY(get_lang_values(comp, name, "Compile-Flags")),
-                    TRY(get_lang_values(comp, name, "Includes")),
-                    TRY(get_defines(comp, name, "Defines")),
-                    TRY(get_optional<std::vector<std::string>>(
-                            comp, name, "Link-Libraries"))
-                        .value_or(std::vector<std::string>{}),
-                    // TODO: this is required if the type != interface
-                    TRY(get_optional<std::string>(comp, name,
-                                                  "Location")),
-                    // XXX: https://github.com/cps-org/cps/issues/34
-                    TRY(get_optional<std::string>(comp, name,
-                                                  "Link-Location")),
-                    TRY(get_optional<std::vector<std::string>>(
-                            comp, name, "Requires"))
-                        .value_or(std::vector<std::string>{})};
+                components[key] =
+                    Component{TRY(get_required<std::string>(comp, name, "Type").map(string_to_type)),
+                              TRY(get_lang_values(comp, name, "Compile-Flags")),
+                              TRY(get_lang_values(comp, name, "Includes")), TRY(get_defines(comp, name, "Defines")),
+                              TRY(get_optional<std::vector<std::string>>(comp, name, "Link-Libraries"))
+                                  .value_or(std::vector<std::string>{}),
+                              // TODO: this is required if the type != interface
+                              TRY(get_optional<std::string>(comp, name, "Location")),
+                              // XXX: https://github.com/cps-org/cps/issues/34
+                              TRY(get_optional<std::string>(comp, name, "Link-Location")),
+                              TRY(get_optional<std::vector<std::string>>(comp, name, "Requires"))
+                                  .value_or(std::vector<std::string>{})};
             }
 
             return components;
@@ -259,12 +224,10 @@ namespace loader {
 
     } // namespace
 
-    Define::Define(std::string name_)
-        : name{std::move(name_)}, value{}, define{true} {};
+    Define::Define(std::string name_) : name{std::move(name_)}, value{}, define{true} {};
     Define::Define(std::string name_, std::string value_)
         : name{std::move(name_)}, value{std::move(value_)}, define{true} {};
-    Define::Define(std::string name_, bool define_)
-        : name{std::move(name_)}, value{}, define{define_} {};
+    Define::Define(std::string name_, bool define_) : name{std::move(name_)}, value{}, define{define_} {};
 
     bool Define::is_undefine() const { return !define; }
 
@@ -274,38 +237,29 @@ namespace loader {
     std::string Define::get_value() const { return value; }
 
     Component::Component() = default;
-    Component::Component(Type _type, LangValues _cflags, LangValues _includes,
-                         Defines _defines, std::vector<std::string> _link_libs,
-                         std::optional<std::string> _loc,
-                         std::optional<std::string> _link_loc,
-                         std::vector<std::string> req)
-        : type{_type}, compile_flags{std::move(_cflags)},
-          includes{std::move(_includes)}, defines{std::move(_defines)},
-          link_libraries{std::move(_link_libs)}, location{std::move(_loc)},
-          link_location{std::move(_link_loc)}, require{std::move(req)} {};
+    Component::Component(Type _type, LangValues _cflags, LangValues _includes, Defines _defines,
+                         std::vector<std::string> _link_libs, std::optional<std::string> _loc,
+                         std::optional<std::string> _link_loc, std::vector<std::string> req)
+        : type{_type}, compile_flags{std::move(_cflags)}, includes{std::move(_includes)}, defines{std::move(_defines)},
+          link_libraries{std::move(_link_libs)}, location{std::move(_loc)}, link_location{std::move(_link_loc)},
+          require{std::move(req)} {};
 
     Configuration::Configuration() = default;
-    Configuration::Configuration(LangValues cflags)
-        : compile_flags{std::move(cflags)} {};
+    Configuration::Configuration(LangValues cflags) : compile_flags{std::move(cflags)} {};
 
     Requirement::Requirement() = default;
-    Requirement::Requirement(std::vector<std::string> && comps)
-        : components{comps} {};
+    Requirement::Requirement(std::vector<std::string> && comps) : components{comps} {};
 
     Platform::Platform() = default;
 
     Package::Package() = default;
     Package::Package(std::string _name, std::string _cps_version,
-                     std::unordered_map<std::string, Component> && _components,
-                     std::string cps_path_,
-                     std::optional<std::vector<std::string>> && _default_comps,
-                     Requires req, std::optional<std::string> ver,
-                     version::Schema schema)
-        : name{std::move(_name)}, cps_version{std::move(_cps_version)},
-          components{std::move(_components)}, cps_path{std::move(cps_path_)},
-          default_components{std::move(_default_comps)},
-          require{std::move(req)}, version{std::move(ver)},
-          version_schema{schema} {};
+                     std::unordered_map<std::string, Component> && _components, std::string cps_path_,
+                     std::optional<std::vector<std::string>> && _default_comps, Requires req,
+                     std::optional<std::string> ver, version::Schema schema)
+        : name{std::move(_name)}, cps_version{std::move(_cps_version)}, components{std::move(_components)},
+          cps_path{std::move(cps_path_)}, default_components{std::move(_default_comps)}, require{std::move(req)},
+          version{std::move(ver)}, version_schema{schema} {};
 
     tl::expected<Package, std::string> load(const fs::path & path) {
         std::ifstream file;
@@ -318,16 +272,13 @@ namespace loader {
             TRY(get_required<std::string>(root, "package", "Name")),
             TRY(get_required<std::string>(root, "package", "Cps-Version")),
             TRY(get_components(root, "package", "Components")),
-            TRY(get_optional<std::string>(root, "package", "Cps-Path"))
-                .value_or(path.parent_path()),
-            TRY(get_optional<std::vector<std::string>>(root, "package",
-                                                       "Default-Components")),
+            TRY(get_optional<std::string>(root, "package", "Cps-Path")).value_or(path.parent_path()),
+            TRY(get_optional<std::vector<std::string>>(root, "package", "Default-Components")),
             TRY(get_requires(root, "package", "Requires")),
             TRY(get_optional<std::string>(root, "package", "Version")),
-            TRY(get_optional<std::string>(root, "package", "Version-Schema")
-                    .map([](auto && v) {
-                        return string_to_schema(v.value_or("simple"));
-                    })),
+            TRY(get_optional<std::string>(root, "package", "Version-Schema").map([](auto && v) {
+                return string_to_schema(v.value_or("simple"));
+            })),
         };
     }
 } // namespace loader
\ No newline at end of file
diff --git a/src/loader.hpp b/src/loader.hpp
index 7f4bae4..6ffcd00 100644
--- a/src/loader.hpp
+++ b/src/loader.hpp
@@ -4,13 +4,13 @@
 #pragma once
 
 #include "error.hpp"
+#include "version.hpp"
 #include <filesystem>
 #include <optional>
 #include <string>
 #include <tl/expected.hpp>
 #include <unordered_map>
 #include <vector>
-#include "version.hpp"
 
 namespace loader {
 
@@ -55,19 +55,16 @@ namespace loader {
         bool define;
     };
 
-    using LangValues =
-        std::unordered_map<KnownLanguages, std::vector<std::string>>;
+    using LangValues = std::unordered_map<KnownLanguages, std::vector<std::string>>;
 
     using Defines = std::unordered_map<KnownLanguages, std::vector<Define>>;
 
     class Component {
       public:
         Component();
-        Component(Type type, LangValues cflags, LangValues includes,
-                  Defines defines, std::vector<std::string> link_libraries,
-                  std::optional<std::string> location,
-                  std::optional<std::string> link_location,
-                  std::vector<std::string> require);
+        Component(Type type, LangValues cflags, LangValues includes, Defines defines,
+                  std::vector<std::string> link_libraries, std::optional<std::string> location,
+                  std::optional<std::string> link_location, std::vector<std::string> require);
 
         Type type;
         LangValues compile_flags;
@@ -134,12 +131,9 @@ namespace loader {
     class Package {
       public:
         Package();
-        Package(std::string name, std::string cps_version,
-                std::unordered_map<std::string, Component> && components,
-                std::string cps_path,
-                std::optional<std::vector<std::string>> && default_comps,
-                Requires require, std::optional<std::string> version,
-                version::Schema schema);
+        Package(std::string name, std::string cps_version, std::unordered_map<std::string, Component> && components,
+                std::string cps_path, std::optional<std::vector<std::string>> && default_comps, Requires require,
+                std::optional<std::string> version, version::Schema schema);
 
         std::string name;
         std::string cps_version;
diff --git a/src/main.cpp b/src/main.cpp
index 57de120..613d990 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -8,8 +8,7 @@
 
 int main(int argc, char * argv[]) {
     if (argc < 2) {
-        fmt::println(stderr, "Error: Got {} arguments, expected at least 2",
-                     argc);
+        fmt::println(stderr, "Error: Got {} arguments, expected at least 2", argc);
         return 1;
     }
 
@@ -58,8 +57,7 @@ int main(int argc, char * argv[]) {
         }
     }
 
-    auto && p =
-        search::find_package(argv[1], components, components.empty());
+    auto && p = search::find_package(argv[1], components, components.empty());
     if (!p) {
         fmt::println(p.error());
         return 1;
diff --git a/src/printer.cpp b/src/printer.cpp
index f104a68..c3484fa 100644
--- a/src/printer.cpp
+++ b/src/printer.cpp
@@ -27,46 +27,38 @@ namespace printer {
         }
 
         if (conf.includes) {
-            if (auto && f = r.includes.find(loader::KnownLanguages::C);
-                f != r.includes.end() && !f->second.empty()) {
-                std::transform(
-                    f->second.begin(), f->second.end(),
-                    std::back_inserter(args),
-                    [](std::string_view s) { return fmt::format("-I{}", s); });
+            if (auto && f = r.includes.find(loader::KnownLanguages::C); f != r.includes.end() && !f->second.empty()) {
+                std::transform(f->second.begin(), f->second.end(), std::back_inserter(args),
+                               [](std::string_view s) { return fmt::format("-I{}", s); });
             }
         }
 
         if (conf.defines) {
-            if (auto && f = r.defines.find(loader::KnownLanguages::C);
-                f != r.defines.end() && !f->second.empty()) {
+            if (auto && f = r.defines.find(loader::KnownLanguages::C); f != r.defines.end() && !f->second.empty()) {
                 auto && transformer = [](auto && d) {
                     if (d.is_define()) {
                         return fmt::format("-D{}", d.get_name());
                     } else if (d.is_undefine()) {
                         return fmt::format("-U{}", d.get_name());
                     } else {
-                        return fmt::format("-D{}={}", d.get_name(),
-                                           d.get_value());
+                        return fmt::format("-D{}={}", d.get_name(), d.get_value());
                     }
                 };
                 args.reserve(args.size() + f->second.size());
-                std::transform(f->second.begin(), f->second.end(),
-                               std::back_inserter(args), transformer);
+                std::transform(f->second.begin(), f->second.end(), std::back_inserter(args), transformer);
             }
         }
 
         if (conf.libs_link) {
             if (auto && f = r.link_location; !f.empty()) {
                 args.reserve(args.size() + f.size());
-                std::transform(
-                    f.begin(), f.end(), std::back_inserter(args),
-                    [](std::string_view s) { return fmt::format("-l{}", s); });
+                std::transform(f.begin(), f.end(), std::back_inserter(args),
+                               [](std::string_view s) { return fmt::format("-l{}", s); });
             }
             if (auto && f = r.link_libraries; !f.empty()) {
                 args.reserve(args.size() + f.size());
-                std::transform(
-                    f.begin(), f.end(), std::back_inserter(args),
-                    [](std::string_view s) { return fmt::format("-l{}", s); });
+                std::transform(f.begin(), f.end(), std::back_inserter(args),
+                               [](std::string_view s) { return fmt::format("-l{}", s); });
             }
         }
 
diff --git a/src/printer.hpp b/src/printer.hpp
index 2a6ae03..5584123 100644
--- a/src/printer.hpp
+++ b/src/printer.hpp
@@ -19,4 +19,4 @@ namespace printer {
 
     int pkgconf(const search::Result & dag, const Config & conf);
 
-}
\ No newline at end of file
+} // namespace printer
\ No newline at end of file
diff --git a/src/search.cpp b/src/search.cpp
index efb390b..a517e37 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -25,8 +25,7 @@ namespace search {
         /// load
         class Dependency {
           public:
-            Dependency(loader::Package && obj,
-                       std::vector<std::string> && comps)
+            Dependency(loader::Package && obj, std::vector<std::string> && comps)
                 : package{std::move(obj)}, components{std::move(comps)} {};
 
             /// @brief The loaded CPS file
@@ -39,15 +38,13 @@ namespace search {
         class Node {
           public:
             Node(Dependency obj) : data{std::move(obj)} {};
-            Node(loader::Package obj, std::vector<std::string> comps)
-                : data{std::move(obj), std::move(comps)} {};
+            Node(loader::Package obj, std::vector<std::string> comps) : data{std::move(obj), std::move(comps)} {};
 
             Dependency data;
             std::vector<std::shared_ptr<Node>> depends;
         };
 
-        void dfs(const std::shared_ptr<Node> & node,
-                 std::unordered_set<std::shared_ptr<Node>> & visited,
+        void dfs(const std::shared_ptr<Node> & node, std::unordered_set<std::shared_ptr<Node>> & visited,
                  std::deque<std::shared_ptr<Node>> & sorted) {
             visited.emplace(node);
             for (auto && d : node->depends) {
@@ -61,8 +58,7 @@ namespace search {
         /// @brief Perform a topological sort of the DAG
         /// @param root The root Node
         /// @return A linear topological sorting of the DAG
-        std::vector<std::shared_ptr<Node>>
-        tsort(const std::shared_ptr<Node> & root) {
+        std::vector<std::shared_ptr<Node>> tsort(const std::shared_ptr<Node> & root) {
             std::deque<std::shared_ptr<Node>> sorted;
             std::unordered_set<std::shared_ptr<Node>> visited;
             dfs(root, visited, sorted);
@@ -107,8 +103,7 @@ namespace search {
         /// @brief Find all possible paths for a given CPS name
         /// @param name The name of the CPS file to find
         /// @return A vector of paths which patch the given name, or an error
-        tl::expected<std::vector<fs::path>, std::string>
-        find_paths(std::string_view name) {
+        tl::expected<std::vector<fs::path>, std::string> find_paths(std::string_view name) {
             // If a path is passed, then just return that.
             if (fs::is_regular_file(name)) {
                 return std::vector<fs::path>{name};
@@ -137,8 +132,7 @@ namespace search {
             }
 
             if (found.empty()) {
-                return tl::unexpected(
-                    fmt::format("Could not find a CPS file for {}", name));
+                return tl::unexpected(fmt::format("Could not find a CPS file for {}", name));
             }
             return found;
         }
@@ -148,8 +142,7 @@ namespace search {
             bool defaults;
 
             ProcessedRequires(bool d) : defaults{d} {};
-            ProcessedRequires(std::string s)
-                : components{{std::move(s)}}, defaults{false} {};
+            ProcessedRequires(std::string s) : components{{std::move(s)}}, defaults{false} {};
         };
 
         /// @brief Extract all required dependencies with their components
@@ -184,9 +177,7 @@ namespace search {
         }
 
         tl::expected<std::shared_ptr<Node>, std::string>
-        build_node(std::string_view name,
-                   const std::vector<std::string> & components,
-                   bool default_components) {
+        build_node(std::string_view name, const std::vector<std::string> & components, bool default_components) {
             const std::vector<fs::path> paths = TRY(find_paths(name));
             for (auto && path : paths) {
 
@@ -194,17 +185,13 @@ namespace search {
 
                 std::vector<std::string> comps = components;
                 if (default_components && p.default_components) {
-                    comps.insert(comps.end(),
-                                 p.default_components.value().begin(),
-                                 p.default_components.value().end());
+                    comps.insert(comps.end(), p.default_components.value().begin(), p.default_components.value().end());
                 }
 
                 // If we don't have all of the components requested this isn't a
                 // valid candidate
-                if (!std::all_of(
-                        comps.begin(), comps.end(), [&](const std::string & s) {
-                            return p.components.find(s) != p.components.end();
-                        })) {
+                if (!std::all_of(comps.begin(), comps.end(),
+                                 [&](const std::string & s) { return p.components.find(s) != p.components.end(); })) {
                     continue;
                 }
 
@@ -221,17 +208,14 @@ namespace search {
                     auto && split = process_requires(comp.require);
                     for (auto && req : split) {
                         if (req.first == "") {
-                            node->data.components.insert(
-                                node->data.components.end(),
-                                req.second.components.begin(),
-                                req.second.components.end());
+                            node->data.components.insert(node->data.components.end(), req.second.components.begin(),
+                                                         req.second.components.end());
                             continue;
                         }
                         // XXX: This loop needs to be transactional, if any of
                         // the nodes is an error, then we need to throw away all
                         // of the work and go back and try again.
-                        auto && n = build_node(req.first, req.second.components,
-                                               req.second.defaults);
+                        auto && n = build_node(req.first, req.second.components, req.second.defaults);
                         if (n.has_value()) {
                             node->depends.emplace_back(std::move(n.value()));
                         }
@@ -241,8 +225,7 @@ namespace search {
                 return node;
             }
 
-            return tl::unexpected(
-                fmt::format("Could not find a dependency to satisfy {}", name));
+            return tl::unexpected(fmt::format("Could not find a dependency to satisfy {}", name));
         }
 
         template <typename T, typename U>
@@ -258,20 +241,15 @@ namespace search {
                           std::unordered_map<T, std::vector<U>> & output,
                           const std::function<U(const U &)> transformer) {
             for (auto && [l, vals] : input) {
-                std::transform(vals.begin(), vals.end(),
-                               std::back_inserter(output[l]), transformer);
+                std::transform(vals.begin(), vals.end(), std::back_inserter(output[l]), transformer);
             }
         }
 
-        template <typename T>
-        void merge_result(const std::vector<T> & input,
-                          std::vector<T> & output) {
+        template <typename T> void merge_result(const std::vector<T> & input, std::vector<T> & output) {
             output.insert(output.end(), input.begin(), input.end());
         }
 
-        template <typename T>
-        void merge_result(const std::optional<T> & input,
-                          std::vector<T> & output) {
+        template <typename T> void merge_result(const std::optional<T> & input, std::vector<T> & output) {
             if (input) {
                 output.emplace_back(input.value());
             }
@@ -305,14 +283,10 @@ namespace search {
 
     Result::Result(){};
 
-    tl::expected<Result, std::string> find_package(std::string_view name) {
-        return find_package(name, {}, true);
-    }
+    tl::expected<Result, std::string> find_package(std::string_view name) { return find_package(name, {}, true); }
 
-    tl::expected<Result, std::string>
-    find_package(std::string_view name,
-                 const std::vector<std::string> & components,
-                 bool default_components) {
+    tl::expected<Result, std::string> find_package(std::string_view name, const std::vector<std::string> & components,
+                                                   bool default_components) {
         // XXX: do we need process_requires here?
         auto && root = TRY(build_node(name, components, default_components));
         auto && flat = tsort(root);
@@ -323,8 +297,7 @@ namespace search {
 
         for (auto && node : flat) {
 
-            const auto && prefix_replacer =
-                [&](const std::string & s) -> std::string {
+            const auto && prefix_replacer = [&](const std::string & s) -> std::string {
                 // TODO: Windows…
                 auto && split = utils::split(s, "/");
                 if (split[0] == "@prefix@") {
@@ -340,10 +313,8 @@ namespace search {
             for (const auto & c_name : node->data.components) {
                 // We should have already errored if this is not the case
                 auto && f = node->data.package.components.find(c_name);
-                assert_fn(
-                    f != node->data.package.components.end(),
-                    fmt::format("Could not find component {} of pacakge {}",
-                                c_name, node->data.package.name));
+                assert_fn(f != node->data.package.components.end(),
+                          fmt::format("Could not find component {} of pacakge {}", c_name, node->data.package.name));
                 auto && comp = f->second;
 
                 // Convert prefix at this point because:
@@ -351,14 +322,13 @@ namespace search {
                 // from
                 // 2. if we do it at the search point we have to plumb overrides
                 // deep into that
-                merge_result<loader::KnownLanguages, std::string>(
-                    comp.includes, result.includes, prefix_replacer);
+                merge_result<loader::KnownLanguages, std::string>(comp.includes, result.includes, prefix_replacer);
                 merge_result(comp.defines, result.defines);
                 merge_result(comp.compile_flags, result.compile_flags);
                 merge_result(comp.link_libraries, result.link_libraries);
                 if (comp.type != loader::Type::INTERFACE) {
-                    result.link_location.emplace_back(prefix_replacer(
-                        comp.link_location.value_or(comp.location.value())));
+                    result.link_location.emplace_back(
+                        prefix_replacer(comp.link_location.value_or(comp.location.value())));
                 }
             }
         }
diff --git a/src/search.hpp b/src/search.hpp
index c46e12b..43d625c 100644
--- a/src/search.hpp
+++ b/src/search.hpp
@@ -3,10 +3,10 @@
 
 #pragma once
 
+#include "loader.hpp"
 #include <string>
 #include <tl/expected.hpp>
 #include <vector>
-#include "loader.hpp"
 
 namespace search {
 
@@ -27,9 +27,7 @@ namespace search {
     // TODO: multiple versions of packages?
     tl::expected<Result, std::string> find_package(std::string_view name);
 
-    tl::expected<Result, std::string>
-    find_package(std::string_view name,
-                 const std::vector<std::string> & components,
-                 bool default_components);
+    tl::expected<Result, std::string> find_package(std::string_view name, const std::vector<std::string> & components,
+                                                   bool default_components);
 
 } // namespace search
\ No newline at end of file
diff --git a/src/utils.cpp b/src/utils.cpp
index d10185a..622534c 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -5,8 +5,7 @@
 
 namespace utils {
 
-    std::vector<std::string> split(std::string_view input,
-                                   std::string_view delim) {
+    std::vector<std::string> split(std::string_view input, std::string_view delim) {
         size_t last = 0, next = 0;
         std::vector<std::string> out;
 
diff --git a/src/utils.hpp b/src/utils.hpp
index b5cd780..ef6283b 100644
--- a/src/utils.hpp
+++ b/src/utils.hpp
@@ -18,10 +18,10 @@ inline void assert_fn(bool expr, std::string_view msg) {
 }
 
 #if HAVE_UNREACHABLE
-#define unreachable(msg)                                                       \
-    do {                                                                       \
-        assert_fn(false, msg);                                                 \
-        __builtin_unreachable();                                               \
+#define unreachable(msg)                                                                                               \
+    do {                                                                                                               \
+        assert_fn(false, msg);                                                                                         \
+        __builtin_unreachable();                                                                                       \
     } while (0)
 #else
 #define unreachable(str) assert_fn(false, msg);
@@ -29,7 +29,6 @@ inline void assert_fn(bool expr, std::string_view msg) {
 
 namespace utils {
 
-    std::vector<std::string> split(std::string_view input,
-                                   std::string_view delim = ":");
+    std::vector<std::string> split(std::string_view input, std::string_view delim = ":");
 
 } // namespace utils
\ No newline at end of file
diff --git a/src/version.cpp b/src/version.cpp
index 9d9f7dc..69c23cb 100644
--- a/src/version.cpp
+++ b/src/version.cpp
@@ -13,8 +13,7 @@ namespace version {
 
     namespace {
 
-        tl::expected<std::vector<uint64_t>, std::string>
-        as_numbers(std::string_view v) {
+        tl::expected<std::vector<uint64_t>, std::string> as_numbers(std::string_view v) {
             std::vector<std::string> split = utils::split(v, ".");
             std::vector<uint64_t> left;
             left.reserve(split.size());
@@ -22,13 +21,11 @@ namespace version {
                 try {
                     left.emplace_back(std::stoull(n));
                 } catch (std::invalid_argument &) {
-                    return tl::unexpected{
-                        fmt::format("'{}' is not a valid number", n)};
+                    return tl::unexpected{fmt::format("'{}' is not a valid number", n)};
                 } catch (std::out_of_range &) {
-                    return tl::unexpected{fmt::format(
-                        "'{}' is too large to be represented by a uint64. What "
-                        "kind of versions are you creating?",
-                        n)};
+                    return tl::unexpected{fmt::format("'{}' is too large to be represented by a uint64. What "
+                                                      "kind of versions are you creating?",
+                                                      n)};
                 }
             }
             return left;
@@ -41,8 +38,7 @@ namespace version {
             }
         }
 
-        inline void equalize_length(std::vector<uint64_t> & left,
-                                    std::vector<uint64_t> & right) {
+        inline void equalize_length(std::vector<uint64_t> & left, std::vector<uint64_t> & right) {
             if (left.size() < right.size()) {
                 lengthen(left, right.size() - left.size());
             } else if (left.size() > right.size()) {
@@ -50,8 +46,7 @@ namespace version {
             }
         }
 
-        tl::expected<bool, std::string>
-        simple_compare(std::string_view l, Operator op, std::string_view r) {
+        tl::expected<bool, std::string> simple_compare(std::string_view l, Operator op, std::string_view r) {
             // TODO: handle the -.* or +.* ending
             // TODO: 32 bit probably needs stoull…
             std::vector<uint64_t> left = TRY(as_numbers(l));
@@ -97,15 +92,12 @@ namespace version {
                 }
             }
 
-            return (op == Operator::EQ || op == Operator::LE ||
-                    op == Operator::GE);
+            return (op == Operator::EQ || op == Operator::LE || op == Operator::GE);
         }
 
     } // namespace
 
-    tl::expected<bool, std::string> compare(std::string_view left, Operator op,
-                                            std::string_view right,
-                                            Schema schema) {
+    tl::expected<bool, std::string> compare(std::string_view left, Operator op, std::string_view right, Schema schema) {
         switch (schema) {
         case Schema::SIMPLE:
             return simple_compare(left, op, right);
diff --git a/src/version.hpp b/src/version.hpp
index a378358..adc1a53 100644
--- a/src/version.hpp
+++ b/src/version.hpp
@@ -27,7 +27,5 @@ namespace version {
     };
 
     /// @brief compare two version strings using the given operator and schema
-    tl::expected<bool, std::string> compare(std::string_view left, Operator op,
-                                            std::string_view right,
-                                            Schema schema);
+    tl::expected<bool, std::string> compare(std::string_view left, Operator op, std::string_view right, Schema schema);
 } // namespace version
\ No newline at end of file
diff --git a/tests/runner.py b/tests/runner.py
index 6301b4c..55bda68 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -46,6 +46,7 @@ class Result:
     stderr: str
     returncode: int
     expected: str
+    command: list[str]
 
 
 async def test(runner: str, case_: TestCase) -> Result:
@@ -66,7 +67,7 @@ async def test(runner: str, case_: TestCase) -> Result:
     async with _PRINT_LOCK:
         print('ok' if success else 'not ok', '-', case_['name'])
 
-    return Result(case_['cps'], success, out, berr.decode().strip(), proc.returncode, expected)
+    return Result(case_['name'], success, out, berr.decode().strip(), proc.returncode, expected, cmd)
 
 
 async def main() -> None:
@@ -91,6 +92,7 @@ async def main() -> None:
             print('  stdout:  ', r.stdout, file=sys.stderr)
             print('  expected:', r.expected, file=sys.stderr)
             print('  stderr:', r.stderr, file=sys.stderr)
+            print('  command:', ' '.join(r.command), file=sys.stderr)
             print('\n')
 
 
diff --git a/tests/version.cpp b/tests/version.cpp
index 9da49d7..2f0d79e 100644
--- a/tests/version.cpp
+++ b/tests/version.cpp
@@ -30,36 +30,24 @@ namespace {
     }
 } // namespace
 
-class SimpleVersionTest
-    : public ::testing::TestWithParam<
-          std::tuple<std::string, Operator, std::string, bool>> {};
+class SimpleVersionTest : public ::testing::TestWithParam<std::tuple<std::string, Operator, std::string, bool>> {};
 
 TEST_P(SimpleVersionTest, compare) {
     auto && [v1, op, v2, expected] = GetParam();
     auto && result = version::compare(v1, op, v2, version::Schema::SIMPLE);
     ASSERT_TRUE(result.has_value()) << "Unexpected error " << result.error();
-    ASSERT_EQ(result.value(), expected)
-        << "Case: " << v1 << " " << to_string(op) << " " << v2 << std::endl;
+    ASSERT_EQ(result.value(), expected) << "Case: " << v1 << " " << to_string(op) << " " << v2 << std::endl;
 }
 
 INSTANTIATE_TEST_SUITE_P(
     VersionTest, SimpleVersionTest,
-    ::testing::Values(std::tuple("0", Operator::EQ, "0000000", true),
-                      std::tuple("0.0", Operator::EQ, "0", true),
-                      std::tuple("0.0.0", Operator::EQ, "0", true),
-                      std::tuple("0.0.0", Operator::EQ, "0.0", true),
+    ::testing::Values(std::tuple("0", Operator::EQ, "0000000", true), std::tuple("0.0", Operator::EQ, "0", true),
+                      std::tuple("0.0.0", Operator::EQ, "0", true), std::tuple("0.0.0", Operator::EQ, "0.0", true),
                       std::tuple("0.0.0", Operator::EQ, "1.0", false),
-                      std::tuple("0.0.0", Operator::EQ, "0.1.0", false),
-                      std::tuple("0.0.0", Operator::GE, "0.0", true),
-                      std::tuple("0.4.0", Operator::GE, "0.0", true),
-                      std::tuple("0.4.0", Operator::GE, "3.0", false),
-                      std::tuple("0.4.0", Operator::GT, "0.0", true),
-                      std::tuple("0.0.0", Operator::GT, "3.0", false),
-                      std::tuple("0.0.0", Operator::LE, "0.0", true),
-                      std::tuple("0.0.0", Operator::LE, "3.0", true),
-                      std::tuple("6.0.0", Operator::LE, "3.0", false),
-                      std::tuple("0.0.0", Operator::LT, "3.0", true),
-                      std::tuple("0.4.0", Operator::LT, "0.0", false),
-                      std::tuple("0.0.0", Operator::NE, "10.0", true),
-                      std::tuple("0.0.0", Operator::NE, "0", false)
-    ));
\ No newline at end of file
+                      std::tuple("0.0.0", Operator::EQ, "0.1.0", false), std::tuple("0.0.0", Operator::GE, "0.0", true),
+                      std::tuple("0.4.0", Operator::GE, "0.0", true), std::tuple("0.4.0", Operator::GE, "3.0", false),
+                      std::tuple("0.4.0", Operator::GT, "0.0", true), std::tuple("0.0.0", Operator::GT, "3.0", false),
+                      std::tuple("0.0.0", Operator::LE, "0.0", true), std::tuple("0.0.0", Operator::LE, "3.0", true),
+                      std::tuple("6.0.0", Operator::LE, "3.0", false), std::tuple("0.0.0", Operator::LT, "3.0", true),
+                      std::tuple("0.4.0", Operator::LT, "0.0", false), std::tuple("0.0.0", Operator::NE, "10.0", true),
+                      std::tuple("0.0.0", Operator::NE, "0", false)));
\ No newline at end of file