diff --git a/include/contractor/graph_contractor.hpp b/include/contractor/graph_contractor.hpp
index 457c4325b10..4479f4fdf77 100644
--- a/include/contractor/graph_contractor.hpp
+++ b/include/contractor/graph_contractor.hpp
@@ -23,13 +23,17 @@ std::vector<bool> contractGraph(ContractorGraph &graph,
 
 // Overload for contracting all nodes
 inline auto contractGraph(ContractorGraph &graph, double core_factor = 1.0)
-{ return contractGraph(graph, {}, {}, core_factor); }
+{
+    return contractGraph(graph, {}, {}, core_factor);
+}
 
 // Overload no contracted nodes
 inline auto contractGraph(ContractorGraph &graph,
                           std::vector<bool> node_is_contractible,
                           double core_factor = 1.0)
-{ return contractGraph(graph, {}, std::move(node_is_contractible), core_factor); }
+{
+    return contractGraph(graph, {}, std::move(node_is_contractible), core_factor);
+}
 
 } // namespace osrm::contractor
 
diff --git a/include/contractor/query_edge.hpp b/include/contractor/query_edge.hpp
index 477d63a66d5..c3056f35543 100644
--- a/include/contractor/query_edge.hpp
+++ b/include/contractor/query_edge.hpp
@@ -62,7 +62,9 @@ struct QueryEdge
     }
 
     bool operator<(const QueryEdge &rhs) const
-    { return std::tie(source, target) < std::tie(rhs.source, rhs.target); }
+    {
+        return std::tie(source, target) < std::tie(rhs.source, rhs.target);
+    }
 
     bool operator==(const QueryEdge &right) const
     {
diff --git a/include/engine/api/base_api.hpp b/include/engine/api/base_api.hpp
index 1d9ffd1b7be..b88b1bcbae9 100644
--- a/include/engine/api/base_api.hpp
+++ b/include/engine/api/base_api.hpp
@@ -47,8 +47,7 @@ class BaseAPI
     util::json::Object MakeWaypoint(const PhantomNodeCandidates &candidates) const
     {
         // TODO: check forward/reverse
-        const auto toName = [this](const auto &phantom)
-        {
+        const auto toName = [this](const auto &phantom) {
             return std::string(
                 facade.GetNameForID(facade.GetNameIndex(phantom.forward_segment_id.id)));
         };
@@ -117,8 +116,7 @@ class BaseAPI
             static_cast<float>(static_cast<double>(util::toFloating(snapped_location.lon))),
             static_cast<float>(static_cast<double>(util::toFloating(snapped_location.lat))));
 
-        const auto toName = [this](const auto &phantom)
-        {
+        const auto toName = [this](const auto &phantom) {
             return std::string(
                 facade.GetNameForID(facade.GetNameIndex(phantom.forward_segment_id.id)));
         };
diff --git a/include/engine/api/json_factory.hpp b/include/engine/api/json_factory.hpp
index c5f9a266682..f66ccf19b8f 100644
--- a/include/engine/api/json_factory.hpp
+++ b/include/engine/api/json_factory.hpp
@@ -37,7 +37,9 @@ inline bool isValidModifier(const guidance::StepManeuver maneuver)
 }
 
 inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection)
-{ return intersection.lanes.lanes_in_turn > 0; }
+{
+    return intersection.lanes.lanes_in_turn > 0;
+}
 
 util::json::Value coordinateToLonLat(const util::Coordinate &coordinate);
 
@@ -50,7 +52,9 @@ inline double roundAndClampBearing(double bearing) { return std::fmod(std::round
 
 template <unsigned POLYLINE_PRECISION, typename ForwardIter>
 util::json::String makePolyline(ForwardIter begin, ForwardIter end)
-{ return {encodePolyline<POLYLINE_PRECISION>(begin, end)}; }
+{
+    return {encodePolyline<POLYLINE_PRECISION>(begin, end)};
+}
 
 template <typename ForwardIter>
 util::json::Object makeGeoJSONGeometry(ForwardIter begin, ForwardIter end)
diff --git a/include/engine/api/route_api.hpp b/include/engine/api/route_api.hpp
index e9adb87b432..12d5bdbebb1 100644
--- a/include/engine/api/route_api.hpp
+++ b/include/engine/api/route_api.hpp
@@ -571,10 +571,14 @@ class RouteAPI : public BaseAPI
         GeometryVisitor(Builder &builder) : builder(builder) {}
 
         void operator()(const flatbuffers::Offset<flatbuffers::String> &value)
-        { builder.add_polyline(value); }
+        {
+            builder.add_polyline(value);
+        }
         void operator()(
             const flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>> &value)
-        { builder.add_coordinates(value); }
+        {
+            builder.add_coordinates(value);
+        }
 
       private:
         Builder &builder;
diff --git a/include/engine/api/route_parameters.hpp b/include/engine/api/route_parameters.hpp
index 5e21684e406..9b5e163090c 100644
--- a/include/engine/api/route_parameters.hpp
+++ b/include/engine/api/route_parameters.hpp
@@ -198,17 +198,16 @@ inline bool operator&(RouteParameters::AnnotationsType lhs, RouteParameters::Ann
 inline RouteParameters::AnnotationsType operator|(RouteParameters::AnnotationsType lhs,
                                                   RouteParameters::AnnotationsType rhs)
 {
-    return (
-        RouteParameters::
-            AnnotationsType)(static_cast<std::underlying_type_t<RouteParameters::AnnotationsType>>(
-                                 lhs) |
-                             static_cast<std::underlying_type_t<RouteParameters::AnnotationsType>>(
-                                 rhs));
+    return (RouteParameters::AnnotationsType)(
+        static_cast<std::underlying_type_t<RouteParameters::AnnotationsType>>(lhs) |
+        static_cast<std::underlying_type_t<RouteParameters::AnnotationsType>>(rhs));
 }
 
 inline RouteParameters::AnnotationsType &operator|=(RouteParameters::AnnotationsType &lhs,
                                                     RouteParameters::AnnotationsType rhs)
-{ return lhs = lhs | rhs; }
+{
+    return lhs = lhs | rhs;
+}
 } // namespace osrm::engine::api
 
 #endif
diff --git a/include/engine/api/table_parameters.hpp b/include/engine/api/table_parameters.hpp
index 5c5c8754e73..c349ab56c52 100644
--- a/include/engine/api/table_parameters.hpp
+++ b/include/engine/api/table_parameters.hpp
@@ -153,17 +153,16 @@ inline bool operator&(TableParameters::AnnotationsType lhs, TableParameters::Ann
 inline TableParameters::AnnotationsType operator|(TableParameters::AnnotationsType lhs,
                                                   TableParameters::AnnotationsType rhs)
 {
-    return (
-        TableParameters::
-            AnnotationsType)(static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(
-                                 lhs) |
-                             static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(
-                                 rhs));
+    return (TableParameters::AnnotationsType)(
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(lhs) |
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(rhs));
 }
 
 inline TableParameters::AnnotationsType &operator|=(TableParameters::AnnotationsType &lhs,
                                                     TableParameters::AnnotationsType rhs)
-{ return lhs = lhs | rhs; }
+{
+    return lhs = lhs | rhs;
+}
 } // namespace osrm::engine::api
 
 #endif // ENGINE_API_TABLE_PARAMETERS_HPP
diff --git a/include/engine/base64.hpp b/include/engine/base64.hpp
index 66b5e275abe..8af51b73973 100644
--- a/include/engine/base64.hpp
+++ b/include/engine/base64.hpp
@@ -72,11 +72,15 @@ inline std::string encodeBase64(const unsigned char *first, std::size_t size)
 
 // Overload for signed char catches (not only but also) C-string literals.
 inline std::string encodeBase64(const signed char *first, std::size_t size)
-{ return encodeBase64(reinterpret_cast<const unsigned char *>(first), size); }
+{
+    return encodeBase64(reinterpret_cast<const unsigned char *>(first), size);
+}
 
 // Overload for char catches (not only but also) C-string literals.
 inline std::string encodeBase64(const char *first, std::size_t size)
-{ return encodeBase64(reinterpret_cast<const unsigned char *>(first), size); }
+{
+    return encodeBase64(reinterpret_cast<const unsigned char *>(first), size);
+}
 
 // Convenience specialization, encoding from string instead of byte-dumping it.
 inline std::string encodeBase64(const std::string &x) { return encodeBase64(x.data(), x.size()); }
diff --git a/include/engine/bearing.hpp b/include/engine/bearing.hpp
index 2651ffa373b..c64e689d5f0 100644
--- a/include/engine/bearing.hpp
+++ b/include/engine/bearing.hpp
@@ -40,7 +40,9 @@ struct Bearing
 };
 
 inline bool operator==(const Bearing lhs, const Bearing rhs)
-{ return lhs.bearing == rhs.bearing && lhs.range == rhs.range; }
+{
+    return lhs.bearing == rhs.bearing && lhs.range == rhs.range;
+}
 inline bool operator!=(const Bearing lhs, const Bearing rhs) { return !(lhs == rhs); }
 } // namespace osrm::engine
 
diff --git a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
index 5f109053693..137beaafc6c 100644
--- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
@@ -71,7 +71,9 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
         const std::string &metric_name,
         std::size_t exclude_index)
         : allocator(std::move(allocator_))
-    { InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index); }
+    {
+        InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index);
+    }
 
     void InitializeInternalPointers(const storage::SharedDataIndex &index,
                                     const std::string &metric_name,
@@ -87,25 +89,37 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
     unsigned GetNumberOfEdges() const override final { return m_query_graph.GetNumberOfEdges(); }
 
     unsigned GetOutDegree(const NodeID edge_based_node_id) const override final
-    { return m_query_graph.GetOutDegree(edge_based_node_id); }
+    {
+        return m_query_graph.GetOutDegree(edge_based_node_id);
+    }
 
     NodeID GetTarget(const EdgeID edge_based_edge_id) const override final
-    { return m_query_graph.GetTarget(edge_based_edge_id); }
+    {
+        return m_query_graph.GetTarget(edge_based_edge_id);
+    }
 
     const EdgeData &GetEdgeData(const EdgeID edge_based_edge_id) const override final
-    { return m_query_graph.GetEdgeData(edge_based_edge_id); }
+    {
+        return m_query_graph.GetEdgeData(edge_based_edge_id);
+    }
 
     EdgeRange GetAdjacentEdgeRange(const NodeID edge_based_node_id) const override final
-    { return m_query_graph.GetAdjacentEdgeRange(edge_based_node_id); }
+    {
+        return m_query_graph.GetAdjacentEdgeRange(edge_based_node_id);
+    }
 
     // searches for a specific edge
     EdgeID FindEdge(const NodeID edge_based_node_from,
                     const NodeID edge_based_node_to) const override final
-    { return m_query_graph.FindEdge(edge_based_node_from, edge_based_node_to); }
+    {
+        return m_query_graph.FindEdge(edge_based_node_from, edge_based_node_to);
+    }
 
     EdgeID FindEdgeInEitherDirection(const NodeID edge_based_node_from,
                                      const NodeID edge_based_node_to) const override final
-    { return m_query_graph.FindEdgeInEitherDirection(edge_based_node_from, edge_based_node_to); }
+    {
+        return m_query_graph.FindEdgeInEitherDirection(edge_based_node_from, edge_based_node_to);
+    }
 
     EdgeID FindEdgeIndicateIfReverse(const NodeID edge_based_node_from,
                                      const NodeID edge_based_node_to,
@@ -119,7 +133,9 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
     FindSmallestEdge(const NodeID edge_based_node_from,
                      const NodeID edge_based_node_to,
                      const std::function<bool(const EdgeData &)> &filter) const override final
-    { return m_query_graph.FindSmallestEdge(edge_based_node_from, edge_based_node_to, filter); }
+    {
+        return m_query_graph.FindSmallestEdge(edge_based_node_from, edge_based_node_to, filter);
+    }
 };
 
 /**
@@ -258,46 +274,68 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
                                            const std::string &metric_name,
                                            const std::size_t exclude_index)
         : allocator(std::move(allocator_))
-    { InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index); }
+    {
+        InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index);
+    }
 
     // node and edge information access
     util::Coordinate GetCoordinateOfNode(const NodeID node_based_node_id) const override final
-    { return m_coordinate_list[node_based_node_id]; }
+    {
+        return m_coordinate_list[node_based_node_id];
+    }
 
     OSMNodeID GetOSMNodeIDOfNode(const NodeID node_based_node_id) const override final
-    { return m_osmnodeid_list[node_based_node_id]; }
+    {
+        return m_osmnodeid_list[node_based_node_id];
+    }
 
     NodeForwardRange GetUncompressedForwardGeometry(const PackedGeometryID id) const override final
-    { return segment_data.GetForwardGeometry(id); }
+    {
+        return segment_data.GetForwardGeometry(id);
+    }
 
     NodeReverseRange GetUncompressedReverseGeometry(const PackedGeometryID id) const override final
-    { return segment_data.GetReverseGeometry(id); }
+    {
+        return segment_data.GetReverseGeometry(id);
+    }
 
     DurationForwardRange
     GetUncompressedForwardDurations(const PackedGeometryID id) const override final
-    { return segment_data.GetForwardDurations(id); }
+    {
+        return segment_data.GetForwardDurations(id);
+    }
 
     DurationReverseRange
     GetUncompressedReverseDurations(const PackedGeometryID id) const override final
-    { return segment_data.GetReverseDurations(id); }
+    {
+        return segment_data.GetReverseDurations(id);
+    }
 
     WeightForwardRange GetUncompressedForwardWeights(const PackedGeometryID id) const override final
-    { return segment_data.GetForwardWeights(id); }
+    {
+        return segment_data.GetForwardWeights(id);
+    }
 
     WeightReverseRange GetUncompressedReverseWeights(const PackedGeometryID id) const override final
-    { return segment_data.GetReverseWeights(id); }
+    {
+        return segment_data.GetReverseWeights(id);
+    }
 
     // Returns the data source ids that were used to supply the edge
     // weights.
     DatasourceForwardRange
     GetUncompressedForwardDatasources(const PackedGeometryID id) const override final
-    { return segment_data.GetForwardDatasources(id); }
+    {
+        return segment_data.GetForwardDatasources(id);
+    }
 
     // Returns the data source ids that were used to supply the edge
     // weights.
     DatasourceReverseRange
     GetUncompressedReverseDatasources(const PackedGeometryID id) const override final
-    { return segment_data.GetReverseDatasources(id); }
+    {
+        return segment_data.GetReverseDatasources(id);
+    }
 
     TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID edge_based_edge_id) const override final
     {
@@ -369,22 +407,34 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     std::uint32_t GetCheckSum() const override final { return m_check_sum; }
 
     std::string GetTimestamp() const override final
-    { return std::string(m_data_timestamp.begin(), m_data_timestamp.end()); }
+    {
+        return std::string(m_data_timestamp.begin(), m_data_timestamp.end());
+    }
 
     GeometryID GetGeometryIndex(const NodeID edge_based_node_id) const override final
-    { return edge_based_node_data.GetGeometryID(edge_based_node_id); }
+    {
+        return edge_based_node_data.GetGeometryID(edge_based_node_id);
+    }
 
     ComponentID GetComponentID(const NodeID edge_based_node_id) const override final
-    { return edge_based_node_data.GetComponentID(edge_based_node_id); }
+    {
+        return edge_based_node_data.GetComponentID(edge_based_node_id);
+    }
 
     extractor::TravelMode GetTravelMode(const NodeID edge_based_node_id) const override final
-    { return edge_based_node_data.GetTravelMode(edge_based_node_id); }
+    {
+        return edge_based_node_data.GetTravelMode(edge_based_node_id);
+    }
 
     extractor::ClassData GetClassData(const NodeID edge_based_node_id) const override final
-    { return edge_based_node_data.GetClassData(edge_based_node_id); }
+    {
+        return edge_based_node_data.GetClassData(edge_based_node_id);
+    }
 
     bool ExcludeNode(const NodeID edge_based_node_id) const override final
-    { return (edge_based_node_data.GetClassData(edge_based_node_id) & exclude_mask) > 0; }
+    {
+        return (edge_based_node_data.GetClassData(edge_based_node_id) & exclude_mask) > 0;
+    }
 
     std::vector<std::string> GetClasses(const extractor::ClassData class_data) const override final
     {
@@ -400,7 +450,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     }
 
     StringViewID GetNameIndex(const NodeID edge_based_node_id) const override final
-    { return edge_based_node_data.GetNameID(edge_based_node_id); }
+    {
+        return edge_based_node_data.GetNameID(edge_based_node_id);
+    }
 
     std::string_view GetNameForID(const StringViewID id) const override final
     {
@@ -433,24 +485,36 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     }
 
     std::string_view GetDatasourceName(const DatasourceID id) const override final
-    { return m_datasources->GetSourceName(id); }
+    {
+        return m_datasources->GetSourceName(id);
+    }
 
     bool GetContinueStraightDefault() const override final
-    { return m_profile_properties->continue_straight_at_waypoint; }
+    {
+        return m_profile_properties->continue_straight_at_waypoint;
+    }
 
     double GetMapMatchingMaxSpeed() const override final
-    { return m_profile_properties->max_speed_for_map_matching; }
+    {
+        return m_profile_properties->max_speed_for_map_matching;
+    }
 
     double GetMaxCollapseDistance() const override final
-    { return m_profile_properties->GetMaxCollapseDistance(); }
+    {
+        return m_profile_properties->GetMaxCollapseDistance();
+    }
 
     const char *GetWeightName() const override final { return m_profile_properties->weight_name; }
 
     unsigned GetWeightPrecision() const override final
-    { return m_profile_properties->weight_precision; }
+    {
+        return m_profile_properties->weight_precision;
+    }
 
     double GetWeightMultiplier() const override final
-    { return m_profile_properties->GetWeightMultiplier(); }
+    {
+        return m_profile_properties->GetWeightMultiplier();
+    }
 
     util::guidance::BearingClass
     GetBearingClass(const NodeID node_based_node_id) const override final
@@ -519,7 +583,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     }
 
     bool IsSegregated(const NodeID edge_based_node_id) const override final
-    { return edge_based_node_data.IsSegregated(edge_based_node_id); }
+    {
+        return edge_based_node_data.IsSegregated(edge_based_node_id);
+    }
 
     std::vector<extractor::ManeuverOverride>
     GetOverridesThatStartAt(const NodeID edge_based_node_id) const override final
@@ -530,9 +596,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         struct Comp
         {
             bool operator()(const extractor::StorageManeuverOverride &s, NodeID i) const
-            { return s.start_node < i; }
+            {
+                return s.start_node < i;
+            }
             bool operator()(NodeID i, const extractor::StorageManeuverOverride &s) const
-            { return i < s.start_node; }
+            {
+                return i < s.start_node;
+            }
         };
 
         auto found_range = std::equal_range(
@@ -606,10 +676,14 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
         const std::string &metric_name,
         const std::size_t exclude_index)
         : allocator(std::move(allocator_))
-    { InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index); }
+    {
+        InitializeInternalPointers(allocator->GetIndex(), metric_name, exclude_index);
+    }
 
     const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const override
-    { return mld_partition; }
+    {
+        return mld_partition;
+    }
 
     const partitioner::CellStorageView &GetCellStorage() const override { return mld_cell_storage; }
 
@@ -623,40 +697,62 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
     unsigned GetNumberOfEdges() const override final { return query_graph.GetNumberOfEdges(); }
 
     unsigned GetOutDegree(const NodeID edge_based_node_id) const override final
-    { return query_graph.GetOutDegree(edge_based_node_id); }
+    {
+        return query_graph.GetOutDegree(edge_based_node_id);
+    }
 
     EdgeRange GetAdjacentEdgeRange(const NodeID edge_based_node_id) const override final
-    { return query_graph.GetAdjacentEdgeRange(edge_based_node_id); }
+    {
+        return query_graph.GetAdjacentEdgeRange(edge_based_node_id);
+    }
 
     EdgeWeight GetNodeWeight(const NodeID edge_based_node_id) const override final
-    { return query_graph.GetNodeWeight(edge_based_node_id); }
+    {
+        return query_graph.GetNodeWeight(edge_based_node_id);
+    }
 
     EdgeDuration GetNodeDuration(const NodeID edge_based_node_id) const override final
-    { return query_graph.GetNodeDuration(edge_based_node_id); }
+    {
+        return query_graph.GetNodeDuration(edge_based_node_id);
+    }
 
     EdgeDistance GetNodeDistance(const NodeID edge_based_node_id) const override final
-    { return query_graph.GetNodeDistance(edge_based_node_id); }
+    {
+        return query_graph.GetNodeDistance(edge_based_node_id);
+    }
 
     bool IsForwardEdge(const NodeID edge_based_node_id) const override final
-    { return query_graph.IsForwardEdge(edge_based_node_id); }
+    {
+        return query_graph.IsForwardEdge(edge_based_node_id);
+    }
 
     bool IsBackwardEdge(const NodeID edge_based_node_id) const override final
-    { return query_graph.IsBackwardEdge(edge_based_node_id); }
+    {
+        return query_graph.IsBackwardEdge(edge_based_node_id);
+    }
 
     NodeID GetTarget(const EdgeID edge_based_edge_id) const override final
-    { return query_graph.GetTarget(edge_based_edge_id); }
+    {
+        return query_graph.GetTarget(edge_based_edge_id);
+    }
 
     const EdgeData &GetEdgeData(const EdgeID edge_based_edge_id) const override final
-    { return query_graph.GetEdgeData(edge_based_edge_id); }
+    {
+        return query_graph.GetEdgeData(edge_based_edge_id);
+    }
 
     EdgeRange GetBorderEdgeRange(const LevelID level,
                                  const NodeID edge_based_node_id) const override final
-    { return query_graph.GetBorderEdgeRange(level, edge_based_node_id); }
+    {
+        return query_graph.GetBorderEdgeRange(level, edge_based_node_id);
+    }
 
     // searches for a specific edge
     EdgeID FindEdge(const NodeID edge_based_node_from,
                     const NodeID edge_based_node_to) const override final
-    { return query_graph.FindEdge(edge_based_node_from, edge_based_node_to); }
+    {
+        return query_graph.FindEdge(edge_based_node_from, edge_based_node_to);
+    }
 };
 
 template <>
diff --git a/include/engine/datafacade_factory.hpp b/include/engine/datafacade_factory.hpp
index 3b63c23b4c1..1eaf1411b1e 100644
--- a/include/engine/datafacade_factory.hpp
+++ b/include/engine/datafacade_factory.hpp
@@ -29,10 +29,14 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     template <typename AllocatorT>
     DataFacadeFactory(const std::shared_ptr<AllocatorT> &allocator)
         : DataFacadeFactory(std::move(allocator), has_exclude_flags)
-    { BOOST_ASSERT_MSG(facades.size() >= 1, "At least one datafacade is needed"); }
+    {
+        BOOST_ASSERT_MSG(facades.size() >= 1, "At least one datafacade is needed");
+    }
 
     template <typename ParameterT> std::shared_ptr<const Facade> Get(const ParameterT &params) const
-    { return Get(params, has_exclude_flags); }
+    {
+        return Get(params, has_exclude_flags);
+    }
 
   private:
     // Algorithm with exclude flags
@@ -88,7 +92,9 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     }
 
     std::shared_ptr<const Facade> Get(const api::TileParameters &, std::false_type) const
-    { return facades[0]; }
+    {
+        return facades[0];
+    }
 
     // Default for non-exclude flags: return only facade
     std::shared_ptr<const Facade> Get(const api::BaseParameters &params, std::false_type) const
@@ -103,7 +109,9 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
 
     // TileParameters don't drive from BaseParameters and generally don't have use for exclude flags
     std::shared_ptr<const Facade> Get(const api::TileParameters &, std::true_type) const
-    { return facades[0]; }
+    {
+        return facades[0];
+    }
 
     // Selection logic for finding the corresponding datafacade for the given parameters
     std::shared_ptr<const Facade> Get(const api::BaseParameters &params, std::true_type) const
diff --git a/include/engine/datafacade_provider.hpp b/include/engine/datafacade_provider.hpp
index d28182bd7bb..7c1b8f6de56 100644
--- a/include/engine/datafacade_provider.hpp
+++ b/include/engine/datafacade_provider.hpp
@@ -36,9 +36,13 @@ class ExternalProvider final : public DataFacadeProvider<AlgorithmT, FacadeT>
     }
 
     std::shared_ptr<const Facade> Get(const api::TileParameters &params) const override final
-    { return facade_factory.Get(params); }
+    {
+        return facade_factory.Get(params);
+    }
     std::shared_ptr<const Facade> Get(const api::BaseParameters &params) const override final
-    { return facade_factory.Get(params); }
+    {
+        return facade_factory.Get(params);
+    }
 
   private:
     DataFacadeFactory<FacadeT, AlgorithmT> facade_factory;
@@ -56,9 +60,13 @@ class ImmutableProvider final : public DataFacadeProvider<AlgorithmT, FacadeT>
     }
 
     std::shared_ptr<const Facade> Get(const api::TileParameters &params) const override final
-    { return facade_factory.Get(params); }
+    {
+        return facade_factory.Get(params);
+    }
     std::shared_ptr<const Facade> Get(const api::BaseParameters &params) const override final
-    { return facade_factory.Get(params); }
+    {
+        return facade_factory.Get(params);
+    }
 
   private:
     DataFacadeFactory<FacadeT, AlgorithmT> facade_factory;
@@ -75,9 +83,13 @@ class WatchingProvider : public DataFacadeProvider<AlgorithmT, FacadeT>
     WatchingProvider(const std::string &dataset_name) : watchdog(dataset_name) {}
 
     std::shared_ptr<const Facade> Get(const api::TileParameters &params) const override final
-    { return watchdog.Get(params); }
+    {
+        return watchdog.Get(params);
+    }
     std::shared_ptr<const Facade> Get(const api::BaseParameters &params) const override final
-    { return watchdog.Get(params); }
+    {
+        return watchdog.Get(params);
+    }
 };
 } // namespace detail
 
diff --git a/include/engine/douglas_peucker.hpp b/include/engine/douglas_peucker.hpp
index fcdd5a60d60..e535593bbb9 100644
--- a/include/engine/douglas_peucker.hpp
+++ b/include/engine/douglas_peucker.hpp
@@ -72,7 +72,9 @@ std::vector<util::Coordinate> douglasPeucker(std::vector<util::Coordinate>::cons
 // Convenience range-based function
 inline std::vector<util::Coordinate> douglasPeucker(const std::vector<util::Coordinate> &geometry,
                                                     const unsigned zoom_level)
-{ return douglasPeucker(begin(geometry), end(geometry), zoom_level); }
+{
+    return douglasPeucker(begin(geometry), end(geometry), zoom_level);
+}
 } // namespace osrm::engine
 
 #endif /* DOUGLAS_PEUCKER_HPP_ */
diff --git a/include/engine/engine.hpp b/include/engine/engine.hpp
index f7a1d7f2e9b..d2491f18679 100644
--- a/include/engine/engine.hpp
+++ b/include/engine/engine.hpp
@@ -89,26 +89,40 @@ class Engine final : public EngineInterface
     virtual ~Engine() override = default;
 
     Status Route(const api::RouteParameters &params, api::ResultT &result) const override final
-    { return route_plugin.HandleRequest(GetAlgorithms(params), params, result); }
+    {
+        return route_plugin.HandleRequest(GetAlgorithms(params), params, result);
+    }
 
     Status Table(const api::TableParameters &params, api::ResultT &result) const override final
-    { return table_plugin.HandleRequest(GetAlgorithms(params), params, result); }
+    {
+        return table_plugin.HandleRequest(GetAlgorithms(params), params, result);
+    }
 
     Status Nearest(const api::NearestParameters &params, api::ResultT &result) const override final
-    { return nearest_plugin.HandleRequest(GetAlgorithms(params), params, result); }
+    {
+        return nearest_plugin.HandleRequest(GetAlgorithms(params), params, result);
+    }
 
     Status Trip(const api::TripParameters &params, api::ResultT &result) const override final
-    { return trip_plugin.HandleRequest(GetAlgorithms(params), params, result); }
+    {
+        return trip_plugin.HandleRequest(GetAlgorithms(params), params, result);
+    }
 
     Status Match(const api::MatchParameters &params, api::ResultT &result) const override final
-    { return match_plugin.HandleRequest(GetAlgorithms(params), params, result); }
+    {
+        return match_plugin.HandleRequest(GetAlgorithms(params), params, result);
+    }
 
     Status Tile(const api::TileParameters &params, api::ResultT &result) const override final
-    { return tile_plugin.HandleRequest(GetAlgorithms(params), params, result); }
+    {
+        return tile_plugin.HandleRequest(GetAlgorithms(params), params, result);
+    }
 
   private:
     template <typename ParametersT> auto GetAlgorithms(const ParametersT &params) const
-    { return RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get(params)}; }
+    {
+        return RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get(params)};
+    }
     std::unique_ptr<DataFacadeProvider<Algorithm>> facade_provider;
     mutable SearchEngineData<Algorithm> heaps;
 
diff --git a/include/engine/geospatial_query.hpp b/include/engine/geospatial_query.hpp
index f7a2fa2bc9e..a3d5a1de613 100644
--- a/include/engine/geospatial_query.hpp
+++ b/include/engine/geospatial_query.hpp
@@ -24,7 +24,9 @@ namespace osrm::engine
 
 inline std::pair<bool, bool> operator&&(const std::pair<bool, bool> &a,
                                         const std::pair<bool, bool> &b)
-{ return {a.first && b.first, a.second && b.second}; }
+{
+    return {a.first && b.first, a.second && b.second};
+}
 
 // Implements complex queries on top of an RTree and builds PhantomNodes from it.
 //
@@ -42,7 +44,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     }
 
     std::vector<EdgeData> Search(const util::RectangleInt2D &bbox)
-    { return rtree.SearchInBox(bbox); }
+    {
+        return rtree.SearchInBox(bbox);
+    }
 
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate input_coordinate,
@@ -494,7 +498,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     bool CheckSegmentDistance(const Coordinate input_coordinate,
                               const CandidateSegment &segment,
                               const double max_distance) const
-    { return GetSegmentDistance(input_coordinate, segment) > max_distance; }
+    {
+        return GetSegmentDistance(input_coordinate, segment) > max_distance;
+    }
 
     std::pair<bool, bool> CheckSegmentExclude(const CandidateSegment &segment) const
     {
diff --git a/include/engine/guidance/collapsing_utility.hpp b/include/engine/guidance/collapsing_utility.hpp
index c31e601ad6c..9a0a1f01714 100644
--- a/include/engine/guidance/collapsing_utility.hpp
+++ b/include/engine/guidance/collapsing_utility.hpp
@@ -21,9 +21,13 @@ const double constexpr STRAIGHT_ANGLE = 180.;
 
 // check if a step is completely without turn type
 inline bool hasTurnType(const RouteStep &step)
-{ return step.maneuver.instruction.type != osrm::guidance::TurnType::NoTurn; }
+{
+    return step.maneuver.instruction.type != osrm::guidance::TurnType::NoTurn;
+}
 inline bool hasWaypointType(const RouteStep &step)
-{ return step.maneuver.waypoint_type != WaypointType::None; }
+{
+    return step.maneuver.waypoint_type != WaypointType::None;
+}
 
 // skip backwards through possibly disabled turns until we find a turn type (or the first step)
 inline RouteStepIterator findPreviousTurn(RouteStepIterator current_step)
@@ -56,17 +60,25 @@ inline RouteStepIterator findNextTurn(RouteStepIterator current_step)
 
 // alias for comparisons
 inline bool hasTurnType(const RouteStep &step, const osrm::guidance::TurnType::Enum type)
-{ return type == step.maneuver.instruction.type; }
+{
+    return type == step.maneuver.instruction.type;
+}
 // alias for comparisons
 inline bool hasModifier(const RouteStep &step,
                         const osrm::guidance::DirectionModifier::Enum modifier)
-{ return modifier == step.maneuver.instruction.direction_modifier; }
+{
+    return modifier == step.maneuver.instruction.direction_modifier;
+}
 inline bool hasLanes(const RouteStep &step)
-{ return step.intersections.front().lanes.lanes_in_turn != 0; }
+{
+    return step.intersections.front().lanes.lanes_in_turn != 0;
+}
 
 // alias for detectors, gives the number of connected roads
 inline std::size_t numberOfAvailableTurns(const RouteStep &step)
-{ return step.intersections.front().entry.size(); }
+{
+    return step.intersections.front().entry.size();
+}
 // alias for detectors, counts only the allowed turns
 inline std::size_t numberOfAllowedTurns(const RouteStep &step)
 {
@@ -83,19 +95,27 @@ inline bool isTrafficLightStep(const RouteStep &step)
 
 // alias for readability
 inline void setInstructionType(RouteStep &step, const osrm::guidance::TurnType::Enum type)
-{ step.maneuver.instruction.type = type; }
+{
+    step.maneuver.instruction.type = type;
+}
 
 // alias for readability
 inline void setModifier(RouteStep &step, const osrm::guidance::DirectionModifier::Enum modifier)
-{ step.maneuver.instruction.direction_modifier = modifier; }
+{
+    step.maneuver.instruction.direction_modifier = modifier;
+}
 
 // alias for readability
 inline bool haveSameMode(const RouteStep &lhs, const RouteStep &rhs)
-{ return lhs.mode == rhs.mode; }
+{
+    return lhs.mode == rhs.mode;
+}
 
 // alias for readability
 inline bool haveSameMode(const RouteStep &first, const RouteStep &second, const RouteStep &third)
-{ return haveSameMode(first, second) && haveSameMode(second, third); }
+{
+    return haveSameMode(first, second) && haveSameMode(second, third);
+}
 
 // alias for readability
 inline bool haveSameName(const RouteStep &lhs, const RouteStep &rhs)
@@ -215,7 +235,9 @@ inline bool bearingsAreReversed(const double bearing_in, const double bearing_ou
 
 // Returns true if the specified step has only one intersection
 inline bool hasSingleIntersection(const RouteStep &step)
-{ return (step.intersections.size() == 1); }
+{
+    return (step.intersections.size() == 1);
+}
 
 // Returns true if the specified angle is a wider straight turn
 inline bool isWiderStraight(const double angle) { return (angle >= 125 && angle <= 235); }
diff --git a/include/engine/guidance/leg_geometry.hpp b/include/engine/guidance/leg_geometry.hpp
index fcf1bc85bbe..55f8968d45c 100644
--- a/include/engine/guidance/leg_geometry.hpp
+++ b/include/engine/guidance/leg_geometry.hpp
@@ -45,10 +45,14 @@ struct LegGeometry
     std::vector<Annotation> annotations;
 
     std::size_t FrontIndex(std::size_t segment_index) const
-    { return segment_offsets[segment_index]; }
+    {
+        return segment_offsets[segment_index];
+    }
 
     std::size_t BackIndex(std::size_t segment_index) const
-    { return segment_offsets[segment_index + 1]; }
+    {
+        return segment_offsets[segment_index + 1];
+    }
 
     std::size_t GetNumberOfSegments() const
     {
diff --git a/include/engine/guidance/route_step.hpp b/include/engine/guidance/route_step.hpp
index 884598d640d..b123e153e3f 100644
--- a/include/engine/guidance/route_step.hpp
+++ b/include/engine/guidance/route_step.hpp
@@ -191,10 +191,14 @@ inline RouteStep &RouteStep::AdaptStepSignage(const RouteStep &origin)
 inline bool RouteStep::HasLanesAtTurn() const { return NumLanesInTotal() != 0; }
 
 inline LaneID RouteStep::NumLanesInTurn() const
-{ return intersections.front().lanes.lanes_in_turn; }
+{
+    return intersections.front().lanes.lanes_in_turn;
+}
 
 inline LaneID RouteStep::NumLanesInTotal() const
-{ return intersections.front().lane_description.size(); }
+{
+    return intersections.front().lane_description.size();
+}
 
 inline LaneID RouteStep::NumLanesToTheRight() const
 {
diff --git a/include/engine/internal_route_result.hpp b/include/engine/internal_route_result.hpp
index c95050e8a3c..78f5d11967d 100644
--- a/include/engine/internal_route_result.hpp
+++ b/include/engine/internal_route_result.hpp
@@ -56,7 +56,9 @@ struct InternalRouteResult
     bool is_valid() const { return INVALID_EDGE_WEIGHT != shortest_path_weight; }
 
     bool is_via_leg(const std::size_t leg) const
-    { return (leg != unpacked_path_segments.size() - 1); }
+    {
+        return (leg != unpacked_path_segments.size() - 1);
+    }
 
     // Note: includes duration for turns, except for at start and end node.
     EdgeDuration duration() const
diff --git a/include/engine/map_matching/hidden_markov_model.hpp b/include/engine/map_matching/hidden_markov_model.hpp
index 72fdf4d2964..f719b076e98 100644
--- a/include/engine/map_matching/hidden_markov_model.hpp
+++ b/include/engine/map_matching/hidden_markov_model.hpp
@@ -30,7 +30,9 @@ struct EmissionLogProbability
     }
 
     double operator()(const double distance) const
-    { return -0.5 * (log_2_pi + (distance / sigma_z) * (distance / sigma_z)) - log_sigma_z; }
+    {
+        return -0.5 * (log_2_pi + (distance / sigma_z) * (distance / sigma_z)) - log_sigma_z;
+    }
 };
 
 struct TransitionLogProbability
diff --git a/include/engine/phantom_node.hpp b/include/engine/phantom_node.hpp
index ec5665c1853..3ddfaa2a55a 100644
--- a/include/engine/phantom_node.hpp
+++ b/include/engine/phantom_node.hpp
@@ -123,18 +123,28 @@ struct PhantomNode
     }
 
     bool IsValid(const unsigned number_of_nodes, const util::Coordinate queried_coordinate) const
-    { return queried_coordinate == input_location && IsValid(number_of_nodes); }
+    {
+        return queried_coordinate == input_location && IsValid(number_of_nodes);
+    }
 
     bool IsValid() const { return location.IsValid(); }
 
     bool IsValidForwardSource() const
-    { return forward_segment_id.enabled && is_valid_forward_source; }
+    {
+        return forward_segment_id.enabled && is_valid_forward_source;
+    }
     bool IsValidForwardTarget() const
-    { return forward_segment_id.enabled && is_valid_forward_target; }
+    {
+        return forward_segment_id.enabled && is_valid_forward_target;
+    }
     bool IsValidReverseSource() const
-    { return reverse_segment_id.enabled && is_valid_reverse_source; }
+    {
+        return reverse_segment_id.enabled && is_valid_reverse_source;
+    }
     bool IsValidReverseTarget() const
-    { return reverse_segment_id.enabled && is_valid_reverse_target; }
+    {
+        return reverse_segment_id.enabled && is_valid_reverse_target;
+    }
     short GetBearing(const bool traversed_in_reverse) const
     {
         if (traversed_in_reverse)
diff --git a/include/engine/plugins/plugin_base.hpp b/include/engine/plugins/plugin_base.hpp
index cb03ee855df..1e29f6d233e 100644
--- a/include/engine/plugins/plugin_base.hpp
+++ b/include/engine/plugins/plugin_base.hpp
@@ -71,7 +71,7 @@ class BasePlugin
         std::string message;
 
         ErrorRenderer(std::string code, std::string message)
-            : code(std::move(code)), message(std::move(message)) {};
+            : code(std::move(code)), message(std::move(message)){};
 
         void operator()(util::json::Object &json_result)
         {
@@ -87,7 +87,9 @@ class BasePlugin
             fb_result.Finish(response.Finish());
         };
         void operator()(std::string &str_result)
-        { str_result = std::format("code={} message={}", code, message); };
+        {
+            str_result = std::format("code={} message={}", code, message);
+        };
     };
 
     Status Error(const std::string &code,
diff --git a/include/engine/routing_algorithms.hpp b/include/engine/routing_algorithms.hpp
index 852621eff79..1c33caf1f82 100644
--- a/include/engine/routing_algorithms.hpp
+++ b/include/engine/routing_algorithms.hpp
@@ -105,28 +105,44 @@ class RoutingAlgorithms final : public RoutingAlgorithmsInterface
     const DataFacadeBase &GetFacade() const final override { return *facade; }
 
     bool HasAlternativePathSearch() const final override
-    { return routing_algorithms::HasAlternativePathSearch<Algorithm>::value; }
+    {
+        return routing_algorithms::HasAlternativePathSearch<Algorithm>::value;
+    }
 
     bool HasShortestPathSearch() const final override
-    { return routing_algorithms::HasShortestPathSearch<Algorithm>::value; }
+    {
+        return routing_algorithms::HasShortestPathSearch<Algorithm>::value;
+    }
 
     bool HasDirectShortestPathSearch() const final override
-    { return routing_algorithms::HasDirectShortestPathSearch<Algorithm>::value; }
+    {
+        return routing_algorithms::HasDirectShortestPathSearch<Algorithm>::value;
+    }
 
     bool HasMapMatching() const final override
-    { return routing_algorithms::HasMapMatching<Algorithm>::value; }
+    {
+        return routing_algorithms::HasMapMatching<Algorithm>::value;
+    }
 
     bool HasManyToManySearch() const final override
-    { return routing_algorithms::HasManyToManySearch<Algorithm>::value; }
+    {
+        return routing_algorithms::HasManyToManySearch<Algorithm>::value;
+    }
 
     bool SupportsDistanceAnnotationType() const final override
-    { return routing_algorithms::SupportsDistanceAnnotationType<Algorithm>::value; }
+    {
+        return routing_algorithms::SupportsDistanceAnnotationType<Algorithm>::value;
+    }
 
     bool HasGetTileTurns() const final override
-    { return routing_algorithms::HasGetTileTurns<Algorithm>::value; }
+    {
+        return routing_algorithms::HasGetTileTurns<Algorithm>::value;
+    }
 
     bool HasExcludeFlags() const final override
-    { return routing_algorithms::HasExcludeFlags<Algorithm>::value; }
+    {
+        return routing_algorithms::HasExcludeFlags<Algorithm>::value;
+    }
 
     bool IsValid() const final override { return static_cast<bool>(facade); }
 
@@ -155,7 +171,9 @@ InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
 template <routing_algorithms::RoutingAlgorithm Algorithm>
 InternalRouteResult RoutingAlgorithms<Algorithm>::DirectShortestPathSearch(
     const PhantomEndpointCandidates &endpoint_candidates) const
-{ return routing_algorithms::directShortestPathSearch(heaps, *facade, endpoint_candidates); }
+{
+    return routing_algorithms::directShortestPathSearch(heaps, *facade, endpoint_candidates);
+}
 
 template <routing_algorithms::RoutingAlgorithm Algorithm>
 inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatching(
@@ -210,7 +228,9 @@ template <routing_algorithms::RoutingAlgorithm Algorithm>
 inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<Algorithm>::GetTileTurns(
     const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
     const std::vector<std::size_t> &sorted_edge_indexes) const
-{ return routing_algorithms::getTileTurns(*facade, edges, sorted_edge_indexes); }
+{
+    return routing_algorithms::getTileTurns(*facade, edges, sorted_edge_indexes);
+}
 
 } // namespace osrm::engine
 
diff --git a/include/engine/routing_algorithms/many_to_many.hpp b/include/engine/routing_algorithms/many_to_many.hpp
index c826cf60b51..61398078440 100644
--- a/include/engine/routing_algorithms/many_to_many.hpp
+++ b/include/engine/routing_algorithms/many_to_many.hpp
@@ -48,16 +48,22 @@ struct NodeBucket
 
     // partial order comparison
     bool operator<(const NodeBucket &rhs) const
-    { return std::tie(middle_node, column_index) < std::tie(rhs.middle_node, rhs.column_index); }
+    {
+        return std::tie(middle_node, column_index) < std::tie(rhs.middle_node, rhs.column_index);
+    }
 
     // functor for equal_range
     struct Compare
     {
         bool operator()(const NodeBucket &lhs, const NodeID &rhs) const
-        { return lhs.middle_node < rhs; }
+        {
+            return lhs.middle_node < rhs;
+        }
 
         bool operator()(const NodeID &lhs, const NodeBucket &rhs) const
-        { return lhs < rhs.middle_node; }
+        {
+            return lhs < rhs.middle_node;
+        }
     };
 
     // functor for equal_range
@@ -65,13 +71,17 @@ struct NodeBucket
     {
         unsigned column_idx;
 
-        ColumnCompare(unsigned column_idx) : column_idx(column_idx) {};
+        ColumnCompare(unsigned column_idx) : column_idx(column_idx){};
 
         bool operator()(const NodeBucket &lhs, const NodeID &rhs) const // lowerbound
-        { return std::tie(lhs.middle_node, lhs.column_index) < std::tie(rhs, column_idx); }
+        {
+            return std::tie(lhs.middle_node, lhs.column_index) < std::tie(rhs, column_idx);
+        }
 
         bool operator()(const NodeID &lhs, const NodeBucket &rhs) const // upperbound
-        { return std::tie(lhs, column_idx) < std::tie(rhs.middle_node, rhs.column_index); }
+        {
+            return std::tie(lhs, column_idx) < std::tie(rhs.middle_node, rhs.column_index);
+        }
     };
 };
 } // namespace
diff --git a/include/engine/routing_algorithms/routing_base_mld.hpp b/include/engine/routing_algorithms/routing_base_mld.hpp
index 267aab33431..7999cb227e2 100644
--- a/include/engine/routing_algorithms/routing_base_mld.hpp
+++ b/include/engine/routing_algorithms/routing_base_mld.hpp
@@ -48,7 +48,9 @@ template <typename MultiLevelPartition>
 inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                  NodeID node,
                                  const PhantomEndpoints &endpoints)
-{ return getNodeQueryLevel(partition, node, endpoints.source_phantom, endpoints.target_phantom); }
+{
+    return getNodeQueryLevel(partition, node, endpoints.source_phantom, endpoints.target_phantom);
+}
 
 template <typename MultiLevelPartition>
 inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
@@ -84,8 +86,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                 std::accumulate(endpoint_candidates.target_phantoms.begin(),
                                 endpoint_candidates.target_phantoms.end(),
                                 level_1,
-                                [&](LevelID level_2, const PhantomNode &target)
-                                {
+                                [&](LevelID level_2, const PhantomNode &target) {
                                     return std::min(
                                         level_2,
                                         getNodeQueryLevel(partition, node, source, target));
@@ -96,17 +97,23 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
 
 template <typename PhantomCandidateT>
 inline bool checkParentCellRestriction(CellID, const PhantomCandidateT &)
-{ return true; }
+{
+    return true;
+}
 
 // Restricted search (Args is LevelID, CellID):
 //   * use the fixed level for queries
 //   * check if the node cell is the same as the specified parent
 template <typename MultiLevelPartition>
 inline LevelID getNodeQueryLevel(const MultiLevelPartition &, NodeID, LevelID level, CellID)
-{ return level; }
+{
+    return level;
+}
 
 inline bool checkParentCellRestriction(CellID cell, LevelID, CellID parent)
-{ return cell == parent; }
+{
+    return cell == parent;
+}
 
 // Unrestricted search with a single phantom node (Args is const PhantomNode &):
 //   * use partition.GetQueryLevel to find the node query level
diff --git a/include/engine/routing_algorithms/shortest_path_impl.hpp b/include/engine/routing_algorithms/shortest_path_impl.hpp
index ff6c07ea2b9..02b3f579202 100644
--- a/include/engine/routing_algorithms/shortest_path_impl.hpp
+++ b/include/engine/routing_algorithms/shortest_path_impl.hpp
@@ -504,10 +504,14 @@ struct route_state
     }
 
     size_t previousForwardPath(size_t previous_leg) const
-    { return previous_leg_path_offset + 2 * previous_leg; }
+    {
+        return previous_leg_path_offset + 2 * previous_leg;
+    }
 
     size_t previousReversePath(size_t previous_leg) const
-    { return previous_leg_path_offset + 2 * previous_leg + 1; }
+    {
+        return previous_leg_path_offset + 2 * previous_leg + 1;
+    }
 
     void addSearchResult(const PhantomCandidatesToTarget &candidates,
                          const std::vector<NodeID> &packed_leg_to_forward,
diff --git a/include/extractor/edge_based_node_segment.hpp b/include/extractor/edge_based_node_segment.hpp
index 9dd1e752946..c3c3937c87a 100644
--- a/include/extractor/edge_based_node_segment.hpp
+++ b/include/extractor/edge_based_node_segment.hpp
@@ -34,7 +34,9 @@ struct EdgeBasedNodeSegment
                                   bool is_startpoint_)
         : forward_segment_id(forward_segment_id_), reverse_segment_id(reverse_segment_id_), u(u),
           v(v), fwd_segment_position(fwd_segment_position), is_startpoint(is_startpoint_)
-    { BOOST_ASSERT(forward_segment_id.enabled || reverse_segment_id.enabled); }
+    {
+        BOOST_ASSERT(forward_segment_id.enabled || reverse_segment_id.enabled);
+    }
 
     SegmentID forward_segment_id; // edge-based graph node ID in forward direction (u->v)
     SegmentID reverse_segment_id; // edge-based graph node ID in reverse direction (v->u if exists)
diff --git a/include/extractor/extraction_helper_functions.hpp b/include/extractor/extraction_helper_functions.hpp
index 466ae47e06b..9667fb00c14 100644
--- a/include/extractor/extraction_helper_functions.hpp
+++ b/include/extractor/extraction_helper_functions.hpp
@@ -165,11 +165,15 @@ inline unsigned parseDuration(const std::string &s)
 
 inline std::string
 trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t count_right)
-{ return guidance::trimLaneString(std::move(lane_string), count_left, count_right); }
+{
+    return guidance::trimLaneString(std::move(lane_string), count_left, count_right);
+}
 
 inline std::string applyAccessTokens(const std::string &lane_string,
                                      const std::string &access_tokens)
-{ return guidance::applyAccessTokens(lane_string, access_tokens); }
+{
+    return guidance::applyAccessTokens(lane_string, access_tokens);
+}
 
 // Takes a string representing a list separated by delim and canonicalizes containing spaces.
 // Example: "aaa;bbb; ccc;  d;dd" => "aaa; bbb; ccc; d; dd"
diff --git a/include/extractor/extraction_relation.hpp b/include/extractor/extraction_relation.hpp
index 6958fdb53d0..41b61c8b2a2 100644
--- a/include/extractor/extraction_relation.hpp
+++ b/include/extractor/extraction_relation.hpp
@@ -60,7 +60,9 @@ struct ExtractionRelation
     }
 
     void AddMember(const OsmIDTyped &member_id, const char *role)
-    { members_role.emplace_back(std::make_pair(member_id.Hash(), std::string(role))); }
+    {
+        members_role.emplace_back(std::make_pair(member_id.Hash(), std::string(role)));
+    }
 
     const char *GetRole(const OsmIDTyped &member_id) const
     {
diff --git a/include/extractor/extraction_way.hpp b/include/extractor/extraction_way.hpp
index f1e474b1a30..2f24bd0420b 100644
--- a/include/extractor/extraction_way.hpp
+++ b/include/extractor/extraction_way.hpp
@@ -78,10 +78,14 @@ struct ExtractionWay
     void SetPronunciation(const char *value) { detail::maybeSetString(pronunciation, value); }
     const char *GetPronunciation() const { return pronunciation.c_str(); }
     void SetTurnLanesForward(const char *value)
-    { detail::maybeSetString(turn_lanes_forward, value); }
+    {
+        detail::maybeSetString(turn_lanes_forward, value);
+    }
     const char *GetTurnLanesForward() const { return turn_lanes_forward.c_str(); }
     void SetTurnLanesBackward(const char *value)
-    { detail::maybeSetString(turn_lanes_backward, value); }
+    {
+        detail::maybeSetString(turn_lanes_backward, value);
+    }
     const char *GetTurnLanesBackward() const { return turn_lanes_backward.c_str(); }
 
     // markers for determining user-defined classes for each way
diff --git a/include/extractor/extractor_config.hpp b/include/extractor/extractor_config.hpp
index cad02f30e65..d12d4ebe483 100644
--- a/include/extractor/extractor_config.hpp
+++ b/include/extractor/extractor_config.hpp
@@ -70,7 +70,9 @@ struct ExtractorConfig final : storage::IOConfig
     }
 
     void UseDefaultOutputNames(const std::filesystem::path &base)
-    { IOConfig::UseDefaultOutputNames(base); }
+    {
+        IOConfig::UseDefaultOutputNames(base);
+    }
 
     std::filesystem::path input_path;
     std::filesystem::path profile_path;
diff --git a/include/extractor/intersection/intersection_edge.hpp b/include/extractor/intersection/intersection_edge.hpp
index 979f21bdc93..7cb95fac739 100644
--- a/include/extractor/intersection/intersection_edge.hpp
+++ b/include/extractor/intersection/intersection_edge.hpp
@@ -16,7 +16,9 @@ struct IntersectionEdge
     EdgeID edge;
 
     bool operator<(const IntersectionEdge &other) const
-    { return std::tie(node, edge) < std::tie(other.node, other.edge); }
+    {
+        return std::tie(node, edge) < std::tie(other.node, other.edge);
+    }
 };
 
 using IntersectionEdges = std::vector<IntersectionEdge>;
diff --git a/include/extractor/intersection/intersection_view.hpp b/include/extractor/intersection/intersection_view.hpp
index 893af7ce467..15320f3e276 100644
--- a/include/extractor/intersection/intersection_view.hpp
+++ b/include/extractor/intersection/intersection_view.hpp
@@ -161,11 +161,15 @@ template <typename Self> struct EnableIntersectionOps
 
     // Returns the right-most road at this intersection.
     const auto &getRightmostRoad() const
-    { return self()->size() > 1 ? self()->operator[](1) : self()->getUTurnRoad(); }
+    {
+        return self()->size() > 1 ? self()->operator[](1) : self()->getUTurnRoad();
+    }
 
     // Returns the left-most road at this intersection.
     const auto &getLeftmostRoad() const
-    { return self()->size() > 1 ? self()->back() : self()->getUTurnRoad(); }
+    {
+        return self()->size() > 1 ? self()->back() : self()->getUTurnRoad();
+    }
 
     // Can this be skipped over?
     auto isObstacle() const { return self()->size() == 2; }
diff --git a/include/extractor/maneuver_override.hpp b/include/extractor/maneuver_override.hpp
index c0c152e8c9c..1688dcb1a48 100644
--- a/include/extractor/maneuver_override.hpp
+++ b/include/extractor/maneuver_override.hpp
@@ -53,7 +53,9 @@ struct NodeBasedTurn
     NodeID to;
 
     bool operator==(const NodeBasedTurn &other) const
-    { return other.from == from && other.via == via && other.to == to; }
+    {
+        return other.from == from && other.via == via && other.to == to;
+    }
 };
 
 // Internal representation of maneuvers during graph extraction phase
diff --git a/include/extractor/node_data_container.hpp b/include/extractor/node_data_container.hpp
index 94cfc7d1ed3..b4a50efde24 100644
--- a/include/extractor/node_data_container.hpp
+++ b/include/extractor/node_data_container.hpp
@@ -68,18 +68,26 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
     ComponentID GetComponentID(const NodeID node_id) const { return nodes[node_id].component_id; }
 
     TravelMode GetTravelMode(const NodeID node_id) const
-    { return annotation_data[nodes[node_id].annotation_id].travel_mode; }
+    {
+        return annotation_data[nodes[node_id].annotation_id].travel_mode;
+    }
 
     bool IsLeftHandDriving(const NodeID node_id) const
-    { return annotation_data[nodes[node_id].annotation_id].is_left_hand_driving; }
+    {
+        return annotation_data[nodes[node_id].annotation_id].is_left_hand_driving;
+    }
 
     bool IsSegregated(const NodeID node_id) const { return nodes[node_id].segregated; }
 
     StringViewID GetNameID(const NodeID node_id) const
-    { return annotation_data[nodes[node_id].annotation_id].string_view_id; }
+    {
+        return annotation_data[nodes[node_id].annotation_id].string_view_id;
+    }
 
     ClassData GetClassData(const NodeID node_id) const
-    { return annotation_data[nodes[node_id].annotation_id].classes; }
+    {
+        return annotation_data[nodes[node_id].annotation_id].classes;
+    }
 
     friend void serialization::read<Ownership>(storage::tar::FileReader &reader,
                                                const std::string &name,
@@ -91,7 +99,9 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
 
     void Renumber(const std::vector<std::uint32_t> &permutation)
         requires(Ownership == storage::Ownership::Container)
-    { util::inplacePermutation(nodes.begin(), nodes.end(), permutation); }
+    {
+        util::inplacePermutation(nodes.begin(), nodes.end(), permutation);
+    }
 
     NodeID NumberOfNodes() const { return nodes.size(); }
 
@@ -102,7 +112,9 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
     EdgeBasedNode const &GetNode(const NodeID node_id) const { return nodes[node_id]; }
 
     NodeBasedEdgeAnnotation const &GetAnnotation(const AnnotationID annotation) const
-    { return annotation_data[annotation]; }
+    {
+        return annotation_data[annotation];
+    }
 
   private:
     Vector<EdgeBasedNode> nodes;
diff --git a/include/extractor/node_restriction_map.hpp b/include/extractor/node_restriction_map.hpp
index 851115dcc61..4c812b2ca54 100644
--- a/include/extractor/node_restriction_map.hpp
+++ b/include/extractor/node_restriction_map.hpp
@@ -19,7 +19,9 @@ template <typename RestrictionFilter> class NodeRestrictionMap
 
     // Find all restrictions applicable to (from,via,*) turns
     auto Restrictions(NodeID from, NodeID via) const
-    { return getRange(from, via) | std::views::filter(index_filter); };
+    {
+        return getRange(from, via) | std::views::filter(index_filter);
+    };
 
     // Find all restrictions applicable to (from,via,to) turns
     auto Restrictions(NodeID from, NodeID via, NodeID to) const
@@ -47,13 +49,17 @@ template <typename RestrictionFilter> class NodeRestrictionMap
 struct ConditionalOnly
 {
     bool operator()(const TurnRestriction *restriction) const
-    { return !restriction->IsUnconditional(); };
+    {
+        return !restriction->IsUnconditional();
+    };
 };
 
 struct UnconditionalOnly
 {
     bool operator()(const TurnRestriction *restriction) const
-    { return restriction->IsUnconditional(); };
+    {
+        return restriction->IsUnconditional();
+    };
 };
 
 using RestrictionMap = NodeRestrictionMap<UnconditionalOnly>;
diff --git a/include/extractor/obstacles.hpp b/include/extractor/obstacles.hpp
index e2f95420f51..5d2417bb681 100644
--- a/include/extractor/obstacles.hpp
+++ b/include/extractor/obstacles.hpp
@@ -130,7 +130,9 @@ class ObstacleMap
     //
     // This function is thread-safe.
     void emplace(OSMNodeID osm_node_id, const Obstacle &obstacle)
-    { osm_obstacles.emplace_back(SPECIAL_OSM_NODEID, osm_node_id, obstacle); }
+    {
+        osm_obstacles.emplace_back(SPECIAL_OSM_NODEID, osm_node_id, obstacle);
+    }
 
     // Insert an obstacle using internal node ids.
     //
@@ -164,7 +166,9 @@ class ObstacleMap
     }
 
     std::vector<Obstacle> get(NodeID to) const
-    { return get(SPECIAL_NODEID, to, Obstacle::Type::All); }
+    {
+        return get(SPECIAL_NODEID, to, Obstacle::Type::All);
+    }
 
     // is there any obstacle at node 'to'?
     // inexpensive general test
@@ -178,7 +182,9 @@ class ObstacleMap
     // pass SPECIAL_NODEID as 'from' to query all obstacles at 'to'
     // 'type' can be a bitwise-or combination of Obstacle::Type
     bool any(NodeID from, NodeID to, Obstacle::Type type = Obstacle::Type::All) const
-    { return any(to) && !get(from, to, type).empty(); }
+    {
+        return any(to) && !get(from, to, type).empty();
+    }
 
     // Preprocess the obstacles
     //
diff --git a/include/extractor/profile_properties.hpp b/include/extractor/profile_properties.hpp
index 5cd36d8a814..0d946d13c6c 100644
--- a/include/extractor/profile_properties.hpp
+++ b/include/extractor/profile_properties.hpp
@@ -37,22 +37,30 @@ struct ProfileProperties
     double GetUturnPenalty() const { return u_turn_penalty / 10.; }
 
     void SetUturnPenalty(const double u_turn_penalty_)
-    { u_turn_penalty = boost::numeric_cast<int>(u_turn_penalty_ * 10.); }
+    {
+        u_turn_penalty = boost::numeric_cast<int>(u_turn_penalty_ * 10.);
+    }
 
     double GetTrafficSignalPenalty() const { return traffic_signal_penalty / 10.; }
 
     void SetTrafficSignalPenalty(const double traffic_signal_penalty_)
-    { traffic_signal_penalty = boost::numeric_cast<int>(traffic_signal_penalty_ * 10.); }
+    {
+        traffic_signal_penalty = boost::numeric_cast<int>(traffic_signal_penalty_ * 10.);
+    }
 
     double GetMaxSpeedForMapMatching() const { return max_speed_for_map_matching; }
 
     void SetMaxSpeedForMapMatching(const double max_speed_for_map_matching_)
-    { max_speed_for_map_matching = max_speed_for_map_matching_; }
+    {
+        max_speed_for_map_matching = max_speed_for_map_matching_;
+    }
 
     double GetMaxCollapseDistance() const { return max_collapse_distance; }
 
     void SetMaxCollapseDistance(const double max_collapse_distance_)
-    { max_collapse_distance = max_collapse_distance_; }
+    {
+        max_collapse_distance = max_collapse_distance_;
+    }
 
     void SetWeightName(const std::string &name)
     {
@@ -74,7 +82,9 @@ struct ProfileProperties
 
     // Mark this combination of classes as excludable
     void SetExcludableClasses(std::size_t index, ClassData classes)
-    { excludable_classes[index] = classes; }
+    {
+        excludable_classes[index] = classes;
+    }
 
     // Check if this classes are excludable
     std::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
@@ -108,7 +118,9 @@ struct ProfileProperties
     double GetWeightMultiplier() const { return std::pow(10., weight_precision); }
 
     double GetMaxTurnWeight() const
-    { return from_alias<double>(MAXIMAL_TURN_PENALTY) / GetWeightMultiplier(); }
+    {
+        return from_alias<double>(MAXIMAL_TURN_PENALTY) / GetWeightMultiplier();
+    }
 
     //! penalty to cross a traffic light in deci-seconds
     std::int32_t traffic_signal_penalty;
diff --git a/include/extractor/restriction.hpp b/include/extractor/restriction.hpp
index 662b10972f4..40843d5c758 100644
--- a/include/extractor/restriction.hpp
+++ b/include/extractor/restriction.hpp
@@ -34,10 +34,14 @@ struct TurnRestriction
     }
 
     explicit TurnRestriction()
-    { turn_path = {ViaNodePath{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID}}; }
+    {
+        turn_path = {ViaNodePath{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID}};
+    }
 
     bool IsTurnRestricted(NodeID to) const
-    { return is_only ? turn_path.To() != to : turn_path.To() == to; }
+    {
+        return is_only ? turn_path.To() != to : turn_path.To() == to;
+    }
 
     bool IsUnconditional() const { return condition.empty(); }
 
diff --git a/include/extractor/segment_data_container.hpp b/include/extractor/segment_data_container.hpp
index 29ef82c4f4c..822d8158256 100644
--- a/include/extractor/segment_data_container.hpp
+++ b/include/extractor/segment_data_container.hpp
@@ -77,7 +77,9 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
     }
 
     auto GetReverseGeometry(const DirectionalGeometryID id)
-    { return GetForwardGeometry(id) | std::views::reverse; }
+    {
+        return GetForwardGeometry(id) | std::views::reverse;
+    }
 
     auto GetForwardDurations(const DirectionalGeometryID id)
     {
@@ -133,7 +135,9 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
     }
 
     auto GetReverseGeometry(const DirectionalGeometryID id) const
-    { return GetForwardGeometry(id) | std::views::reverse; }
+    {
+        return GetForwardGeometry(id) | std::views::reverse;
+    }
 
     auto GetForwardDurations(const DirectionalGeometryID id) const
     {
diff --git a/include/extractor/serialization.hpp b/include/extractor/serialization.hpp
index 1f2a2043cff..f9e7ff29f35 100644
--- a/include/extractor/serialization.hpp
+++ b/include/extractor/serialization.hpp
@@ -46,7 +46,9 @@ inline void write(storage::tar::FileWriter &writer,
 // read/write for properties file
 inline void
 read(storage::tar::FileReader &reader, const std::string &name, ProfileProperties &properties)
-{ reader.ReadInto(name, properties); }
+{
+    reader.ReadInto(name, properties);
+}
 
 inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
@@ -58,7 +60,9 @@ inline void write(storage::tar::FileWriter &writer,
 
 // read/write for datasources file
 inline void read(storage::tar::FileReader &reader, const std::string &name, Datasources &sources)
-{ reader.ReadInto(name, sources); }
+{
+    reader.ReadInto(name, sources);
+}
 
 inline void write(storage::tar::FileWriter &writer, const std::string &name, Datasources &sources)
 {
@@ -208,7 +212,9 @@ template <storage::Ownership Ownership>
 inline void read(storage::tar::FileReader &reader,
                  const std::string &name,
                  detail::StringTableImpl<Ownership> &string_table)
-{ util::serialization::read(reader, name, string_table.indexed_data); }
+{
+    util::serialization::read(reader, name, string_table.indexed_data);
+}
 } // namespace osrm::extractor::serialization
 
 #endif
diff --git a/include/extractor/turn_path.hpp b/include/extractor/turn_path.hpp
index a7931418db1..4bd751ed454 100644
--- a/include/extractor/turn_path.hpp
+++ b/include/extractor/turn_path.hpp
@@ -130,10 +130,14 @@ struct ViaNodePath
 
     // check if all parts of the restriction reference an actual node
     bool Valid() const
-    { return from != SPECIAL_NODEID && to != SPECIAL_NODEID && via != SPECIAL_NODEID; };
+    {
+        return from != SPECIAL_NODEID && to != SPECIAL_NODEID && via != SPECIAL_NODEID;
+    };
 
     bool operator==(const ViaNodePath &other) const
-    { return std::tie(from, via, to) == std::tie(other.from, other.via, other.to); }
+    {
+        return std::tie(from, via, to) == std::tie(other.from, other.via, other.to);
+    }
 };
 
 //
@@ -163,7 +167,9 @@ struct ViaWayPath
     };
 
     bool operator==(const ViaWayPath &other) const
-    { return std::tie(from, via, to) == std::tie(other.from, other.via, other.to); }
+    {
+        return std::tie(from, via, to) == std::tie(other.from, other.via, other.to);
+    }
 };
 
 // Wrapper for turn paths that gives more information on its type / handles the switch
diff --git a/include/guidance/statistics_handler.hpp b/include/guidance/statistics_handler.hpp
index 541ef5febd1..4ee32b6d684 100644
--- a/include/guidance/statistics_handler.hpp
+++ b/include/guidance/statistics_handler.hpp
@@ -71,7 +71,9 @@ class StatisticsHandler final : public IntersectionHandler
     }
 
     bool canProcess(const NodeID, const EdgeID, const Intersection &) const override final
-    { return true; }
+    {
+        return true;
+    }
 
     Intersection
     operator()(const NodeID, const EdgeID, Intersection intersection) const override final
diff --git a/include/guidance/turn_data_container.hpp b/include/guidance/turn_data_container.hpp
index 199b929cf80..fb091df36bb 100644
--- a/include/guidance/turn_data_container.hpp
+++ b/include/guidance/turn_data_container.hpp
@@ -73,7 +73,9 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
     bool HasLaneData(const EdgeID id) const { return INVALID_LANE_DATAID != lane_data_ids[id]; }
 
     guidance::TurnInstruction GetTurnInstruction(const EdgeID id) const
-    { return turn_instructions[id]; }
+    {
+        return turn_instructions[id];
+    }
 
     // Used by EdgeBasedGraphFactory to fill data structure
     void push_back(const TurnData &data)
diff --git a/include/guidance/turn_instruction.hpp b/include/guidance/turn_instruction.hpp
index f7ab82b9056..83132ac2495 100644
--- a/include/guidance/turn_instruction.hpp
+++ b/include/guidance/turn_instruction.hpp
@@ -75,7 +75,9 @@ struct TurnInstruction
     DirectionModifier::Enum direction_modifier : 3;
 
     bool IsUTurn() const
-    { return type != TurnType::NoTurn && direction_modifier == DirectionModifier::UTurn; }
+    {
+        return type != TurnType::NoTurn && direction_modifier == DirectionModifier::UTurn;
+    }
 
     static TurnInstruction INVALID() { return {TurnType::Invalid, DirectionModifier::UTurn}; }
 
@@ -83,7 +85,9 @@ struct TurnInstruction
 
     static TurnInstruction REMAIN_ROUNDABOUT(const RoundaboutType,
                                              const DirectionModifier::Enum modifier)
-    { return {TurnType::StayOnRoundabout, modifier}; }
+    {
+        return {TurnType::StayOnRoundabout, modifier};
+    }
 
     static TurnInstruction ENTER_ROUNDABOUT(const RoundaboutType roundabout_type,
                                             const DirectionModifier::Enum modifier)
@@ -129,16 +133,22 @@ struct TurnInstruction
     }
 
     static TurnInstruction SUPPRESSED(const DirectionModifier::Enum modifier)
-    { return {TurnType::Suppressed, modifier}; }
+    {
+        return {TurnType::Suppressed, modifier};
+    }
 };
 
 static_assert(sizeof(TurnInstruction) == 1, "TurnInstruction does not fit a byte");
 
 inline bool operator!=(const TurnInstruction lhs, const TurnInstruction rhs)
-{ return lhs.type != rhs.type || lhs.direction_modifier != rhs.direction_modifier; }
+{
+    return lhs.type != rhs.type || lhs.direction_modifier != rhs.direction_modifier;
+}
 
 inline bool operator==(const TurnInstruction lhs, const TurnInstruction rhs)
-{ return lhs.type == rhs.type && lhs.direction_modifier == rhs.direction_modifier; }
+{
+    return lhs.type == rhs.type && lhs.direction_modifier == rhs.direction_modifier;
+}
 
 // check if a instruction is associated in any form with a roundabout
 inline bool hasRoundaboutType(const TurnInstruction instruction)
diff --git a/include/nodejs/json_v8_renderer.hpp b/include/nodejs/json_v8_renderer.hpp
index 90eb388b26b..75c6871981c 100644
--- a/include/nodejs/json_v8_renderer.hpp
+++ b/include/nodejs/json_v8_renderer.hpp
@@ -12,10 +12,14 @@ struct V8Renderer
     explicit V8Renderer(const Napi::Env &env, Napi::Value &out) : env(env), out(out) {}
 
     void operator()(const osrm::json::String &string) const
-    { out = Napi::String::New(env, string.value); }
+    {
+        out = Napi::String::New(env, string.value);
+    }
 
     void operator()(const osrm::json::Number &number) const
-    { out = Napi::Number::New(env, number.value); }
+    {
+        out = Napi::Number::New(env, number.value);
+    }
 
     void operator()(const osrm::json::Object &object) const
     {
diff --git a/include/nodejs/node_osrm_support.hpp b/include/nodejs/node_osrm_support.hpp
index 24f7af61ec7..510f0c6f0a3 100644
--- a/include/nodejs/node_osrm_support.hpp
+++ b/include/nodejs/node_osrm_support.hpp
@@ -55,7 +55,9 @@ using ObjectOrString = typename std::variant<osrm::json::Object, std::string>;
 template <typename ResultT> inline Napi::Value render(const Napi::Env &env, const ResultT &result);
 
 template <> Napi::Value inline render(const Napi::Env &env, const std::string &result)
-{ return Napi::Buffer<char>::Copy(env, result.data(), result.size()); }
+{
+    return Napi::Buffer<char>::Copy(env, result.data(), result.size());
+}
 
 template <> Napi::Value inline render(const Napi::Env &env, const ObjectOrString &result)
 {
@@ -118,10 +120,14 @@ inline void ParseResult(const osrm::Status &result_status,
 }
 
 inline void ThrowError(const Napi::Env &env, const char *message)
-{ Napi::Error::New(env, message).ThrowAsJavaScriptException(); }
+{
+    Napi::Error::New(env, message).ThrowAsJavaScriptException();
+}
 
 inline void ThrowTypeError(const Napi::Env &env, const char *message)
-{ Napi::TypeError::New(env, message).ThrowAsJavaScriptException(); }
+{
+    Napi::TypeError::New(env, message).ThrowAsJavaScriptException();
+}
 
 inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
 {
diff --git a/include/partitioner/cell_storage.hpp b/include/partitioner/cell_storage.hpp
index 23f732fed32..1577e9662a7 100644
--- a/include/partitioner/cell_storage.hpp
+++ b/include/partitioner/cell_storage.hpp
@@ -103,7 +103,9 @@ template <storage::Ownership Ownership> class CellStorageImpl
 
             explicit ColumnIterator(ValuePtrT begin, std::size_t row_length)
                 : current(begin), stride(row_length)
-            { BOOST_ASSERT(begin != nullptr); }
+            {
+                BOOST_ASSERT(begin != nullptr);
+            }
 
             ColumnIterator &operator+=(difference_type n)
             {
@@ -143,12 +145,18 @@ template <storage::Ownership Ownership> class CellStorageImpl
             reference operator*() const { return *current; }
 
             friend difference_type operator-(const ColumnIterator &a, const ColumnIterator &b)
-            { return (a.current - b.current) / static_cast<std::intptr_t>(a.stride); }
+            {
+                return (a.current - b.current) / static_cast<std::intptr_t>(a.stride);
+            }
 
             friend bool operator==(const ColumnIterator &a, const ColumnIterator &b)
-            { return a.current == b.current; }
+            {
+                return a.current == b.current;
+            }
             friend bool operator!=(const ColumnIterator &a, const ColumnIterator &b)
-            { return !(a == b); }
+            {
+                return !(a == b);
+            }
 
           private:
             ValuePtrT current;
@@ -196,7 +204,9 @@ template <storage::Ownership Ownership> class CellStorageImpl
         auto GetOutDistance(NodeID node) const { return GetOutRange(distances, node); }
 
         auto GetSourceNodes() const
-        { return std::ranges::subrange(source_boundary, source_boundary + num_source_nodes); }
+        {
+            return std::ranges::subrange(source_boundary, source_boundary + num_source_nodes);
+        }
 
         auto GetDestinationNodes() const
         {
diff --git a/include/partitioner/multi_level_partition.hpp b/include/partitioner/multi_level_partition.hpp
index d682e66eb58..ddc7ce7034a 100644
--- a/include/partitioner/multi_level_partition.hpp
+++ b/include/partitioner/multi_level_partition.hpp
@@ -78,7 +78,9 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
                             const std::vector<std::uint32_t> &lidx_to_num_cells)
         requires(Ownership == storage::Ownership::Container)
         : level_data(MakeLevelData(lidx_to_num_cells))
-    { InitializePartitionIDs(partitions); }
+    {
+        InitializePartitionIDs(partitions);
+    }
 
     MultiLevelPartitionImpl(LevelDataPtr level_data,
                             Vector<PartitionID> partition_,
@@ -116,7 +118,9 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
     std::uint8_t GetNumberOfLevels() const { return level_data->num_level; }
 
     std::uint32_t GetNumberOfCells(LevelID level) const
-    { return GetCell(level, GetSentinelNode()); }
+    {
+        return GetCell(level, GetSentinelNode());
+    }
 
     // Returns the lowest cell id (at `level - 1`) of all children `cell` at `level`
     CellID BeginChildren(LevelID level, CellID cell) const
diff --git a/include/partitioner/partitioner_config.hpp b/include/partitioner/partitioner_config.hpp
index 55319b5d4b7..d77a923c2da 100644
--- a/include/partitioner/partitioner_config.hpp
+++ b/include/partitioner/partitioner_config.hpp
@@ -27,7 +27,9 @@ struct PartitionerConfig final : storage::IOConfig
     }
 
     void UseDefaultOutputNames(const std::filesystem::path &base)
-    { IOConfig::UseDefaultOutputNames(base); }
+    {
+        IOConfig::UseDefaultOutputNames(base);
+    }
 
     std::filesystem::path GetOutputPath(const std::string &ext) const
     {
diff --git a/include/partitioner/remove_unconnected.hpp b/include/partitioner/remove_unconnected.hpp
index b5be6692b6a..1b0c9963f67 100644
--- a/include/partitioner/remove_unconnected.hpp
+++ b/include/partitioner/remove_unconnected.hpp
@@ -62,8 +62,7 @@ std::size_t removeUnconnectedBoundaryNodes(const GraphT &edge_based_graph,
                     auto new_end =
                         std::remove_if(witnesses.begin(),
                                        witnesses.end(),
-                                       [&](const auto &witness)
-                                       {
+                                       [&](const auto &witness) {
                                            return partitions[level_index + 1][node] !=
                                                   partitions[level_index + 1][witness.id];
                                        });
@@ -90,11 +89,12 @@ std::size_t removeUnconnectedBoundaryNodes(const GraphT &edge_based_graph,
                     }
                 }
 
-                auto best_witness = std::min_element(
-                    witnesses.begin(),
-                    witnesses.end(),
-                    [](const auto &lhs, const auto &rhs)
-                    { return lhs.induced_border_edges < rhs.induced_border_edges; });
+                auto best_witness =
+                    std::min_element(witnesses.begin(),
+                                     witnesses.end(),
+                                     [](const auto &lhs, const auto &rhs) {
+                                         return lhs.induced_border_edges < rhs.induced_border_edges;
+                                     });
                 BOOST_ASSERT(best_witness != witnesses.end());
 
                 // assign `node` to same subcells as `best_witness`
diff --git a/include/partitioner/renumber.hpp b/include/partitioner/renumber.hpp
index 75960fd7358..ead377d4d69 100644
--- a/include/partitioner/renumber.hpp
+++ b/include/partitioner/renumber.hpp
@@ -35,7 +35,9 @@ inline void renumber(util::StaticGraph<EdgeDataT> &graph,
 
 inline void renumber(extractor::EdgeBasedNodeDataContainer &node_data_container,
                      const std::vector<std::uint32_t> &permutation)
-{ node_data_container.Renumber(permutation); }
+{
+    node_data_container.Renumber(permutation);
+}
 
 inline void renumber(std::vector<Partition> &partitions,
                      const std::vector<std::uint32_t> &permutation)
diff --git a/include/server/api/base_parameters_grammar.hpp b/include/server/api/base_parameters_grammar.hpp
index 9ae97f0807a..8fe5fb5434f 100644
--- a/include/server/api/base_parameters_grammar.hpp
+++ b/include/server/api/base_parameters_grammar.hpp
@@ -47,19 +47,27 @@ template <typename T, char... Fmt> struct no_trailing_dot_policy : x3::real_poli
     }
 
     template <typename Iterator> static bool parse_exp(Iterator &, const Iterator &)
-    { return false; }
+    {
+        return false;
+    }
 
     template <typename Iterator, typename Attribute>
     static bool parse_exp_n(Iterator &, const Iterator &, Attribute &)
-    { return false; }
+    {
+        return false;
+    }
 
     template <typename Iterator, typename Attribute>
     static bool parse_nan(Iterator &, const Iterator &, Attribute &)
-    { return false; }
+    {
+        return false;
+    }
 
     template <typename Iterator, typename Attribute>
     static bool parse_inf(Iterator &, const Iterator &, Attribute &)
-    { return false; }
+    {
+        return false;
+    }
 };
 
 namespace base_grammar
@@ -159,58 +167,59 @@ inline const auto query_rule = x3::rule<struct base_query_tag>{"base_query"} =
 inline const auto format_rule = x3::rule<struct base_format_tag>{"base_format"} =
     -format_type[([](auto &ctx) { x3::get<params_tag>(ctx).get().format = x3::_attr(ctx); })];
 
-inline const auto radiuses_rule =
-    x3::lit("radiuses=") >
-    (-radius_value)[(
-        [](auto &ctx)
-        {
-            auto &params = x3::get<params_tag>(ctx).get();
-            auto &opt = x3::_attr(ctx);
-            params.radiuses.push_back(opt ? std::make_optional(*opt) : std::nullopt);
-        })] %
-        ';';
-
-inline const auto hints_rule =
-    x3::lit("hints=") >
-    (*hint_string)[(
-        [](auto &ctx)
-        {
-            auto &params = x3::get<params_tag>(ctx).get();
-            auto &hint_strings = x3::_attr(ctx);
-            if (!hint_strings.empty())
-            {
-                std::vector<engine::SegmentHint> location_hints(hint_strings.size());
-                std::transform(hint_strings.begin(),
-                               hint_strings.end(),
-                               location_hints.begin(),
-                               [](const auto &hs) { return engine::SegmentHint::FromBase64(hs); });
-                params.hints.push_back(engine::Hint{std::move(location_hints)});
-            }
-            else
-            {
-                params.hints.emplace_back(std::nullopt);
-            }
-        })] %
-        ';';
-
-inline const auto bearings_rule =
-    x3::lit("bearings=") >
-    (-(x3::short_ > ',' > x3::short_))[(
-        [](auto &ctx)
-        {
-            auto &params = x3::get<params_tag>(ctx).get();
-            auto &opt = x3::_attr(ctx);
-            if (opt)
-            {
-                params.bearings.push_back(
-                    engine::Bearing{boost::fusion::at_c<0>(*opt), boost::fusion::at_c<1>(*opt)});
-            }
-            else
-            {
-                params.bearings.push_back(std::nullopt);
-            }
-        })] %
-        ';';
+inline const auto radiuses_rule = x3::lit("radiuses=") >
+                                  (-radius_value)[(
+                                      [](auto &ctx)
+                                      {
+                                          auto &params = x3::get<params_tag>(ctx).get();
+                                          auto &opt = x3::_attr(ctx);
+                                          params.radiuses.push_back(opt ? std::make_optional(*opt)
+                                                                        : std::nullopt);
+                                      })] %
+                                      ';';
+
+inline const auto
+    hints_rule = x3::lit("hints=") >
+                 (*hint_string)[(
+                     [](auto &ctx)
+                     {
+                         auto &params = x3::get<params_tag>(ctx).get();
+                         auto &hint_strings = x3::_attr(ctx);
+                         if (!hint_strings.empty())
+                         {
+                             std::vector<engine::SegmentHint> location_hints(hint_strings.size());
+                             std::transform(hint_strings.begin(),
+                                            hint_strings.end(),
+                                            location_hints.begin(),
+                                            [](const auto &hs)
+                                            { return engine::SegmentHint::FromBase64(hs); });
+                             params.hints.push_back(engine::Hint{std::move(location_hints)});
+                         }
+                         else
+                         {
+                             params.hints.emplace_back(std::nullopt);
+                         }
+                     })] %
+                     ';';
+
+inline const auto bearings_rule = x3::lit("bearings=") >
+                                  (-(x3::short_ > ',' > x3::short_))[(
+                                      [](auto &ctx)
+                                      {
+                                          auto &params = x3::get<params_tag>(ctx).get();
+                                          auto &opt = x3::_attr(ctx);
+                                          if (opt)
+                                          {
+                                              params.bearings.push_back(
+                                                  engine::Bearing{boost::fusion::at_c<0>(*opt),
+                                                                  boost::fusion::at_c<1>(*opt)});
+                                          }
+                                          else
+                                          {
+                                              params.bearings.push_back(std::nullopt);
+                                          }
+                                      })] %
+                                      ';';
 
 inline const auto generate_hints_rule =
     x3::lit("generate_hints=") >
@@ -220,16 +229,16 @@ inline const auto skip_waypoints_rule =
     x3::lit("skip_waypoints=") >
     x3::bool_[([](auto &ctx) { x3::get<params_tag>(ctx).get().skip_waypoints = x3::_attr(ctx); })];
 
-inline const auto approach_rule =
-    x3::lit("approaches=") >
-    (-approach_type)[(
-        [](auto &ctx)
-        {
-            auto &params = x3::get<params_tag>(ctx).get();
-            auto &opt = x3::_attr(ctx);
-            params.approaches.push_back(opt ? std::make_optional(*opt) : std::nullopt);
-        })] %
-        ';';
+inline const auto approach_rule = x3::lit("approaches=") >
+                                  (-approach_type)[(
+                                      [](auto &ctx)
+                                      {
+                                          auto &params = x3::get<params_tag>(ctx).get();
+                                          auto &opt = x3::_attr(ctx);
+                                          params.approaches.push_back(opt ? std::make_optional(*opt)
+                                                                          : std::nullopt);
+                                      })] %
+                                      ';';
 
 inline const auto snapping_rule =
     x3::lit("snapping=") >
diff --git a/include/server/api/route_parameters_grammar.hpp b/include/server/api/route_parameters_grammar.hpp
index e277a18a5bc..9500e5808b4 100644
--- a/include/server/api/route_parameters_grammar.hpp
+++ b/include/server/api/route_parameters_grammar.hpp
@@ -46,21 +46,21 @@ inline const auto annotations_type = []()
 
 // --- Route-specific parameter rules ---
 
-inline const auto alternatives_rule =
-    x3::lit("alternatives=") > (x3::uint_[(
-                                    [](auto &ctx)
-                                    {
-                                        auto &p = x3::get<params_tag>(ctx).get();
-                                        p.number_of_alternatives = x3::_attr(ctx);
-                                        p.alternatives = x3::_attr(ctx) > 0;
-                                    })] |
-                                x3::bool_[(
-                                    [](auto &ctx)
-                                    {
-                                        auto &p = x3::get<params_tag>(ctx).get();
-                                        p.number_of_alternatives = x3::_attr(ctx);
-                                        p.alternatives = x3::_attr(ctx);
-                                    })]);
+inline const auto alternatives_rule = x3::lit("alternatives=") >
+                                      (x3::uint_[(
+                                           [](auto &ctx)
+                                           {
+                                               auto &p = x3::get<params_tag>(ctx).get();
+                                               p.number_of_alternatives = x3::_attr(ctx);
+                                               p.alternatives = x3::_attr(ctx) > 0;
+                                           })] |
+                                       x3::bool_[(
+                                           [](auto &ctx)
+                                           {
+                                               auto &p = x3::get<params_tag>(ctx).get();
+                                               p.number_of_alternatives = x3::_attr(ctx);
+                                               p.alternatives = x3::_attr(ctx);
+                                           })]);
 
 inline const auto continue_straight_rule =
     x3::lit("continue_straight=") >
@@ -90,11 +90,11 @@ inline const auto add_annotation = [](auto &ctx)
     p.annotations = p.annotations_type != AnnotationsType::None;
 };
 
-inline const auto annotations_rule =
-    x3::lit("annotations=") >
-    ((x3::lit("true") >> x3::attr(AnnotationsType::All))[add_annotation] |
-     (x3::lit("false") >> x3::attr(AnnotationsType::None))[add_annotation] |
-     annotations_type[add_annotation] % ',');
+inline const auto
+    annotations_rule = x3::lit("annotations=") >
+                       ((x3::lit("true") >> x3::attr(AnnotationsType::All))[add_annotation] |
+                        (x3::lit("false") >> x3::attr(AnnotationsType::None))[add_annotation] |
+                        annotations_type[add_annotation] % ',');
 
 inline const auto waypoints_rule =
     x3::lit("waypoints=") >
diff --git a/include/server/server.hpp b/include/server/server.hpp
index 3bcada85d6f..f5320911003 100644
--- a/include/server/server.hpp
+++ b/include/server/server.hpp
@@ -155,7 +155,9 @@ class Server : public std::enable_shared_from_this<Server>
     }
 
     void RegisterServiceHandler(std::unique_ptr<ServiceHandlerInterface> service_handler_)
-    { request_handler.RegisterServiceHandler(std::move(service_handler_)); }
+    {
+        request_handler.RegisterServiceHandler(std::move(service_handler_));
+    }
 
   private:
     void DoAccept()
diff --git a/include/storage/io.hpp b/include/storage/io.hpp
index 3eec80f23f6..577bf441242 100644
--- a/include/storage/io.hpp
+++ b/include/storage/io.hpp
@@ -141,12 +141,16 @@ class FileReader
     }
 
     template <typename T> void ReadInto(std::vector<T> &target)
-    { ReadInto(target.data(), target.size()); }
+    {
+        ReadInto(target.data(), target.size());
+    }
 
     template <typename T> void ReadInto(T &target) { ReadInto(&target, 1); }
 
     template <typename T> void Skip(const std::size_t element_count)
-    { boost::iostreams::seek(input_stream, element_count * sizeof(T), BOOST_IOS::cur); }
+    {
+        boost::iostreams::seek(input_stream, element_count * sizeof(T), BOOST_IOS::cur);
+    }
 
     /*******************************************/
 
@@ -248,7 +252,9 @@ class FileWriter
     }
 
     template <typename T> void WriteFrom(const std::vector<T> &src)
-    { WriteFrom(src.data(), src.size()); }
+    {
+        WriteFrom(src.data(), src.size());
+    }
 
     template <typename T> void WriteFrom(const T &src) { WriteFrom(&src, 1); }
 
@@ -261,7 +267,9 @@ class FileWriter
     }
 
     template <typename T> void Skip(const std::size_t element_count)
-    { boost::iostreams::seek(output_stream, element_count * sizeof(T), BOOST_IOS::cur); }
+    {
+        boost::iostreams::seek(output_stream, element_count * sizeof(T), BOOST_IOS::cur);
+    }
 
     void SkipToBeginning()
     {
diff --git a/include/storage/io_config.hpp b/include/storage/io_config.hpp
index ecf6c9d1c22..73e23b9a4a6 100644
--- a/include/storage/io_config.hpp
+++ b/include/storage/io_config.hpp
@@ -36,7 +36,9 @@ struct IOConfig
     }
 
     bool IsRequiredConfiguredInput(const std::string &fileName) const
-    { return IsConfigured(fileName, required_input_files); }
+    {
+        return IsConfigured(fileName, required_input_files);
+    }
 
     std::filesystem::path base_path;
 
diff --git a/include/storage/serialization.hpp b/include/storage/serialization.hpp
index 84e9e468762..233f4bc402d 100644
--- a/include/storage/serialization.hpp
+++ b/include/storage/serialization.hpp
@@ -140,7 +140,9 @@ template <typename T> void write(io::BufferWriter &writer, const std::vector<T>
 }
 
 template <typename T> inline void write(io::BufferWriter &writer, const T &data)
-{ writer.WriteFrom(data); }
+{
+    writer.WriteFrom(data);
+}
 
 template <typename T> inline void read(io::BufferReader &reader, T &data) { reader.ReadInto(data); }
 
@@ -207,21 +209,29 @@ void write(tar::FileWriter &writer, const std::string &name, const util::vector_
 template <>
 inline void
 read<bool>(tar::FileReader &reader, const std::string &name, util::vector_view<bool> &data)
-{ detail::readBoolVector(reader, name, data); }
+{
+    detail::readBoolVector(reader, name, data);
+}
 
 template <>
 inline void
 write<bool>(tar::FileWriter &writer, const std::string &name, const util::vector_view<bool> &data)
-{ detail::writeBoolVector(writer, name, data); }
+{
+    detail::writeBoolVector(writer, name, data);
+}
 
 template <>
 inline void read<bool>(tar::FileReader &reader, const std::string &name, std::vector<bool> &data)
-{ detail::readBoolVector(reader, name, data); }
+{
+    detail::readBoolVector(reader, name, data);
+}
 
 template <>
 inline void
 write<bool>(tar::FileWriter &writer, const std::string &name, const std::vector<bool> &data)
-{ detail::writeBoolVector(writer, name, data); }
+{
+    detail::writeBoolVector(writer, name, data);
+}
 
 template <typename K, typename V> void read(io::BufferReader &reader, std::map<K, V> &data)
 {
@@ -250,7 +260,9 @@ template <typename K, typename V> void write(io::BufferWriter &writer, const std
 inline void read(io::BufferReader &reader, BaseDataLayout &layout) { read(reader, layout.blocks); }
 
 inline void write(io::BufferWriter &writer, const BaseDataLayout &layout)
-{ write(writer, layout.blocks); }
+{
+    write(writer, layout.blocks);
+}
 } // namespace osrm::storage::serialization
 
 #endif
diff --git a/include/storage/shared_datatype.hpp b/include/storage/shared_datatype.hpp
index 23b000ead7a..63a7cb8dbf0 100644
--- a/include/storage/shared_datatype.hpp
+++ b/include/storage/shared_datatype.hpp
@@ -56,10 +56,14 @@ class BaseDataLayout
     inline void SetBlock(const std::string &name, const Block &block) { blocks[name] = block; }
 
     inline std::uint64_t GetBlockEntries(const std::string &name) const
-    { return GetBlock(name).num_entries; }
+    {
+        return GetBlock(name).num_entries;
+    }
 
     inline std::uint64_t GetBlockSize(const std::string &name) const
-    { return GetBlock(name).byte_size; }
+    {
+        return GetBlock(name).byte_size;
+    }
 
     inline bool HasBlock(const std::string &name) const { return blocks.contains(name); }
 
@@ -196,7 +200,9 @@ struct SharedRegion
     SharedRegion() : name{0}, timestamp{0} {}
     SharedRegion(const std::string &name_, std::uint64_t timestamp, ProjID proj_id)
         : name{0}, timestamp{timestamp}, proj_id{proj_id}
-    { std::copy_n(name_.begin(), std::min<std::size_t>(MAX_NAME_LENGTH, name_.size()), name); }
+    {
+        std::copy_n(name_.begin(), std::min<std::size_t>(MAX_NAME_LENGTH, name_.size()), name);
+    }
 
     bool IsEmpty() const { return timestamp == 0; }
 
@@ -218,8 +224,7 @@ struct SharedRegionRegister
         auto iter = std::find_if(
             regions.begin(),
             regions.end(),
-            [&](const auto &region)
-            {
+            [&](const auto &region) {
                 return std::strncmp(region.name, name.c_str(), SharedRegion::MAX_NAME_LENGTH) == 0;
             });
 
diff --git a/include/storage/shared_monitor.hpp b/include/storage/shared_monitor.hpp
index be1da9cfb32..0e709be8777 100644
--- a/include/storage/shared_monitor.hpp
+++ b/include/storage/shared_monitor.hpp
@@ -204,7 +204,9 @@ template <typename Data> struct SharedMonitor
         }
 
         void invalidate_semaphore(void *semaphore) const
-        { std::memset(semaphore, 0xff, sizeof(bi::interprocess_semaphore)); }
+        {
+            std::memset(semaphore, 0xff, sizeof(bi::interprocess_semaphore));
+        }
 
         bool is_semaphore_valid(void *semaphore) const
         {
@@ -226,7 +228,9 @@ template <typename Data> struct SharedMonitor
                   "Data and internal data need to fit into shared memory");
 
     InternalData &internal() const
-    { return *reinterpret_cast<InternalData *>(reinterpret_cast<char *>(region.get_address())); }
+    {
+        return *reinterpret_cast<InternalData *>(reinterpret_cast<char *>(region.get_address()));
+    }
 
     bi::shared_memory_object shmem;
     bi::mapped_region region;
diff --git a/include/storage/storage_config.hpp b/include/storage/storage_config.hpp
index ed4732b8a60..3cc1720d476 100644
--- a/include/storage/storage_config.hpp
+++ b/include/storage/storage_config.hpp
@@ -98,7 +98,9 @@ struct StorageConfig final : IOConfig
     StorageConfig(const std::filesystem::path &base,
                   const std::vector<storage::FeatureDataset> &disabled_feature_datasets_ = {})
         : StorageConfig(disabled_feature_datasets_)
-    { IOConfig::UseDefaultOutputNames(base); }
+    {
+        IOConfig::UseDefaultOutputNames(base);
+    }
 
     StorageConfig(const std::vector<storage::FeatureDataset> &disabled_feature_datasets_ = {})
         : IOConfig(
diff --git a/include/storage/tar.hpp b/include/storage/tar.hpp
index dc3f30f84f5..d27fbaaa804 100644
--- a/include/storage/tar.hpp
+++ b/include/storage/tar.hpp
@@ -95,7 +95,9 @@ class FileReader
     }
 
     template <typename T> void ReadInto(const std::string &name, T &tmp)
-    { ReadInto(name, &tmp, 1); }
+    {
+        ReadInto(name, &tmp, 1);
+    }
 
     template <typename T, typename OutIter> void ReadStreaming(const std::string &name, OutIter out)
     {
@@ -348,10 +350,14 @@ class FileWriter
     FileWriter &operator=(const FileWriter &) = delete;
 
     void WriteElementCount64(const std::string &name, const std::uint64_t count)
-    { WriteFrom(name + ".meta", count); }
+    {
+        WriteFrom(name + ".meta", count);
+    }
 
     template <typename T> void WriteFrom(const std::string &name, const T &data)
-    { WriteFrom(name, &data, 1); }
+    {
+        WriteFrom(name, &data, 1);
+    }
 
     template <typename T, typename Iter>
     void WriteStreaming(const std::string &name, Iter iter, const std::uint64_t number_of_elements)
diff --git a/include/storage/view_factory.hpp b/include/storage/view_factory.hpp
index 8e411dae78c..23a4c55127e 100644
--- a/include/storage/view_factory.hpp
+++ b/include/storage/view_factory.hpp
@@ -41,7 +41,9 @@ namespace osrm::storage
 
 template <typename T>
 util::vector_view<T> make_vector_view(const SharedDataIndex &index, const std::string &name)
-{ return util::vector_view<T>(index.GetBlockPtr<T>(name), index.GetBlockEntries(name)); }
+{
+    return util::vector_view<T>(index.GetBlockPtr<T>(name), index.GetBlockEntries(name));
+}
 
 template <>
 inline util::vector_view<bool> make_vector_view(const SharedDataIndex &index,
@@ -75,7 +77,9 @@ inline auto make_string_table_view(const SharedDataIndex &index, const std::stri
 }
 
 inline auto make_lane_data_view(const SharedDataIndex &index, const std::string &name)
-{ return make_vector_view<util::guidance::LaneTupleIdPair>(index, name + "/data"); }
+{
+    return make_vector_view<util::guidance::LaneTupleIdPair>(index, name + "/data");
+}
 
 inline auto make_turn_lane_description_views(const SharedDataIndex &index, const std::string &name)
 {
@@ -158,7 +162,9 @@ inline auto make_segment_data_view(const SharedDataIndex &index, const std::stri
 }
 
 inline auto make_coordinates_view(const SharedDataIndex &index, const std::string &name)
-{ return make_vector_view<util::Coordinate>(index, name); }
+{
+    return make_vector_view<util::Coordinate>(index, name);
+}
 
 inline auto make_osm_ids_view(const SharedDataIndex &index, const std::string &name)
 {
@@ -173,10 +179,14 @@ inline auto make_nbn_data_view(const SharedDataIndex &index, const std::string &
 }
 
 inline auto make_turn_weight_view(const SharedDataIndex &index, const std::string &name)
-{ return make_vector_view<TurnPenalty>(index, name + "/weight"); }
+{
+    return make_vector_view<TurnPenalty>(index, name + "/weight");
+}
 
 inline auto make_turn_duration_view(const SharedDataIndex &index, const std::string &name)
-{ return make_vector_view<TurnPenalty>(index, name + "/duration"); }
+{
+    return make_vector_view<TurnPenalty>(index, name + "/duration");
+}
 
 inline auto make_search_tree_view(const SharedDataIndex &index, const std::string &name)
 {
@@ -218,7 +228,9 @@ inline auto make_intersection_bearings_view(const SharedDataIndex &index, const
 }
 
 inline auto make_entry_classes_view(const SharedDataIndex &index, const std::string &name)
-{ return make_vector_view<util::guidance::EntryClass>(index, name); }
+{
+    return make_vector_view<util::guidance::EntryClass>(index, name);
+}
 
 inline auto make_contracted_metric_view(const SharedDataIndex &index, const std::string &name)
 {
@@ -248,7 +260,9 @@ inline auto make_partition_view(const SharedDataIndex &index, const std::string
 }
 
 inline auto make_timestamp_view(const SharedDataIndex &index, const std::string &name)
-{ return std::string_view(index.GetBlockPtr<char>(name), index.GetBlockEntries(name)); }
+{
+    return std::string_view(index.GetBlockPtr<char>(name), index.GetBlockEntries(name));
+}
 
 inline auto make_cell_storage_view(const SharedDataIndex &index, const std::string &name)
 {
diff --git a/include/updater/csv_file_parser.hpp b/include/updater/csv_file_parser.hpp
index a52e1157872..9f3b758e565 100644
--- a/include/updater/csv_file_parser.hpp
+++ b/include/updater/csv_file_parser.hpp
@@ -76,8 +76,7 @@ template <typename Key, typename Value> struct CSVFilesParser
             // The operands order is swapped to make descending ordering on (key, source)
             tbb::parallel_sort(begin(lookup),
                                end(lookup),
-                               [](const auto &lhs, const auto &rhs)
-                               {
+                               [](const auto &lhs, const auto &rhs) {
                                    return std::tie(rhs.first, rhs.second.source) <
                                           std::tie(lhs.first, lhs.second.source);
                                });
diff --git a/include/updater/source.hpp b/include/updater/source.hpp
index 563f31280d5..57407bc4d68 100644
--- a/include/updater/source.hpp
+++ b/include/updater/source.hpp
@@ -39,9 +39,13 @@ struct Segment final
     }
 
     bool operator<(const Segment &rhs) const
-    { return std::tie(from, to) < std::tie(rhs.from, rhs.to); }
+    {
+        return std::tie(from, to) < std::tie(rhs.from, rhs.to);
+    }
     bool operator==(const Segment &rhs) const
-    { return std::tie(from, to) == std::tie(rhs.from, rhs.to); }
+    {
+        return std::tie(from, to) == std::tie(rhs.from, rhs.to);
+    }
 };
 
 struct SpeedSource final
@@ -66,9 +70,13 @@ struct Turn final
     {
     }
     bool operator<(const Turn &rhs) const
-    { return std::tie(from, via, to) < std::tie(rhs.from, rhs.via, rhs.to); }
+    {
+        return std::tie(from, via, to) < std::tie(rhs.from, rhs.via, rhs.to);
+    }
     bool operator==(const Turn &rhs) const
-    { return std::tie(from, via, to) == std::tie(rhs.from, rhs.via, rhs.to); }
+    {
+        return std::tie(from, via, to) == std::tie(rhs.from, rhs.via, rhs.to);
+    }
 };
 
 struct PenaltySource final
diff --git a/include/updater/updater_config.hpp b/include/updater/updater_config.hpp
index 50eb849210a..221371b0507 100644
--- a/include/updater/updater_config.hpp
+++ b/include/updater/updater_config.hpp
@@ -58,7 +58,9 @@ struct UpdaterConfig final : storage::IOConfig
     }
 
     void UseDefaultOutputNames(const std::filesystem::path &base)
-    { IOConfig::UseDefaultOutputNames(base); }
+    {
+        IOConfig::UseDefaultOutputNames(base);
+    }
 
     double log_edge_updates_factor = 0.0;
     std::time_t valid_now;
diff --git a/include/util/alias.hpp b/include/util/alias.hpp
index 9e91a6e1e29..10536071e56 100644
--- a/include/util/alias.hpp
+++ b/include/util/alias.hpp
@@ -50,22 +50,36 @@ template <typename From, typename Tag> struct Alias final
     explicit operator From &() { return __value; }
     explicit operator From() const { return __value; }
     inline Alias operator+(const Alias rhs_) const
-    { return Alias{__value + static_cast<const From>(rhs_)}; }
+    {
+        return Alias{__value + static_cast<const From>(rhs_)};
+    }
     inline Alias operator-(const Alias rhs_) const
-    { return Alias{__value - static_cast<const From>(rhs_)}; }
+    {
+        return Alias{__value - static_cast<const From>(rhs_)};
+    }
     inline Alias operator-() const
         requires(std::is_signed_v<From> || std::is_floating_point_v<From>)
-    { return Alias{-__value}; }
+    {
+        return Alias{-__value};
+    }
     inline Alias operator*(const Alias rhs_) const
-    { return Alias{__value * static_cast<const From>(rhs_)}; }
+    {
+        return Alias{__value * static_cast<const From>(rhs_)};
+    }
     inline Alias operator*(const double rhs_) const { return Alias{__value * rhs_}; }
     inline Alias operator/(const Alias rhs_) const
-    { return Alias{__value / static_cast<const From>(rhs_)}; }
+    {
+        return Alias{__value / static_cast<const From>(rhs_)};
+    }
     inline Alias operator/(const double rhs_) const { return Alias{__value / rhs_}; }
     inline Alias operator|(const Alias rhs_) const
-    { return Alias{__value | static_cast<const From>(rhs_)}; }
+    {
+        return Alias{__value | static_cast<const From>(rhs_)};
+    }
     inline Alias operator&(const Alias rhs_) const
-    { return Alias{__value & static_cast<const From>(rhs_)}; }
+    {
+        return Alias{__value & static_cast<const From>(rhs_)};
+    }
     auto operator<=>(const Alias &) const = default;
 
     inline Alias operator++()
@@ -145,7 +159,9 @@ template <typename ToAlias> inline ToAlias to_alias(const ToAlias &from) { retur
 
 template <typename From, typename Tag>
 inline std::ostream &operator<<(std::ostream &stream, const Alias<From, Tag> &inst)
-{ return stream << inst.__value; }
+{
+    return stream << inst.__value;
+}
 } // namespace osrm
 
 namespace std
@@ -155,7 +171,9 @@ template <typename From, typename Tag> struct hash<osrm::Alias<From, Tag>>
     using argument_type = osrm::Alias<From, Tag>;
     using result_type = std::size_t;
     result_type operator()(argument_type const &s) const
-    { return std::hash<From>()(static_cast<const From>(s)); }
+    {
+        return std::hash<From>()(static_cast<const From>(s));
+    }
 };
 } // namespace std
 
diff --git a/include/util/bearing.hpp b/include/util/bearing.hpp
index a0a4e7a3071..13f78684d7f 100644
--- a/include/util/bearing.hpp
+++ b/include/util/bearing.hpp
@@ -75,7 +75,9 @@ inline double reverse(const double bearing)
 // All other cases are handled by first rotating both bearings to an
 // entry_bearing of 0.
 inline double angleBetween(const double entry_bearing, const double exit_bearing)
-{ return std::fmod(entry_bearing - exit_bearing + 540., 360.); }
+{
+    return std::fmod(entry_bearing - exit_bearing + 540., 360.);
+}
 
 } // namespace bearing
 
diff --git a/include/util/bit_range.hpp b/include/util/bit_range.hpp
index cbacfc7bfa0..1a512a8090f 100644
--- a/include/util/bit_range.hpp
+++ b/include/util/bit_range.hpp
@@ -40,7 +40,9 @@ template <typename DataT> class BitIterator
     }
 
     friend bool operator==(const BitIterator &a, const BitIterator &b)
-    { return a.m_value == b.m_value; }
+    {
+        return a.m_value == b.m_value;
+    }
     friend bool operator!=(const BitIterator &a, const BitIterator &b) { return !(a == b); }
 
   private:
diff --git a/include/util/coordinate.hpp b/include/util/coordinate.hpp
index 3bcafa9606f..4ac4a8a7ce9 100644
--- a/include/util/coordinate.hpp
+++ b/include/util/coordinate.hpp
@@ -109,16 +109,24 @@ static_assert(std::is_trivially_copyable<UnsafeFloatLongitude>(),
               "UnsafeFloatLongitude must be trivially copyable.");
 
 inline FixedLatitude operator""_lat(unsigned long long latitude)
-{ return FixedLatitude{boost::numeric_cast<std::int32_t>(latitude)}; }
+{
+    return FixedLatitude{boost::numeric_cast<std::int32_t>(latitude)};
+}
 
 constexpr FloatLatitude operator""_lat(long double latitude)
-{ return FloatLatitude{static_cast<double>(latitude)}; }
+{
+    return FloatLatitude{static_cast<double>(latitude)};
+}
 
 inline FixedLongitude operator""_lon(unsigned long long longitude)
-{ return FixedLongitude{boost::numeric_cast<std::int32_t>(longitude)}; }
+{
+    return FixedLongitude{boost::numeric_cast<std::int32_t>(longitude)};
+}
 
 constexpr FloatLongitude operator""_lon(long double longitude)
-{ return FloatLongitude{static_cast<double>(longitude)}; }
+{
+    return FloatLongitude{static_cast<double>(longitude)};
+}
 
 /**
  * Converts a typed latitude from floating to fixed representation.
diff --git a/include/util/coordinate_calculation.hpp b/include/util/coordinate_calculation.hpp
index bbaf1c52ac1..601e3a7a0bd 100644
--- a/include/util/coordinate_calculation.hpp
+++ b/include/util/coordinate_calculation.hpp
@@ -32,7 +32,9 @@ inline double radToDeg(const double radian) { return radian * (180.0 * std::numb
 const constexpr static double METERS_PER_DEGREE_LAT = 110567.0;
 
 inline double metersPerLngDegree(const FixedLatitude lat)
-{ return std::cos(detail::degToRad(static_cast<double>(toFloating(lat)))) * METERS_PER_DEGREE_LAT; }
+{
+    return std::cos(detail::degToRad(static_cast<double>(toFloating(lat)))) * METERS_PER_DEGREE_LAT;
+}
 
 //! Takes the squared euclidean distance of the input coordinates. Does not return meters!
 std::uint64_t squaredEuclideanDistance(const Coordinate lhs, const Coordinate rhs);
diff --git a/include/util/deallocating_vector.hpp b/include/util/deallocating_vector.hpp
index 20af5f94213..dad3d63deba 100644
--- a/include/util/deallocating_vector.hpp
+++ b/include/util/deallocating_vector.hpp
@@ -110,10 +110,14 @@ template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK> class ConstDealloca
 
     friend bool operator==(ConstDeallocatingVectorIterator const &a,
                            ConstDeallocatingVectorIterator const &b)
-    { return a.current_state.index == b.current_state.index; }
+    {
+        return a.current_state.index == b.current_state.index;
+    }
     friend bool operator!=(ConstDeallocatingVectorIterator const &a,
                            ConstDeallocatingVectorIterator const &b)
-    { return !(a == b); }
+    {
+        return !(a == b);
+    }
 
     friend std::ptrdiff_t operator-(ConstDeallocatingVectorIterator const &a,
                                     ConstDeallocatingVectorIterator const &b)
@@ -201,10 +205,14 @@ template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK> class DeallocatingV
     }
 
     friend bool operator==(DeallocatingVectorIterator const &a, DeallocatingVectorIterator const &b)
-    { return a.current_state.index == b.current_state.index; }
+    {
+        return a.current_state.index == b.current_state.index;
+    }
 
     friend bool operator!=(DeallocatingVectorIterator const &a, DeallocatingVectorIterator const &b)
-    { return !(a == b); }
+    {
+        return !(a == b);
+    }
 
     friend std::ptrdiff_t operator-(DeallocatingVectorIterator const &a,
                                     DeallocatingVectorIterator const &b)
@@ -260,7 +268,9 @@ template <typename ElementT> class DeallocatingVector
     using const_iterator = ConstDeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>;
 
     DeallocatingVector() : current_size(0)
-    { bucket_list.emplace_back(new ElementT[ELEMENTS_PER_BLOCK]); }
+    {
+        bucket_list.emplace_back(new ElementT[ELEMENTS_PER_BLOCK]);
+    }
 
     // Performs a deep copy of the buckets
     DeallocatingVector(const DeallocatingVector &other)
@@ -381,7 +391,9 @@ template <typename ElementT> class DeallocatingVector
     iterator end() { return iterator(size(), &bucket_list); }
 
     const_iterator begin() const
-    { return const_iterator(static_cast<std::size_t>(0), &bucket_list); }
+    {
+        return const_iterator(static_cast<std::size_t>(0), &bucket_list);
+    }
 
     const_iterator end() const { return const_iterator(size(), &bucket_list); }
 
@@ -418,7 +430,9 @@ template <typename ElementT> class DeallocatingVector
 };
 
 template <typename T> void swap(DeallocatingVector<T> &lhs, DeallocatingVector<T> &rhs) noexcept
-{ lhs.swap(rhs); }
+{
+    lhs.swap(rhs);
+}
 } // namespace osrm::util
 
 #endif /* DEALLOCATING_VECTOR_HPP */
diff --git a/include/util/dist_table_wrapper.hpp b/include/util/dist_table_wrapper.hpp
index 1f9af2f565b..7d2da832865 100644
--- a/include/util/dist_table_wrapper.hpp
+++ b/include/util/dist_table_wrapper.hpp
@@ -65,7 +65,9 @@ template <typename T> class DistTableWrapper
     Iterator end() { return std::end(table_); }
 
     NodeID GetIndexOfMaxValue() const
-    { return std::distance(table_.begin(), std::max_element(table_.begin(), table_.end())); }
+    {
+        return std::distance(table_.begin(), std::max_element(table_.begin(), table_.end()));
+    }
 
     std::vector<T> GetTable() const { return table_; }
 
diff --git a/include/util/dynamic_graph.hpp b/include/util/dynamic_graph.hpp
index 8e1143e5dd2..643b2f27e1a 100644
--- a/include/util/dynamic_graph.hpp
+++ b/include/util/dynamic_graph.hpp
@@ -74,7 +74,9 @@ template <typename EdgeDataT> class DynamicGraph
         }
 
         bool operator<(const InputEdge &rhs) const
-        { return std::tie(source, target) < std::tie(rhs.source, rhs.target); }
+        {
+            return std::tie(source, target) < std::tie(rhs.source, rhs.target);
+        }
     };
 
     DynamicGraph() : DynamicGraph(0) {}
@@ -247,13 +249,19 @@ template <typename EdgeDataT> class DynamicGraph
     const EdgeDataT &GetEdgeData(const EdgeIterator e) const { return edge_list[e].data; }
 
     EdgeIterator BeginEdges(const NodeIterator n) const
-    { return EdgeIterator(node_array[n].first_edge); }
+    {
+        return EdgeIterator(node_array[n].first_edge);
+    }
 
     EdgeIterator EndEdges(const NodeIterator n) const
-    { return EdgeIterator(node_array[n].first_edge + node_array[n].edges); }
+    {
+        return EdgeIterator(node_array[n].first_edge + node_array[n].edges);
+    }
 
     EdgeRange GetAdjacentEdgeRange(const NodeIterator node) const
-    { return irange(BeginEdges(node), EndEdges(node)); }
+    {
+        return irange(BeginEdges(node), EndEdges(node));
+    }
 
     NodeIterator InsertNode()
     {
@@ -455,10 +463,14 @@ template <typename EdgeDataT> class DynamicGraph
 
   protected:
     bool isDummy(const EdgeIterator edge) const
-    { return edge_list[edge].target == (std::numeric_limits<NodeIterator>::max)(); }
+    {
+        return edge_list[edge].target == (std::numeric_limits<NodeIterator>::max)();
+    }
 
     void makeDummy(const EdgeIterator edge)
-    { edge_list[edge].target = (std::numeric_limits<NodeIterator>::max)(); }
+    {
+        edge_list[edge].target = (std::numeric_limits<NodeIterator>::max)();
+    }
 
     NodeIterator number_of_nodes;
     std::atomic_uint number_of_edges;
diff --git a/include/util/filtered_graph.hpp b/include/util/filtered_graph.hpp
index 59e2660007a..eda75460dd3 100644
--- a/include/util/filtered_graph.hpp
+++ b/include/util/filtered_graph.hpp
@@ -61,7 +61,9 @@ class FilteredGraphImpl<util::StaticGraph<EdgeDataT, Ownership>, Ownership>
     }
 
     auto GetAdjacentEdgeRange(const NodeIterator n) const
-    { return EdgeRange{graph.BeginEdges(n), graph.EndEdges(n), edge_filter}; }
+    {
+        return EdgeRange{graph.BeginEdges(n), graph.EndEdges(n), edge_filter};
+    }
 
     // searches for a specific edge
     EdgeIterator FindEdge(const NodeIterator from, const NodeIterator to) const
@@ -123,7 +125,9 @@ class FilteredGraphImpl<util::StaticGraph<EdgeDataT, Ownership>, Ownership>
 
     FilteredGraphImpl(Graph graph_, Vector<bool> edge_filter_)
         : graph(std::move(graph_)), edge_filter(std::move(edge_filter_))
-    { BOOST_ASSERT(edge_filter.empty() || edge_filter.size() == graph.GetNumberOfEdges()); }
+    {
+        BOOST_ASSERT(edge_filter.empty() || edge_filter.size() == graph.GetNumberOfEdges());
+    }
 
     // Takes a graph and a function that maps EdgeID to true
     // if the edge should be included in the graph.
diff --git a/include/util/filtered_integer_range.hpp b/include/util/filtered_integer_range.hpp
index a1cb4b38b2d..b48ac886402 100644
--- a/include/util/filtered_integer_range.hpp
+++ b/include/util/filtered_integer_range.hpp
@@ -41,9 +41,13 @@ template <typename Integer, typename Filter> class filtered_integer_iterator
     }
 
     friend bool operator==(const filtered_integer_iterator &a, const filtered_integer_iterator &b)
-    { return a.value == b.value; }
+    {
+        return a.value == b.value;
+    }
     friend bool operator!=(const filtered_integer_iterator &a, const filtered_integer_iterator &b)
-    { return !(a == b); }
+    {
+        return !(a == b);
+    }
 
   private:
     value_type value;
@@ -79,7 +83,9 @@ template <typename Integer, typename Filter>
 filtered_range<Integer, Filter>
 filtered_irange(const Integer first, const Integer last, const Filter &filter) noexcept
     requires std::integral<Integer>
-{ return filtered_range<Integer, Filter>(first, last, filter); }
+{
+    return filtered_range<Integer, Filter>(first, last, filter);
+}
 
 } // namespace osrm::util
 
diff --git a/include/util/for_each_indexed.hpp b/include/util/for_each_indexed.hpp
index 90e198d35c8..a5daa354106 100644
--- a/include/util/for_each_indexed.hpp
+++ b/include/util/for_each_indexed.hpp
@@ -17,7 +17,9 @@ void for_each_indexed(ForwardIterator first, ForwardIterator last, Function func
 
 template <class ContainerT, typename Function>
 void for_each_indexed(ContainerT &container, Function function)
-{ for_each_indexed(std::begin(container), std::end(container), function); }
+{
+    for_each_indexed(std::begin(container), std::end(container), function);
+}
 
 } // namespace osrm::util
 
diff --git a/include/util/format.hpp b/include/util/format.hpp
index f3bc44c124e..0b74ad7d71a 100644
--- a/include/util/format.hpp
+++ b/include/util/format.hpp
@@ -18,7 +18,9 @@ struct RuntimeFormatString
 inline RuntimeFormatString runtime_format(std::string_view s) { return {s}; }
 
 template <typename... Args> std::string format(RuntimeFormatString fmt, Args &&...args)
-{ return std::vformat(fmt.str, std::make_format_args(args...)); }
+{
+    return std::vformat(fmt.str, std::make_format_args(args...));
+}
 } // namespace osrm::util::compat
 
 #endif // OSRM_FORMAT_HPP
diff --git a/include/util/integer_range.hpp b/include/util/integer_range.hpp
index 1f0ad82d68b..797b8acc836 100644
--- a/include/util/integer_range.hpp
+++ b/include/util/integer_range.hpp
@@ -73,9 +73,13 @@ template <typename Integer> class integer_iterator
     }
 
     friend bool operator==(const integer_iterator &a, const integer_iterator &b)
-    { return a.m_value == b.m_value; }
+    {
+        return a.m_value == b.m_value;
+    }
     friend bool operator!=(const integer_iterator &a, const integer_iterator &b)
-    { return !(a == b); }
+    {
+        return !(a == b);
+    }
 
   private:
     value_type m_value;
@@ -103,7 +107,9 @@ template <typename Integer> class range
 template <typename Integer>
     requires std::integral<Integer>
 range<Integer> irange(const Integer first, const Integer last) noexcept
-{ return range<Integer>(first, last); }
+{
+    return range<Integer>(first, last);
+}
 
 } // namespace osrm::util
 
diff --git a/include/util/iterator_adapters.hpp b/include/util/iterator_adapters.hpp
index 8be877c28ae..3c0d460e3bb 100644
--- a/include/util/iterator_adapters.hpp
+++ b/include/util/iterator_adapters.hpp
@@ -41,7 +41,9 @@ template <typename Func> class function_output_iterator
 };
 
 template <typename Func> inline auto make_function_output_iterator(Func f)
-{ return function_output_iterator<Func>(std::move(f)); }
+{
+    return function_output_iterator<Func>(std::move(f));
+}
 
 // function_input_iterator: returns value from callable on deref, ++ is a no-op
 template <typename Func> class function_input_iterator
@@ -64,7 +66,9 @@ template <typename Func> class function_input_iterator
 };
 
 template <typename Func> inline auto make_function_input_iterator(Func f)
-{ return function_input_iterator<Func>(std::move(f)); }
+{
+    return function_input_iterator<Func>(std::move(f));
+}
 
 // permutation_iterator: iterates over underlying container in order specified by index iterator
 template <typename BaseIt, typename IndexIt> class permutation_iterator
@@ -130,15 +134,23 @@ template <typename BaseIt, typename IndexIt> class permutation_iterator
     }
 
     friend difference_type operator-(const permutation_iterator &a, const permutation_iterator &b)
-    { return a.index_it - b.index_it; }
+    {
+        return a.index_it - b.index_it;
+    }
 
     reference operator[](difference_type n) const
-    { return *(base + static_cast<std::size_t>(*(index_it + n))); }
+    {
+        return *(base + static_cast<std::size_t>(*(index_it + n)));
+    }
 
     friend bool operator==(const permutation_iterator &a, const permutation_iterator &b)
-    { return a.index_it == b.index_it; }
+    {
+        return a.index_it == b.index_it;
+    }
     friend bool operator!=(const permutation_iterator &a, const permutation_iterator &b)
-    { return !(a == b); }
+    {
+        return !(a == b);
+    }
 
   private:
     BaseIt base{};
@@ -147,7 +159,9 @@ template <typename BaseIt, typename IndexIt> class permutation_iterator
 
 template <typename BaseIt, typename IndexIt>
 inline auto make_permutation_iterator(BaseIt base, IndexIt index_it)
-{ return permutation_iterator<BaseIt, IndexIt>(base, index_it); }
+{
+    return permutation_iterator<BaseIt, IndexIt>(base, index_it);
+}
 
 } // namespace osrm::util
 
diff --git a/include/util/json_deep_compare.hpp b/include/util/json_deep_compare.hpp
index cb983c919fd..8a64cdb8589 100644
--- a/include/util/json_deep_compare.hpp
+++ b/include/util/json_deep_compare.hpp
@@ -148,7 +148,9 @@ struct Comparator
 };
 
 inline bool compare(const Value &reference, const Value &result, std::string &reason)
-{ return std::visit(Comparator(reason, "reference", "result"), reference, result); }
+{
+    return std::visit(Comparator(reason, "reference", "result"), reference, result);
+}
 } // namespace osrm::util::json
 
 #endif
diff --git a/include/util/json_renderer.hpp b/include/util/json_renderer.hpp
index cb0a3f8b3b2..cae21563c60 100644
--- a/include/util/json_renderer.hpp
+++ b/include/util/json_renderer.hpp
@@ -120,31 +120,41 @@ template <typename Out> struct Renderer
     void write(char ch);
 
     template <size_t StrLength> void write(const char (&str)[StrLength])
-    { write(str, StrLength - 1); }
+    {
+        write(str, StrLength - 1);
+    }
 
   private:
     Out &out;
 };
 
 template <> inline void Renderer<std::vector<char>>::write(std::string_view str)
-{ out.insert(out.end(), str.begin(), str.end()); }
+{
+    out.insert(out.end(), str.begin(), str.end());
+}
 
 template <> inline void Renderer<std::vector<char>>::write(const char *str, size_t size)
-{ out.insert(out.end(), str, str + size); }
+{
+    out.insert(out.end(), str, str + size);
+}
 
 template <> inline void Renderer<std::vector<char>>::write(char ch) { out.push_back(ch); }
 
 template <> inline void Renderer<std::ostream>::write(std::string_view str) { out << str; }
 
 template <> inline void Renderer<std::ostream>::write(const char *str, size_t size)
-{ out.write(str, size); }
+{
+    out.write(str, size);
+}
 
 template <> inline void Renderer<std::ostream>::write(char ch) { out << ch; }
 
 template <> inline void Renderer<std::string>::write(std::string_view str) { out += str; }
 
 template <> inline void Renderer<std::string>::write(const char *str, size_t size)
-{ out.append(str, size); }
+{
+    out.append(str, size);
+}
 
 template <> inline void Renderer<std::string>::write(char ch) { out += ch; }
 
diff --git a/include/util/linear_hash_storage.hpp b/include/util/linear_hash_storage.hpp
index beaf3fd5885..b75a84c03dc 100644
--- a/include/util/linear_hash_storage.hpp
+++ b/include/util/linear_hash_storage.hpp
@@ -53,7 +53,9 @@ class LinearHashStorage
 
   public:
     explicit LinearHashStorage(std::size_t size) : cells(size), mask{size - 1}
-    { BOOST_ASSERT_MSG((size & mask) == 0, "size must be a power of 2"); }
+    {
+        BOOST_ASSERT_MSG((size & mask) == 0, "size must be a power of 2");
+    }
 
     ValueType &operator[](const KeyType key)
     {
diff --git a/include/util/mmap_file.hpp b/include/util/mmap_file.hpp
index 5f8c1ce5d0c..deb106c3931 100644
--- a/include/util/mmap_file.hpp
+++ b/include/util/mmap_file.hpp
@@ -63,18 +63,24 @@ mmapFile(const std::filesystem::path &file, MmapContainerT &mmap_container, cons
 template <typename T>
 util::vector_view<const T> mmapFile(const std::filesystem::path &file,
                                     boost::iostreams::mapped_file_source &mmap_container)
-{ return detail::mmapFile<const T>(file, mmap_container); }
+{
+    return detail::mmapFile<const T>(file, mmap_container);
+}
 
 template <typename T>
 util::vector_view<T> mmapFile(const std::filesystem::path &file,
                               boost::iostreams::mapped_file &mmap_container)
-{ return detail::mmapFile<T>(file, mmap_container); }
+{
+    return detail::mmapFile<T>(file, mmap_container);
+}
 
 template <typename T>
 util::vector_view<T> mmapFile(const std::filesystem::path &file,
                               boost::iostreams::mapped_file &mmap_container,
                               std::size_t size)
-{ return detail::mmapFile<T>(file, mmap_container, size); }
+{
+    return detail::mmapFile<T>(file, mmap_container, size);
+}
 } // namespace osrm::util
 
 #endif
diff --git a/include/util/opening_hours.hpp b/include/util/opening_hours.hpp
index f0f2fd9ee29..b8afa552115 100644
--- a/include/util/opening_hours.hpp
+++ b/include/util/opening_hours.hpp
@@ -123,7 +123,9 @@ struct OpeningHours
 
         bool IsValid() const { return year > 0 || month != 0 || day != 0; }
         bool operator==(const Monthday &rhs) const
-        { return std::tie(year, month, day) == std::tie(rhs.year, rhs.month, rhs.day); }
+        {
+            return std::tie(year, month, day) == std::tie(rhs.year, rhs.month, rhs.day);
+        }
     };
 
     struct MonthdayRange
diff --git a/include/util/packed_vector.hpp b/include/util/packed_vector.hpp
index 7b7cbbe6d68..338962587b1 100644
--- a/include/util/packed_vector.hpp
+++ b/include/util/packed_vector.hpp
@@ -42,17 +42,23 @@ namespace detail
 template <typename WordT, typename T>
 inline T get_lower_half_value(WordT word, WordT mask, std::uint8_t offset)
     requires std::integral<T>
-{ return static_cast<T>((word & mask) >> offset); }
+{
+    return static_cast<T>((word & mask) >> offset);
+}
 
 template <typename WordT, typename T>
 inline T get_lower_half_value(WordT word, WordT mask, std::uint8_t offset)
     requires(!std::integral<T>)
-{ return T{static_cast<T::value_type>((word & mask) >> offset)}; }
+{
+    return T{static_cast<T::value_type>((word & mask) >> offset)};
+}
 
 template <typename WordT, typename T>
 inline T get_upper_half_value(WordT word, WordT mask, std::uint8_t offset)
     requires std::integral<T>
-{ return static_cast<T>((word & mask) << offset); }
+{
+    return static_cast<T>((word & mask) << offset);
+}
 
 template <typename WordT, typename T>
 inline T get_upper_half_value(WordT word, WordT mask, std::uint8_t offset)
@@ -236,7 +242,9 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         std::uint8_t element;
 
         bool operator==(const InternalIndex &other) const
-        { return std::tie(lower_word, element) == std::tie(other.lower_word, other.element); }
+        {
+            return std::tie(lower_word, element) == std::tie(other.lower_word, other.element);
+        }
     };
 
   public:
@@ -261,14 +269,20 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         operator T() const { return container.get_value(internal_index); }
 
         bool operator==(const internal_reference &other) const
-        { return &container == &other.container && internal_index == other.internal_index; }
+        {
+            return &container == &other.container && internal_index == other.internal_index;
+        }
 
         // FIXME: This is needed for tests on Boost ranges to correctly compare Alias values.
         template <typename F, typename U> bool operator!=(const osrm::Alias<F, U> value) const
-        { return container.get_value(internal_index) != value; }
+        {
+            return container.get_value(internal_index) != value;
+        }
 
         friend std::ostream &operator<<(std::ostream &os, const internal_reference &rhs)
-        { return os << static_cast<T>(rhs); }
+        {
+            return os << static_cast<T>(rhs);
+        }
 
       private:
         PackedVector &container;
@@ -355,7 +369,9 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
         }
 
         difference_type operator-(const iterator_impl &other) const
-        { return static_cast<difference_type>(index) - static_cast<difference_type>(other.index); }
+        {
+            return static_cast<difference_type>(index) - static_cast<difference_type>(other.index);
+        }
 
         bool operator==(const iterator_impl &other) const { return index == other.index; }
         bool operator!=(const iterator_impl &other) const { return !(*this == other); }
@@ -381,7 +397,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
             push_back(value);
     }
 
-    PackedVector() {};
+    PackedVector(){};
     PackedVector(const PackedVector &) = default;
     PackedVector(PackedVector &&) = default;
     PackedVector &operator=(const PackedVector &) = default;
@@ -406,7 +422,9 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
     auto operator[](const std::size_t index) const { return get_value(get_internal_index(index)); }
 
     auto operator[](const std::size_t index)
-    { return internal_reference{*this, get_internal_index(index)}; }
+    {
+        return internal_reference{*this, get_internal_index(index)};
+    }
 
     auto at(std::size_t index) const
     {
@@ -449,7 +467,9 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
 
     // Since we only allow passing by value anyway this is just an alias
     template <class... Args> void emplace_back(Args... args)
-    { push_back(T{std::forward<Args>(args)...}); }
+    {
+        push_back(T{std::forward<Args>(args)...});
+    }
 
     void push_back(const T value)
     {
@@ -502,7 +522,9 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
 
   private:
     void allocate_blocks(std::size_t num_blocks)
-    { vec.resize(vec.size() + num_blocks * BLOCK_WORDS); }
+    {
+        vec.resize(vec.size() + num_blocks * BLOCK_WORDS);
+    }
 
     inline InternalIndex get_internal_index(const std::size_t index) const
     {
diff --git a/include/util/percent.hpp b/include/util/percent.hpp
index 8d98a13ad4f..173e3b657bf 100644
--- a/include/util/percent.hpp
+++ b/include/util/percent.hpp
@@ -15,7 +15,9 @@ class Percent
 
   public:
     explicit Percent(Log &log_, unsigned max_value, unsigned step = 5) : log{log_}
-    { Reinit(max_value, step); }
+    {
+        Reinit(max_value, step);
+    }
 
     // Reinitializes
     void Reinit(unsigned max_value, unsigned step = 5)
diff --git a/include/util/permutation.hpp b/include/util/permutation.hpp
index 835bda4f8de..578f8659411 100644
--- a/include/util/permutation.hpp
+++ b/include/util/permutation.hpp
@@ -15,7 +15,9 @@ namespace permutation_detail
 template <typename T> static inline void swap(T &a, T &b) noexcept { std::swap(a, b); }
 
 static inline void swap(std::vector<bool>::reference a, std::vector<bool>::reference b) noexcept
-{ std::vector<bool>::swap(a, b); }
+{
+    std::vector<bool>::swap(a, b);
+}
 } // namespace permutation_detail
 
 template <typename RandomAccessIterator, typename IndexT>
diff --git a/include/util/query_heap.hpp b/include/util/query_heap.hpp
index 942ef53db13..1953489d812 100644
--- a/include/util/query_heap.hpp
+++ b/include/util/query_heap.hpp
@@ -158,7 +158,9 @@ class QueryHeap
     };
 
     template <typename... StorageArgs> explicit QueryHeap(StorageArgs... args) : node_index(args...)
-    { Clear(); }
+    {
+        Clear();
+    }
 
     void Clear()
     {
diff --git a/include/util/static_assert.hpp b/include/util/static_assert.hpp
index 4fb2c96eaef..60e73bacd89 100644
--- a/include/util/static_assert.hpp
+++ b/include/util/static_assert.hpp
@@ -8,7 +8,9 @@ namespace osrm::util
 {
 
 template <typename It, typename Value> inline void static_assert_iter_value()
-{ static_assert(std::is_same_v<std::iter_value_t<It>, Value>, ""); }
+{
+    static_assert(std::is_same_v<std::iter_value_t<It>, Value>, "");
+}
 
 template <typename It, typename Category> inline void static_assert_iter_category()
 {
diff --git a/include/util/static_graph.hpp b/include/util/static_graph.hpp
index 8941d2e7541..0865a17926b 100644
--- a/include/util/static_graph.hpp
+++ b/include/util/static_graph.hpp
@@ -73,10 +73,14 @@ template <> struct SortableEdgeWithData<void>
     }
 
     bool operator<(const SortableEdgeWithData &right) const
-    { return std::tie(source, target) < std::tie(right.source, right.target); }
+    {
+        return std::tie(source, target) < std::tie(right.source, right.target);
+    }
 
     bool operator==(const SortableEdgeWithData &right) const
-    { return std::tie(source, target) == std::tie(right.source, right.target); }
+    {
+        return std::tie(source, target) == std::tie(right.source, right.target);
+    }
 };
 
 template <typename EdgeDataT> struct SortableEdgeWithData : SortableEdgeWithData<void>
@@ -118,7 +122,9 @@ class StaticGraph
     using EdgeArrayEntry = static_graph_details::EdgeArrayEntry<EdgeDataT>;
 
     EdgeRange GetAdjacentEdgeRange(const NodeID node) const
-    { return irange(BeginEdges(node), EndEdges(node)); }
+    {
+        return irange(BeginEdges(node), EndEdges(node));
+    }
 
     StaticGraph() {}
 
@@ -148,17 +154,23 @@ class StaticGraph
     unsigned GetOutDegree(const NodeIterator n) const { return EndEdges(n) - BeginEdges(n); }
 
     inline NodeIterator GetTarget(const EdgeIterator e) const
-    { return NodeIterator(edge_array[e].target); }
+    {
+        return NodeIterator(edge_array[e].target);
+    }
 
     auto &GetEdgeData(const EdgeIterator e) { return edge_array[e].data; }
 
     const auto &GetEdgeData(const EdgeIterator e) const { return edge_array[e].data; }
 
     EdgeIterator BeginEdges(const NodeIterator n) const
-    { return EdgeIterator(node_array.at(n).first_edge); }
+    {
+        return EdgeIterator(node_array.at(n).first_edge);
+    }
 
     EdgeIterator EndEdges(const NodeIterator n) const
-    { return EdgeIterator(node_array.at(n + 1).first_edge); }
+    {
+        return EdgeIterator(node_array.at(n + 1).first_edge);
+    }
 
     // searches for a specific edge
     EdgeIterator FindEdge(const NodeIterator from, const NodeIterator to) const
diff --git a/include/util/static_rtree.hpp b/include/util/static_rtree.hpp
index dc582d0bce2..e881eb8659b 100644
--- a/include/util/static_rtree.hpp
+++ b/include/util/static_rtree.hpp
@@ -207,7 +207,9 @@ class StaticRTree
         std::uint32_t m_original_index;
 
         inline bool operator<(const WrappedInputElement &other) const
-        { return m_hilbert_value < other.m_hilbert_value; }
+        {
+            return m_hilbert_value < other.m_hilbert_value;
+        }
     };
 
     struct QueryCandidate
@@ -228,7 +230,9 @@ class StaticRTree
         }
 
         inline bool is_segment() const
-        { return segment_index != std::numeric_limits<std::uint32_t>::max(); }
+        {
+            return segment_index != std::numeric_limits<std::uint32_t>::max();
+        }
 
         inline bool operator<(const QueryCandidate &other) const
         {
diff --git a/include/util/std_hash.hpp b/include/util/std_hash.hpp
index 67de3e632a1..6bb4d5cd4a5 100644
--- a/include/util/std_hash.hpp
+++ b/include/util/std_hash.hpp
@@ -10,7 +10,9 @@
 // "The C++ Standard Library" 2nd Edition. Nicolai M. Josuttis. 2012.
 
 template <typename T> void hash_combine(std::size_t &seed, const T &val)
-{ seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2); }
+{
+    seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+}
 
 template <typename It> void hash_range(std::size_t &seed, It first, const It last)
 {
@@ -48,13 +50,17 @@ template <typename... T> struct hash<std::tuple<T...>>
     }
 
     auto operator()(const std::tuple<T...> &t) const
-    { return apply_tuple(t, std::make_index_sequence<sizeof...(T)>()); }
+    {
+        return apply_tuple(t, std::make_index_sequence<sizeof...(T)>());
+    }
 };
 
 template <typename T1, typename T2> struct hash<std::pair<T1, T2>>
 {
     std::size_t operator()(const std::pair<T1, T2> &pair) const
-    { return hash_val(pair.first, pair.second); }
+    {
+        return hash_val(pair.first, pair.second);
+    }
 };
 
 template <typename T> struct hash<std::vector<T>>
diff --git a/include/util/tarjan_scc.hpp b/include/util/tarjan_scc.hpp
index ffe943ccb6e..df1e89c73a5 100644
--- a/include/util/tarjan_scc.hpp
+++ b/include/util/tarjan_scc.hpp
@@ -49,7 +49,9 @@ template <typename GraphT> class TarjanSCC
     TarjanSCC(const GraphT &graph)
         : components_index(graph.GetNumberOfNodes(), SPECIAL_NODEID), m_graph(graph),
           size_one_counter(0)
-    { BOOST_ASSERT(m_graph.GetNumberOfNodes() > 0); }
+    {
+        BOOST_ASSERT(m_graph.GetNumberOfNodes() > 0);
+    }
 
     void Run()
     {
@@ -168,7 +170,9 @@ template <typename GraphT> class TarjanSCC
     std::size_t GetSizeOneCount() const { return size_one_counter; }
 
     unsigned GetComponentSize(const unsigned component_id) const
-    { return component_size_vector[component_id]; }
+    {
+        return component_size_vector[component_id];
+    }
 
     unsigned GetComponentID(const NodeID node) const { return components_index[node]; }
 };
diff --git a/include/util/typedefs.hpp b/include/util/typedefs.hpp
index f6069ba30b9..6e1fe1787be 100644
--- a/include/util/typedefs.hpp
+++ b/include/util/typedefs.hpp
@@ -172,7 +172,9 @@ static constexpr auto INVALID_CELL_ID = std::numeric_limits<CellID>::max();
 struct SegmentID
 {
     SegmentID(const NodeID id_, const bool enabled_) : id{id_}, enabled{enabled_}
-    { BOOST_ASSERT(!enabled || id != SPECIAL_SEGMENTID); }
+    {
+        BOOST_ASSERT(!enabled || id != SPECIAL_SEGMENTID);
+    }
 
     NodeID id : 31;
     std::uint32_t enabled : 1;
diff --git a/include/util/vector_view.hpp b/include/util/vector_view.hpp
index d71fe22c8e8..7d2435de18f 100644
--- a/include/util/vector_view.hpp
+++ b/include/util/vector_view.hpp
@@ -73,7 +73,9 @@ template <typename DataT> class VectorViewIterator
     reference operator*() const { return *m_value; }
 
     friend difference_type operator-(const VectorViewIterator &a, const VectorViewIterator &b)
-    { return a.m_value - b.m_value; }
+    {
+        return a.m_value - b.m_value;
+    }
 
     friend VectorViewIterator operator+(VectorViewIterator it, difference_type n)
     {
@@ -214,10 +216,14 @@ template <> class vector_view<bool>
         operator bool() const { return (*m_ptr) & mask; }
 
         bool operator==(const reference &other) const
-        { return other.m_ptr == m_ptr && other.mask == mask; }
+        {
+            return other.m_ptr == m_ptr && other.mask == mask;
+        }
 
         friend std::ostream &operator<<(std::ostream &os, const reference &rhs)
-        { return os << static_cast<bool>(rhs); }
+        {
+            return os << static_cast<bool>(rhs);
+        }
 
         Word *m_ptr;
         const Word mask;
diff --git a/include/util/web_mercator.hpp b/include/util/web_mercator.hpp
index 2fcc40cb192..9fcfa07c3f8 100644
--- a/include/util/web_mercator.hpp
+++ b/include/util/web_mercator.hpp
@@ -57,7 +57,9 @@ inline double latToY(const FloatLatitude latitude)
 template <typename T> constexpr double horner(double, T an) { return an; }
 
 template <typename T, typename... U> constexpr double horner(double x, T an, U... a)
-{ return horner(x, a...) * x + an; }
+{
+    return horner(x, a...) * x + an;
+}
 
 inline double latToYapprox(const FloatLatitude latitude)
 {
@@ -123,10 +125,14 @@ inline double degreeToPixel(FloatLatitude lat, unsigned zoom)
 }
 
 inline FloatCoordinate fromWGS84(const FloatCoordinate &wgs84_coordinate)
-{ return {wgs84_coordinate.lon, FloatLatitude{latToYapprox(wgs84_coordinate.lat)}}; }
+{
+    return {wgs84_coordinate.lon, FloatLatitude{latToYapprox(wgs84_coordinate.lat)}};
+}
 
 inline FloatCoordinate toWGS84(const FloatCoordinate &mercator_coordinate)
-{ return {mercator_coordinate.lon, yToLat(static_cast<double>(mercator_coordinate.lat))}; }
+{
+    return {mercator_coordinate.lon, yToLat(static_cast<double>(mercator_coordinate.lat))};
+}
 
 // Converts a WMS tile coordinate (z,x,y) into a wgs bounding box
 inline void xyzToWGS84(const int x,
diff --git a/package-lock.json b/package-lock.json
index b5e4362d528..109feef3af6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -6,7 +6,7 @@
   "packages": {
     "": {
       "name": "@project-osrm/osrm",
-      "version": "26.6.5",
+      "version": "26.7.3",
       "hasInstallScript": true,
       "license": "BSD-2-Clause",
       "dependencies": {
@@ -3951,9 +3951,9 @@
       }
     },
     "node_modules/@nodable/entities": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-2.2.0.tgz",
-      "integrity": "sha512-9uGyhaQavEUMC8AIddIjau4NsnsXhou+j5sBAGojCM1oxmQpVKTWR/9JxABD6UAv12vpIms55fPZKFQEhG6uBg==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-3.0.0.tgz",
+      "integrity": "sha512-8L9xFeTYKhm49xfIypoe2W5wV1m/3Z58kT+7kR9A8OyFxcPduI4VmxaUMQyKYrRjUoLLSXv6EKKID5Tvj9cUVw==",
       "dev": true,
       "funding": [
         {
@@ -9166,9 +9166,9 @@
       }
     },
     "node_modules/fast-xml-parser": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.9.3.tgz",
-      "integrity": "sha512-brCNCeScma/kqa54J4PIDriSSSLssRkuYaUCpvHJulGc3HGI/xxKUCTDcYkAdqJsyb//ydpbxecjC3hB9+tb/g==",
+      "version": "5.10.1",
+      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.10.1.tgz",
+      "integrity": "sha512-IEMIf7298kXuZSRFoGfMYrl7is8LpavODgbNz1cwIudv7KwVFnuU+UsMporfq6PD6aXSlawZlARiA3UywCTfMw==",
       "dev": true,
       "funding": [
         {
@@ -9178,17 +9178,33 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@nodable/entities": "^2.2.0",
+        "@nodable/entities": "^3.0.0",
         "fast-xml-builder": "^1.2.0",
-        "is-unsafe": "^1.0.1",
-        "path-expression-matcher": "^1.5.0",
+        "is-unsafe": "^2.0.0",
+        "path-expression-matcher": "^1.6.2",
         "strnum": "^2.4.1",
-        "xml-naming": "^0.1.0"
+        "xml-naming": "^0.3.0"
       },
       "bin": {
         "fxparser": "src/cli/cli.js"
       }
     },
+    "node_modules/fast-xml-parser/node_modules/xml-naming": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/xml-naming/-/xml-naming-0.3.0.tgz",
+      "integrity": "sha512-ghig2TBE/H11aOVgmahA3MhimvkBr6JIYknH/Dhdk10nXwdbIqBJsbfMxpvFPG8bAw77gN29aQWvKpmVoPlvPQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/fdir": {
       "version": "6.5.0",
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
@@ -10605,9 +10621,9 @@
       }
     },
     "node_modules/is-unsafe": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-1.0.1.tgz",
-      "integrity": "sha512-CLK2+VdgERgD96EYm5lUQssZYlRg2tkZnbsxZoacmSiRxiFJ4Nk4SzjCl+Ur+v3kXIY9dTIdb3IH22y1mZ56LA==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-2.0.0.tgz",
+      "integrity": "sha512-2LdV822R+wmI86unXA93WCFpL6g+av8ynWk0nrHyJqGop5VoocYsSLFgN8jrfalT6iGeLNM4KXuVSsULP53kEA==",
       "dev": true,
       "funding": [
         {
@@ -11873,9 +11889,9 @@
       }
     },
     "node_modules/path-expression-matcher": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.5.0.tgz",
-      "integrity": "sha512-cbrerZV+6rvdQrrD+iGMcZFEiiSrbv9Tfdkvnusy6y0x0GKBXREFg/Y65GhIfm0tnLntThhzCnfKwp1WRjeCyQ==",
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.2.tgz",
+      "integrity": "sha512-enSlaiat05iasnzmgNxRj8reFdj3puY2QpNgP1aPIaVfT6nn9ICuPoFlKHk8EN22HcwewshO+mN2DGbkCEOtqQ==",
       "dev": true,
       "funding": [
         {
@@ -13592,9 +13608,9 @@
       }
     },
     "node_modules/tar": {
-      "version": "7.5.16",
-      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.16.tgz",
-      "integrity": "sha512-56adEpPMouktRlBLXiaYFFzZ/3+JXa8P9n7WbR+ibIjtviN55mEaOkiysCnPnWm+7kkui1Dn8J9l+g6zV8731w==",
+      "version": "7.5.22",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.22.tgz",
+      "integrity": "sha512-MFO/QzvtAOmJbkhOaCTvbGcFN9L9b+JunIsDwaKljSOdcLMea3NJ1k9Usz/rjdfSXTq4dfzfeS7W4p4YOAAHeA==",
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "@isaacs/fs-minipass": "^4.0.0",
diff --git a/package.json b/package.json
index 18a61db48bd..c86f3bb535a 100644
--- a/package.json
+++ b/package.json
@@ -95,7 +95,7 @@
     "glob": "^13.0.0",
     "ajv": ">=6.14.0",
     "minimatch": ">=10.2.1",
-    "tar": ">=7.5.10"
+    "tar": "7.5.22"
   },
   "allowScripts": {
     "esbuild@0.27.2": true,
diff --git a/src/contractor/graph_contractor.cpp b/src/contractor/graph_contractor.cpp
index 449f6c05576..090691a04d0 100644
--- a/src/contractor/graph_contractor.cpp
+++ b/src/contractor/graph_contractor.cpp
@@ -657,10 +657,10 @@ std::vector<bool> contractGraph(ContractorGraph &graph,
         TIMER_START(update_priorities);
         if (remaining_nodes.size() > number_of_core_nodes)
         {
-            tbb::parallel_for_each(
-                independent_nodes,
-                [&](const NodeID v)
-                { UpdateNeighbourPriorities(graph, v, node_data, thread_data); });
+            tbb::parallel_for_each(independent_nodes,
+                                   [&](const NodeID v) {
+                                       UpdateNeighbourPriorities(graph, v, node_data, thread_data);
+                                   });
         }
         TIMER_STOP(update_priorities);
 
@@ -733,11 +733,12 @@ GraphAndFilter contractExcludableGraph(ContractorGraph contractor_graph_,
         // Add all non-core edges to container
         {
             auto non_core_edges = toEdges<QueryEdge>(contractor_graph);
-            auto new_end = std::remove_if(
-                non_core_edges.begin(),
-                non_core_edges.end(),
-                [&](const auto &edge)
-                { return is_shared_core[edge.source] && is_shared_core[edge.target]; });
+            auto new_end = std::remove_if(non_core_edges.begin(),
+                                          non_core_edges.end(),
+                                          [&](const auto &edge) {
+                                              return is_shared_core[edge.source] &&
+                                                     is_shared_core[edge.target];
+                                          });
             non_core_edges.resize(new_end - non_core_edges.begin());
             edge_container.Insert(std::move(non_core_edges));
 
diff --git a/src/engine/api/json_factory.cpp b/src/engine/api/json_factory.cpp
index d34ba086cd6..895fe3a083b 100644
--- a/src/engine/api/json_factory.cpp
+++ b/src/engine/api/json_factory.cpp
@@ -293,12 +293,12 @@ util::json::Array makeRouteLegs(std::vector<guidance::RouteLeg> legs,
         auto leg = std::move(legs[idx]);
         util::json::Array json_steps;
         json_steps.values.reserve(leg.steps.size());
-        std::transform(
-            std::make_move_iterator(leg.steps.begin()),
-            std::make_move_iterator(leg.steps.end()),
-            std::back_inserter(json_steps.values),
-            [&step_geometry_iter](guidance::RouteStep step)
-            { return makeRouteStep(std::move(step), std::move(*step_geometry_iter++)); });
+        std::transform(std::make_move_iterator(leg.steps.begin()),
+                       std::make_move_iterator(leg.steps.end()),
+                       std::back_inserter(json_steps.values),
+                       [&step_geometry_iter](guidance::RouteStep step) {
+                           return makeRouteStep(std::move(step), std::move(*step_geometry_iter++));
+                       });
         std::optional<util::json::Object> annotation;
         std::optional<util::json::Value> leg_geometry;
         if (leg_geometries.size() > 0)
diff --git a/src/engine/guidance/collapse_turns.cpp b/src/engine/guidance/collapse_turns.cpp
index 92039feca5b..ab5ac1d3bf3 100644
--- a/src/engine/guidance/collapse_turns.cpp
+++ b/src/engine/guidance/collapse_turns.cpp
@@ -148,7 +148,9 @@ void NoModificationStrategy::operator()(RouteStep &, const RouteStep &) const
 // transfer turn type from a different turn
 void TransferTurnTypeStrategy::operator()(RouteStep &step_at_turn_location,
                                           const RouteStep &transfer_from_step) const
-{ step_at_turn_location.maneuver = transfer_from_step.maneuver; }
+{
+    step_at_turn_location.maneuver = transfer_from_step.maneuver;
+}
 
 AdjustToCombinedTurnAngleStrategy::AdjustToCombinedTurnAngleStrategy(
     const double max_collapse_distance_)
@@ -410,7 +412,9 @@ SetFixedInstructionStrategy::SetFixedInstructionStrategy(const TurnInstruction i
 
 void SetFixedInstructionStrategy::operator()(RouteStep &step_at_turn_location,
                                              const RouteStep &) const
-{ step_at_turn_location.maneuver.instruction = instruction; }
+{
+    step_at_turn_location.maneuver.instruction = instruction;
+}
 
 void TransferSignageStrategy::operator()(RouteStep &step_at_turn_location,
                                          const RouteStep &transfer_from_step) const
diff --git a/src/engine/hint.cpp b/src/engine/hint.cpp
index 9dd1e292b5e..b50560ee125 100644
--- a/src/engine/hint.cpp
+++ b/src/engine/hint.cpp
@@ -45,12 +45,16 @@ SegmentHint SegmentHint::FromBase64(const std::string &base64Hint)
 }
 
 bool operator==(const SegmentHint &lhs, const SegmentHint &rhs)
-{ return lhs.deprecated_data == rhs.deprecated_data && lhs.data_checksum == rhs.data_checksum; }
+{
+    return lhs.deprecated_data == rhs.deprecated_data && lhs.data_checksum == rhs.data_checksum;
+}
 
 bool operator!=(const SegmentHint &lhs, const SegmentHint &rhs) { return !(lhs == rhs); }
 
 std::ostream &operator<<(std::ostream &out, const SegmentHint &hint)
-{ return out << hint.ToBase64(); }
+{
+    return out << hint.ToBase64();
+}
 
 std::string Hint::ToBase64() const
 {
diff --git a/src/engine/plugins/tile.cpp b/src/engine/plugins/tile.cpp
index 21545fa84d7..6f93b334852 100644
--- a/src/engine/plugins/tile.cpp
+++ b/src/engine/plugins/tile.cpp
@@ -315,10 +315,14 @@ class SpeedLayerFeatureBuilder : public vtzero::linestring_feature_builder
   public:
     SpeedLayerFeatureBuilder(SpeedLayer &layer, uint64_t id)
         : vtzero::linestring_feature_builder(layer), m_layer(layer)
-    { set_id(id); }
+    {
+        set_id(id);
+    }
 
     void set_speed(unsigned int value)
-    { add_property(m_layer.key_speed, m_layer.uint_index(std::min(value, 127u))); }
+    {
+        add_property(m_layer.key_speed, m_layer.uint_index(std::min(value, 127u)));
+    }
 
     void set_is_small(bool value) { add_property(m_layer.key_is_small, m_layer.bool_index(value)); }
 
@@ -331,7 +335,9 @@ class SpeedLayerFeatureBuilder : public vtzero::linestring_feature_builder
     void set_weight(double value) { add_property(m_layer.key_weight, m_layer.double_index(value)); }
 
     void set_duration(double value)
-    { add_property(m_layer.key_duration, m_layer.double_index(value)); }
+    {
+        add_property(m_layer.key_duration, m_layer.double_index(value));
+    }
 
     void set_name(const std::string_view value)
     {
@@ -343,7 +349,9 @@ class SpeedLayerFeatureBuilder : public vtzero::linestring_feature_builder
     void set_rate(double value) { add_property(m_layer.key_rate, m_layer.double_index(value)); }
 
     void set_is_startpoint(bool value)
-    { add_property(m_layer.key_is_startpoint, m_layer.bool_index(value)); }
+    {
+        add_property(m_layer.key_is_startpoint, m_layer.bool_index(value));
+    }
 
 }; // class SpeedLayerFeatureBuilder
 
@@ -382,13 +390,19 @@ class TurnsLayerFeatureBuilder : public vtzero::point_feature_builder
   public:
     TurnsLayerFeatureBuilder(TurnsLayer &layer, uint64_t id)
         : vtzero::point_feature_builder(layer), m_layer(layer)
-    { set_id(id); }
+    {
+        set_id(id);
+    }
 
     void set_bearing_in(int value)
-    { add_property(m_layer.key_bearing_in, m_layer.int_index(value)); }
+    {
+        add_property(m_layer.key_bearing_in, m_layer.int_index(value));
+    }
 
     void set_turn_angle(int value)
-    { add_property(m_layer.key_turn_angle, m_layer.int_index(value)); }
+    {
+        add_property(m_layer.key_turn_angle, m_layer.int_index(value));
+    }
 
     void set_cost(float value) { add_property(m_layer.key_cost, m_layer.float_index(value)); }
 
diff --git a/src/engine/plugins/trip.cpp b/src/engine/plugins/trip.cpp
index 714d841c5fb..2b857d531c4 100644
--- a/src/engine/plugins/trip.cpp
+++ b/src/engine/plugins/trip.cpp
@@ -24,7 +24,9 @@ bool IsStronglyConnectedComponent(const util::DistTableWrapper<EdgeDuration> &re
 bool IsSupportedParameterCombination(const bool fixed_start,
                                      const bool fixed_end,
                                      const bool roundtrip)
-{ return roundtrip || fixed_start || fixed_end; }
+{
+    return roundtrip || fixed_start || fixed_end;
+}
 
 // given the node order in which to visit, compute the actual route (with geometry, travel time and
 // so on) and return the result
diff --git a/src/engine/plugins/viaroute.cpp b/src/engine/plugins/viaroute.cpp
index 7e0adbd3501..a59a2c467e0 100644
--- a/src/engine/plugins/viaroute.cpp
+++ b/src/engine/plugins/viaroute.cpp
@@ -159,20 +159,20 @@ Status ViaRoutePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithm
         const auto all_in_same_component =
             [](const std::vector<PhantomNodeCandidates> &waypoint_candidates)
         {
-            return std::any_of(
-                waypoint_candidates.front().begin(),
-                waypoint_candidates.front().end(),
-                // For each of the first possible phantoms, check if all other
-                // positions in the list have a phantom from the same component.
-                [&](const PhantomNode &phantom)
-                {
-                    const auto component_id = phantom.component.id;
-                    return std::all_of(
-                        std::next(waypoint_candidates.begin()),
-                        std::end(waypoint_candidates),
-                        [component_id](const PhantomNodeCandidates &candidates)
-                        { return candidatesHaveComponent(candidates, component_id); });
-                });
+            return std::any_of(waypoint_candidates.front().begin(),
+                               waypoint_candidates.front().end(),
+                               // For each of the first possible phantoms, check if all other
+                               // positions in the list have a phantom from the same component.
+                               [&](const PhantomNode &phantom)
+                               {
+                                   const auto component_id = phantom.component.id;
+                                   return std::all_of(
+                                       std::next(waypoint_candidates.begin()),
+                                       std::end(waypoint_candidates),
+                                       [component_id](const PhantomNodeCandidates &candidates) {
+                                           return candidatesHaveComponent(candidates, component_id);
+                                       });
+                               });
         };
 
         if (!all_in_same_component(snapped_phantoms))
diff --git a/src/engine/routing_algorithms/alternative_path_ch.cpp b/src/engine/routing_algorithms/alternative_path_ch.cpp
index a0e7745d48a..9d5d5f3eebc 100644
--- a/src/engine/routing_algorithms/alternative_path_ch.cpp
+++ b/src/engine/routing_algorithms/alternative_path_ch.cpp
@@ -38,7 +38,9 @@ struct RankedCandidateNode
     EdgeWeight sharing;
 
     bool operator<(const RankedCandidateNode &other) const
-    { return (EdgeWeight{2} * weight + sharing) < (EdgeWeight{2} * other.weight + other.sharing); }
+    {
+        return (EdgeWeight{2} * weight + sharing) < (EdgeWeight{2} * other.weight + other.sharing);
+    }
 };
 
 // todo: reorder parameters
diff --git a/src/engine/routing_algorithms/tile_turns.cpp b/src/engine/routing_algorithms/tile_turns.cpp
index cfd70e1d40f..68e44b3d178 100644
--- a/src/engine/routing_algorithms/tile_turns.cpp
+++ b/src/engine/routing_algorithms/tile_turns.cpp
@@ -254,7 +254,9 @@ std::vector<TurnData> getTileTurns(const DataFacade<mld::Algorithm> &facade,
         const DataFacade<mld::Algorithm> &facade;
 
         EdgeID operator()(const NodeID approach_node, const NodeID exit_node) const
-        { return facade.FindEdge(approach_node, exit_node); }
+        {
+            return facade.FindEdge(approach_node, exit_node);
+        }
     };
 
     EdgeFinderMLD edge_finder(facade);
diff --git a/src/extractor/edge_based_graph_factory.cpp b/src/extractor/edge_based_graph_factory.cpp
index 2552ec60cc2..948e91b2a8d 100644
--- a/src/extractor/edge_based_graph_factory.cpp
+++ b/src/extractor/edge_based_graph_factory.cpp
@@ -86,10 +86,14 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodeDistances(
 }
 
 std::uint32_t EdgeBasedGraphFactory::GetConnectivityChecksum() const
-{ return m_connectivity_checksum; }
+{
+    return m_connectivity_checksum;
+}
 
 std::uint64_t EdgeBasedGraphFactory::GetNumberOfEdgeBasedNodes() const
-{ return m_number_of_edge_based_nodes; }
+{
+    return m_number_of_edge_based_nodes;
+}
 
 NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeID node_v)
 {
diff --git a/src/extractor/extraction_containers.cpp b/src/extractor/extraction_containers.cpp
index 0dfcb4eec1b..140428b45eb 100644
--- a/src/extractor/extraction_containers.cpp
+++ b/src/extractor/extraction_containers.cpp
@@ -31,14 +31,18 @@ struct CmpEdgeByOSMStartID
 {
     using value_type = oe::InternalExtractorEdge;
     bool operator()(const value_type &lhs, const value_type &rhs) const
-    { return lhs.result.osm_source_id < rhs.result.osm_source_id; }
+    {
+        return lhs.result.osm_source_id < rhs.result.osm_source_id;
+    }
 };
 
 struct CmpEdgeByOSMTargetID
 {
     using value_type = oe::InternalExtractorEdge;
     bool operator()(const value_type &lhs, const value_type &rhs) const
-    { return lhs.result.osm_target_id < rhs.result.osm_target_id; }
+    {
+        return lhs.result.osm_target_id < rhs.result.osm_target_id;
+    }
 };
 
 struct CmpEdgeByInternalSourceTargetAndName
diff --git a/src/extractor/extractor_callbacks.cpp b/src/extractor/extractor_callbacks.cpp
index 47fba192631..79fc524c6dc 100644
--- a/src/extractor/extractor_callbacks.cpp
+++ b/src/extractor/extractor_callbacks.cpp
@@ -65,10 +65,14 @@ void ExtractorCallbacks::ProcessNode(const osmium::Node &input_node, const Extra
 }
 
 void ExtractorCallbacks::ProcessRestriction(const InputTurnRestriction &restriction)
-{ external_memory.restrictions_list.push_back(restriction); }
+{
+    external_memory.restrictions_list.push_back(restriction);
+}
 
 void ExtractorCallbacks::ProcessManeuverOverride(const InputManeuverOverride &override)
-{ external_memory.external_maneuver_overrides_list.push_back(override); }
+{
+    external_memory.external_maneuver_overrides_list.push_back(override);
+}
 
 /**
  * Takes the geometry contained in the ```input_way``` and the tags computed
diff --git a/src/extractor/intersection/coordinate_extractor.cpp b/src/extractor/intersection/coordinate_extractor.cpp
index 14eb77c964e..fa71031aa24 100644
--- a/src/extractor/intersection/coordinate_extractor.cpp
+++ b/src/extractor/intersection/coordinate_extractor.cpp
@@ -554,7 +554,9 @@ util::Coordinate CoordinateExtractor::GetCoordinateCloseToTurn(const NodeID from
 
 std::vector<util::Coordinate>
 CoordinateExtractor::GetForwardCoordinatesAlongRoad(const NodeID from, const EdgeID turn_edge) const
-{ return GetCoordinatesAlongRoad(from, turn_edge, false, node_based_graph.GetTarget(turn_edge)); }
+{
+    return GetCoordinatesAlongRoad(from, turn_edge, false, node_based_graph.GetTarget(turn_edge));
+}
 
 std::vector<util::Coordinate>
 CoordinateExtractor::GetCoordinatesAlongRoad(const NodeID intersection_node,
diff --git a/src/extractor/intersection/intersection.cpp b/src/extractor/intersection/intersection.cpp
index fd975b87000..c7f5a0a3b4d 100644
--- a/src/extractor/intersection/intersection.cpp
+++ b/src/extractor/intersection/intersection.cpp
@@ -6,7 +6,9 @@ namespace osrm::extractor::intersection
 {
 
 bool IntersectionViewData::CompareByAngle(const IntersectionViewData &other) const
-{ return angle < other.angle; }
+{
+    return angle < other.angle;
+}
 
 std::string toString(const IntersectionEdgeGeometry &shape)
 {
diff --git a/src/extractor/intersection/intersection_analysis.cpp b/src/extractor/intersection/intersection_analysis.cpp
index d71e3b4874c..64128870d93 100644
--- a/src/extractor/intersection/intersection_analysis.cpp
+++ b/src/extractor/intersection/intersection_analysis.cpp
@@ -413,10 +413,14 @@ inline auto findEdge(const IntersectionEdgeGeometries &geometries, const EdgeID
 }
 
 double findEdgeBearing(const IntersectionEdgeGeometries &geometries, const EdgeID &edge)
-{ return findEdge(geometries, edge)->perceived_bearing; }
+{
+    return findEdge(geometries, edge)->perceived_bearing;
+}
 
 double findEdgeLength(const IntersectionEdgeGeometries &geometries, const EdgeID &edge)
-{ return findEdge(geometries, edge)->segment_length; }
+{
+    return findEdge(geometries, edge)->segment_length;
+}
 
 template <typename RestrictionsRange>
 bool isTurnRestricted(RestrictionsRange restrictions, const NodeID to)
diff --git a/src/extractor/node_based_graph_factory.cpp b/src/extractor/node_based_graph_factory.cpp
index 084d3f16439..28d7fe57f34 100644
--- a/src/extractor/node_based_graph_factory.cpp
+++ b/src/extractor/node_based_graph_factory.cpp
@@ -150,7 +150,9 @@ void NodeBasedGraphFactory::CompressAnnotationData()
         }
 
         bool operator()(AnnotationID a, AnnotationID b) const
-        { return annotation_data[a] < annotation_data[b]; }
+        {
+            return annotation_data[a] < annotation_data[b];
+        }
 
       private:
         const std::vector<NodeBasedEdgeAnnotation> &annotation_data;
diff --git a/src/extractor/scripting_environment_lua.cpp b/src/extractor/scripting_environment_lua.cpp
index b6aee38fa38..f4f90d2ba7e 100644
--- a/src/extractor/scripting_environment_lua.cpp
+++ b/src/extractor/scripting_environment_lua.cpp
@@ -70,10 +70,14 @@ const char *get_value_by_key(T const &object, const char *key, D const default_v
 }
 
 template <class T> double latToDouble(T const &object)
-{ return static_cast<double>(util::toFloating(object.lat)); }
+{
+    return static_cast<double>(util::toFloating(object.lat));
+}
 
 template <class T> double lonToDouble(T const &object)
-{ return static_cast<double>(util::toFloating(object.lon)); }
+{
+    return static_cast<double>(util::toFloating(object.lon));
+}
 
 struct to_lua_object
 {
@@ -109,7 +113,9 @@ Sol2ScriptingEnvironment::Sol2ScriptingEnvironment(
     const std::string &file_name,
     const std::vector<std::filesystem::path> &location_dependent_data_paths)
     : file_name(file_name), location_dependent_data(location_dependent_data_paths)
-{ util::Log() << "Using script " << file_name; }
+{
+    util::Log() << "Using script " << file_name;
+}
 
 void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
 {
@@ -1007,7 +1013,9 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
 }
 
 const ProfileProperties &Sol2ScriptingEnvironment::GetProfileProperties()
-{ return GetSol2Context().properties; }
+{
+    return GetSol2Context().properties;
+}
 
 LuaScriptingContext &Sol2ScriptingEnvironment::GetSol2Context()
 {
diff --git a/src/extractor/suffix_table.cpp b/src/extractor/suffix_table.cpp
index acc3440fc66..f1177cc61b9 100644
--- a/src/extractor/suffix_table.cpp
+++ b/src/extractor/suffix_table.cpp
@@ -22,9 +22,13 @@ SuffixTable::SuffixTable(ScriptingEnvironment &scripting_environment)
 }
 
 bool SuffixTable::isSuffix(const std::string &possible_suffix) const
-{ return isSuffix(std::string_view{possible_suffix}); }
+{
+    return isSuffix(std::string_view{possible_suffix});
+}
 
 bool SuffixTable::isSuffix(std::string_view possible_suffix) const
-{ return suffix_set.contains(possible_suffix); }
+{
+    return suffix_set.contains(possible_suffix);
+}
 
 } // namespace osrm::extractor
diff --git a/src/extractor/way_restriction_map.cpp b/src/extractor/way_restriction_map.cpp
index 96ba0d085a8..b7d257526d9 100644
--- a/src/extractor/way_restriction_map.cpp
+++ b/src/extractor/way_restriction_map.cpp
@@ -9,10 +9,14 @@ WayRestrictionMap::WayRestrictionMap(const RestrictionGraph &restriction_graph)
 }
 
 std::size_t WayRestrictionMap::NumberOfDuplicatedNodes() const
-{ return restriction_graph.num_via_nodes; }
+{
+    return restriction_graph.num_via_nodes;
+}
 
 bool WayRestrictionMap::IsViaWayEdge(const NodeID from, const NodeID to) const
-{ return restriction_graph.via_edge_to_node.contains({from, to}); }
+{
+    return restriction_graph.via_edge_to_node.contains({from, to});
+}
 
 std::vector<DuplicatedNodeID> WayRestrictionMap::DuplicatedNodeIDs(const NodeID from,
                                                                    const NodeID to) const
diff --git a/src/guidance/motorway_handler.cpp b/src/guidance/motorway_handler.cpp
index 3319b7b4137..a06b53dfb0f 100644
--- a/src/guidance/motorway_handler.cpp
+++ b/src/guidance/motorway_handler.cpp
@@ -19,10 +19,14 @@ namespace
 {
 
 inline bool isMotorwayClass(EdgeID eid, const util::NodeBasedDynamicGraph &node_based_graph)
-{ return node_based_graph.GetEdgeData(eid).flags.road_classification.IsMotorwayClass(); }
+{
+    return node_based_graph.GetEdgeData(eid).flags.road_classification.IsMotorwayClass();
+}
 inline extractor::RoadClassification roadClass(const ConnectedRoad &road,
                                                const util::NodeBasedDynamicGraph &graph)
-{ return graph.GetEdgeData(road.eid).flags.road_classification; }
+{
+    return graph.GetEdgeData(road.eid).flags.road_classification;
+}
 
 inline bool isRampClass(EdgeID eid,
                         const util::NodeBasedDynamicGraph &node_based_graph,
diff --git a/src/guidance/sliproad_handler.cpp b/src/guidance/sliproad_handler.cpp
index 171b02db626..e898220f047 100644
--- a/src/guidance/sliproad_handler.cpp
+++ b/src/guidance/sliproad_handler.cpp
@@ -44,7 +44,9 @@ SliproadHandler::SliproadHandler(const util::NodeBasedDynamicGraph &node_based_g
 bool SliproadHandler::canProcess(const NodeID /*nid*/,
                                  const EdgeID /*via_eid*/,
                                  const Intersection &intersection) const
-{ return intersection.size() > 2; }
+{
+    return intersection.size() > 2;
+}
 
 // Detect sliproad b-d in the following example:
 //
diff --git a/src/guidance/turn_handler.cpp b/src/guidance/turn_handler.cpp
index 221ce219daa..18d80ad9f8a 100644
--- a/src/guidance/turn_handler.cpp
+++ b/src/guidance/turn_handler.cpp
@@ -97,9 +97,13 @@ ConnectedRoad &TurnHandler::Fork::getMiddle() const
     return *(begin + 1);
 }
 std::size_t TurnHandler::Fork::getRightIndex() const
-{ return std::distance(intersection_base, begin); }
+{
+    return std::distance(intersection_base, begin);
+}
 std::size_t TurnHandler::Fork::getLeftIndex() const
-{ return std::distance(intersection_base, end) - 1; }
+{
+    return std::distance(intersection_base, end) - 1;
+}
 
 TurnHandler::TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
                          const extractor::EdgeBasedNodeDataContainer &node_data_container,
@@ -123,7 +127,9 @@ TurnHandler::TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
 }
 
 bool TurnHandler::canProcess(const NodeID, const EdgeID, const Intersection &) const
-{ return true; }
+{
+    return true;
+}
 
 // Handles and processes possible turns
 // Input parameters describe an intersection as described in
@@ -219,11 +225,12 @@ bool TurnHandler::isObviousOfTwo(const EdgeID via_edge,
 
 bool TurnHandler::hasObvious(const EdgeID &via_edge, const Fork &fork) const
 {
-    auto obvious_road = std::adjacent_find(
-        fork.begin,
-        fork.end,
-        [&, this](const auto &a, const auto &b)
-        { return this->isObviousOfTwo(via_edge, a, b) || this->isObviousOfTwo(via_edge, b, a); });
+    auto obvious_road = std::adjacent_find(fork.begin,
+                                           fork.end,
+                                           [&, this](const auto &a, const auto &b) {
+                                               return this->isObviousOfTwo(via_edge, a, b) ||
+                                                      this->isObviousOfTwo(via_edge, b, a);
+                                           });
     // return whether an obvious road was found
     return obvious_road != fork.end;
 }
diff --git a/src/guidance/turn_lane_data.cpp b/src/guidance/turn_lane_data.cpp
index 9f5bcb1c852..bc1cca41d88 100644
--- a/src/guidance/turn_lane_data.cpp
+++ b/src/guidance/turn_lane_data.cpp
@@ -152,6 +152,8 @@ LaneDataVector::const_iterator findTag(const TurnLaneType::Mask tag, const LaneD
 }
 
 bool hasTag(const TurnLaneType::Mask tag, const LaneDataVector &data)
-{ return findTag(tag, data) != data.cend(); }
+{
+    return findTag(tag, data) != data.cend();
+}
 
 } // namespace osrm::guidance::lanes
diff --git a/src/nodejs/node_osrm.cpp b/src/nodejs/node_osrm.cpp
index 276f66c4f6f..2a7f9da6633 100644
--- a/src/nodejs/node_osrm.cpp
+++ b/src/nodejs/node_osrm.cpp
@@ -690,6 +690,8 @@ Napi::Value Engine::trip(const Napi::CallbackInfo &info)
 } // namespace node_osrm
 
 Napi::Object InitAll(Napi::Env env, Napi::Object exports)
-{ return node_osrm::Engine::Init(env, exports); }
+{
+    return node_osrm::Engine::Init(env, exports);
+}
 
 NODE_API_MODULE(addon, InitAll)
diff --git a/src/osrm/osrm.cpp b/src/osrm/osrm.cpp
index de7e4beff6f..3596c06cb48 100644
--- a/src/osrm/osrm.cpp
+++ b/src/osrm/osrm.cpp
@@ -61,7 +61,9 @@ Status OSRM::Route(const engine::api::RouteParameters &params, json::Object &jso
 }
 
 Status OSRM::Route(const RouteParameters &params, engine::api::ResultT &result) const
-{ return engine_->Route(params, result); }
+{
+    return engine_->Route(params, result);
+}
 
 Status OSRM::Table(const engine::api::TableParameters &params, json::Object &json_result) const
 {
@@ -72,7 +74,9 @@ Status OSRM::Table(const engine::api::TableParameters &params, json::Object &jso
 }
 
 Status OSRM::Table(const TableParameters &params, engine::api::ResultT &result) const
-{ return engine_->Table(params, result); }
+{
+    return engine_->Table(params, result);
+}
 
 Status OSRM::Nearest(const engine::api::NearestParameters &params, json::Object &json_result) const
 {
@@ -83,7 +87,9 @@ Status OSRM::Nearest(const engine::api::NearestParameters &params, json::Object
 }
 
 Status OSRM::Nearest(const NearestParameters &params, engine::api::ResultT &result) const
-{ return engine_->Nearest(params, result); }
+{
+    return engine_->Nearest(params, result);
+}
 
 Status OSRM::Trip(const engine::api::TripParameters &params, json::Object &json_result) const
 {
@@ -95,7 +101,9 @@ Status OSRM::Trip(const engine::api::TripParameters &params, json::Object &json_
 
 engine::Status OSRM::Trip(const engine::api::TripParameters &params,
                           engine::api::ResultT &result) const
-{ return engine_->Trip(params, result); }
+{
+    return engine_->Trip(params, result);
+}
 
 Status OSRM::Match(const engine::api::MatchParameters &params, json::Object &json_result) const
 {
@@ -106,7 +114,9 @@ Status OSRM::Match(const engine::api::MatchParameters &params, json::Object &jso
 }
 
 Status OSRM::Match(const MatchParameters &params, engine::api::ResultT &result) const
-{ return engine_->Match(params, result); }
+{
+    return engine_->Match(params, result);
+}
 
 Status OSRM::Tile(const engine::api::TileParameters &params, std::string &str_result) const
 {
@@ -117,6 +127,8 @@ Status OSRM::Tile(const engine::api::TileParameters &params, std::string &str_re
 }
 
 Status OSRM::Tile(const engine::api::TileParameters &params, engine::api::ResultT &result) const
-{ return engine_->Tile(params, result); }
+{
+    return engine_->Tile(params, result);
+}
 
 } // namespace osrm
diff --git a/src/partitioner/bisection_graph_view.cpp b/src/partitioner/bisection_graph_view.cpp
index 687aeabb0e9..61ce7687fd1 100644
--- a/src/partitioner/bisection_graph_view.cpp
+++ b/src/partitioner/bisection_graph_view.cpp
@@ -40,9 +40,13 @@ BisectionGraph::ConstNodeIterator BisectionGraphView::Begin() const { return beg
 BisectionGraph::ConstNodeIterator BisectionGraphView::End() const { return end; }
 
 const BisectionGraphView::NodeT &BisectionGraphView::Node(const NodeID nid) const
-{ return *(begin + nid); }
+{
+    return *(begin + nid);
+}
 
 const BisectionGraphView::EdgeT &BisectionGraphView::Edge(const EdgeID eid) const
-{ return bisection_graph.Edge(eid); }
+{
+    return bisection_graph.Edge(eid);
+}
 
 } // namespace osrm::partitioner
diff --git a/src/partitioner/dinic_max_flow.cpp b/src/partitioner/dinic_max_flow.cpp
index 544aea040db..5324fffd5d9 100644
--- a/src/partitioner/dinic_max_flow.cpp
+++ b/src/partitioner/dinic_max_flow.cpp
@@ -69,11 +69,11 @@ DinicMaxFlow::MinCut DinicMaxFlow::operator()(const BisectionGraphView &view,
         auto levels = ComputeLevelGraph(view, border_source_nodes, source_nodes, sink_nodes, flow);
 
         // check if the sink can be reached from the source, it's enough to check the border
-        const auto separated =
-            std::find_if(border_sink_nodes.begin(),
-                         border_sink_nodes.end(),
-                         [&levels](const auto node)
-                         { return levels[node] != INVALID_LEVEL; }) == border_sink_nodes.end();
+        const auto separated = std::find_if(border_sink_nodes.begin(),
+                                            border_sink_nodes.end(),
+                                            [&levels](const auto node) {
+                                                return levels[node] != INVALID_LEVEL;
+                                            }) == border_sink_nodes.end();
 
         if (!separated)
         {
@@ -297,11 +297,11 @@ bool DinicMaxFlow::Validate(const BisectionGraphView &view,
                             const SourceSinkNodes &sink_nodes) const
 {
     // sink and source cannot share a common node
-    const auto separated =
-        std::find_if(source_nodes.begin(),
-                     source_nodes.end(),
-                     [&sink_nodes](const auto node)
-                     { return sink_nodes.contains(node); }) == source_nodes.end();
+    const auto separated = std::find_if(source_nodes.begin(),
+                                        source_nodes.end(),
+                                        [&sink_nodes](const auto node) {
+                                            return sink_nodes.contains(node);
+                                        }) == source_nodes.end();
 
     const auto invalid_id = [&view](const NodeID nid) { return nid >= view.NumberOfNodes(); };
     const auto in_range_source =
diff --git a/src/partitioner/inertial_flow.cpp b/src/partitioner/inertial_flow.cpp
index 0f9ab2e2440..407d767b52f 100644
--- a/src/partitioner/inertial_flow.cpp
+++ b/src/partitioner/inertial_flow.cpp
@@ -161,6 +161,8 @@ DinicMaxFlow::MinCut computeInertialFlowCut(const BisectionGraphView &view,
                                             const std::size_t num_slopes,
                                             const double balance,
                                             const double source_sink_rate)
-{ return bestMinCut(view, num_slopes, source_sink_rate, balance); }
+{
+    return bestMinCut(view, num_slopes, source_sink_rate, balance);
+}
 
 } // namespace osrm::partitioner
diff --git a/src/partitioner/recursive_bisection.cpp b/src/partitioner/recursive_bisection.cpp
index 3dedfb7e0cb..43359801418 100644
--- a/src/partitioner/recursive_bisection.cpp
+++ b/src/partitioner/recursive_bisection.cpp
@@ -105,7 +105,9 @@ RecursiveBisection::RecursiveBisection(BisectionGraph &bisection_graph_,
 }
 
 const std::vector<BisectionID> &RecursiveBisection::BisectionIDs() const
-{ return internal_state.BisectionIDs(); }
+{
+    return internal_state.BisectionIDs();
+}
 
 std::uint32_t RecursiveBisection::SCCDepth() const { return internal_state.SCCDepth(); }
 
diff --git a/src/partitioner/recursive_bisection_state.cpp b/src/partitioner/recursive_bisection_state.cpp
index 6b791c710b1..21acf142b43 100644
--- a/src/partitioner/recursive_bisection_state.cpp
+++ b/src/partitioner/recursive_bisection_state.cpp
@@ -13,12 +13,16 @@ namespace osrm::partitioner
 
 RecursiveBisectionState::RecursiveBisectionState(BisectionGraph &bisection_graph_)
     : scc_levels(0), bisection_graph(bisection_graph_)
-{ bisection_ids.resize(bisection_graph.NumberOfNodes(), BisectionID{0}); }
+{
+    bisection_ids.resize(bisection_graph.NumberOfNodes(), BisectionID{0});
+}
 
 RecursiveBisectionState::~RecursiveBisectionState() {}
 
 BisectionID RecursiveBisectionState::GetBisectionID(const NodeID node) const
-{ return bisection_ids[node]; }
+{
+    return bisection_ids[node];
+}
 
 RecursiveBisectionState::NodeIterator
 RecursiveBisectionState::ApplyBisection(const NodeIterator const_begin,
@@ -181,7 +185,9 @@ RecursiveBisectionState::PrePartitionWithSCC(const std::size_t small_component_s
 }
 
 const std::vector<BisectionID> &RecursiveBisectionState::BisectionIDs() const
-{ return bisection_ids; }
+{
+    return bisection_ids;
+}
 
 std::uint32_t RecursiveBisectionState::SCCDepth() const { return scc_levels; }
 
diff --git a/src/partitioner/tarjan_graph_wrapper.cpp b/src/partitioner/tarjan_graph_wrapper.cpp
index 14239e05f50..f1e693ec213 100644
--- a/src/partitioner/tarjan_graph_wrapper.cpp
+++ b/src/partitioner/tarjan_graph_wrapper.cpp
@@ -11,9 +11,13 @@ TarjanGraphWrapper::TarjanGraphWrapper(const BisectionGraph &bisection_graph_)
 std::size_t TarjanGraphWrapper::GetNumberOfNodes() const { return bisection_graph.NumberOfNodes(); }
 
 util::range<EdgeID> TarjanGraphWrapper::GetAdjacentEdgeRange(const NodeID nid) const
-{ return util::irange<EdgeID>(bisection_graph.BeginEdgeID(nid), bisection_graph.EndEdgeID(nid)); }
+{
+    return util::irange<EdgeID>(bisection_graph.BeginEdgeID(nid), bisection_graph.EndEdgeID(nid));
+}
 
 NodeID TarjanGraphWrapper::GetTarget(const EdgeID eid) const
-{ return bisection_graph.Edge(eid).target; }
+{
+    return bisection_graph.Edge(eid).target;
+}
 
 } // namespace osrm::partitioner
diff --git a/src/python/include/python/types/jsoncontainer_nb.hpp b/src/python/include/python/types/jsoncontainer_nb.hpp
index d98d6ea780d..8e67768f859 100644
--- a/src/python/include/python/types/jsoncontainer_nb.hpp
+++ b/src/python/include/python/types/jsoncontainer_nb.hpp
@@ -27,8 +27,7 @@ template <> struct type_caster<JSONValue>
     static handle from_cpp(T &&val, rv_policy policy, cleanup_list *cleanup) noexcept
     {
         return std::visit(
-            [&](auto &&v)
-            {
+            [&](auto &&v) {
                 return Caster<decltype(v)>::from_cpp(std::forward<decltype(v)>(v), policy, cleanup);
             },
             std::forward<T>(val));
@@ -38,28 +37,38 @@ template <> struct type_caster<JSONValue>
 template <> struct type_caster<json::String> : type_caster_base<json::String>
 {
     static handle from_cpp(const json::String &val, rv_policy, cleanup_list *) noexcept
-    { return PyUnicode_FromStringAndSize(val.value.c_str(), val.value.size()); }
+    {
+        return PyUnicode_FromStringAndSize(val.value.c_str(), val.value.size());
+    }
 };
 template <> struct type_caster<json::Number> : type_caster_base<json::Number>
 {
     static handle from_cpp(const json::Number &val, rv_policy, cleanup_list *) noexcept
-    { return PyFloat_FromDouble((double)val.value); }
+    {
+        return PyFloat_FromDouble((double)val.value);
+    }
 };
 
 template <> struct type_caster<json::True> : type_caster_base<json::True>
 {
     static handle from_cpp(const json::True &, rv_policy, cleanup_list *) noexcept
-    { return handle(Py_True).inc_ref(); }
+    {
+        return handle(Py_True).inc_ref();
+    }
 };
 template <> struct type_caster<json::False> : type_caster_base<json::False>
 {
     static handle from_cpp(const json::False &, rv_policy, cleanup_list *) noexcept
-    { return handle(Py_False).inc_ref(); }
+    {
+        return handle(Py_False).inc_ref();
+    }
 };
 template <> struct type_caster<json::Null> : type_caster_base<json::Null>
 {
     static handle from_cpp(const json::Null &, rv_policy, cleanup_list *) noexcept
-    { return none().release(); }
+    {
+        return none().release();
+    }
 };
 
 } // namespace nanobind::detail
diff --git a/src/python/src/parameters/tableparameter_nb.cpp b/src/python/src/parameters/tableparameter_nb.cpp
index a86d8b92625..665e36cf578 100644
--- a/src/python/src/parameters/tableparameter_nb.cpp
+++ b/src/python/src/parameters/tableparameter_nb.cpp
@@ -133,8 +133,7 @@ void init_TableParameters(nb::module_ &m)
             "Instantiates a FallbackCoordinateType based on provided String value.")
         .def(
             "__repr__",
-            [](TableParameters::FallbackCoordinateType type)
-            {
+            [](TableParameters::FallbackCoordinateType type) {
                 return osrm_nb_util::enum_to_str(type, "TableFallbackCoordinateType", fallback_map);
             },
             "Return a String based on FallbackCoordinateType value.");
diff --git a/src/python/src/types/jsoncontainer_nb.cpp b/src/python/src/types/jsoncontainer_nb.cpp
index 8b7e50a1bcf..a61aa8c1a82 100644
--- a/src/python/src/types/jsoncontainer_nb.cpp
+++ b/src/python/src/types/jsoncontainer_nb.cpp
@@ -29,8 +29,7 @@ void init_JSONContainer(nb::module_ &m)
              { return obj.values.count(key) > 0; })
         .def(
             "__iter__",
-            [m](const json::Object &obj)
-            {
+            [m](const json::Object &obj) {
                 return nb::make_key_iterator(
                     m, "key_iterator", obj.values.begin(), obj.values.end());
             },
diff --git a/src/python/src/utility/osrm_utility.cpp b/src/python/src/utility/osrm_utility.cpp
index 9c7c772d088..9bdbb2555dc 100644
--- a/src/python/src/utility/osrm_utility.cpp
+++ b/src/python/src/utility/osrm_utility.cpp
@@ -121,9 +121,9 @@ void populate_cfg_from_kwargs(const nb::kwargs &kwargs, EngineConfig &config)
                    {"verbosity",
                     [&config](const std::pair<nb::handle, nb::handle> &val)
                     { assign_val(config.verbosity, val); }},
-                   {"dataset_name",
-                    [&config](const std::pair<nb::handle, nb::handle> &val)
-                    { assign_val(config.dataset_name, val); }}};
+                   {"dataset_name", [&config](const std::pair<nb::handle, nb::handle> &val) {
+                        assign_val(config.dataset_name, val);
+                    }}};
 
     for (auto kwarg : kwargs)
     {
diff --git a/src/server/api/parameters_parser.cpp b/src/server/api/parameters_parser.cpp
index 890e7e8e17e..e4aabbc9dd0 100644
--- a/src/server/api/parameters_parser.cpp
+++ b/src/server/api/parameters_parser.cpp
@@ -75,7 +75,9 @@ std::optional<engine::api::NearestParameters> parseParameters(std::string::itera
 template <>
 std::optional<engine::api::TripParameters> parseParameters(std::string::iterator &iter,
                                                            const std::string::iterator end)
-{ return detail::parseParameters<engine::api::TripParameters>(iter, end, trip_grammar::root_rule); }
+{
+    return detail::parseParameters<engine::api::TripParameters>(iter, end, trip_grammar::root_rule);
+}
 
 template <>
 std::optional<engine::api::MatchParameters> parseParameters(std::string::iterator &iter,
diff --git a/src/server/connection.cpp b/src/server/connection.cpp
index 51dbb43b936..63591b4821a 100644
--- a/src/server/connection.cpp
+++ b/src/server/connection.cpp
@@ -24,7 +24,9 @@ Connection::Connection(tcp::socket socket,
                        short keepalive_timeout)
     : stream_(std::move(socket)), request_handler_(handler), max_header_size_(max_header_size),
       keepalive_timeout_(keepalive_timeout)
-{ stream_.expires_after(std::chrono::seconds(keepalive_timeout_)); }
+{
+    stream_.expires_after(std::chrono::seconds(keepalive_timeout_));
+}
 
 void Connection::start() { handle_read(); }
 
diff --git a/src/server/request_handler.cpp b/src/server/request_handler.cpp
index 2ad06721139..b65de76db2e 100644
--- a/src/server/request_handler.cpp
+++ b/src/server/request_handler.cpp
@@ -81,7 +81,9 @@ void SendResponse(ServiceHandler::ResultT &result,
 
 void RequestHandler::RegisterServiceHandler(
     std::unique_ptr<ServiceHandlerInterface> service_handler_)
-{ service_handler = std::move(service_handler_); }
+{
+    service_handler = std::move(service_handler_);
+}
 
 void RequestHandler::HandleRequest(const Request &current_request,
                                    Response &current_reply,
diff --git a/src/storage/shared_memory.cpp b/src/storage/shared_memory.cpp
index 96d16bd65bb..e5c87f7b6e7 100644
--- a/src/storage/shared_memory.cpp
+++ b/src/storage/shared_memory.cpp
@@ -24,7 +24,9 @@ struct OSRMLockFile
     }
     const std::filesystem::path to_path() { return lock_file; }
     operator const std::filesystem::path::value_type *() const noexcept
-    { return lock_file.c_str(); }
+    {
+        return lock_file.c_str();
+    }
 
   private:
     std::filesystem::path lock_file;
diff --git a/src/tools/components.cpp b/src/tools/components.cpp
index 7ad4f629ed2..1287979cfc5 100644
--- a/src/tools/components.cpp
+++ b/src/tools/components.cpp
@@ -64,7 +64,9 @@ std::size_t loadGraph(const std::string &path,
 struct FeatureWriter
 {
     FeatureWriter(std::ostream &out_) : out(out_)
-    { out << "{\"type\":\"FeatureCollection\",\"features\":["; }
+    {
+        out << "{\"type\":\"FeatureCollection\",\"features\":[";
+    }
 
     void AddLine(const util::Coordinate from,
                  const util::Coordinate to,
diff --git a/src/util/assert.cpp b/src/util/assert.cpp
index 7e881c2aeb2..07aea522d5a 100644
--- a/src/util/assert.cpp
+++ b/src/util/assert.cpp
@@ -21,8 +21,12 @@ namespace
 namespace boost
 {
 void assertion_failed(char const *expr, char const *function, char const *file, long line)
-{ ::assertion_failed_msg_helper(expr, "", function, file, line); }
+{
+    ::assertion_failed_msg_helper(expr, "", function, file, line);
+}
 void assertion_failed_msg(
     char const *expr, char const *msg, char const *function, char const *file, long line)
-{ ::assertion_failed_msg_helper(expr, msg, function, file, line); }
+{
+    ::assertion_failed_msg_helper(expr, msg, function, file, line);
+}
 } // namespace boost
diff --git a/src/util/coordinate.cpp b/src/util/coordinate.cpp
index de3d23ff4a5..09509b80461 100644
--- a/src/util/coordinate.cpp
+++ b/src/util/coordinate.cpp
@@ -22,9 +22,13 @@ bool FloatCoordinate::IsValid() const
 }
 
 bool operator==(const Coordinate lhs, const Coordinate rhs)
-{ return lhs.lat == rhs.lat && lhs.lon == rhs.lon; }
+{
+    return lhs.lat == rhs.lat && lhs.lon == rhs.lon;
+}
 bool operator==(const FloatCoordinate lhs, const FloatCoordinate rhs)
-{ return lhs.lat == rhs.lat && lhs.lon == rhs.lon; }
+{
+    return lhs.lat == rhs.lat && lhs.lon == rhs.lon;
+}
 
 bool operator!=(const Coordinate lhs, const Coordinate rhs) { return !(lhs == rhs); }
 bool operator!=(const FloatCoordinate lhs, const FloatCoordinate rhs) { return !(lhs == rhs); }
diff --git a/src/util/coordinate_calculation.cpp b/src/util/coordinate_calculation.cpp
index 1404eaf5555..19fbc2d0eb3 100644
--- a/src/util/coordinate_calculation.cpp
+++ b/src/util/coordinate_calculation.cpp
@@ -298,7 +298,9 @@ double signedArea(const Coordinate first_coordinate,
 bool isCCW(const Coordinate first_coordinate,
            const Coordinate second_coordinate,
            const Coordinate third_coordinate)
-{ return signedArea(first_coordinate, second_coordinate, third_coordinate) > 0; }
+{
+    return signedArea(first_coordinate, second_coordinate, third_coordinate) > 0;
+}
 
 // find the closest distance between a coordinate and a segment
 double findClosestDistance(const Coordinate coordinate,
diff --git a/src/util/guidance/bearing_class.cpp b/src/util/guidance/bearing_class.cpp
index 4f7635ec56b..f2e6714a6f8 100644
--- a/src/util/guidance/bearing_class.cpp
+++ b/src/util/guidance/bearing_class.cpp
@@ -44,7 +44,9 @@ bool BearingClass::operator<(const BearingClass &other) const
 void BearingClass::add(const DiscreteBearing bearing) { available_bearings.push_back(bearing); }
 
 const std::vector<DiscreteBearing> &BearingClass::getAvailableBearings() const
-{ return available_bearings; }
+{
+    return available_bearings;
+}
 
 DiscreteBearing BearingClass::getDiscreteBearing(const double bearing)
 {
@@ -63,8 +65,7 @@ std::size_t BearingClass::findMatchingBearing(const double bearing) const
     auto max_element =
         std::max_element(available_bearings.begin(),
                          available_bearings.end(),
-                         [&](const DiscreteBearing first, const DiscreteBearing second)
-                         {
+                         [&](const DiscreteBearing first, const DiscreteBearing second) {
                              return angularDeviation(first, discrete_bearing) >
                                     angularDeviation(second, discrete_bearing);
                          });
diff --git a/src/util/guidance/entry_class.cpp b/src/util/guidance/entry_class.cpp
index 6ae6178c9fc..6fe304123ce 100644
--- a/src/util/guidance/entry_class.cpp
+++ b/src/util/guidance/entry_class.cpp
@@ -23,9 +23,13 @@ bool EntryClass::allowsEntry(std::uint32_t index) const
 }
 
 bool EntryClass::operator==(const EntryClass &other) const
-{ return enabled_entries_flags == other.enabled_entries_flags; }
+{
+    return enabled_entries_flags == other.enabled_entries_flags;
+}
 
 bool EntryClass::operator<(const EntryClass &other) const
-{ return enabled_entries_flags < other.enabled_entries_flags; }
+{
+    return enabled_entries_flags < other.enabled_entries_flags;
+}
 
 } // namespace osrm::util::guidance
diff --git a/src/util/guidance/turn_lanes.cpp b/src/util/guidance/turn_lanes.cpp
index 01eba996995..e44dca9d5e7 100644
--- a/src/util/guidance/turn_lanes.cpp
+++ b/src/util/guidance/turn_lanes.cpp
@@ -24,6 +24,8 @@ bool LaneTuple::operator==(const LaneTuple other) const
 bool LaneTuple::operator!=(const LaneTuple other) const { return !(*this == other); }
 
 bool LaneTupleIdPair::operator==(const LaneTupleIdPair &other) const
-{ return other.first == first && other.second == second; }
+{
+    return other.first == first && other.second == second;
+}
 
 } // namespace osrm::util::guidance
diff --git a/src/util/log.cpp b/src/util/log.cpp
index b8e691e703c..b66add48783 100644
--- a/src/util/log.cpp
+++ b/src/util/log.cpp
@@ -160,5 +160,7 @@ Log::~Log()
 
 UnbufferedLog::UnbufferedLog(LogLevel level_)
     : Log(level_, (level_ == logWARNING || level_ == logERROR) ? std::cerr : std::cout)
-{ stream.flags(std::ios_base::unitbuf); }
+{
+    stream.flags(std::ios_base::unitbuf);
+}
 } // namespace osrm::util
diff --git a/src/util/opening_hours.cpp b/src/util/opening_hours.cpp
index 6bdfa8220c6..5e913dcf1c3 100644
--- a/src/util/opening_hours.cpp
+++ b/src/util/opening_hours.cpp
@@ -76,7 +76,9 @@ inline std::ostream &operator<<(std::ostream &stream, const OpeningHours::Time &
 }
 
 inline std::ostream &operator<<(std::ostream &stream, const OpeningHours::TimeSpan &value)
-{ return stream << value.from << "-" << value.to; }
+{
+    return stream << value.from << "-" << value.to;
+}
 
 inline std::ostream &operator<<(std::ostream &stream, const OpeningHours::Monthday &value)
 {
@@ -105,7 +107,9 @@ inline std::ostream &operator<<(std::ostream &stream, const OpeningHours::Weekda
 }
 
 inline std::ostream &operator<<(std::ostream &stream, const OpeningHours::MonthdayRange &value)
-{ return stream << value.from << "-" << value.to; }
+{
+    return stream << value.from << "-" << value.to;
+}
 
 inline std::ostream &operator<<(std::ostream &stream, const OpeningHours &value)
 {
diff --git a/unit_tests/engine/offline_facade.cpp b/unit_tests/engine/offline_facade.cpp
index f0964fbe236..161518dbd5d 100644
--- a/unit_tests/engine/offline_facade.cpp
+++ b/unit_tests/engine/offline_facade.cpp
@@ -80,10 +80,14 @@ struct ExternalCellStorage
     struct CellImpl
     {
         auto GetOutWeight(NodeID /*node*/) const
-        { return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0); }
+        {
+            return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0);
+        }
 
         auto GetInWeight(NodeID /*node*/) const
-        { return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0); }
+        {
+            return std::ranges::subrange((EdgeWeight *)0, (EdgeWeight *)0);
+        }
 
         auto GetSourceNodes() const { return std::ranges::subrange((NodeID *)0, (NodeID *)0); }
 
@@ -130,7 +134,9 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     const auto &GetCellMetric() const { return external_cell_metric; }
 
     auto GetBorderEdgeRange(const LevelID /*level*/, const NodeID /*node*/) const
-    { return util::irange<EdgeID>(0, 0); }
+    {
+        return util::irange<EdgeID>(0, 0);
+    }
 
     EdgeID FindEdge(const NodeID /*from*/, const NodeID /*to*/) const { return SPECIAL_EDGEID; }
 
@@ -138,54 +144,84 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
 
     // node and edge information access
     util::Coordinate GetCoordinateOfNode(const NodeID /*id*/) const override
-    { return {osrm::util::FloatLongitude{7.437069}, osrm::util::FloatLatitude{43.749249}}; }
+    {
+        return {osrm::util::FloatLongitude{7.437069}, osrm::util::FloatLatitude{43.749249}};
+    }
 
     OSMNodeID GetOSMNodeIDOfNode(const NodeID /*id*/) const override { return OSMNodeID(); }
 
     GeometryID GetGeometryIndex(const NodeID /*id*/) const override { return GeometryID{0, false}; }
 
     NodeForwardRange GetUncompressedForwardGeometry(const EdgeID /*id*/) const override
-    { return {}; }
+    {
+        return {};
+    }
 
     NodeReverseRange GetUncompressedReverseGeometry(const EdgeID /*id*/) const override
-    { return NodeReverseRange(NodeForwardRange()); }
+    {
+        return NodeReverseRange(NodeForwardRange());
+    }
 
     TurnPenalty GetWeightPenaltyForEdgeID(const unsigned /*id*/) const override
-    { return INVALID_TURN_PENALTY; }
+    {
+        return INVALID_TURN_PENALTY;
+    }
 
     TurnPenalty GetDurationPenaltyForEdgeID(const unsigned /*id*/) const override
-    { return INVALID_TURN_PENALTY; }
+    {
+        return INVALID_TURN_PENALTY;
+    }
 
     WeightForwardRange GetUncompressedForwardWeights(const EdgeID /*id*/) const override
-    { return {}; }
+    {
+        return {};
+    }
 
     WeightReverseRange GetUncompressedReverseWeights(const EdgeID /*id*/) const override
-    { return WeightReverseRange(WeightForwardRange()); }
+    {
+        return WeightReverseRange(WeightForwardRange());
+    }
 
     DurationForwardRange GetUncompressedForwardDurations(const EdgeID /*geomID*/) const override
-    { return {}; }
+    {
+        return {};
+    }
 
     DurationReverseRange GetUncompressedReverseDurations(const EdgeID /*geomID*/) const override
-    { return DurationReverseRange(DurationForwardRange()); }
+    {
+        return DurationReverseRange(DurationForwardRange());
+    }
 
     DatasourceForwardRange GetUncompressedForwardDatasources(const EdgeID /*id*/) const override
-    { return {}; }
+    {
+        return {};
+    }
 
     DatasourceReverseRange GetUncompressedReverseDatasources(const EdgeID /*id*/) const override
-    { return DatasourceReverseRange(DatasourceForwardRange()); }
+    {
+        return DatasourceReverseRange(DatasourceForwardRange());
+    }
 
     std::string_view GetDatasourceName(const DatasourceID /*id*/) const override
-    { return std::string_view{}; }
+    {
+        return std::string_view{};
+    }
 
     guidance::TurnInstruction GetTurnInstructionForEdgeID(const EdgeID /*id*/) const override
-    { return guidance::TurnInstruction{}; }
+    {
+        return guidance::TurnInstruction{};
+    }
 
     extractor::TravelMode GetTravelMode(const NodeID /*id*/) const override
-    { return extractor::TRAVEL_MODE_DRIVING; }
+    {
+        return extractor::TRAVEL_MODE_DRIVING;
+    }
 
     std::vector<RTreeLeaf> GetEdgesInBox(const util::Coordinate /*south_west*/,
                                          const util::Coordinate /*north_east*/) const override
-    { return {}; }
+    {
+        return {};
+    }
 
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate /*input_coordinate*/,
@@ -193,7 +229,9 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
                                const std::optional<engine::Bearing> /*bearing*/,
                                const engine::Approach /*approach*/,
                                const bool /*use_all_edges*/) const override
-    { return {}; };
+    {
+        return {};
+    };
 
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate /*input_coordinate*/,
@@ -201,7 +239,9 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
                         const std::optional<double> /*max_distance*/,
                         const std::optional<engine::Bearing> /*bearing*/,
                         const engine::Approach /*approach*/) const override
-    { return {}; };
+    {
+        return {};
+    };
 
     engine::PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
         const util::Coordinate /*input_coordinate*/,
@@ -209,14 +249,20 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
         const std::optional<engine::Bearing> /*bearing*/,
         const engine::Approach /*approach*/,
         const bool /*use_all_edges*/) const override
-    { return {}; };
+    {
+        return {};
+    };
 
     util::guidance::LaneTupleIdPair GetLaneData(const EdgeID /*id*/) const override
-    { return util::guidance::LaneTupleIdPair{}; }
+    {
+        return util::guidance::LaneTupleIdPair{};
+    }
 
     extractor::TurnLaneDescription
     GetTurnDescription(const LaneDescriptionID /*laneDescriptionID*/) const override
-    { return {}; }
+    {
+        return {};
+    }
 
     EdgeWeight GetNodeWeight(const NodeID /*node*/) const { return {0}; }
 
@@ -227,15 +273,25 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     bool HasLaneData(const EdgeID /*id*/) const override { return false; }
     StringViewID GetNameIndex(const NodeID /*nodeID*/) const override { return EMPTY_STRINGVIEWID; }
     std::string_view GetNameForID(const StringViewID /*id*/) const override
-    { return std::string_view{}; }
+    {
+        return std::string_view{};
+    }
     std::string_view GetRefForID(const StringViewID /*id*/) const override
-    { return std::string_view{}; }
+    {
+        return std::string_view{};
+    }
     std::string_view GetPronunciationForID(const StringViewID /*id*/) const override
-    { return std::string_view{}; }
+    {
+        return std::string_view{};
+    }
     std::string_view GetDestinationsForID(const StringViewID /*id*/) const override
-    { return std::string_view{}; }
+    {
+        return std::string_view{};
+    }
     std::string_view GetExitsForID(const StringViewID /*id*/) const override
-    { return std::string_view{}; }
+    {
+        return std::string_view{};
+    }
     bool GetContinueStraightDefault() const override { return false; }
     std::string GetTimestamp() const override { return ""; }
     double GetMapMatchingMaxSpeed() const override { return 0; }
@@ -247,18 +303,26 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     bool ExcludeNode(const NodeID) const override { return false; }
 
     guidance::TurnBearing PreTurnBearing(const EdgeID /*eid*/) const override
-    { return guidance::TurnBearing(0); }
+    {
+        return guidance::TurnBearing(0);
+    }
 
     guidance::TurnBearing PostTurnBearing(const EdgeID /*eid*/) const override
-    { return guidance::TurnBearing(0); }
+    {
+        return guidance::TurnBearing(0);
+    }
 
     util::guidance::BearingClass
     GetBearingClass(const BearingClassID /*bearing_class_id*/) const override
-    { return util::guidance::BearingClass{}; }
+    {
+        return util::guidance::BearingClass{};
+    }
 
     osrm::extractor::ClassData GetClassData(const NodeID /*id*/) const override { return 0; }
     std::vector<std::string> GetClasses(const extractor::ClassData /*class_data*/) const override
-    { return {}; }
+    {
+        return {};
+    }
 
     util::guidance::EntryClass GetEntryClass(const EdgeID /*turn_id*/) const override { return {}; }
     bool IsLeftHandDriving(const NodeID /*id*/) const override { return false; }
@@ -266,7 +330,9 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
 
     std::vector<extractor::ManeuverOverride>
     GetOverridesThatStartAt(const NodeID /* edge_based_node_id */) const override
-    { return {}; }
+    {
+        return {};
+    }
 };
 
 } // namespace datafacade
@@ -303,7 +369,9 @@ void unpackPath(const FacadeT &facade,
                 RandomIter packed_path_end,
                 const PhantomEndpoints &endpoints,
                 std::vector<PathData> &unpacked_path)
-{ mld::unpackPath(facade, packed_path_begin, packed_path_end, endpoints, unpacked_path); }
+{
+    mld::unpackPath(facade, packed_path_begin, packed_path_end, endpoints, unpacked_path);
+}
 
 } // namespace routing_algorithms::offline
 
diff --git a/unit_tests/extractor/car_profile_width_penalty.cpp b/unit_tests/extractor/car_profile_width_penalty.cpp
index de9fd3653d9..4bf06d2f19c 100644
--- a/unit_tests/extractor/car_profile_width_penalty.cpp
+++ b/unit_tests/extractor/car_profile_width_penalty.cpp
@@ -59,7 +59,9 @@ process_way(std::initializer_list<std::pair<const char *, const char *>> tags)
 }
 
 double forward_rate_for_width(const char *width)
-{ return process_way({{"highway", "primary"}, {"width", width}}).forward_rate; }
+{
+    return process_way({{"highway", "primary"}, {"width", width}}).forward_rate;
+}
 
 } // namespace
 
diff --git a/unit_tests/extractor/restriction_graph.cpp b/unit_tests/extractor/restriction_graph.cpp
index d27fe7ab7ff..b5c24694f14 100644
--- a/unit_tests/extractor/restriction_graph.cpp
+++ b/unit_tests/extractor/restriction_graph.cpp
@@ -38,7 +38,9 @@ std::ostream &operator<<(std::ostream &os, const instruction &in)
 }
 
 bool operator==(const instruction &lhs, const instruction &rhs) noexcept
-{ return lhs.to == rhs.to && lhs.is_only == rhs.is_only; }
+{
+    return lhs.to == rhs.to && lhs.is_only == rhs.is_only;
+}
 
 bool operator!=(const instruction &lhs, const instruction &rhs) noexcept { return !(lhs == rhs); }
 
@@ -46,12 +48,12 @@ void checkInstructions(RestrictionGraph::RestrictionRange restrictions,
                        std::vector<instruction> expected_instructions)
 {
     std::vector<instruction> actual_instructions;
-    std::transform(
-        restrictions.begin(),
-        restrictions.end(),
-        std::back_inserter(actual_instructions),
-        [](const auto &restriction)
-        { return instruction{restriction->turn_path.To(), bool(restriction->is_only)}; });
+    std::transform(restrictions.begin(),
+                   restrictions.end(),
+                   std::back_inserter(actual_instructions),
+                   [](const auto &restriction) {
+                       return instruction{restriction->turn_path.To(), bool(restriction->is_only)};
+                   });
     std::sort(actual_instructions.begin(),
               actual_instructions.end(),
               [](const auto &lhs, const auto &rhs)
diff --git a/unit_tests/extractor/turn_lane_matcher_tests.cpp b/unit_tests/extractor/turn_lane_matcher_tests.cpp
index 59ff2f33ac9..22368d4d43e 100644
--- a/unit_tests/extractor/turn_lane_matcher_tests.cpp
+++ b/unit_tests/extractor/turn_lane_matcher_tests.cpp
@@ -18,7 +18,9 @@ namespace IntersectionDetail = osrm::extractor::intersection;
 
 // Helper to create a TurnInstruction with given type and direction modifier.
 TurnInstruction makeInstruction(TurnType::Enum type, DirectionModifier::Enum modifier)
-{ return {type, modifier}; }
+{
+    return {type, modifier};
+}
 
 // Helper to create a ConnectedRoad.
 // eid, entry_allowed, angle, instruction, lane_data_id
@@ -98,7 +100,9 @@ makeGraph(const std::vector<std::tuple<NodeID, NodeID, bool>> &edges, NodeID num
 BOOST_AUTO_TEST_SUITE(TurnLaneMatcherGetMatchingModifier)
 
 BOOST_AUTO_TEST_CASE(uturn_tag_maps_to_uturn)
-{ BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::uturn), DirectionModifier::UTurn); }
+{
+    BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::uturn), DirectionModifier::UTurn);
+}
 
 BOOST_AUTO_TEST_CASE(sharp_right_tag_maps_to_sharp_right)
 {
@@ -107,7 +111,9 @@ BOOST_AUTO_TEST_CASE(sharp_right_tag_maps_to_sharp_right)
 }
 
 BOOST_AUTO_TEST_CASE(right_tag_maps_to_right)
-{ BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::right), DirectionModifier::Right); }
+{
+    BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::right), DirectionModifier::Right);
+}
 
 BOOST_AUTO_TEST_CASE(slight_right_tag_maps_to_slight_right)
 {
@@ -116,7 +122,9 @@ BOOST_AUTO_TEST_CASE(slight_right_tag_maps_to_slight_right)
 }
 
 BOOST_AUTO_TEST_CASE(straight_tag_maps_to_straight)
-{ BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::straight), DirectionModifier::Straight); }
+{
+    BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::straight), DirectionModifier::Straight);
+}
 
 BOOST_AUTO_TEST_CASE(slight_left_tag_maps_to_slight_left)
 {
@@ -125,10 +133,14 @@ BOOST_AUTO_TEST_CASE(slight_left_tag_maps_to_slight_left)
 }
 
 BOOST_AUTO_TEST_CASE(left_tag_maps_to_left)
-{ BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::left), DirectionModifier::Left); }
+{
+    BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::left), DirectionModifier::Left);
+}
 
 BOOST_AUTO_TEST_CASE(sharp_left_tag_maps_to_sharp_left)
-{ BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::sharp_left), DirectionModifier::SharpLeft); }
+{
+    BOOST_CHECK_EQUAL(getMatchingModifier(TurnLaneType::sharp_left), DirectionModifier::SharpLeft);
+}
 
 BOOST_AUTO_TEST_CASE(merge_to_left_tag_maps_to_straight)
 {
diff --git a/unit_tests/library/limits.cpp b/unit_tests/library/limits.cpp
index 34ccd3d7b54..cedbef4cb09 100644
--- a/unit_tests/library/limits.cpp
+++ b/unit_tests/library/limits.cpp
@@ -15,7 +15,9 @@
 namespace
 {
 osrm::util::Coordinate getZeroCoordinate()
-{ return {osrm::util::FloatLongitude{0}, osrm::util::FloatLatitude{0}}; }
+{
+    return {osrm::util::FloatLongitude{0}, osrm::util::FloatLatitude{0}};
+}
 } // namespace
 
 BOOST_AUTO_TEST_SUITE(limits)
diff --git a/unit_tests/library/nearest.cpp b/unit_tests/library/nearest.cpp
index b728f1eda20..a42cc7e1822 100644
--- a/unit_tests/library/nearest.cpp
+++ b/unit_tests/library/nearest.cpp
@@ -77,9 +77,13 @@ void test_nearest_response_skip_waypoints(bool use_json_only_api)
     BOOST_CHECK(!json_result.values.contains("waypoints"));
 }
 BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints_old_api)
-{ test_nearest_response_skip_waypoints(true); }
+{
+    test_nearest_response_skip_waypoints(true);
+}
 BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints_new_api)
-{ test_nearest_response_skip_waypoints(false); }
+{
+    test_nearest_response_skip_waypoints(false);
+}
 
 void test_nearest_response_no_coordinates(bool use_json_only_api)
 {
@@ -97,9 +101,13 @@ void test_nearest_response_no_coordinates(bool use_json_only_api)
     BOOST_CHECK_EQUAL(code, "InvalidOptions");
 }
 BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates_old_api)
-{ test_nearest_response_no_coordinates(true); }
+{
+    test_nearest_response_no_coordinates(true);
+}
 BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates_new_api)
-{ test_nearest_response_no_coordinates(false); }
+{
+    test_nearest_response_no_coordinates(false);
+}
 
 void test_nearest_response_multiple_coordinates(bool use_json_only_api)
 {
@@ -119,9 +127,13 @@ void test_nearest_response_multiple_coordinates(bool use_json_only_api)
     BOOST_CHECK_EQUAL(code, "InvalidOptions");
 }
 BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates_old_api)
-{ test_nearest_response_multiple_coordinates(true); }
+{
+    test_nearest_response_multiple_coordinates(true);
+}
 BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates_new_api)
-{ test_nearest_response_multiple_coordinates(false); }
+{
+    test_nearest_response_multiple_coordinates(false);
+}
 
 void test_nearest_response_for_location_in_small_component(bool use_json_only_api)
 {
@@ -161,9 +173,13 @@ void test_nearest_response_for_location_in_small_component(bool use_json_only_ap
     }
 }
 BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component_old_api)
-{ test_nearest_response_for_location_in_small_component(true); }
+{
+    test_nearest_response_for_location_in_small_component(true);
+}
 BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component_new_api)
-{ test_nearest_response_for_location_in_small_component(false); }
+{
+    test_nearest_response_for_location_in_small_component(false);
+}
 
 BOOST_AUTO_TEST_CASE(test_nearest_fb_serialization)
 {
diff --git a/unit_tests/library/route.cpp b/unit_tests/library/route.cpp
index dacc3fd3b1c..0da1e77ed85 100644
--- a/unit_tests/library/route.cpp
+++ b/unit_tests/library/route.cpp
@@ -130,9 +130,13 @@ void test_route_same_coordinates_fixture(bool use_json_only_api)
     CHECK_EQUAL_JSON(reference, json_result);
 }
 BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture_old_api)
-{ test_route_same_coordinates_fixture(true); }
+{
+    test_route_same_coordinates_fixture(true);
+}
 BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture_new_api)
-{ test_route_same_coordinates_fixture(false); }
+{
+    test_route_same_coordinates_fixture(false);
+}
 
 void test_route_same_coordinates(bool use_json_only_api)
 {
@@ -339,9 +343,13 @@ void test_route_same_coordinates_no_waypoints(bool use_json_only_api)
     }
 }
 BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints_old_api)
-{ test_route_same_coordinates_no_waypoints(true); }
+{
+    test_route_same_coordinates_no_waypoints(true);
+}
 BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints_new_api)
-{ test_route_same_coordinates_no_waypoints(false); }
+{
+    test_route_same_coordinates_no_waypoints(false);
+}
 
 void test_route_response_for_locations_in_small_component(bool use_json_only_api)
 {
@@ -378,9 +386,13 @@ void test_route_response_for_locations_in_small_component(bool use_json_only_api
     }
 }
 BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component_old_api)
-{ test_route_response_for_locations_in_small_component(true); }
+{
+    test_route_response_for_locations_in_small_component(true);
+}
 BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component_new_api)
-{ test_route_response_for_locations_in_small_component(false); }
+{
+    test_route_response_for_locations_in_small_component(false);
+}
 
 void test_route_response_for_locations_in_big_component(bool use_json_only_api)
 {
@@ -417,9 +429,13 @@ void test_route_response_for_locations_in_big_component(bool use_json_only_api)
     }
 }
 BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component_old_api)
-{ test_route_response_for_locations_in_big_component(true); }
+{
+    test_route_response_for_locations_in_big_component(true);
+}
 BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component_new_api)
-{ test_route_response_for_locations_in_big_component(false); }
+{
+    test_route_response_for_locations_in_big_component(false);
+}
 
 void test_route_response_for_locations_across_components(bool use_json_only_api)
 {
@@ -458,9 +474,13 @@ void test_route_response_for_locations_across_components(bool use_json_only_api)
     }
 }
 BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components_old_api)
-{ test_route_response_for_locations_across_components(true); }
+{
+    test_route_response_for_locations_across_components(true);
+}
 BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components_new_api)
-{ test_route_response_for_locations_across_components(false); }
+{
+    test_route_response_for_locations_across_components(false);
+}
 
 void test_route_user_disables_generating_hints(bool use_json_only_api)
 {
@@ -482,9 +502,13 @@ void test_route_user_disables_generating_hints(bool use_json_only_api)
         BOOST_CHECK_EQUAL(std::get<json::Object>(waypoint).values.count("hint"), 0);
 }
 BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints_old_api)
-{ test_route_user_disables_generating_hints(true); }
+{
+    test_route_user_disables_generating_hints(true);
+}
 BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints_new_api)
-{ test_route_user_disables_generating_hints(false); }
+{
+    test_route_user_disables_generating_hints(false);
+}
 
 void speed_annotation_matches_duration_and_distance(bool use_json_only_api)
 {
@@ -529,9 +553,13 @@ void speed_annotation_matches_duration_and_distance(bool use_json_only_api)
     }
 }
 BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance_old_api)
-{ speed_annotation_matches_duration_and_distance(true); }
+{
+    speed_annotation_matches_duration_and_distance(true);
+}
 BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance_new_api)
-{ speed_annotation_matches_duration_and_distance(false); }
+{
+    speed_annotation_matches_duration_and_distance(false);
+}
 
 void test_manual_setting_of_annotations_property(bool use_json_only_api)
 {
@@ -564,9 +592,13 @@ void test_manual_setting_of_annotations_property(bool use_json_only_api)
     BOOST_CHECK_EQUAL(annotations.size(), 7);
 }
 BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property_old_api)
-{ test_manual_setting_of_annotations_property(true); }
+{
+    test_manual_setting_of_annotations_property(true);
+}
 BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property_new_api)
-{ test_manual_setting_of_annotations_property(false); }
+{
+    test_manual_setting_of_annotations_property(false);
+}
 
 BOOST_AUTO_TEST_CASE(test_route_serialize_fb)
 {
@@ -836,9 +868,13 @@ void test_route_json_overview_by_legs(bool use_json_only_api)
     }
 }
 BOOST_AUTO_TEST_CASE(test_route_json_overview_by_legs_old_api)
-{ test_route_json_overview_by_legs(true); }
+{
+    test_route_json_overview_by_legs(true);
+}
 BOOST_AUTO_TEST_CASE(test_route_json_overview_by_legs_new_api)
-{ test_route_json_overview_by_legs(false); }
+{
+    test_route_json_overview_by_legs(false);
+}
 
 BOOST_AUTO_TEST_CASE(test_route_json_overview_full_no_leg_geometry)
 {
diff --git a/unit_tests/library/table.cpp b/unit_tests/library/table.cpp
index 8a18a387b3a..b4148dda774 100644
--- a/unit_tests/library/table.cpp
+++ b/unit_tests/library/table.cpp
@@ -88,9 +88,13 @@ void test_table_three_coords_one_source_one_dest_matrix(bool use_json_only_api)
     }
 }
 BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_old_api)
-{ test_table_three_coords_one_source_one_dest_matrix(true); }
+{
+    test_table_three_coords_one_source_one_dest_matrix(true);
+}
 BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_new_api)
-{ test_table_three_coords_one_source_one_dest_matrix(false); }
+{
+    test_table_three_coords_one_source_one_dest_matrix(false);
+}
 
 void test_table_three_coords_one_source_one_dest_matrix_no_waypoints(bool use_json_only_api)
 {
@@ -141,9 +145,13 @@ void test_table_three_coords_one_source_one_dest_matrix_no_waypoints(bool use_js
     BOOST_CHECK(!json_result.values.contains("sources"));
 }
 BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypoints_old_api)
-{ test_table_three_coords_one_source_one_dest_matrix_no_waypoints(true); }
+{
+    test_table_three_coords_one_source_one_dest_matrix_no_waypoints(true);
+}
 BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypoints_new_api)
-{ test_table_three_coords_one_source_one_dest_matrix_no_waypoints(false); }
+{
+    test_table_three_coords_one_source_one_dest_matrix_no_waypoints(false);
+}
 
 void test_table_three_coords_one_source_matrix(bool use_json_only_api)
 {
@@ -193,9 +201,13 @@ void test_table_three_coords_one_source_matrix(bool use_json_only_api)
     }
 }
 BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix_old_api)
-{ test_table_three_coords_one_source_matrix(true); }
+{
+    test_table_three_coords_one_source_matrix(true);
+}
 BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix_new_api)
-{ test_table_three_coords_one_source_matrix(false); }
+{
+    test_table_three_coords_one_source_matrix(false);
+}
 
 void test_table_three_coordinates_matrix(bool use_json_only_api)
 {
@@ -240,9 +252,13 @@ void test_table_three_coordinates_matrix(bool use_json_only_api)
     }
 }
 BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix_old_api)
-{ test_table_three_coordinates_matrix(true); }
+{
+    test_table_three_coordinates_matrix(true);
+}
 BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix_new_api)
-{ test_table_three_coordinates_matrix(false); }
+{
+    test_table_three_coordinates_matrix(false);
+}
 
 // See https://github.com/Project-OSRM/osrm-backend/pull/3992
 void test_table_no_segment_for_some_coordinates(bool use_json_only_api)
@@ -268,9 +284,13 @@ void test_table_no_segment_for_some_coordinates(bool use_json_only_api)
     BOOST_CHECK_EQUAL(message, "Could not find a matching segment for coordinate 0");
 }
 BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates_old_api)
-{ test_table_no_segment_for_some_coordinates(true); }
+{
+    test_table_no_segment_for_some_coordinates(true);
+}
 BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates_new_api)
-{ test_table_no_segment_for_some_coordinates(false); }
+{
+    test_table_no_segment_for_some_coordinates(false);
+}
 
 BOOST_AUTO_TEST_CASE(test_table_serialiaze_fb)
 {
diff --git a/unit_tests/library/tile.cpp b/unit_tests/library/tile.cpp
index a1d23cd79f0..7b3933ec215 100644
--- a/unit_tests/library/tile.cpp
+++ b/unit_tests/library/tile.cpp
@@ -42,7 +42,9 @@ BOOST_AUTO_TEST_SUITE(tile)
 using variant_type = std::variant<std::string, float, double, int64_t, uint64_t, bool>;
 
 std::string to_string(const protozero::data_view &view)
-{ return std::string{view.data(), view.size()}; }
+{
+    return std::string{view.data(), view.size()};
+}
 
 void validate_feature_layer(vtzero::layer layer)
 {
@@ -327,9 +329,13 @@ void test_tile_turns_ch(osrm::EngineConfig::Algorithm algorithm, bool use_string
     test_tile_turns(osrm, use_string_only_api);
 }
 BOOST_AUTO_TEST_CASE(test_tile_turns_ch_old_api)
-{ test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, true); }
+{
+    test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, true);
+}
 BOOST_AUTO_TEST_CASE(test_tile_turns_ch_new_api)
-{ test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, false); }
+{
+    test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, false);
+}
 
 void test_tile_turns_mld(bool use_string_only_api)
 {
@@ -400,9 +406,13 @@ void test_tile_speeds_ch(osrm::EngineConfig::Algorithm algorithm, bool use_strin
     test_tile_speeds(osrm, use_string_only_api);
 }
 BOOST_AUTO_TEST_CASE(test_tile_speeds_ch_old_api)
-{ test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, true); }
+{
+    test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, true);
+}
 BOOST_AUTO_TEST_CASE(test_tile_speeds_ch_new_api)
-{ test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, false); }
+{
+    test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, false);
+}
 
 void test_tile_speeds_mld(bool use_string_only_api)
 {
@@ -457,9 +467,13 @@ void test_tile_nodes_ch(osrm::EngineConfig::Algorithm algorithm, bool use_string
     test_tile_nodes(osrm, use_string_only_api);
 }
 BOOST_AUTO_TEST_CASE(test_tile_node_ch_old_api)
-{ test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, true); }
+{
+    test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, true);
+}
 BOOST_AUTO_TEST_CASE(test_tile_node_ch_new_api)
-{ test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, false); }
+{
+    test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, false);
+}
 
 void test_tile_nodes_mld(bool use_string_only_api)
 {
diff --git a/unit_tests/library/trip.cpp b/unit_tests/library/trip.cpp
index 88e1e71f54a..10d0d3fe7f6 100644
--- a/unit_tests/library/trip.cpp
+++ b/unit_tests/library/trip.cpp
@@ -70,9 +70,13 @@ void test_roundtrip_response_for_locations_in_small_component(bool use_json_only
     }
 }
 BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_old_api)
-{ test_roundtrip_response_for_locations_in_small_component(true); }
+{
+    test_roundtrip_response_for_locations_in_small_component(true);
+}
 BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_new_api)
-{ test_roundtrip_response_for_locations_in_small_component(false); }
+{
+    test_roundtrip_response_for_locations_in_small_component(false);
+}
 
 void test_roundtrip_response_for_locations_in_small_component_skip_waypoints(bool use_json_only_api)
 {
@@ -98,10 +102,14 @@ void test_roundtrip_response_for_locations_in_small_component_skip_waypoints(boo
 }
 BOOST_AUTO_TEST_CASE(
     test_roundtrip_response_for_locations_in_small_component_skip_waypoints_old_api)
-{ test_roundtrip_response_for_locations_in_small_component_skip_waypoints(true); }
+{
+    test_roundtrip_response_for_locations_in_small_component_skip_waypoints(true);
+}
 BOOST_AUTO_TEST_CASE(
     test_roundtrip_response_for_locations_in_small_component_skip_waypoints_new_api)
-{ test_roundtrip_response_for_locations_in_small_component_skip_waypoints(false); }
+{
+    test_roundtrip_response_for_locations_in_small_component_skip_waypoints(false);
+}
 
 void test_roundtrip_response_for_locations_in_big_component(bool use_json_only_api)
 {
@@ -145,9 +153,13 @@ void test_roundtrip_response_for_locations_in_big_component(bool use_json_only_a
     }
 }
 BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component_old_api)
-{ test_roundtrip_response_for_locations_in_big_component(true); }
+{
+    test_roundtrip_response_for_locations_in_big_component(true);
+}
 BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component_new_api)
-{ test_roundtrip_response_for_locations_in_big_component(false); }
+{
+    test_roundtrip_response_for_locations_in_big_component(false);
+}
 
 void test_roundtrip_response_for_locations_across_components(bool use_json_only_api)
 {
@@ -195,9 +207,13 @@ void test_roundtrip_response_for_locations_across_components(bool use_json_only_
     }
 }
 BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components_old_api)
-{ test_roundtrip_response_for_locations_across_components(true); }
+{
+    test_roundtrip_response_for_locations_across_components(true);
+}
 BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components_new_api)
-{ test_roundtrip_response_for_locations_across_components(false); }
+{
+    test_roundtrip_response_for_locations_across_components(false);
+}
 
 void test_tfse_1(bool use_json_only_api)
 {
diff --git a/unit_tests/mocks/mock_datafacade.hpp b/unit_tests/mocks/mock_datafacade.hpp
index f66fbb367a6..2f1142b6e87 100644
--- a/unit_tests/mocks/mock_datafacade.hpp
+++ b/unit_tests/mocks/mock_datafacade.hpp
@@ -28,17 +28,27 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     bool ExcludeNode(const NodeID) const override { return false; };
 
     util::Coordinate GetCoordinateOfNode(const NodeID /* id */) const override
-    { return {util::FixedLongitude{0}, util::FixedLatitude{0}}; }
+    {
+        return {util::FixedLongitude{0}, util::FixedLatitude{0}};
+    }
     OSMNodeID GetOSMNodeIDOfNode(const NodeID /* id */) const override { return OSMNodeID{0}; }
     bool EdgeIsCompressed(const EdgeID /* id */) const { return false; }
     GeometryID GetGeometryIndex(const NodeID /* id */) const override
-    { return GeometryID{SPECIAL_GEOMETRYID, false}; }
+    {
+        return GeometryID{SPECIAL_GEOMETRYID, false};
+    }
     ComponentID GetComponentID(const NodeID /* id */) const override
-    { return ComponentID{INVALID_COMPONENTID, false}; }
+    {
+        return ComponentID{INVALID_COMPONENTID, false};
+    }
     TurnPenalty GetWeightPenaltyForEdgeID(const unsigned /* id */) const override final
-    { return {0}; }
+    {
+        return {0};
+    }
     TurnPenalty GetDurationPenaltyForEdgeID(const unsigned /* id */) const override final
-    { return {0}; }
+    {
+        return {0};
+    }
     std::string GetTimestamp() const override { return ""; }
     NodeForwardRange GetUncompressedForwardGeometry(const EdgeID /* id */) const override
     {
@@ -47,7 +57,9 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
         return NodeForwardRange{nodes.data(), nodes.size()};
     }
     NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const override
-    { return NodeReverseRange(GetUncompressedForwardGeometry(id)); }
+    {
+        return NodeReverseRange(GetUncompressedForwardGeometry(id));
+    }
     WeightForwardRange GetUncompressedForwardWeights(const EdgeID /* id */) const override
     {
         static std::uint64_t data[] = {1, 2, 3};
@@ -56,7 +68,9 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
         return WeightForwardRange(weights.begin(), weights.end());
     }
     WeightReverseRange GetUncompressedReverseWeights(const EdgeID id) const override
-    { return WeightReverseRange(GetUncompressedForwardWeights(id)); }
+    {
+        return WeightReverseRange(GetUncompressedForwardWeights(id));
+    }
     DurationForwardRange GetUncompressedForwardDurations(const EdgeID /*id*/) const override
     {
         static std::uint64_t data[] = {1, 2, 3};
@@ -65,20 +79,30 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
         return DurationForwardRange(durations.begin(), durations.end());
     }
     DurationReverseRange GetUncompressedReverseDurations(const EdgeID id) const override
-    { return DurationReverseRange(GetUncompressedForwardDurations(id)); }
+    {
+        return DurationReverseRange(GetUncompressedForwardDurations(id));
+    }
     DatasourceForwardRange GetUncompressedForwardDatasources(const EdgeID /*id*/) const override
-    { return {}; }
+    {
+        return {};
+    }
     DatasourceReverseRange GetUncompressedReverseDatasources(const EdgeID /*id*/) const override
-    { return DatasourceReverseRange(DatasourceForwardRange()); }
+    {
+        return DatasourceReverseRange(DatasourceForwardRange());
+    }
 
     std::string_view GetDatasourceName(const DatasourceID) const override final { return {}; }
 
     osrm::guidance::TurnInstruction
     GetTurnInstructionForEdgeID(const EdgeID /* id */) const override
-    { return osrm::guidance::TurnInstruction::NO_TURN(); }
+    {
+        return osrm::guidance::TurnInstruction::NO_TURN();
+    }
     std::vector<RTreeLeaf> GetEdgesInBox(const util::Coordinate /* south_west */,
                                          const util::Coordinate /*north_east */) const override
-    { return {}; }
+    {
+        return {};
+    }
 
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::Coordinate /*input_coordinate*/,
@@ -86,7 +110,9 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
                                const std::optional<engine::Bearing> /*bearing*/,
                                const engine::Approach /*approach*/,
                                const bool /*use_all_edges*/) const override
-    { return {}; };
+    {
+        return {};
+    };
 
     std::vector<engine::PhantomNodeWithDistance>
     NearestPhantomNodes(const util::Coordinate /*input_coordinate*/,
@@ -94,7 +120,9 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
                         const std::optional<double> /*max_distance*/,
                         const std::optional<engine::Bearing> /*bearing*/,
                         const engine::Approach /*approach*/) const override
-    { return {}; };
+    {
+        return {};
+    };
 
     engine::PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
         const util::Coordinate /*input_coordinate*/,
@@ -102,17 +130,23 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
         const std::optional<engine::Bearing> /*bearing*/,
         const engine::Approach /*approach*/,
         const bool /*use_all_edges*/) const override
-    { return {}; };
+    {
+        return {};
+    };
 
     std::uint32_t GetCheckSum() const override { return 0; }
 
     extractor::TravelMode GetTravelMode(const NodeID /* id */) const override
-    { return extractor::TRAVEL_MODE_INACCESSIBLE; }
+    {
+        return extractor::TRAVEL_MODE_INACCESSIBLE;
+    }
 
     extractor::ClassData GetClassData(const NodeID /*id*/) const override final { return 0; }
 
     std::vector<std::string> GetClasses(const extractor::ClassData /*data*/) const override final
-    { return {}; }
+    {
+        return {};
+    }
 
     StringViewID GetNameIndex(const NodeID /* id */) const override { return 0; }
 
@@ -132,16 +166,24 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     bool IsSegregated(const NodeID /*id*/) const override { return false; }
 
     guidance::TurnBearing PreTurnBearing(const EdgeID /*eid*/) const override final
-    { return guidance::TurnBearing{0.0}; }
+    {
+        return guidance::TurnBearing{0.0};
+    }
     guidance::TurnBearing PostTurnBearing(const EdgeID /*eid*/) const override final
-    { return guidance::TurnBearing{0.0}; }
+    {
+        return guidance::TurnBearing{0.0};
+    }
 
     bool HasLaneData(const EdgeID /*id*/) const override final { return true; };
     util::guidance::LaneTupleIdPair GetLaneData(const EdgeID /*id*/) const override final
-    { return {{0, 0}, 0}; }
+    {
+        return {{0, 0}, 0};
+    }
     extractor::TurnLaneDescription
     GetTurnDescription(const LaneDescriptionID /*lane_description_id*/) const override final
-    { return {}; }
+    {
+        return {};
+    }
 
     util::guidance::BearingClass GetBearingClass(const NodeID /*node*/) const override
     {
@@ -164,7 +206,9 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
 
     std::vector<extractor::ManeuverOverride>
     GetOverridesThatStartAt(const NodeID /* edge_based_node_id */) const override
-    { return {}; }
+    {
+        return {};
+    }
 };
 
 template <typename AlgorithmT> class MockAlgorithmDataFacade;
@@ -183,22 +227,32 @@ class MockAlgorithmDataFacade<engine::datafacade::CH>
     NodeID GetTarget(const EdgeID /* e */) const override { return SPECIAL_NODEID; }
     const EdgeData &GetEdgeData(const EdgeID /* e */) const override { return foo; }
     EdgeRange GetAdjacentEdgeRange(const NodeID /* node */) const override
-    { return EdgeRange(static_cast<EdgeID>(0), static_cast<EdgeID>(0), {}); }
+    {
+        return EdgeRange(static_cast<EdgeID>(0), static_cast<EdgeID>(0), {});
+    }
     EdgeID FindEdge(const NodeID /* from */, const NodeID /* to */) const override
-    { return SPECIAL_EDGEID; }
+    {
+        return SPECIAL_EDGEID;
+    }
     EdgeID FindEdgeInEitherDirection(const NodeID /* from */, const NodeID /* to */) const override
-    { return SPECIAL_EDGEID; }
+    {
+        return SPECIAL_EDGEID;
+    }
 
     EdgeID
     FindSmallestEdge(const NodeID /* from */,
                      const NodeID /* to */,
                      const std::function<bool(const EdgeData &)> & /* filter */) const override
-    { return SPECIAL_EDGEID; }
+    {
+        return SPECIAL_EDGEID;
+    }
 
     EdgeID FindEdgeIndicateIfReverse(const NodeID /* from */,
                                      const NodeID /* to */,
                                      bool & /* result */) const override
-    { return SPECIAL_EDGEID; }
+    {
+        return SPECIAL_EDGEID;
+    }
 };
 
 template <typename AlgorithmT>
diff --git a/unit_tests/util/static_rtree.cpp b/unit_tests/util/static_rtree.cpp
index 8e87808602a..6803bb918d2 100644
--- a/unit_tests/util/static_rtree.cpp
+++ b/unit_tests/util/static_rtree.cpp
@@ -228,7 +228,9 @@ void sampling_verify_rtree(RTreeT &rtree,
 
 template <typename RTreeT, typename FixtureT>
 auto make_rtree(const std::filesystem::path &path, FixtureT &fixture)
-{ return RTreeT(fixture.edges, fixture.coords, path); }
+{
+    return RTreeT(fixture.edges, fixture.coords, path);
+}
 
 template <typename RTreeT = TestStaticRTree, typename FixtureT>
 void construction_test(const std::string &path, FixtureT &fixture)
@@ -247,19 +249,29 @@ BOOST_FIXTURE_TEST_CASE(construct_tiny, TestRandomGraphFixture_10_30)
 }
 
 BOOST_FIXTURE_TEST_CASE(construct_half_leaf_test, TestRandomGraphFixture_LeafHalfFull)
-{ construction_test("test_1", *this); }
+{
+    construction_test("test_1", *this);
+}
 
 BOOST_FIXTURE_TEST_CASE(construct_full_leaf_test, TestRandomGraphFixture_LeafFull)
-{ construction_test("test_2", *this); }
+{
+    construction_test("test_2", *this);
+}
 
 BOOST_FIXTURE_TEST_CASE(construct_two_leaves_test, TestRandomGraphFixture_TwoLeaves)
-{ construction_test("test_3", *this); }
+{
+    construction_test("test_3", *this);
+}
 
 BOOST_FIXTURE_TEST_CASE(construct_branch_test, TestRandomGraphFixture_Branch)
-{ construction_test("test_4", *this); }
+{
+    construction_test("test_4", *this);
+}
 
 BOOST_FIXTURE_TEST_CASE(construct_multiple_levels_test, TestRandomGraphFixture_MultipleLevels)
-{ construction_test("test_5", *this); }
+{
+    construction_test("test_5", *this);
+}
 
 // Bug: If you querry a point that lies between two BBs that have a gap,
 // one BB will be pruned, even if it could contain a nearer match.