diff --git a/phlex/app/load_module.cpp b/phlex/app/load_module.cpp
index ffdbcfd8..4a6d3f11 100644
--- a/phlex/app/load_module.cpp
+++ b/phlex/app/load_module.cpp
@@ -8,7 +8,10 @@
 #include "boost/dll/import.hpp"
 #include "boost/json.hpp"
 
+#include <cstdlib>
+#include <filesystem>
 #include <functional>
+#include <stdexcept>
 #include <string>
 
 using namespace std::string_literals;
@@ -21,12 +24,13 @@ namespace phlex::experimental {
     std::vector<std::function<detail::module_creator_t>> create_module;
     std::function<detail::source_creator_t> create_source;
 
-    template <typename creator_t>
-    std::function<creator_t> plugin_loader(std::string const& spec, std::string const& symbol_name)
+    template <typename CreatorT>
+    std::function<CreatorT> plugin_loader(std::string const& spec, std::string const& symbol_name)
     {
       char const* plugin_path_ptr = std::getenv("PHLEX_PLUGIN_PATH");
-      if (!plugin_path_ptr)
+      if (!plugin_path_ptr) {
         throw std::runtime_error("PHLEX_PLUGIN_PATH has not been set.");
+      }
 
       using namespace boost;
       std::vector<std::string> subdirs;
@@ -37,7 +41,7 @@ namespace phlex::experimental {
         std::filesystem::path shared_library_path{subdir};
         shared_library_path /= "lib" + spec + ".so";
         if (exists(shared_library_path)) {
-          return dll::import_alias<creator_t>(shared_library_path, symbol_name);
+          return dll::import_alias<CreatorT>(shared_library_path, symbol_name);
         }
       }
       throw std::runtime_error("Could not locate library with specification '"s + spec +
diff --git a/phlex/configuration.hpp b/phlex/configuration.hpp
index 30f4406f..19658c10 100644
--- a/phlex/configuration.hpp
+++ b/phlex/configuration.hpp
@@ -4,17 +4,18 @@
 #include "boost/json.hpp"
 
 #include <optional>
+#include <utility>
 
 namespace phlex::experimental {
   class configuration {
   public:
     configuration() = default;
-    explicit configuration(boost::json::object const& config) : config_{config} {}
+    explicit configuration(boost::json::object config) : config_{std::move(config)} {}
 
     template <typename T>
     std::optional<T> get_if_present(std::string const& key) const
     {
-      if (auto pkey = config_.if_contains(key)) {
+      if (auto const* pkey = config_.if_contains(key)) {
         return value_to<T>(*pkey);
       }
       return std::nullopt;
diff --git a/phlex/core/consumer.cpp b/phlex/core/consumer.cpp
index f02a89d5..8e57506d 100644
--- a/phlex/core/consumer.cpp
+++ b/phlex/core/consumer.cpp
@@ -1,4 +1,9 @@
 #include "phlex/core/consumer.hpp"
+#include "phlex/model/algorithm_name.hpp"
+
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace phlex::experimental {
   consumer::consumer(algorithm_name name, std::vector<std::string> predicates) :
diff --git a/phlex/core/declared_fold.hpp b/phlex/core/declared_fold.hpp
index 2295ea71..a670cf57 100644
--- a/phlex/core/declared_fold.hpp
+++ b/phlex/core/declared_fold.hpp
@@ -38,7 +38,7 @@ namespace phlex::experimental {
     declared_fold(algorithm_name name,
                   std::vector<std::string> predicates,
                   specified_labels input_products);
-    virtual ~declared_fold();
+    ~declared_fold() override;
 
     virtual tbb::flow::sender<message>& sender() = 0;
     virtual tbb::flow::sender<message>& to_output() = 0;
@@ -55,10 +55,10 @@ namespace phlex::experimental {
   class fold_node : public declared_fold, private count_stores {
     using all_parameter_types = typename AlgorithmBits::input_parameter_types;
     using input_parameter_types = skip_first_type<all_parameter_types>; // Skip fold object
-    static constexpr auto N = std::tuple_size_v<input_parameter_types>;
-    using R = std::decay_t<std::tuple_element_t<0, all_parameter_types>>;
+    static constexpr auto number_inputs = std::tuple_size_v<input_parameter_types>;
+    using result_type = std::decay_t<std::tuple_element_t<0, all_parameter_types>>;
 
-    static constexpr std::size_t M = 1; // hard-coded for now
+    static constexpr std::size_t number_output_products = 1; // hard-coded for now
     using function_t = typename AlgorithmBits::bound_type;
 
   public:
@@ -75,10 +75,11 @@ namespace phlex::experimental {
       initializer_{std::move(initializer)},
       output_{to_qualified_names(full_name(), std::move(output))},
       partition_{std::move(partition)},
-      join_{make_join_or_none(g, std::make_index_sequence<N>{})},
+      join_{make_join_or_none(g, std::make_index_sequence<number_inputs>{})},
       fold_{g,
             concurrency,
-            [this, ft = alg.release_algorithm()](messages_t<N> const& messages, auto& outputs) {
+            [this, ft = alg.release_algorithm()](messages_t<number_inputs> const& messages,
+                                                 auto& outputs) {
               // N.B. The assumption is that a fold will *never* need to cache
               //      the product store it creates.  Any flush messages *do not* need
               //      to be propagated to downstream nodes.
@@ -104,13 +105,13 @@ namespace phlex::experimental {
               if (store->is_flush()) {
                 counter_for(id_hash_for_counter).set_flush_value(store, original_message_id);
               } else {
-                call(ft, messages, std::make_index_sequence<N>{});
+                call(ft, messages, std::make_index_sequence<number_inputs>{});
                 counter_for(id_hash_for_counter).increment(store->id()->level_hash());
               }
 
               if (auto counter = done_with(id_hash_for_counter)) {
                 auto parent = fold_store->make_continuation(this->full_name());
-                commit_(*parent);
+                commit(*parent);
                 ++product_count_;
                 // FIXME: This msg.eom value may be wrong!
                 get<0>(outputs).try_put({parent, msg.eom, counter->original_message_id()});
@@ -123,17 +124,22 @@ namespace phlex::experimental {
   private:
     tbb::flow::receiver<message>& port_for(specified_label const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label);
+      return receiver_for<number_inputs>(join_, input(), product_label);
     }
 
-    std::vector<tbb::flow::receiver<message>*> ports() override { return input_ports<N>(join_); }
+    std::vector<tbb::flow::receiver<message>*> ports() override
+    {
+      return input_ports<number_inputs>(join_);
+    }
 
     tbb::flow::sender<message>& sender() override { return output_port<0ull>(fold_); }
     tbb::flow::sender<message>& to_output() override { return sender(); }
     qualified_names const& output() const override { return output_; }
 
     template <std::size_t... Is>
-    void call(function_t const& ft, messages_t<N> const& messages, std::index_sequence<Is...>)
+    void call(function_t const& ft,
+              messages_t<number_inputs> const& messages,
+              std::index_sequence<Is...>)
     {
       auto const& parent_id = *most_derived(messages).store->id()->parent(partition_);
       // FIXME: Not the safest approach!
@@ -142,8 +148,7 @@ namespace phlex::experimental {
         it =
           results_
             .insert({parent_id,
-                     initialized_object(std::move(initializer_),
-                                        std::make_index_sequence<std::tuple_size_v<InitTuple>>{})})
+                     initialized_object(std::make_index_sequence<std::tuple_size_v<InitTuple>>{})})
             .first;
       }
       ++calls_;
@@ -154,13 +159,12 @@ namespace phlex::experimental {
     std::size_t product_count() const final { return product_count_.load(); }
 
     template <size_t... Is>
-    auto initialized_object(InitTuple&& tuple, std::index_sequence<Is...>) const
+    auto initialized_object(std::index_sequence<Is...>) const
     {
-      return std::unique_ptr<R>{
-        new R{std::forward<std::tuple_element_t<Is, InitTuple>>(std::get<Is>(tuple))...}};
+      return std::unique_ptr<result_type>{new result_type{std::get<Is>(initializer_)...}};
     }
 
-    void commit_(product_store& store)
+    void commit(product_store& store)
     {
       auto& result = results_.at(*store.id());
       if constexpr (requires { send(*result); }) {
@@ -177,9 +181,9 @@ namespace phlex::experimental {
     input_retriever_types<input_parameter_types> input_{input_arguments<input_parameter_types>()};
     qualified_names output_;
     std::string partition_;
-    join_or_none_t<N> join_;
-    tbb::flow::multifunction_node<messages_t<N>, messages_t<1>> fold_;
-    tbb::concurrent_unordered_map<level_id, std::unique_ptr<R>> results_;
+    join_or_none_t<number_inputs> join_;
+    tbb::flow::multifunction_node<messages_t<number_inputs>, messages_t<1>> fold_;
+    tbb::concurrent_unordered_map<level_id, std::unique_ptr<result_type>> results_;
     std::atomic<std::size_t> calls_;
     std::atomic<std::size_t> product_count_;
   };
diff --git a/phlex/core/declared_observer.hpp b/phlex/core/declared_observer.hpp
index 5488507c..a1b642d1 100644
--- a/phlex/core/declared_observer.hpp
+++ b/phlex/core/declared_observer.hpp
@@ -35,7 +35,7 @@ namespace phlex::experimental {
     declared_observer(algorithm_name name,
                       std::vector<std::string> predicates,
                       specified_labels input_products);
-    virtual ~declared_observer();
+    ~declared_observer() override;
 
   protected:
     using hashes_t = tbb::concurrent_hash_map<level_id::hash_type, bool>;
@@ -51,9 +51,9 @@ namespace phlex::experimental {
 
   template <typename AlgorithmBits>
   class observer_node : public declared_observer, private detect_flush_flag {
-    using InputArgs = typename AlgorithmBits::input_parameter_types;
+    using input_args = typename AlgorithmBits::input_parameter_types;
     using function_t = typename AlgorithmBits::bound_type;
-    static constexpr auto N = AlgorithmBits::number_inputs;
+    static constexpr auto number_inputs = AlgorithmBits::number_inputs;
 
   public:
     static constexpr auto number_output_products = 0;
@@ -66,17 +66,17 @@ namespace phlex::experimental {
                   AlgorithmBits alg,
                   specified_labels input_products) :
       declared_observer{std::move(name), std::move(predicates), std::move(input_products)},
-      join_{make_join_or_none(g, std::make_index_sequence<N>{})},
+      join_{make_join_or_none(g, std::make_index_sequence<number_inputs>{})},
       observer_{g,
                 concurrency,
                 [this, ft = alg.release_algorithm()](
-                  messages_t<N> const& messages) -> oneapi::tbb::flow::continue_msg {
+                  messages_t<number_inputs> const& messages) -> oneapi::tbb::flow::continue_msg {
                   auto const& msg = most_derived(messages);
                   auto const& [store, message_id] = std::tie(msg.store, msg.id);
                   if (store->is_flush()) {
                     flag_for(store->id()->hash()).flush_received(message_id);
                   } else if (accessor a; needs_new(store, a)) {
-                    call(ft, messages, std::make_index_sequence<N>{});
+                    call(ft, messages, std::make_index_sequence<number_inputs>{});
                     a->second = true;
                     flag_for(store->id()->hash()).mark_as_processed();
                   }
@@ -90,15 +90,26 @@ namespace phlex::experimental {
       make_edge(join_, observer_);
     }
 
-    ~observer_node() { report_cached_hashes(cached_hashes_); }
+    ~observer_node() override { report_cached_hashes(cached_hashes_); }
+
+    observer_node(observer_node const&) = default;
+    observer_node& operator=(observer_node const&) = default;
+
+    // NOLINTBEGIN(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
+    observer_node(observer_node&&) = default;
+    observer_node& operator=(observer_node&&) = default;
+    // NOLINTEND(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
 
   private:
     tbb::flow::receiver<message>& port_for(specified_label const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label);
+      return receiver_for<number_inputs>(join_, input(), product_label);
     }
 
-    std::vector<tbb::flow::receiver<message>*> ports() override { return input_ports<N>(join_); }
+    std::vector<tbb::flow::receiver<message>*> ports() override
+    {
+      return input_ports<number_inputs>(join_);
+    }
 
     bool needs_new(product_store_const_ptr const& store, accessor& a)
     {
@@ -109,7 +120,9 @@ namespace phlex::experimental {
     }
 
     template <std::size_t... Is>
-    void call(function_t const& ft, messages_t<N> const& messages, std::index_sequence<Is...>)
+    void call(function_t const& ft,
+              messages_t<number_inputs> const& messages,
+              std::index_sequence<Is...>)
     {
       ++calls_;
       return std::invoke(ft, std::get<Is>(input_).retrieve(messages)...);
@@ -117,9 +130,9 @@ namespace phlex::experimental {
 
     std::size_t num_calls() const final { return calls_.load(); }
 
-    input_retriever_types<InputArgs> input_{input_arguments<InputArgs>()};
-    join_or_none_t<N> join_;
-    tbb::flow::function_node<messages_t<N>> observer_;
+    input_retriever_types<input_args> input_{input_arguments<input_args>()};
+    join_or_none_t<number_inputs> join_;
+    tbb::flow::function_node<messages_t<number_inputs>> observer_;
     hashes_t cached_hashes_;
     std::atomic<std::size_t> calls_;
   };
diff --git a/phlex/core/declared_predicate.hpp b/phlex/core/declared_predicate.hpp
index d8e6a0c0..2f721440 100644
--- a/phlex/core/declared_predicate.hpp
+++ b/phlex/core/declared_predicate.hpp
@@ -38,7 +38,7 @@ namespace phlex::experimental {
     declared_predicate(algorithm_name name,
                        std::vector<std::string> predicates,
                        specified_labels input_products);
-    virtual ~declared_predicate();
+    ~declared_predicate() override;
 
     virtual tbb::flow::sender<predicate_result>& sender() = 0;
 
@@ -57,9 +57,9 @@ namespace phlex::experimental {
 
   template <typename AlgorithmBits>
   class predicate_node : public declared_predicate, private detect_flush_flag {
-    using InputArgs = typename AlgorithmBits::input_parameter_types;
+    using input_args = typename AlgorithmBits::input_parameter_types;
     using function_t = typename AlgorithmBits::bound_type;
-    static constexpr auto N = AlgorithmBits::number_inputs;
+    static constexpr auto number_inputs = AlgorithmBits::number_inputs;
 
   public:
     static constexpr auto number_output_products = 0ull;
@@ -72,47 +72,60 @@ namespace phlex::experimental {
                    AlgorithmBits alg,
                    specified_labels input_products) :
       declared_predicate{std::move(name), std::move(predicates), std::move(input_products)},
-      join_{make_join_or_none(g, std::make_index_sequence<N>{})},
-      predicate_{
-        g,
-        concurrency,
-        [this, ft = alg.release_algorithm()](messages_t<N> const& messages) -> predicate_result {
-          auto const& msg = most_derived(messages);
-          auto const& [store, message_id] = std::tie(msg.store, msg.id);
-          predicate_result result{};
-          if (store->is_flush()) {
-            flag_for(store->id()->hash()).flush_received(message_id);
-          } else if (const_accessor a; results_.find(a, store->id()->hash())) {
-            result = {msg.eom, message_id, a->second.result};
-          } else if (accessor a; results_.insert(a, store->id()->hash())) {
-            bool const rc = call(ft, messages, std::make_index_sequence<N>{});
-            result = a->second = {msg.eom, message_id, rc};
-            flag_for(store->id()->hash()).mark_as_processed();
-          }
-
-          if (done_with(store)) {
-            results_.erase(store->id()->hash());
-          }
-          return result;
-        }}
+      join_{make_join_or_none(g, std::make_index_sequence<number_inputs>{})},
+      predicate_{g,
+                 concurrency,
+                 [this, ft = alg.release_algorithm()](
+                   messages_t<number_inputs> const& messages) -> predicate_result {
+                   auto const& msg = most_derived(messages);
+                   auto const& [store, message_id] = std::tie(msg.store, msg.id);
+                   predicate_result result{};
+                   if (store->is_flush()) {
+                     flag_for(store->id()->hash()).flush_received(message_id);
+                   } else if (const_accessor a; results_.find(a, store->id()->hash())) {
+                     result = {msg.eom, message_id, a->second.result};
+                   } else if (accessor a; results_.insert(a, store->id()->hash())) {
+                     bool const rc = call(ft, messages, std::make_index_sequence<number_inputs>{});
+                     result = a->second = {msg.eom, message_id, rc};
+                     flag_for(store->id()->hash()).mark_as_processed();
+                   }
+
+                   if (done_with(store)) {
+                     results_.erase(store->id()->hash());
+                   }
+                   return result;
+                 }}
     {
       make_edge(join_, predicate_);
     }
 
-    ~predicate_node() { report_cached_results(results_); }
+    ~predicate_node() override { report_cached_results(results_); }
+
+    predicate_node(predicate_node const&) = default;
+    predicate_node& operator=(predicate_node const&) = default;
+
+    // NOLINTBEGIN(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
+    predicate_node(predicate_node&&) = default;
+    predicate_node& operator=(predicate_node&&) = default;
+    // NOLINTEND(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
 
   private:
     tbb::flow::receiver<message>& port_for(specified_label const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label);
+      return receiver_for<number_inputs>(join_, input(), product_label);
     }
 
-    std::vector<tbb::flow::receiver<message>*> ports() override { return input_ports<N>(join_); }
+    std::vector<tbb::flow::receiver<message>*> ports() override
+    {
+      return input_ports<number_inputs>(join_);
+    }
 
     tbb::flow::sender<predicate_result>& sender() override { return predicate_; }
 
     template <std::size_t... Is>
-    bool call(function_t const& ft, messages_t<N> const& messages, std::index_sequence<Is...>)
+    bool call(function_t const& ft,
+              messages_t<number_inputs> const& messages,
+              std::index_sequence<Is...>)
     {
       ++calls_;
       return std::invoke(ft, std::get<Is>(input_).retrieve(messages)...);
@@ -120,9 +133,9 @@ namespace phlex::experimental {
 
     std::size_t num_calls() const final { return calls_.load(); }
 
-    input_retriever_types<InputArgs> input_{input_arguments<InputArgs>()};
-    join_or_none_t<N> join_;
-    tbb::flow::function_node<messages_t<N>, predicate_result> predicate_;
+    input_retriever_types<input_args> input_{input_arguments<input_args>()};
+    join_or_none_t<number_inputs> join_;
+    tbb::flow::function_node<messages_t<number_inputs>, predicate_result> predicate_;
     results_t results_;
     std::atomic<std::size_t> calls_;
   };
diff --git a/phlex/core/declared_transform.hpp b/phlex/core/declared_transform.hpp
index daa654de..08500044 100644
--- a/phlex/core/declared_transform.hpp
+++ b/phlex/core/declared_transform.hpp
@@ -42,7 +42,7 @@ namespace phlex::experimental {
     declared_transform(algorithm_name name,
                        std::vector<std::string> predicates,
                        specified_labels input_products);
-    virtual ~declared_transform();
+    ~declared_transform() override;
 
     virtual tbb::flow::sender<message>& sender() = 0;
     virtual tbb::flow::sender<message>& to_output() = 0;
@@ -67,12 +67,11 @@ namespace phlex::experimental {
     using function_t = typename AlgorithmBits::bound_type;
     using input_parameter_types = typename AlgorithmBits::input_parameter_types;
 
-    static constexpr auto N = AlgorithmBits::number_inputs;
-    static constexpr auto M = number_output_objects<function_t>;
+    static constexpr auto number_inputs = AlgorithmBits::number_inputs;
 
   public:
     using node_ptr_type = declared_transform_ptr;
-    static constexpr auto number_output_products = M;
+    static constexpr auto number_output_products = number_output_objects<function_t>;
 
     transform_node(algorithm_name name,
                    std::size_t concurrency,
@@ -83,10 +82,11 @@ namespace phlex::experimental {
                    std::vector<std::string> output) :
       declared_transform{std::move(name), std::move(predicates), std::move(input_products)},
       output_{to_qualified_names(full_name(), std::move(output))},
-      join_{make_join_or_none(g, std::make_index_sequence<N>{})},
+      join_{make_join_or_none(g, std::make_index_sequence<number_inputs>{})},
       transform_{g,
                  concurrency,
-                 [this, ft = alg.release_algorithm()](messages_t<N> const& messages, auto& output) {
+                 [this, ft = alg.release_algorithm()](messages_t<number_inputs> const& messages,
+                                                      auto& output) {
                    auto const& msg = most_derived(messages);
                    auto const& [store, message_eom, message_id] =
                      std::tie(msg.store, msg.eom, msg.id);
@@ -98,7 +98,7 @@ namespace phlex::experimental {
                    } else {
                      accessor a;
                      if (stores_.insert(a, store->id()->hash())) {
-                       auto result = call(ft, messages, std::make_index_sequence<N>{});
+                       auto result = call(ft, messages, std::make_index_sequence<number_inputs>{});
                        ++calls_;
                        ++product_count_[store->id()->level_hash()];
                        products new_products;
@@ -123,22 +123,35 @@ namespace phlex::experimental {
       make_edge(join_, transform_);
     }
 
-    ~transform_node() { report_cached_stores(stores_); }
+    ~transform_node() override { report_cached_stores(stores_); }
+
+    transform_node(transform_node const&) = default;
+    transform_node& operator=(transform_node const&) = default;
+
+    // NOLINTBEGIN(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
+    transform_node(transform_node&&) = default;
+    transform_node& operator=(transform_node&&) = default;
+    // NOLINTEND(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
 
   private:
     tbb::flow::receiver<message>& port_for(specified_label const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label);
+      return receiver_for<number_inputs>(join_, input(), product_label);
     }
 
-    std::vector<tbb::flow::receiver<message>*> ports() override { return input_ports<N>(join_); }
+    std::vector<tbb::flow::receiver<message>*> ports() override
+    {
+      return input_ports<number_inputs>(join_);
+    }
 
     tbb::flow::sender<message>& sender() override { return output_port<0>(transform_); }
     tbb::flow::sender<message>& to_output() override { return output_port<1>(transform_); }
     qualified_names const& output() const override { return output_; }
 
     template <std::size_t... Is>
-    auto call(function_t const& ft, messages_t<N> const& messages, std::index_sequence<Is...>)
+    auto call(function_t const& ft,
+              messages_t<number_inputs> const& messages,
+              std::index_sequence<Is...>)
     {
       return std::invoke(ft, std::get<Is>(input_).retrieve(messages)...);
     }
@@ -155,8 +168,8 @@ namespace phlex::experimental {
 
     input_retriever_types<input_parameter_types> input_{input_arguments<input_parameter_types>()};
     qualified_names output_;
-    join_or_none_t<N> join_;
-    tbb::flow::multifunction_node<messages_t<N>, messages_t<2u>> transform_;
+    join_or_none_t<number_inputs> join_;
+    tbb::flow::multifunction_node<messages_t<number_inputs>, messages_t<2u>> transform_;
     stores_t stores_;
     std::atomic<std::size_t> calls_;
     tbb::concurrent_unordered_map<std::size_t, std::atomic<std::size_t>> product_count_;
diff --git a/phlex/core/declared_unfold.hpp b/phlex/core/declared_unfold.hpp
index 7b0477ba..f793f7a1 100644
--- a/phlex/core/declared_unfold.hpp
+++ b/phlex/core/declared_unfold.hpp
@@ -9,7 +9,6 @@
 #include "phlex/core/products_consumer.hpp"
 #include "phlex/core/store_counters.hpp"
 #include "phlex/model/algorithm_name.hpp"
-#include "phlex/model/handle.hpp"
 #include "phlex/model/level_id.hpp"
 #include "phlex/model/product_store.hpp"
 #include "phlex/model/qualified_name.hpp"
@@ -27,6 +26,7 @@
 #include <ranges>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -58,7 +58,7 @@ namespace phlex::experimental {
     declared_unfold(algorithm_name name,
                     std::vector<std::string> predicates,
                     specified_labels input_products);
-    virtual ~declared_unfold();
+    ~declared_unfold() override;
 
     virtual tbb::flow::sender<message>& sender() = 0;
     virtual tbb::flow::sender<message>& to_output() = 0;
@@ -80,9 +80,8 @@ namespace phlex::experimental {
 
   template <typename Object, typename Predicate, typename Unfold>
   class unfold_node : public declared_unfold, private detect_flush_flag {
-    using InputArgs = constructor_parameter_types<Object>;
-    static constexpr std::size_t N = std::tuple_size_v<InputArgs>;
-    static constexpr std::size_t M = number_output_objects<Unfold>;
+    using input_args = constructor_parameter_types<Object>;
+    static constexpr std::size_t number_inputs = std::tuple_size_v<input_args>;
 
   public:
     unfold_node(algorithm_name name,
@@ -97,43 +96,60 @@ namespace phlex::experimental {
       declared_unfold{std::move(name), std::move(predicates), std::move(product_labels)},
       output_{to_qualified_names(full_name(), std::move(output_products))},
       new_level_name_{std::move(new_level_name)},
-      join_{make_join_or_none(g, std::make_index_sequence<N>{})},
-      unfold_{
-        g,
-        concurrency,
-        [this, p = std::move(predicate), ufold = std::move(unfold)](messages_t<N> const& messages,
-                                                                    auto& output) {
-          auto const& msg = most_derived(messages);
-          auto const& store = msg.store;
-          if (store->is_flush()) {
-            flag_for(store->id()->hash()).flush_received(msg.id);
-            std::get<0>(output).try_put(msg);
-          } else if (accessor a; stores_.insert(a, store->id()->hash())) {
-            std::size_t const original_message_id{msg_counter_};
-            generator g{msg.store, this->full_name(), new_level_name_};
-            call(p, ufold, msg.store->id(), g, msg.eom, messages, std::make_index_sequence<N>{});
-
-            message const flush_msg{g.flush_store(), msg.eom, ++msg_counter_, original_message_id};
-            std::get<0>(output).try_put(flush_msg);
-            flag_for(store->id()->hash()).mark_as_processed();
-          }
-
-          if (done_with(store)) {
-            stores_.erase(store->id()->hash());
-          }
-        }}
+      join_{make_join_or_none(g, std::make_index_sequence<number_inputs>{})},
+      unfold_{g,
+              concurrency,
+              [this, p = std::move(predicate), ufold = std::move(unfold)](
+                messages_t<number_inputs> const& messages, auto& output) {
+                auto const& msg = most_derived(messages);
+                auto const& store = msg.store;
+                if (store->is_flush()) {
+                  flag_for(store->id()->hash()).flush_received(msg.id);
+                  std::get<0>(output).try_put(msg);
+                } else if (accessor a; stores_.insert(a, store->id()->hash())) {
+                  std::size_t const original_message_id{msg_counter_};
+                  generator g{msg.store, this->full_name(), new_level_name_};
+                  call(p,
+                       ufold,
+                       msg.store->id(),
+                       g,
+                       msg.eom,
+                       messages,
+                       std::make_index_sequence<number_inputs>{});
+
+                  message const flush_msg{
+                    g.flush_store(), msg.eom, ++msg_counter_, original_message_id};
+                  std::get<0>(output).try_put(flush_msg);
+                  flag_for(store->id()->hash()).mark_as_processed();
+                }
+
+                if (done_with(store)) {
+                  stores_.erase(store->id()->hash());
+                }
+              }}
     {
       make_edge(join_, unfold_);
     }
 
-    ~unfold_node() { report_cached_stores(stores_); }
+    ~unfold_node() override { report_cached_stores(stores_); }
+
+    unfold_node(unfold_node const&) = default;
+    unfold_node& operator=(unfold_node const&) = default;
+
+    // NOLINTBEGIN(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
+    unfold_node(unfold_node&&) = default;
+    unfold_node& operator=(unfold_node&&) = default;
+    // NOLINTEND(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
 
   private:
     tbb::flow::receiver<message>& port_for(specified_label const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label);
+      return receiver_for<number_inputs>(join_, input(), product_label);
+    }
+    std::vector<tbb::flow::receiver<message>*> ports() override
+    {
+      return input_ports<number_inputs>(join_);
     }
-    std::vector<tbb::flow::receiver<message>*> ports() override { return input_ports<N>(join_); }
 
     tbb::flow::sender<message>& sender() override { return output_port<0>(unfold_); }
     tbb::flow::sender<message>& to_output() override { return sender(); }
@@ -145,7 +161,7 @@ namespace phlex::experimental {
               level_id_ptr const& unfolded_id,
               generator& g,
               end_of_message_ptr const& eom,
-              messages_t<N> const& messages,
+              messages_t<number_inputs> const& messages,
               std::index_sequence<Is...>)
     {
       ++calls_;
@@ -166,7 +182,8 @@ namespace phlex::experimental {
         }
         ++product_count_;
         auto child = g.make_child_for(counter++, std::move(new_products));
-        message const child_msg{child, eom->make_child(child->id()), ++msg_counter_};
+        message const child_msg{
+          .store = child, .eom = eom->make_child(child->id()), .id = ++msg_counter_};
         output_port<0>(unfold_).try_put(child_msg);
       }
     }
@@ -174,15 +191,15 @@ namespace phlex::experimental {
     std::size_t num_calls() const final { return calls_.load(); }
     std::size_t product_count() const final { return product_count_.load(); }
 
-    input_retriever_types<InputArgs> input_{input_arguments<InputArgs>()};
+    input_retriever_types<input_args> input_{input_arguments<input_args>()};
     qualified_names output_;
     std::string new_level_name_;
-    join_or_none_t<N> join_;
-    tbb::flow::multifunction_node<messages_t<N>, messages_t<1u>> unfold_;
+    join_or_none_t<number_inputs> join_;
+    tbb::flow::multifunction_node<messages_t<number_inputs>, messages_t<1u>> unfold_;
     tbb::concurrent_hash_map<level_id::hash_type, product_store_ptr> stores_;
-    std::atomic<std::size_t> msg_counter_{}; // Is this sufficient?  Probably not.
-    std::atomic<std::size_t> calls_{};
-    std::atomic<std::size_t> product_count_{};
+    std::atomic<std::size_t> msg_counter_; // Is this sufficient?  Probably not.
+    std::atomic<std::size_t> calls_;
+    std::atomic<std::size_t> product_count_;
   };
 }
 
diff --git a/phlex/core/detail/filter_impl.cpp b/phlex/core/detail/filter_impl.cpp
index 4c576e23..15560ab0 100644
--- a/phlex/core/detail/filter_impl.cpp
+++ b/phlex/core/detail/filter_impl.cpp
@@ -1,7 +1,11 @@
 #include "phlex/core/detail/filter_impl.hpp"
+#include "phlex/core/specified_label.hpp"
+#include "phlex/model/product_store.hpp"
 
 #include <cassert>
+#include <cstddef>
 #include <string>
+#include <utility>
 
 namespace {
   phlex::experimental::specified_label const output_dummy{phlex::experimental::qualified_name{
@@ -75,8 +79,9 @@ namespace phlex::experimental {
 
     // Fill slots in the order of the input arguments to the downstream node.
     for (std::size_t i = 0; i != nargs_; ++i) {
-      if (elem[i] or not store->contains_product((*product_names_)[i].name.full()))
+      if (elem[i] or not store->contains_product((*product_names_)[i].name.full())) {
         continue;
+      }
       elem[i] = store;
     }
   }
diff --git a/phlex/core/detail/filter_impl.hpp b/phlex/core/detail/filter_impl.hpp
index 2749a938..44f8d3d3 100644
--- a/phlex/core/detail/filter_impl.hpp
+++ b/phlex/core/detail/filter_impl.hpp
@@ -12,8 +12,8 @@
 namespace phlex::experimental {
   struct predicate_result {
     end_of_message_ptr eom;
-    std::size_t msg_id;
-    bool result;
+    std::size_t msg_id{};
+    bool result{false};
   };
 
   inline constexpr unsigned int true_value{-1u};
@@ -44,6 +44,7 @@ namespace phlex::experimental {
     bool claim(accessor& a, std::size_t msg_id);
 
   private:
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
     unsigned int const total_decisions_;
     decisions_t results_;
   };
@@ -58,10 +59,10 @@ namespace phlex::experimental {
     explicit data_map(for_output_t);
     explicit data_map(specified_labels const& product_names);
 
-    bool is_complete(std::size_t const msg_id) const;
+    bool is_complete(std::size_t msg_id) const;
 
-    void update(std::size_t const msg_id, product_store_const_ptr const& store);
-    std::vector<product_store_const_ptr> release_data(std::size_t const msg_id);
+    void update(std::size_t msg_id, product_store_const_ptr const& store);
+    std::vector<product_store_const_ptr> release_data(std::size_t msg_id);
 
   private:
     stores_t stores_;
diff --git a/phlex/core/end_of_message.cpp b/phlex/core/end_of_message.cpp
index 89a1ec73..b5c2867f 100644
--- a/phlex/core/end_of_message.cpp
+++ b/phlex/core/end_of_message.cpp
@@ -1,4 +1,5 @@
 #include "phlex/core/end_of_message.hpp"
+#include "phlex/core/fwd.hpp"
 #include "phlex/model/level_hierarchy.hpp"
 
 namespace phlex::experimental {
diff --git a/phlex/core/end_of_message.hpp b/phlex/core/end_of_message.hpp
index 9082c621..1684aa26 100644
--- a/phlex/core/end_of_message.hpp
+++ b/phlex/core/end_of_message.hpp
@@ -14,6 +14,13 @@ namespace phlex::experimental {
     end_of_message_ptr make_child(level_id_ptr id);
     ~end_of_message();
 
+    // Default copy/move constructors and assignment operators are adequate
+    end_of_message(end_of_message const&) = default;
+    end_of_message(end_of_message&&) = default;
+
+    end_of_message& operator=(end_of_message const&) = default;
+    end_of_message& operator=(end_of_message&&) = default;
+
   private:
     end_of_message(end_of_message_ptr parent, level_hierarchy* hierarchy, level_id_ptr id);
 
diff --git a/phlex/core/framework_graph.cpp b/phlex/core/framework_graph.cpp
index 64520562..a2ccde09 100644
--- a/phlex/core/framework_graph.cpp
+++ b/phlex/core/framework_graph.cpp
@@ -11,6 +11,7 @@
 
 #include <cassert>
 #include <iostream>
+#include <utility>
 
 namespace phlex::experimental {
   level_sentry::level_sentry(flush_counters& counters,
@@ -40,9 +41,9 @@ namespace phlex::experimental {
   }
 
   // FIXME: The algorithm below should support user-specified flush stores.
-  framework_graph::framework_graph(detail::next_store_t next_store, int const max_parallelism) :
+  framework_graph::framework_graph(detail::next_store_t f, int const max_parallelism) :
     parallelism_limit_{static_cast<std::size_t>(max_parallelism)},
-    driver_{std::move(next_store)},
+    driver_{std::move(f)},
     src_{graph_,
          [this](tbb::flow_control& fc) mutable -> message {
            auto item = driver_();
diff --git a/phlex/core/framework_graph.hpp b/phlex/core/framework_graph.hpp
index 18aa00cc..de4c6ddd 100644
--- a/phlex/core/framework_graph.hpp
+++ b/phlex/core/framework_graph.hpp
@@ -39,8 +39,10 @@ namespace phlex::experimental {
     std::size_t depth() const noexcept;
 
   private:
+    // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
     flush_counters& counters_;
     message_sender& sender_;
+    // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
     product_store_ptr store_;
     std::size_t depth_;
   };
@@ -131,15 +133,15 @@ namespace phlex::experimental {
     void drain();
     std::size_t original_message_id(product_store_ptr const& store);
 
-    resource_usage graph_resource_usage_{};
+    resource_usage graph_resource_usage_;
     max_allowed_parallelism parallelism_limit_;
-    level_hierarchy hierarchy_{};
+    level_hierarchy hierarchy_;
     node_catalog nodes_{};
-    std::map<std::string, filter> filters_{};
+    std::map<std::string, filter> filters_;
     // The graph_ object uses the filters_, nodes_, and hierarchy_ objects implicitly.
-    tbb::flow::graph graph_{};
+    tbb::flow::graph graph_;
     framework_driver driver_;
-    std::vector<std::string> registration_errors_{};
+    std::vector<std::string> registration_errors_;
     tbb::flow::input_node<message> src_;
     multiplexer multiplexer_;
     std::stack<end_of_message_ptr> eoms_;
diff --git a/phlex/core/glue.hpp b/phlex/core/glue.hpp
index 7f0cfdbb..8941f0f3 100644
--- a/phlex/core/glue.hpp
+++ b/phlex/core/glue.hpp
@@ -36,7 +36,7 @@ namespace phlex::experimental {
          std::shared_ptr<T> bound_obj,
          std::vector<std::string>& errors,
          configuration const* config = nullptr) :
-      graph_{g}, nodes_{nodes}, bound_obj_{std::move(bound_obj)}, errors_{errors}, config_{config}
+      graph_{g}, nodes_{nodes}, errors_{errors}, bound_obj_{std::move(bound_obj)}, config_{config}
     {
     }
 
@@ -135,10 +135,12 @@ namespace phlex::experimental {
     }
 
   private:
+    // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
     tbb::flow::graph& graph_;
     node_catalog& nodes_;
-    std::shared_ptr<T> bound_obj_;
     std::vector<std::string>& errors_;
+    // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
+    std::shared_ptr<T> bound_obj_;
     configuration const* config_;
   };
 }
diff --git a/phlex/core/graph_proxy.hpp b/phlex/core/graph_proxy.hpp
index 8e5239d8..6584d2ad 100644
--- a/phlex/core/graph_proxy.hpp
+++ b/phlex/core/graph_proxy.hpp
@@ -32,7 +32,7 @@ namespace phlex::experimental {
                 node_catalog& nodes,
                 std::vector<std::string>& errors)
       requires(std::same_as<T, void_tag>)
-      : config_{&config}, graph_{g}, nodes_{nodes}, errors_{errors}
+      : graph_{g}, nodes_{nodes}, errors_{errors}, config_{&config}
     {
     }
 
@@ -99,7 +99,7 @@ namespace phlex::experimental {
                 std::shared_ptr<T> bound_obj,
                 std::vector<std::string>& errors)
       requires(not std::same_as<T, void_tag>)
-      : config_{config}, graph_{g}, nodes_{nodes}, bound_obj_{bound_obj}, errors_{errors}
+      : graph_{g}, nodes_{nodes}, errors_{errors}, bound_obj_{std::move(bound_obj)}, config_{config}
     {
     }
 
@@ -108,11 +108,13 @@ namespace phlex::experimental {
       return glue{graph_, nodes_, (use_bound_object ? bound_obj_ : nullptr), errors_, config_};
     }
 
-    configuration const* config_;
+    // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
     tbb::flow::graph& graph_;
     node_catalog& nodes_;
-    std::shared_ptr<T> bound_obj_;
     std::vector<std::string>& errors_;
+    // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
+    std::shared_ptr<T> bound_obj_;
+    configuration const* config_;
   };
 }
 
diff --git a/phlex/core/input_arguments.hpp b/phlex/core/input_arguments.hpp
index 864364a7..f2abf482 100644
--- a/phlex/core/input_arguments.hpp
+++ b/phlex/core/input_arguments.hpp
@@ -50,9 +50,10 @@ namespace phlex::experimental {
   template <typename InputTypes>
   auto form_input_arguments(std::string const& algorithm_name, specified_labels const& args)
   {
-    constexpr auto N = std::tuple_size_v<InputTypes>;
+    constexpr auto number_input_types = std::tuple_size_v<InputTypes>;
     detail::verify_no_duplicate_input_products(algorithm_name, args);
-    return form_input_arguments_impl<InputTypes>(args, std::make_index_sequence<N>{});
+    return form_input_arguments_impl<InputTypes>(args,
+                                                 std::make_index_sequence<number_input_types>{});
   }
 }
 
diff --git a/phlex/core/message.cpp b/phlex/core/message.cpp
index a2718c66..f9f9b5cf 100644
--- a/phlex/core/message.cpp
+++ b/phlex/core/message.cpp
@@ -8,7 +8,7 @@
 
 namespace phlex::experimental {
 
-  std::size_t MessageHasher::operator()(message const& msg) const noexcept { return msg.id; }
+  std::size_t message_hasher::operator()(message const& msg) const noexcept { return msg.id; }
 
   message const& more_derived(message const& a, message const& b)
   {
@@ -30,7 +30,7 @@ namespace phlex::experimental {
     return std::distance(b, it);
   }
 
-  detail::no_join::no_join(tbb::flow::graph& g, MessageHasher) :
+  detail::no_join::no_join(tbb::flow::graph& g, message_hasher) :
     no_join_base_t{g, tbb::flow::unlimited, [](message const& msg) { return std::tuple{msg}; }}
   {
   }
diff --git a/phlex/core/message.hpp b/phlex/core/message.hpp
index 6e7d3a3c..539d88f3 100644
--- a/phlex/core/message.hpp
+++ b/phlex/core/message.hpp
@@ -20,20 +20,25 @@ namespace phlex::experimental {
   struct message {
     product_store_const_ptr store;
     end_of_message_ptr eom;
-    std::size_t id;
+    std::size_t id{};
     std::size_t original_id{-1ull}; // Used during flush
   };
 
   template <std::size_t N>
   using messages_t = sized_tuple<message, N>;
 
-  struct MessageHasher {
+  struct message_hasher {
     std::size_t operator()(message const& msg) const noexcept;
   };
 
   // Overload for use with most_derived
   message const& more_derived(message const& a, message const& b);
 
+  // Delete overloads that can result in dangling reference
+  message const& more_derived(message&&, message&&) = delete;
+  message const& more_derived(message const&, message&&) = delete;
+  message const& more_derived(message&&, message const&) = delete;
+
   namespace detail {
     template <std::size_t N>
     using join_messages_t = tbb::flow::join_node<messages_t<N>, tbb::flow::tag_matching>;
@@ -41,7 +46,7 @@ namespace phlex::experimental {
       tbb::flow::function_node<message, messages_t<1ull>, tbb::flow::lightweight>;
 
     struct no_join : no_join_base_t {
-      no_join(tbb::flow::graph& g, MessageHasher);
+      no_join(tbb::flow::graph& g, message_hasher);
     };
   }
 
@@ -51,7 +56,7 @@ namespace phlex::experimental {
   template <std::size_t... Is>
   auto make_join_or_none(tbb::flow::graph& g, std::index_sequence<Is...>)
   {
-    return join_or_none_t<sizeof...(Is)>{g, type_t<MessageHasher, Is>{}...};
+    return join_or_none_t<sizeof...(Is)>{g, type_t<message_hasher, Is>{}...};
   }
 
   template <std::size_t N>
diff --git a/phlex/core/message_sender.hpp b/phlex/core/message_sender.hpp
index 2ef9162f..eaf7dc46 100644
--- a/phlex/core/message_sender.hpp
+++ b/phlex/core/message_sender.hpp
@@ -23,9 +23,11 @@ namespace phlex::experimental {
   private:
     std::size_t original_message_id(product_store_ptr const& store);
 
+    // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
     level_hierarchy& hierarchy_;
     multiplexer& multiplexer_;
     std::stack<end_of_message_ptr>& eoms_;
+    // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
     std::map<level_id_ptr, std::size_t> original_message_ids_;
     std::size_t calls_{};
   };
diff --git a/phlex/core/multiplexer.hpp b/phlex/core/multiplexer.hpp
index 2ba355b0..855ca678 100644
--- a/phlex/core/multiplexer.hpp
+++ b/phlex/core/multiplexer.hpp
@@ -20,11 +20,11 @@ namespace phlex::experimental {
     using base = tbb::flow::function_node<message>;
 
   public:
-    ~multiplexer();
+    ~multiplexer() final;
 
     struct named_input_port {
       specified_label product_label;
-      tbb::flow::receiver<message>* port;
+      tbb::flow::receiver<message>* port{nullptr};
     };
     using named_input_ports_t = std::vector<named_input_port>;
     using head_ports_t = std::map<std::string, named_input_ports_t>;
@@ -39,7 +39,7 @@ namespace phlex::experimental {
   private:
     head_ports_t head_ports_;
     bool debug_;
-    std::atomic<std::size_t> received_messages_{};
+    std::atomic<std::size_t> received_messages_;
     std::chrono::duration<float, std::chrono::microseconds::period> execution_time_{};
   };
 
diff --git a/phlex/core/node_catalog.hpp b/phlex/core/node_catalog.hpp
index 36123c4e..b17504cf 100644
--- a/phlex/core/node_catalog.hpp
+++ b/phlex/core/node_catalog.hpp
@@ -26,12 +26,12 @@ namespace phlex::experimental {
     std::size_t execution_counts(std::string const& node_name) const;
     std::size_t product_counts(std::string const& node_name) const;
 
-    simple_ptr_map<declared_predicate_ptr> predicates{};
-    simple_ptr_map<declared_observer_ptr> observers{};
-    simple_ptr_map<declared_output_ptr> outputs{};
-    simple_ptr_map<declared_fold_ptr> folds{};
-    simple_ptr_map<declared_unfold_ptr> unfolds{};
-    simple_ptr_map<declared_transform_ptr> transforms{};
+    simple_ptr_map<declared_predicate_ptr> predicates;
+    simple_ptr_map<declared_observer_ptr> observers;
+    simple_ptr_map<declared_output_ptr> outputs;
+    simple_ptr_map<declared_fold_ptr> folds;
+    simple_ptr_map<declared_unfold_ptr> unfolds;
+    simple_ptr_map<declared_transform_ptr> transforms;
   };
 }
 
diff --git a/phlex/core/products_consumer.cpp b/phlex/core/products_consumer.cpp
index c0ed2b91..6a08d902 100644
--- a/phlex/core/products_consumer.cpp
+++ b/phlex/core/products_consumer.cpp
@@ -1,4 +1,10 @@
 #include "phlex/core/products_consumer.hpp"
+#include "phlex/core/specified_label.hpp"
+#include "phlex/model/algorithm_name.hpp"
+
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace phlex::experimental {
 
diff --git a/phlex/core/registrar.hpp b/phlex/core/registrar.hpp
index 92ef9e55..b23de96f 100644
--- a/phlex/core/registrar.hpp
+++ b/phlex/core/registrar.hpp
@@ -63,11 +63,11 @@ namespace phlex::experimental {
 
   template <typename Ptr>
   class registrar {
-    using Nodes = simple_ptr_map<Ptr>;
+    using nodes_t = simple_ptr_map<Ptr>;
     using node_creator = std::function<Ptr(std::vector<std::string>, std::vector<std::string>)>;
 
   public:
-    explicit registrar(Nodes& nodes, std::vector<std::string>& errors) :
+    explicit registrar(nodes_t& nodes, std::vector<std::string>& errors) :
       nodes_{&nodes}, errors_{&errors}
     {
     }
@@ -116,11 +116,11 @@ namespace phlex::experimental {
       }
     }
 
-    Nodes* nodes_;
+    nodes_t* nodes_;
     std::vector<std::string>* errors_;
     node_creator creator_{};
     std::optional<std::vector<std::string>> predicates_;
-    std::vector<std::string> output_products_{};
+    std::vector<std::string> output_products_;
   };
 }
 
diff --git a/phlex/core/registration_api.hpp b/phlex/core/registration_api.hpp
index 86a180f1..f5182fc6 100644
--- a/phlex/core/registration_api.hpp
+++ b/phlex/core/registration_api.hpp
@@ -24,10 +24,10 @@ namespace phlex::experimental {
   template <template <typename...> typename HOF, typename AlgorithmBits>
   class registration_api {
     using hof_type = HOF<AlgorithmBits>;
-    using NodePtr = typename hof_type::node_ptr_type;
+    using node_ptr = typename hof_type::node_ptr_type;
 
-    static constexpr auto N = AlgorithmBits::number_inputs;
-    static constexpr auto M = hof_type::number_output_products;
+    static constexpr auto number_inputs = AlgorithmBits::number_inputs;
+    static constexpr auto number_output_products = hof_type::number_output_products;
 
   public:
     registration_api(configuration const* config,
@@ -42,15 +42,18 @@ namespace phlex::experimental {
       alg_{std::move(alg)},
       concurrency_{c},
       graph_{g},
-      registrar_{nodes.registrar_for<NodePtr>(errors)}
+      registrar_{nodes.registrar_for<node_ptr>(errors)}
     {
     }
 
-    auto input_family(std::array<specified_label, N> input_args)
+    auto input_family(std::array<specified_label, number_inputs> input_args)
     {
-      if constexpr (M == 0ull) {
+      if constexpr (number_output_products == 0ull) {
+        // NOLINTBEGIN(performance-unnecessary-value-param)
         registrar_.set_creator(
-          [this, inputs = std::move(input_args)](auto predicates, auto /* output_products */) {
+          [this, inputs = std::move(input_args)](std::vector<std::string> predicates,
+                                                 std::vector<std::string> /* output_products */
+          ) {
             return std::make_unique<hof_type>(std::move(name_),
                                               concurrency_.value,
                                               std::move(predicates),
@@ -58,9 +61,11 @@ namespace phlex::experimental {
                                               std::move(alg_),
                                               std::vector(inputs.begin(), inputs.end()));
           });
+        // NOLINTEND(performance-unnecessary-value-param)
       } else {
         registrar_.set_creator(
-          [this, inputs = std::move(input_args)](auto predicates, auto output_products) {
+          [this, inputs = std::move(input_args)](std::vector<std::string> predicates,
+                                                 std::vector<std::string> output_products) {
             return std::make_unique<hof_type>(std::move(name_),
                                               concurrency_.value,
                                               std::move(predicates),
@@ -70,22 +75,21 @@ namespace phlex::experimental {
                                               std::move(output_products));
           });
       }
-      return upstream_predicates<NodePtr, M>{std::move(registrar_), config_};
+      return upstream_predicates<node_ptr, number_output_products>{std::move(registrar_), config_};
     }
 
     template <label_compatible L>
-    auto input_family(std::array<L, N> input_args)
+    auto input_family(std::array<L, number_inputs> const& input_args)
     {
       return input_family(to_labels(input_args));
     }
 
     auto input_family(label_compatible auto... input_args)
     {
-      static_assert(N == sizeof...(input_args),
+      static_assert(number_inputs == sizeof...(input_args),
                     "The number of function parameters is not the same as the number of specified "
                     "input arguments.");
-      return input_family(
-        {specified_label::create(std::forward<decltype(input_args)>(input_args))...});
+      return input_family({specified_label::create(std::move(input_args))...});
     }
 
   private:
@@ -93,8 +97,8 @@ namespace phlex::experimental {
     algorithm_name name_;
     AlgorithmBits alg_;
     concurrency concurrency_;
-    tbb::flow::graph& graph_;
-    registrar<NodePtr> registrar_;
+    tbb::flow::graph& graph_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
+    registrar<node_ptr> registrar_;
   };
 
   template <template <typename...> typename HOF, typename AlgorithmBits>
@@ -115,10 +119,10 @@ namespace phlex::experimental {
 
   template <typename AlgorithmBits, typename... InitArgs>
   class fold_api {
-    using InitTuple = std::tuple<InitArgs...>;
+    using init_tuple = std::tuple<InitArgs...>;
 
-    static constexpr auto N = AlgorithmBits::number_inputs;
-    static constexpr auto M = 1; // For now
+    static constexpr auto number_inputs = AlgorithmBits::number_inputs;
+    static constexpr auto number_output_products = 1; // For now
 
   public:
     fold_api(configuration const* config,
@@ -141,11 +145,12 @@ namespace phlex::experimental {
     {
     }
 
-    auto input_family(std::array<specified_label, N - 1> input_args)
+    auto input_family(std::array<specified_label, number_inputs - 1> input_args)
     {
       registrar_.set_creator(
-        [this, inputs = std::move(input_args)](auto predicates, auto output_products) {
-          return std::make_unique<fold_node<AlgorithmBits, InitTuple>>(
+        [this, inputs = std::move(input_args)](std::vector<std::string> predicates,
+                                               std::vector<std::string> output_products) {
+          return std::make_unique<fold_node<AlgorithmBits, init_tuple>>(
             std::move(name_),
             concurrency_.value,
             std::move(predicates),
@@ -156,18 +161,19 @@ namespace phlex::experimental {
             std::move(output_products),
             std::move(partition_));
         });
-      return upstream_predicates<declared_fold_ptr, M>{std::move(registrar_), config_};
+      return upstream_predicates<declared_fold_ptr, number_output_products>{std::move(registrar_),
+                                                                            config_};
     }
 
     template <label_compatible L>
-    auto input_family(std::array<L, N> input_args)
+    auto input_family(std::array<L, number_inputs> input_args)
     {
       return input_family(to_labels(input_args));
     }
 
     auto input_family(label_compatible auto... input_args)
     {
-      static_assert(N - 1 == sizeof...(input_args),
+      static_assert(number_inputs - 1 == sizeof...(input_args),
                     "The number of function parameters is not the same as the number of specified "
                     "input arguments.");
       return input_family(
@@ -179,9 +185,9 @@ namespace phlex::experimental {
     algorithm_name name_;
     AlgorithmBits alg_;
     concurrency concurrency_;
-    tbb::flow::graph& graph_;
+    tbb::flow::graph& graph_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
     std::string partition_;
-    InitTuple init_;
+    init_tuple init_;
     registrar<declared_fold_ptr> registrar_;
   };
 
@@ -192,8 +198,8 @@ namespace phlex::experimental {
   class unfold_api {
     using input_parameter_types = constructor_parameter_types<Object>;
 
-    static constexpr auto N = std::tuple_size_v<input_parameter_types>;
-    static constexpr std::size_t M = number_output_objects<Unfold>;
+    static constexpr auto number_inputs = std::tuple_size_v<input_parameter_types>;
+    static constexpr std::size_t number_output_products = number_output_objects<Unfold>;
 
     // FIXME: Should maybe use some type of static assert, but not in a way that
     //        constrains the arguments of the Predicate and the Unfold to be the same.
@@ -222,10 +228,11 @@ namespace phlex::experimental {
     {
     }
 
-    auto input_family(std::array<specified_label, N> input_args)
+    auto input_family(std::array<specified_label, number_inputs> input_args)
     {
       registrar_.set_creator(
-        [this, inputs = std::move(input_args)](auto upstream_predicates, auto output_products) {
+        [this, inputs = std::move(input_args)](std::vector<std::string> upstream_predicates,
+                                               std::vector<std::string> output_products) {
           return std::make_unique<unfold_node<Object, Predicate, Unfold>>(
             std::move(name_),
             concurrency_,
@@ -237,12 +244,13 @@ namespace phlex::experimental {
             std::move(output_products),
             std::move(destination_layer_));
         });
-      return upstream_predicates<declared_unfold_ptr, M>{std::move(registrar_), config_};
+      return upstream_predicates<declared_unfold_ptr, number_output_products>{std::move(registrar_),
+                                                                              config_};
     }
 
     auto input_family(label_compatible auto... input_args)
     {
-      static_assert(N == sizeof...(input_args),
+      static_assert(number_inputs == sizeof...(input_args),
                     "The number of function parameters is not the same as the number of specified "
                     "input arguments.");
       return input_family({specified_label{std::forward<decltype(input_args)>(input_args)}...});
@@ -253,7 +261,7 @@ namespace phlex::experimental {
     registrar<declared_unfold_ptr> registrar_;
     algorithm_name name_;
     std::size_t concurrency_;
-    tbb::flow::graph& graph_;
+    tbb::flow::graph& graph_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
     Predicate predicate_;
     Unfold unfold_;
     std::string destination_layer_;
@@ -280,7 +288,7 @@ namespace phlex::experimental {
 
   private:
     algorithm_name name_;
-    tbb::flow::graph& graph_;
+    tbb::flow::graph& graph_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
     detail::output_function_t ft_;
     concurrency concurrency_;
     registrar<declared_output_ptr> reg_;
diff --git a/phlex/core/specified_label.cpp b/phlex/core/specified_label.cpp
index 624b7ef6..bf1a3c73 100644
--- a/phlex/core/specified_label.cpp
+++ b/phlex/core/specified_label.cpp
@@ -2,14 +2,17 @@
 
 #include "fmt/format.h"
 
+#include <cstddef>
 #include <ostream>
 #include <stdexcept>
+#include <string>
 #include <tuple>
+#include <utility>
 
 namespace phlex::experimental {
   specified_label specified_label::operator()(std::string family) &&
   {
-    return {std::move(name), std::move(family)};
+    return {.name = std::move(name), .family = std::move(family)};
   }
 
   std::string specified_label::to_string() const
@@ -50,7 +53,7 @@ namespace phlex::experimental {
 
   specified_label specified_label::create(std::string const& s)
   {
-    return {qualified_name::create(s)};
+    return {.name = qualified_name::create(s)};
   }
 
   specified_label specified_label::create(specified_label l) { return l; }
diff --git a/phlex/core/specified_label.hpp b/phlex/core/specified_label.hpp
index c2f06d90..e6a1094c 100644
--- a/phlex/core/specified_label.hpp
+++ b/phlex/core/specified_label.hpp
@@ -26,7 +26,7 @@ namespace phlex::experimental {
   inline auto& to_name(specified_label const& label) { return label.name.name(); }
   inline auto& to_family(specified_label& label) { return label.family; }
 
-  specified_label operator""_in(char const* str, std::size_t);
+  specified_label operator""_in(char const* name, std::size_t);
   bool operator==(specified_label const& a, specified_label const& b);
   bool operator!=(specified_label const& a, specified_label const& b);
   bool operator<(specified_label const& a, specified_label const& b);
diff --git a/phlex/core/store_counters.hpp b/phlex/core/store_counters.hpp
index a32b083d..657c19e8 100644
--- a/phlex/core/store_counters.hpp
+++ b/phlex/core/store_counters.hpp
@@ -44,7 +44,7 @@ namespace phlex::experimental {
 
   class store_counter {
   public:
-    void set_flush_value(product_store_const_ptr const& ptr, std::size_t original_message_id);
+    void set_flush_value(product_store_const_ptr const& store, std::size_t original_message_id);
     void increment(level_id::hash_type level_hash);
     bool is_complete();
     unsigned int original_message_id() const noexcept;
@@ -52,7 +52,7 @@ namespace phlex::experimental {
   private:
     using counts_t2 = tbb::concurrent_unordered_map<level_id::hash_type, std::atomic<std::size_t>>;
 
-    counts_t2 counts_{};
+    counts_t2 counts_;
 #ifdef __cpp_lib_atomic_shared_ptr
     std::atomic<flush_counts_ptr> flush_counts_{nullptr};
 #else
diff --git a/phlex/metaprogramming/delegate.hpp b/phlex/metaprogramming/delegate.hpp
index 996a340d..b7f4c89e 100644
--- a/phlex/metaprogramming/delegate.hpp
+++ b/phlex/metaprogramming/delegate.hpp
@@ -5,18 +5,21 @@
 
 #include <functional>
 #include <memory>
+#include <utility>
 
 namespace phlex::experimental {
   struct void_tag {};
 
   template <typename FT>
-  auto delegate(std::shared_ptr<void_tag>, FT f) // Used for lambda closures
+  auto delegate(std::shared_ptr<void_tag>, // NOLINT(performance-unnecessary-value-param)
+                FT f)                      // Used for lambda closures
   {
     return std::function{f};
   }
 
   template <typename R, typename... Args>
-  auto delegate(std::shared_ptr<void_tag>, R (*f)(Args...))
+  auto delegate(std::shared_ptr<void_tag>, // NOLINT(performance-unnecessary-value-param)
+                R (*f)(Args...))
   {
     return std::function{f};
   }
@@ -24,13 +27,15 @@ namespace phlex::experimental {
   template <typename R, typename T, typename... Args>
   auto delegate(std::shared_ptr<T> obj, R (T::*f)(Args...))
   {
-    return std::function{[t = obj, f](Args... args) mutable -> R { return ((*t).*f)(args...); }};
+    return std::function{
+      [t = std::move(obj), f](Args... args) mutable -> R { return ((*t).*f)(args...); }};
   }
 
   template <typename R, typename T, typename... Args>
   auto delegate(std::shared_ptr<T> obj, R (T::*f)(Args...) const)
   {
-    return std::function{[t = obj, f](Args... args) mutable -> R { return ((*t).*f)(args...); }};
+    return std::function{
+      [t = std::move(obj), f](Args... args) mutable -> R { return ((*t).*f)(args...); }};
   }
 
   template <typename Bound, typename Algorithm>
diff --git a/phlex/metaprogramming/detail/ctor_reflect_types.hpp b/phlex/metaprogramming/detail/ctor_reflect_types.hpp
index 6a3b4d00..8e3e418a 100644
--- a/phlex/metaprogramming/detail/ctor_reflect_types.hpp
+++ b/phlex/metaprogramming/detail/ctor_reflect_types.hpp
@@ -17,6 +17,8 @@
 // a loophole in the C++ type system.  Presumably, once reflection is available, we won't
 // have to resort to these shenanigans.
 
+// NOLINTBEGIN(cert-dcl50-cpp)
+
 // Begin Alexandr code
 // ===========================================================================
 
@@ -118,6 +120,8 @@ namespace refl {
 // ===========================================================================
 // End Alexandr code
 
+// NOLINTEND(cert-dcl50-cpp)
+
 #if BOOST_COMP_GNUC
 #pragma GCC diagnostic pop
 #endif
diff --git a/phlex/model/algorithm_name.cpp b/phlex/model/algorithm_name.cpp
index 10b48f9c..45836bc4 100644
--- a/phlex/model/algorithm_name.cpp
+++ b/phlex/model/algorithm_name.cpp
@@ -2,6 +2,7 @@
 
 #include <cassert>
 #include <regex>
+#include <stdexcept>
 #include <tuple>
 
 namespace {
@@ -11,8 +12,8 @@ namespace {
 namespace phlex::experimental {
   algorithm_name::algorithm_name() = default;
 
-  algorithm_name::algorithm_name(char const* name) : algorithm_name{std::string{name}} {}
-  algorithm_name::algorithm_name(std::string name) { *this = create(name); }
+  algorithm_name::algorithm_name(char const* spec) : algorithm_name{std::string{spec}} {}
+  algorithm_name::algorithm_name(std::string const& spec) { *this = create(spec); }
 
   algorithm_name::algorithm_name(std::string plugin,
                                  std::string algorithm,
diff --git a/phlex/model/algorithm_name.hpp b/phlex/model/algorithm_name.hpp
index 55a3a0e8..c4cd1131 100644
--- a/phlex/model/algorithm_name.hpp
+++ b/phlex/model/algorithm_name.hpp
@@ -1,17 +1,18 @@
 #ifndef PHLEX_MODEL_ALGORITHM_NAME_HPP
 #define PHLEX_MODEL_ALGORITHM_NAME_HPP
 
+#include <cstdint>
 #include <string>
 
 namespace phlex::experimental {
   class algorithm_name {
-    enum specified_fields { neither, either, both };
+    enum specified_fields : std::uint8_t { neither, either, both };
 
   public:
     algorithm_name();
 
     algorithm_name(char const* spec);
-    algorithm_name(std::string spec);
+    algorithm_name(std::string const& spec);
     algorithm_name(std::string plugin,
                    std::string algorithm,
                    specified_fields fields = specified_fields::both);
diff --git a/phlex/model/fwd.hpp b/phlex/model/fwd.hpp
index 7aeffc9e..4023dd6e 100644
--- a/phlex/model/fwd.hpp
+++ b/phlex/model/fwd.hpp
@@ -1,6 +1,7 @@
 #ifndef PHLEX_MODEL_FWD_HPP
 #define PHLEX_MODEL_FWD_HPP
 
+#include <cstdint>
 #include <memory>
 
 namespace phlex::experimental {
@@ -13,7 +14,7 @@ namespace phlex::experimental {
   using product_store_const_ptr = std::shared_ptr<product_store const>;
   using product_store_ptr = std::shared_ptr<product_store>;
 
-  enum class stage { process, flush };
+  enum class stage : std::uint8_t { process, flush };
 }
 
 #endif // PHLEX_MODEL_FWD_HPP
diff --git a/phlex/model/level_counter.cpp b/phlex/model/level_counter.cpp
index 68770e2e..4a5e14e2 100644
--- a/phlex/model/level_counter.cpp
+++ b/phlex/model/level_counter.cpp
@@ -1,7 +1,10 @@
 #include "phlex/model/level_counter.hpp"
+#include "phlex/model/level_id.hpp"
 #include "phlex/utilities/hashing.hpp"
 
 #include <cassert>
+#include <map>
+#include <utility>
 
 namespace phlex::experimental {
 
@@ -26,6 +29,13 @@ namespace phlex::experimental {
     }
   }
 
+  // Explicitly defined because of the custom-defined destructor (C++ core guideline C.21)
+  level_counter::level_counter(level_counter const&) = default;
+  level_counter& level_counter::operator=(level_counter const&) = default;
+
+  level_counter::level_counter(level_counter&&) noexcept(false) = default;
+  level_counter& level_counter::operator=(level_counter&&) noexcept(false) = default;
+
   level_counter level_counter::make_child(std::string const& level_name)
   {
     return {this, level_name};
diff --git a/phlex/model/level_counter.hpp b/phlex/model/level_counter.hpp
index 0ba3c229..c72f0164 100644
--- a/phlex/model/level_counter.hpp
+++ b/phlex/model/level_counter.hpp
@@ -30,7 +30,7 @@ namespace phlex::experimental {
     }
 
   private:
-    std::map<level_id::hash_type, std::size_t> child_counts_{};
+    std::map<level_id::hash_type, std::size_t> child_counts_;
   };
 
   using flush_counts_ptr = std::shared_ptr<flush_counts const>;
@@ -41,6 +41,13 @@ namespace phlex::experimental {
     level_counter(level_counter* parent, std::string const& level_name);
     ~level_counter();
 
+    level_counter(level_counter const&);
+    level_counter& operator=(level_counter const&);
+
+    // std::map data member prevents noexcept moves
+    level_counter(level_counter&&) noexcept(false);
+    level_counter& operator=(level_counter&&) noexcept(false);
+
     level_counter make_child(std::string const& level_name);
     flush_counts result() const
     {
@@ -55,13 +62,13 @@ namespace phlex::experimental {
 
     level_counter* parent_;
     level_id::hash_type level_hash_;
-    std::map<level_id::hash_type, std::size_t> child_counts_{};
+    std::map<level_id::hash_type, std::size_t> child_counts_;
   };
 
   class flush_counters {
   public:
-    void update(level_id_ptr const id);
-    flush_counts extract(level_id_ptr const id);
+    void update(level_id_ptr id);
+    flush_counts extract(level_id_ptr id);
 
   private:
     std::map<level_id::hash_type, std::shared_ptr<level_counter>> counters_;
diff --git a/phlex/model/level_hierarchy.cpp b/phlex/model/level_hierarchy.cpp
index eefb430e..6e408a17 100644
--- a/phlex/model/level_hierarchy.cpp
+++ b/phlex/model/level_hierarchy.cpp
@@ -12,6 +12,16 @@ namespace {
 
 namespace phlex::experimental {
 
+  // Explicitly defined because of the custom-defined destructor (C++ core guideline C.21)
+  level_hierarchy::level_hierarchy() = default;
+  level_hierarchy::level_hierarchy(level_hierarchy const&) = default;
+  level_hierarchy& level_hierarchy::operator=(level_hierarchy const&) = default;
+
+  level_hierarchy::level_hierarchy(level_hierarchy&&) noexcept(
+    std::is_nothrow_move_constructible<levels_t>{}) = default;
+  level_hierarchy& level_hierarchy::operator=(level_hierarchy&&) noexcept(
+    std::is_nothrow_move_assignable<levels_t>{}) = default;
+
   level_hierarchy::~level_hierarchy() { print(); }
 
   void level_hierarchy::increment_count(level_id_ptr const& id)
diff --git a/phlex/model/level_hierarchy.hpp b/phlex/model/level_hierarchy.hpp
index bf4b8e5c..ee3ffe8a 100644
--- a/phlex/model/level_hierarchy.hpp
+++ b/phlex/model/level_hierarchy.hpp
@@ -8,14 +8,37 @@
 
 #include <map>
 #include <memory>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace phlex::experimental {
 
   class level_hierarchy {
+    struct level_entry {
+      level_entry(std::string n, std::size_t par_hash) : name{std::move(n)}, parent_hash{par_hash}
+      {
+      }
+
+      std::string name;
+      std::size_t parent_hash;
+      std::atomic<std::size_t> count;
+    };
+
+    using levels_t = tbb::concurrent_unordered_map<std::size_t, std::shared_ptr<level_entry>>;
+
   public:
+    level_hierarchy();
+    level_hierarchy(level_hierarchy const&);
+    level_hierarchy& operator=(level_hierarchy const&);
+
+    // NOLINTNEXTLINE(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
+    level_hierarchy(level_hierarchy&&) noexcept(std::is_nothrow_move_constructible<levels_t>{});
+    level_hierarchy& operator=(level_hierarchy&&) noexcept(
+      std::is_nothrow_move_assignable<levels_t>{});
+
     ~level_hierarchy();
+
     void increment_count(level_id_ptr const& id);
     std::size_t count_for(std::string const& level_name) const;
 
@@ -30,17 +53,7 @@ namespace phlex::experimental {
                                std::string const& parent_name,
                                std::string indent = {}) const;
 
-    struct level_entry {
-      level_entry(std::string n, std::size_t par_hash) : name{std::move(n)}, parent_hash{par_hash}
-      {
-      }
-
-      std::string name;
-      std::size_t parent_hash;
-      std::atomic<std::size_t> count{};
-    };
-
-    tbb::concurrent_unordered_map<std::size_t, std::shared_ptr<level_entry>> levels_;
+    levels_t levels_;
   };
 
 }
diff --git a/phlex/model/level_id.cpp b/phlex/model/level_id.cpp
index 39030892..9c75ce92 100644
--- a/phlex/model/level_id.cpp
+++ b/phlex/model/level_id.cpp
@@ -4,10 +4,10 @@
 #include "boost/algorithm/string.hpp"
 
 #include <algorithm>
+#include <cstddef>
 #include <iterator>
 #include <map>
 #include <numeric>
-#include <stdexcept>
 
 namespace {
 
@@ -46,7 +46,7 @@ namespace phlex::experimental {
   level_id const& level_id::base() { return *base_ptr(); }
   level_id_ptr level_id::base_ptr()
   {
-    static phlex::experimental::level_id_ptr base_id{new level_id};
+    static phlex::experimental::level_id_ptr const base_id{new level_id};
     return base_id;
   }
 
@@ -127,9 +127,9 @@ namespace phlex::experimental {
   std::string level_id::to_string() const
   {
     // FIXME: prefix needs to be adjusted esp. if a root name can be supplied by the user.
-    std::string prefix{"["}; //"root: ["};
+    std::string const prefix{"["}; //"root: ["};
     std::string result;
-    std::string suffix{"]"};
+    std::string const suffix{"]"};
 
     if (number_ != -1ull) {
       result = to_string_this_level();
diff --git a/phlex/model/product_matcher.cpp b/phlex/model/product_matcher.cpp
index af3b568a..21aeab03 100644
--- a/phlex/model/product_matcher.cpp
+++ b/phlex/model/product_matcher.cpp
@@ -2,8 +2,11 @@
 
 #include "fmt/format.h"
 
+#include <array>
 #include <cassert>
 #include <regex>
+#include <stdexcept>
+#include <utility>
 
 namespace {
   auto value_or(std::string const& value, std::string const& default_value)
diff --git a/phlex/model/product_store.cpp b/phlex/model/product_store.cpp
index 22823a49..cff7cd3d 100644
--- a/phlex/model/product_store.cpp
+++ b/phlex/model/product_store.cpp
@@ -1,5 +1,5 @@
 #include "phlex/model/product_store.hpp"
-#include "phlex/model/level_id.hpp"
+#include "phlex/model/fwd.hpp"
 
 #include <memory>
 #include <utility>
@@ -115,9 +115,9 @@ namespace phlex::experimental {
   level_id_ptr const& product_store::id() const noexcept { return id_; }
   bool product_store::is_flush() const noexcept { return stage_ == stage::flush; }
 
-  bool product_store::contains_product(std::string const& product_name) const
+  bool product_store::contains_product(std::string const& key) const
   {
-    return products_.contains(product_name);
+    return products_.contains(key);
   }
 
   product_store_ptr const& more_derived(product_store_ptr const& a, product_store_ptr const& b)
diff --git a/phlex/model/product_store.hpp b/phlex/model/product_store.hpp
index c0060902..c08e2f46 100644
--- a/phlex/model/product_store.hpp
+++ b/phlex/model/product_store.hpp
@@ -10,6 +10,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <type_traits>
 
 namespace phlex::experimental {
@@ -37,7 +38,8 @@ namespace phlex::experimental {
     product_store_ptr make_child(std::size_t new_level_number,
                                  std::string const& new_level_name,
                                  std::string source = {},
-                                 stage st = stage::process);
+                                 stage processing_stage = stage::process);
+
     level_id_ptr const& id() const noexcept;
     bool is_flush() const noexcept;
 
@@ -84,11 +86,16 @@ namespace phlex::experimental {
 
   product_store_ptr const& more_derived(product_store_ptr const& a, product_store_ptr const& b);
 
+  // Delete overloads that result in dangling reference
+  product_store_ptr const& more_derived(product_store_ptr&&, product_store_ptr&&) = delete;
+  product_store_ptr const& more_derived(product_store_ptr&&, product_store_ptr const&) = delete;
+  product_store_ptr const& more_derived(product_store_ptr const&, product_store_ptr&&) = delete;
+
   template <std::size_t I, typename Tuple, typename Element>
   Element const& get_most_derived(Tuple const& tup, Element const& element)
   {
-    constexpr auto N = std::tuple_size_v<Tuple>;
-    if constexpr (I == N - 1) {
+    constexpr auto n_stores = std::tuple_size_v<Tuple>;
+    if constexpr (I == n_stores - 1) {
       return more_derived(element, std::get<I>(tup));
     } else {
       return get_most_derived<I + 1>(tup, more_derived(element, std::get<I>(tup)));
@@ -98,9 +105,9 @@ namespace phlex::experimental {
   template <typename Tuple>
   auto const& most_derived(Tuple const& tup)
   {
-    constexpr auto N = std::tuple_size_v<Tuple>;
-    static_assert(N > 0ull);
-    if constexpr (N == 1ull) {
+    constexpr auto n_stores = std::tuple_size_v<Tuple>;
+    static_assert(n_stores > 0ull);
+    if constexpr (n_stores == 1ull) {
       return std::get<0>(tup);
     } else {
       return get_most_derived<1ull>(tup, std::get<0>(tup));
diff --git a/phlex/model/products.hpp b/phlex/model/products.hpp
index f57d1513..e44a98bd 100644
--- a/phlex/model/products.hpp
+++ b/phlex/model/products.hpp
@@ -30,7 +30,7 @@ namespace phlex::experimental {
     explicit product(T&& prod) : obj{std::move(prod)} {}
 
     void const* address() const final { return &obj; }
-    virtual std::type_index type() const { return std::type_index{typeid(T)}; }
+    std::type_index type() const final { return std::type_index{typeid(T)}; }
     std::remove_cvref_t<T> obj;
   };
 
@@ -63,9 +63,9 @@ namespace phlex::experimental {
     void add_all(qualified_names const& names, std::tuple<Ts...> ts)
     {
       assert(names.size() == sizeof...(Ts));
-      [this, &names]<std::size_t... Is>(auto const& ts, std::index_sequence<Is...>) {
-        (this->add(names[Is].name(), std::get<Is>(ts)), ...);
-      }(ts, std::index_sequence_for<Ts...>{});
+      [this, &names]<std::size_t... Is>(auto ts, std::index_sequence<Is...>) {
+        (this->add(names[Is].name(), std::move(std::get<Is>(ts))), ...);
+      }(std::move(ts), std::index_sequence_for<Ts...>{});
     }
 
     template <typename T>
@@ -85,8 +85,9 @@ namespace phlex::experimental {
       // Unfortunately, this doesn't work well whenever products are inserted across
       // modules and shared object libraries.
 
-      auto available_product = it->second.get();
+      auto const* available_product = it->second.get();
       if (std::strcmp(typeid(T).name(), available_product->type().name()) == 0) {
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return reinterpret_cast<product<T> const*>(available_product)->obj;
       }
 
diff --git a/phlex/model/qualified_name.cpp b/phlex/model/qualified_name.cpp
index 5b2934ce..01a63c01 100644
--- a/phlex/model/qualified_name.cpp
+++ b/phlex/model/qualified_name.cpp
@@ -2,13 +2,16 @@
 #include "phlex/model/algorithm_name.hpp"
 
 #include <algorithm>
-#include <regex>
+#include <iterator>
+#include <tuple>
+#include <utility>
+#include <vector>
 
 namespace phlex::experimental {
   qualified_name::qualified_name() = default;
 
   qualified_name::qualified_name(char const* name) : qualified_name{std::string{name}} {}
-  qualified_name::qualified_name(std::string name) { *this = create(name); }
+  qualified_name::qualified_name(std::string const& name) { *this = create(name); }
 
   qualified_name::qualified_name(algorithm_name qualifier, std::string name) :
     qualifier_{std::move(qualifier)}, name_{std::move(name)}
@@ -40,7 +43,7 @@ namespace phlex::experimental {
 
   qualified_name qualified_name::create(std::string const& s)
   {
-    auto forward_slash = s.find("/");
+    auto forward_slash = s.find('/');
     if (forward_slash != std::string::npos) {
       return {algorithm_name::create(s.substr(0, forward_slash)), s.substr(forward_slash + 1)};
     }
diff --git a/phlex/model/qualified_name.hpp b/phlex/model/qualified_name.hpp
index 962c54e9..318b03e6 100644
--- a/phlex/model/qualified_name.hpp
+++ b/phlex/model/qualified_name.hpp
@@ -11,7 +11,7 @@ namespace phlex::experimental {
   public:
     qualified_name();
     qualified_name(char const* name);
-    qualified_name(std::string name);
+    qualified_name(std::string const& name);
     qualified_name(algorithm_name qualifier, std::string name);
 
     std::string full() const;
@@ -43,7 +43,7 @@ namespace phlex::experimental {
     }
 
   private:
-    algorithm_name const& qualifier_;
+    algorithm_name const& qualifier_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
   };
 
   qualified_names to_qualified_names(std::string const& name,
diff --git a/phlex/module.hpp b/phlex/module.hpp
index 8fc8e103..05d5a1bb 100644
--- a/phlex/module.hpp
+++ b/phlex/module.hpp
@@ -15,18 +15,22 @@ namespace phlex::experimental::detail {
 #define NARGS(...) BOOST_PP_DEC(BOOST_PP_VARIADIC_SIZE(__VA_OPT__(, ) __VA_ARGS__))
 
 #define CREATE_1ARG(m)                                                                             \
-  void create(phlex::experimental::graph_proxy<phlex::experimental::void_tag>& m,                  \
+  void create(phlex::experimental::graph_proxy<phlex::experimental::void_tag>&(m),                 \
               phlex::experimental::configuration const&)
-#define CREATE_2ARGS(m, pset)                                                                      \
-  void create(phlex::experimental::graph_proxy<phlex::experimental::void_tag>& m,                  \
-              phlex::experimental::configuration const& config)
+#define CREATE_2ARGS(m, config)                                                                    \
+  void create(phlex::experimental::graph_proxy<phlex::experimental::void_tag>&(m),                 \
+              phlex::experimental::configuration const&(config))
 
 #define SELECT_SIGNATURE(...)                                                                      \
   BOOST_PP_IF(BOOST_PP_EQUAL(NARGS(__VA_ARGS__), 1), CREATE_1ARG, CREATE_2ARGS)(__VA_ARGS__)
 
 #define PHLEX_EXPERIMENTAL_REGISTER_ALGORITHMS(...)                                                \
+  /* NOLINTBEGIN(misc-use-anonymous-namespace) */                                                  \
   static SELECT_SIGNATURE(__VA_ARGS__);                                                            \
+  /* NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables) */                            \
   BOOST_DLL_ALIAS(create, create_module)                                                           \
+  /* NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables) */                              \
+  /* NOLINTEND(misc-use-anonymous-namespace) */                                                    \
   SELECT_SIGNATURE(__VA_ARGS__)
 
 #endif // PHLEX_MODULE_HPP
diff --git a/phlex/source.hpp b/phlex/source.hpp
index 3182eab6..c5533e65 100644
--- a/phlex/source.hpp
+++ b/phlex/source.hpp
@@ -64,6 +64,8 @@ namespace phlex::experimental::detail {
 }
 
 #define PHLEX_EXPERIMENTAL_REGISTER_SOURCE(source)                                                 \
-  BOOST_DLL_ALIAS(phlex::experimental::detail::create_next<source>, create_source)
+  /* NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables) */                            \
+  BOOST_DLL_ALIAS(phlex::experimental::detail::create_next<source>, create_source)                 \
+  /* NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables) */
 
 #endif // PHLEX_SOURCE_HPP
diff --git a/phlex/utilities/async_driver.hpp b/phlex/utilities/async_driver.hpp
index 31c29a1d..2cf9e0d7 100644
--- a/phlex/utilities/async_driver.hpp
+++ b/phlex/utilities/async_driver.hpp
@@ -3,6 +3,7 @@
 
 #include <atomic>
 #include <condition_variable>
+#include <cstdint>
 #include <functional>
 #include <mutex>
 #include <optional>
@@ -13,7 +14,7 @@ namespace phlex::experimental {
 
   template <typename RT>
   class async_driver {
-    enum class states { off, drive, park };
+    enum class states : std::uint8_t { off, drive, park };
 
   public:
     template <typename FT>
@@ -22,6 +23,12 @@ namespace phlex::experimental {
     }
     async_driver(void (*ft)(async_driver<RT>&)) : driver_{ft} {}
 
+    // Moves and copies not allowed because of (e.g.) std::atomic
+    async_driver(async_driver const&) = delete;
+    async_driver(async_driver&&) = delete;
+    async_driver& operator=(async_driver const&) = delete;
+    async_driver& operator=(async_driver&&) = delete;
+
     ~async_driver() { thread_.join(); }
 
     std::optional<RT> operator()()
diff --git a/phlex/utilities/hashing.cpp b/phlex/utilities/hashing.cpp
index 4c0964ab..5c27348f 100644
--- a/phlex/utilities/hashing.cpp
+++ b/phlex/utilities/hashing.cpp
@@ -2,6 +2,9 @@
 
 #include "boost/functional/hash.hpp"
 
+#include <cstddef>
+#include <string>
+
 namespace phlex::experimental {
   std::hash<std::string> const string_hasher{};
 
diff --git a/phlex/utilities/resource_usage.cpp b/phlex/utilities/resource_usage.cpp
index dba3ad7a..36e6a250 100644
--- a/phlex/utilities/resource_usage.cpp
+++ b/phlex/utilities/resource_usage.cpp
@@ -3,6 +3,7 @@
 #include "fmt/std.h"
 #include "spdlog/spdlog.h"
 
+#include <chrono>
 #include <sys/resource.h>
 
 using namespace std::chrono;
@@ -24,7 +25,7 @@ namespace {
     rusage used;
     getrusage(RUSAGE_SELF, &used);
     auto const [secs, microsecs] = used.ru_utime;
-    return {.elapsed_time = secs + microsecs / 1e6, .max_rss = used.ru_maxrss / mem_denominator};
+    return {.elapsed_time = secs + (microsecs / 1e6), .max_rss = used.ru_maxrss / mem_denominator};
   }
 }
 
@@ -46,4 +47,10 @@ namespace phlex::experimental {
                  cpu_time / real_time * 100);
     spdlog::info("Max. RSS: {:.3f} MB", max_rss);
   }
+
+  resource_usage::resource_usage(resource_usage const&) = default;
+  resource_usage& resource_usage::operator=(resource_usage const&) = default;
+
+  resource_usage::resource_usage(resource_usage&&) = default;
+  resource_usage& resource_usage::operator=(resource_usage&&) = default;
 }
diff --git a/phlex/utilities/resource_usage.hpp b/phlex/utilities/resource_usage.hpp
index f79f4b4c..ee3fec6d 100644
--- a/phlex/utilities/resource_usage.hpp
+++ b/phlex/utilities/resource_usage.hpp
@@ -14,6 +14,14 @@ namespace phlex::experimental {
     resource_usage() noexcept;
     ~resource_usage();
 
+    resource_usage(resource_usage const&);
+    resource_usage& operator=(resource_usage const&);
+
+    // NOLINTBEGIN(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
+    resource_usage(resource_usage&&);
+    resource_usage& operator=(resource_usage&&);
+    // NOLINTEND(cppcoreguidelines-noexcept-move-operations,performance-noexcept-move-constructor)
+
   private:
     std::chrono::time_point<std::chrono::steady_clock> begin_wall_;
     double begin_cpu_;
diff --git a/phlex/utilities/simple_ptr_map.hpp b/phlex/utilities/simple_ptr_map.hpp
index 162d34f0..8821db7d 100644
--- a/phlex/utilities/simple_ptr_map.hpp
+++ b/phlex/utilities/simple_ptr_map.hpp
@@ -28,22 +28,27 @@ namespace phlex::experimental {
   // Support std::unique_ptr<T> only for now
   template <typename T>
   class simple_ptr_map<std::unique_ptr<T>> {
-    using Ptr = std::unique_ptr<T>;
-    std::map<std::string, Ptr> data_;
+    using ptr_t = std::unique_ptr<T>;
+    std::map<std::string, ptr_t> data_;
 
   public:
-    // std::map<std::string, Ptr> has a default constructor that does
+    // std::map<std::string, ptr_t> has a default constructor that does
     // not invoke the deleted default constructor of its
-    // std::pair<std::string const, Ptr> data member, but the compiler
+    // std::pair<std::string const, ptr_t> data member, but the compiler
     // doesn't look at that when deciding whether to delete the default
     // constructor of simple_ptr_map
     simple_ptr_map() = default;
+    ~simple_ptr_map() = default;
 
     // Explicitly disable copying
     simple_ptr_map(simple_ptr_map const&) = delete;
     simple_ptr_map& operator=(simple_ptr_map const&) = delete;
 
-    auto try_emplace(std::string node_name, Ptr ptr)
+    // Enable moves
+    simple_ptr_map(simple_ptr_map&&) = default;
+    simple_ptr_map& operator=(simple_ptr_map&&) = default;
+
+    auto try_emplace(std::string node_name, ptr_t ptr)
     {
       return data_.try_emplace(std::move(node_name), std::move(ptr));
     }
@@ -51,7 +56,7 @@ namespace phlex::experimental {
     auto begin() const { return data_.begin(); }
     auto end() const { return data_.end(); }
 
-    typename Ptr::element_type* get(std::string const& node_name) const
+    typename ptr_t::element_type* get(std::string const& node_name) const
     {
       if (auto it = data_.find(node_name); it != data_.end()) {
         return it->second.get();
diff --git a/phlex/utilities/stripped_name.cpp b/phlex/utilities/stripped_name.cpp
index 69e153ae..6ac9aeb3 100644
--- a/phlex/utilities/stripped_name.cpp
+++ b/phlex/utilities/stripped_name.cpp
@@ -1,17 +1,17 @@
 #include "phlex/utilities/stripped_name.hpp"
 
 #include <regex>
+#include <string>
 
 namespace {
   std::regex const keep_up_to_paren_right_before_function_params{R"((.*\w)\(.*)"};
 }
 
 namespace phlex::experimental::detail {
-
   std::string stripped_name(std::string full_name)
   {
     full_name = std::regex_replace(full_name, keep_up_to_paren_right_before_function_params, "$1");
     // Remove any upfront qualifiers
-    return full_name.substr(full_name.find_last_of(":") + 1ull);
+    return full_name.substr(full_name.find_last_of(':') + 1ull);
   }
 }
diff --git a/phlex/utilities/stripped_name.hpp b/phlex/utilities/stripped_name.hpp
index 61f583d7..c82de602 100644
--- a/phlex/utilities/stripped_name.hpp
+++ b/phlex/utilities/stripped_name.hpp
@@ -3,11 +3,8 @@
 
 #include <string>
 
-namespace phlex::experimental {
-  namespace detail {
-
-    std::string stripped_name(std::string full_name);
-  }
+namespace phlex::experimental::detail {
+  std::string stripped_name(std::string full_name);
 }
 
 #endif // PHLEX_UTILITIES_STRIPPED_NAME_HPP
diff --git a/phlex/utilities/thread_counter.hpp b/phlex/utilities/thread_counter.hpp
index 82966992..3f5ff79c 100644
--- a/phlex/utilities/thread_counter.hpp
+++ b/phlex/utilities/thread_counter.hpp
@@ -21,8 +21,15 @@ namespace phlex::experimental {
     }
     ~thread_counter() { --counter_; }
 
+    // Copying and moving not intended
+    thread_counter(thread_counter const&) = delete;
+    thread_counter(thread_counter&&) = delete;
+
+    thread_counter& operator=(thread_counter const&) = delete;
+    thread_counter& operator=(thread_counter&&) = delete;
+
   private:
-    counter_type& counter_;
+    counter_type& counter_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
     value_type max_;
   };
 }
diff --git a/test/allowed_families.cpp b/test/allowed_families.cpp
index 204c5d37..39c89965 100644
--- a/test/allowed_families.cpp
+++ b/test/allowed_families.cpp
@@ -1,11 +1,10 @@
 #include "phlex/core/framework_graph.hpp"
+#include "phlex/core/fwd.hpp"
 #include "phlex/model/level_id.hpp"
 #include "phlex/model/product_store.hpp"
 
 #include "catch2/catch_test_macros.hpp"
 
-#include <iostream>
-
 using namespace phlex::experimental;
 using namespace oneapi::tbb;
 
diff --git a/test/benchmarks/fibonacci_numbers.cpp b/test/benchmarks/fibonacci_numbers.cpp
index b04c805d..b998355d 100644
--- a/test/benchmarks/fibonacci_numbers.cpp
+++ b/test/benchmarks/fibonacci_numbers.cpp
@@ -1,6 +1,7 @@
 #include "test/benchmarks/fibonacci_numbers.hpp"
 
 #include <algorithm>
+#include <vector>
 
 namespace {
   auto fibs_less_than(int const n)
@@ -22,8 +23,5 @@ namespace {
 namespace test {
   fibonacci_numbers::fibonacci_numbers(int const n) : numbers_{fibs_less_than(n + 1)} {}
 
-  bool fibonacci_numbers::accept(int i) const
-  {
-    return std::binary_search(begin(numbers_), end(numbers_), i);
-  }
+  bool fibonacci_numbers::accept(int i) const { return std::ranges::binary_search(numbers_, i); }
 }
diff --git a/test/cached_execution_source.hpp b/test/cached_execution_source.hpp
index 41643edc..abddf942 100644
--- a/test/cached_execution_source.hpp
+++ b/test/cached_execution_source.hpp
@@ -27,17 +27,17 @@ namespace test {
       auto job_store = product_store::base();
       driver.yield(job_store);
 
-      for (std::size_t i : std::views::iota(0u, n_runs)) {
+      for (std::size_t const i : std::views::iota(0u, n_runs)) {
         auto run_store = job_store->make_child(i, "run");
         run_store->add_product<int>("number", 2 * i);
         driver.yield(run_store);
 
-        for (std::size_t j : std::views::iota(0u, n_subruns)) {
+        for (std::size_t const j : std::views::iota(0u, n_subruns)) {
           auto subrun_store = run_store->make_child(j, "subrun");
           subrun_store->add_product<int>("another", 3 * j);
           driver.yield(subrun_store);
 
-          for (std::size_t k : std::views::iota(0u, n_events)) {
+          for (std::size_t const k : std::views::iota(0u, n_events)) {
             auto event_store = subrun_store->make_child(k, "event");
             event_store->add_product<int>("still", 4 * k);
             driver.yield(event_store);
diff --git a/test/class_registration.cpp b/test/class_registration.cpp
index bb537b28..52403abe 100644
--- a/test/class_registration.cpp
+++ b/test/class_registration.cpp
@@ -1,4 +1,5 @@
 #include "phlex/core/framework_graph.hpp"
+#include "phlex/core/specified_label.hpp"
 #include "phlex/model/product_store.hpp"
 
 #include "catch2/catch_test_macros.hpp"
@@ -49,8 +50,9 @@ namespace {
 
 TEST_CASE("Call non-framework functions", "[programming model]")
 {
-  std::array const product_names{
-    specified_label{"number"}, specified_label{"temperature"}, specified_label{"name"}};
+  std::array const product_names{specified_label{.name = "number"},
+                                 specified_label{.name = "temperature"},
+                                 specified_label{.name = "name"}};
   std::array const oproduct_names{"onumber"s, "otemperature"s, "oname"s};
 
   auto store = product_store::base();
@@ -95,4 +97,6 @@ TEST_CASE("Call non-framework functions", "[programming model]")
   g.observe("verify_results", verify_results, concurrency::unlimited).input_family(product_names);
 
   g.execute();
+
+  CHECK(g.execution_counts("verify_results") == 1ull);
 }
diff --git a/test/concepts.cpp b/test/concepts.cpp
index dd4b0f76..c2b71419 100644
--- a/test/concepts.cpp
+++ b/test/concepts.cpp
@@ -1,13 +1,16 @@
 #include "phlex/core/concepts.hpp"
-#include "phlex/core/framework_graph.hpp"
 
 using namespace phlex::experimental;
 
 namespace {
+  // FIXME: Should is_transform_like support a function signature that
+  //        takes an argument by non-const reference?  It can make
+  //        sense if the function receives an argument corresponding
+  //        to a (mutable) resource.  But not for a data product...
   int transform [[maybe_unused]] (double&) { return 1; };
   void not_a_transform [[maybe_unused]] (int) {}
 
-  struct A {
+  struct struct_with_member_function {
     int call(int, int) const noexcept { return 1; };
   };
 }
@@ -15,7 +18,7 @@ namespace {
 int main()
 {
   static_assert(is_transform_like<decltype(transform)>);
-  static_assert(is_transform_like<decltype(&A::call)>);
+  static_assert(is_transform_like<decltype(&struct_with_member_function::call)>);
   static_assert(not is_transform_like<decltype(not_a_transform)>);
 
   static_assert(not is_observer_like<decltype(transform)>);
diff --git a/test/demo-giantdata/log_record.hpp b/test/demo-giantdata/log_record.hpp
index b5b4c9a3..22a65811 100644
--- a/test/demo-giantdata/log_record.hpp
+++ b/test/demo-giantdata/log_record.hpp
@@ -11,9 +11,10 @@
 static_assert(static_cast<int>(-1ULL) == -1, "static_cast<int>(-1ULL) is not -1");
 
 namespace demo {
-  inline int constexpr convert_to_int(std::size_t value) { return static_cast<int>(value); }
+  constexpr int convert_to_int(std::size_t value) { return static_cast<int>(value); }
+
+  constexpr std::size_t event_name_size = 16;
 
-  std::size_t const EVENT_NAME_SIZE = 16;
   struct record {
     record(char const* event,
            std::size_t run_id,
@@ -37,8 +38,8 @@ namespace demo {
       double const ts =
         static_cast<double>(std::chrono::duration_cast<std::chrono::microseconds>(t).count());
       timestamp = ts * 1.0e-6;
-      std::strncpy(this->event, event, EVENT_NAME_SIZE);
-      this->event[EVENT_NAME_SIZE - 1] = '\0'; // ensure null-termination
+      std::strncpy(this->event, event, event_name_size);
+      this->event[event_name_size - 1] = '\0'; // ensure null-termination
     }
 
     int run_id;
@@ -49,7 +50,7 @@ namespace demo {
     int data;
     void const* orig;
     double timestamp;
-    char event[EVENT_NAME_SIZE];
+    char event[event_name_size];
     int thread_index;
   };
 
@@ -74,9 +75,10 @@ namespace demo {
                          std::size_t data = 0,
                          void const* orig = nullptr)
   {
-    record r(event, run_id, subrun_id, spill_id, apa_id, active, data, orig);
+    record const r(event, run_id, subrun_id, spill_id, apa_id, active, data, orig);
     global_queue.push(r);
   }
+
   inline void write_log(std::string const& filename)
   {
     std::ofstream log_file(filename, std::ios_base::out | std::ios_base::trunc);
diff --git a/test/demo-giantdata/summed_clamped_waveforms.hpp b/test/demo-giantdata/summed_clamped_waveforms.hpp
index e7ece55e..719181bb 100644
--- a/test/demo-giantdata/summed_clamped_waveforms.hpp
+++ b/test/demo-giantdata/summed_clamped_waveforms.hpp
@@ -6,7 +6,7 @@
 
 namespace demo {
 
-  struct SummedClampedWaveforms {
+  struct summed_clamped_waveforms {
     std::size_t size = 0;
     double sum = 0.0;
   };
diff --git a/test/demo-giantdata/unfold_transform_fold.cpp b/test/demo-giantdata/unfold_transform_fold.cpp
index 8c48565b..698be56b 100644
--- a/test/demo-giantdata/unfold_transform_fold.cpp
+++ b/test/demo-giantdata/unfold_transform_fold.cpp
@@ -5,11 +5,12 @@
 #include "test/products_for_output.hpp"
 
 #include "test/demo-giantdata/log_record.hpp"
+#include "test/demo-giantdata/summed_clamped_waveforms.hpp"
 #include "test/demo-giantdata/user_algorithms.hpp"
 #include "test/demo-giantdata/waveform_generator.hpp"
 #include "test/demo-giantdata/waveform_generator_input.hpp"
 
-#include <algorithm>
+#include <cstddef>
 #include <ranges>
 #include <string>
 #include <vector>
@@ -21,7 +22,6 @@ using namespace phlex::experimental;
 // ./unfold_transform_fold [number of spills [APAs per spill]]
 int main(int argc, char* argv[])
 {
-
   std::vector<std::string> const args(argv + 1, argv + argc);
   std::size_t const n_runs = [&args]() {
     if (args.size() > 1) {
@@ -62,15 +62,15 @@ int main(int argc, char* argv[])
     driver.yield(job_store);
 
     // job -> run -> subrun -> spill levels
-    for (unsigned runno : std::views::iota(0u, n_runs)) {
+    for (unsigned int const runno : std::views::iota(0u, n_runs)) {
       auto run_store = job_store->make_child(runno, "run");
       driver.yield(run_store);
 
-      for (unsigned subrunno : std::views::iota(0u, n_subruns)) {
+      for (unsigned int const subrunno : std::views::iota(0u, n_subruns)) {
         auto subrun_store = run_store->make_child(subrunno, "subrun");
         driver.yield(subrun_store);
 
-        for (unsigned spillno : std::views::iota(0u, n_spills)) {
+        for (unsigned int const spillno : std::views::iota(0u, n_spills)) {
 
           auto spill_store = subrun_store->make_child(spillno, "spill");
 
@@ -106,13 +106,13 @@ int main(int argc, char* argv[])
     framework_graph g{source};
 
     // Add the unfold node to the graph. We do not yet know how to provide the chunksize
-    // to the constructor of the WaveformGenerator, so we will use the default value.
+    // to the constructor of the waveform_generator, so we will use the default value.
     demo::log_record("add_unfold");
     auto const chunksize = 256LL; // this could be read from a configuration file
 
-    g.unfold<demo::WaveformGenerator>(
-       &demo::WaveformGenerator::predicate,
-       [](demo::WaveformGenerator const& wg, std::size_t running_value) {
+    g.unfold<demo::waveform_generator>(
+       &demo::waveform_generator::predicate,
+       [](demo::waveform_generator const& wg, std::size_t running_value) {
          return wg.op(running_value, chunksize);
        },
        concurrency::unlimited,
@@ -122,12 +122,12 @@ int main(int argc, char* argv[])
 
     // Add the transform node to the graph.
     demo::log_record("add_transform");
-    auto wrapped_user_function = [](phlex::experimental::handle<demo::Waveforms> hwf) {
+    auto wrapped_user_function = [](phlex::experimental::handle<demo::waveforms> hwf) {
       auto apa_id = hwf.level_id().number();
       auto spill_id = hwf.level_id().parent()->number();
       auto subrun_id = hwf.level_id().parent()->parent()->number();
       auto run_id = hwf.level_id().parent()->parent()->parent()->number();
-      return demo::clampWaveforms(*hwf, run_id, subrun_id, spill_id, apa_id);
+      return demo::clamp_waveforms(*hwf, run_id, subrun_id, spill_id, apa_id);
     };
 
     g.transform("clamp_node", wrapped_user_function, concurrency::unlimited)
@@ -138,12 +138,12 @@ int main(int argc, char* argv[])
     demo::log_record("add_fold");
     g.fold(
        "accum_for_spill",
-       [](demo::SummedClampedWaveforms& scw, phlex::experimental::handle<demo::Waveforms> hwf) {
+       [](demo::summed_clamped_waveforms& scw, phlex::experimental::handle<demo::waveforms> hwf) {
          auto apa_id = hwf.level_id().number();
          auto spill_id = hwf.level_id().parent()->number();
          auto subrun_id = hwf.level_id().parent()->parent()->number();
          auto run_id = hwf.level_id().parent()->parent()->parent()->number();
-         demo::accumulateSCW(scw, *hwf, run_id, subrun_id, spill_id, apa_id);
+         demo::accumulate_scw(scw, *hwf, run_id, subrun_id, spill_id, apa_id);
        },
        concurrency::unlimited,
        "spill" // partition the output by the spill
diff --git a/test/demo-giantdata/user_algorithms.cpp b/test/demo-giantdata/user_algorithms.cpp
index 231099b3..e4da7046 100644
--- a/test/demo-giantdata/user_algorithms.cpp
+++ b/test/demo-giantdata/user_algorithms.cpp
@@ -5,16 +5,16 @@
 
 // This function is used to transform an input Waveforms object into an
 // output Waveforms object. The output is a clamped version of the input.
-demo::Waveforms demo::clampWaveforms(demo::Waveforms const& input,
-                                     std::size_t run_id,
-                                     std::size_t subrun_id,
-                                     std::size_t spill_id,
-                                     std::size_t apa_id)
+demo::waveforms demo::clamp_waveforms(demo::waveforms const& input,
+                                      std::size_t run_id,
+                                      std::size_t subrun_id,
+                                      std::size_t spill_id,
+                                      std::size_t apa_id)
 {
   demo::log_record(
     "start_clamp", run_id, subrun_id, spill_id, apa_id, &input, input.size(), nullptr);
-  demo::Waveforms result(input);
-  for (demo::Waveform& wf : result.waveforms) {
+  demo::waveforms result(input);
+  for (demo::waveform& wf : result.data) {
     for (double& x : wf.samples) {
       x = std::clamp(x, -10.0, 10.0);
     }
@@ -23,19 +23,19 @@ demo::Waveforms demo::clampWaveforms(demo::Waveforms const& input,
   return result;
 }
 
-// This is the fold operator that will accumulate a SummedClampedWaveforms object.
-void demo::accumulateSCW(demo::SummedClampedWaveforms& accumulator,
-                         demo::Waveforms const& wf,
-                         std::size_t run_id,
-                         std::size_t subrun_id,
-                         std::size_t spill_id,
-                         std::size_t apa_id)
+// This is the fold operator that will accumulate a summed_clamped_waveforms object.
+void demo::accumulate_scw(demo::summed_clamped_waveforms& accumulator,
+                          demo::waveforms const& wf,
+                          std::size_t run_id,
+                          std::size_t subrun_id,
+                          std::size_t spill_id,
+                          std::size_t apa_id)
 {
-  // This is the fold operator that will accumulate a SummedClampedWaveforms object.
+  // This is the fold operator that will accumulate a summed_clamped_waveforms object.
   demo::log_record(
     "start_accSCW", run_id, subrun_id, spill_id, apa_id, &accumulator, wf.size(), &wf);
   accumulator.size += wf.size();
-  for (auto const& w : wf.waveforms) {
+  for (auto const& w : wf.data) {
     for (double x : w.samples) {
       accumulator.sum += x;
     }
diff --git a/test/demo-giantdata/user_algorithms.hpp b/test/demo-giantdata/user_algorithms.hpp
index 6c7e6759..5c38291b 100644
--- a/test/demo-giantdata/user_algorithms.hpp
+++ b/test/demo-giantdata/user_algorithms.hpp
@@ -8,19 +8,19 @@ namespace demo {
 
   // This function is used to transform an input Waveforms object into an
   // output Waveforms object. The output is a clamped version of the input.
-  Waveforms clampWaveforms(Waveforms const& input,
-                           std::size_t run_id,
-                           std::size_t subrun_id,
-                           std::size_t spill_id,
-                           std::size_t apa_id);
+  waveforms clamp_waveforms(waveforms const& input,
+                            std::size_t run_id,
+                            std::size_t subrun_id,
+                            std::size_t spill_id,
+                            std::size_t apa_id);
 
-  // This is the fold operator that will accumulate a SummedClampedWaveforms object.
-  void accumulateSCW(SummedClampedWaveforms& scw,
-                     Waveforms const& wf,
-                     std::size_t run_id,
-                     std::size_t subrun_id,
-                     std::size_t spill_id,
-                     std::size_t apa_id);
+  // This is the fold operator that will accumulate a summed_clamped_waveforms object.
+  void accumulate_scw(summed_clamped_waveforms& accumulator,
+                      waveforms const& wf,
+                      std::size_t run_id,
+                      std::size_t subrun_id,
+                      std::size_t spill_id,
+                      std::size_t apa_id);
 
 } // namespace demo
 
diff --git a/test/demo-giantdata/waveform_generator.cpp b/test/demo-giantdata/waveform_generator.cpp
index c5e8b638..3ea50e12 100644
--- a/test/demo-giantdata/waveform_generator.cpp
+++ b/test/demo-giantdata/waveform_generator.cpp
@@ -6,20 +6,20 @@
 
 #include <cstddef>
 
-demo::WaveformGenerator::WaveformGenerator(WGI const& wgi) :
+demo::waveform_generator::waveform_generator(WGI const& wgi) :
   maxsize_{wgi.size}, spill_id_(wgi.spill_id)
 {
   log_record("wgctor", -1, -1, spill_id_, -1, this, sizeof(*this), nullptr);
 }
 
-demo::WaveformGenerator::~WaveformGenerator()
+demo::waveform_generator::~waveform_generator()
 {
   log_record("wgdtor", -1, -1, spill_id_, -1, this, sizeof(*this), nullptr);
 }
 
-std::size_t demo::WaveformGenerator::initial_value() const { return 0; }
+std::size_t demo::waveform_generator::initial_value() const { return 0; }
 
-bool demo::WaveformGenerator::predicate(std::size_t made_so_far) const
+bool demo::waveform_generator::predicate(std::size_t made_so_far) const
 {
   log_record("start_pred", -1, -1, spill_id_, -1, this, made_so_far, nullptr);
   bool const result = made_so_far < maxsize_;
@@ -27,14 +27,14 @@ bool demo::WaveformGenerator::predicate(std::size_t made_so_far) const
   return result;
 }
 
-std::pair<std::size_t, demo::Waveforms> demo::WaveformGenerator::op(std::size_t made_so_far,
-                                                                    std::size_t chunksize) const
+std::pair<std::size_t, demo::waveforms> demo::waveform_generator::op(std::size_t made_so_far,
+                                                                     std::size_t chunksize) const
 {
   // How many waveforms should go into this chunk?
   log_record("start_op", -1, -1, spill_id_, -1, this, chunksize, nullptr);
   std::size_t const newsize = std::min(chunksize, maxsize_ - made_so_far);
   auto result =
-    std::make_pair(made_so_far + newsize, Waveforms{newsize, 1.0 * made_so_far, -1, -1, -1, -1});
+    std::make_pair(made_so_far + newsize, waveforms{newsize, 1.0 * made_so_far, -1, -1, -1, -1});
   log_record("end_op", -1, -1, spill_id_, -1, this, newsize, nullptr);
   return result;
-}
\ No newline at end of file
+}
diff --git a/test/demo-giantdata/waveform_generator.hpp b/test/demo-giantdata/waveform_generator.hpp
index 62d1485c..fda9ffa9 100644
--- a/test/demo-giantdata/waveform_generator.hpp
+++ b/test/demo-giantdata/waveform_generator.hpp
@@ -12,17 +12,17 @@ namespace demo {
   // when the unfold is stopped.
   // Note that this class knows nothing about "spills" or "APAs". It does not
   // know where the values of maxsize and chunksize come from.
-  class WaveformGenerator {
+  class waveform_generator {
   public:
-    // Create a WaveformGenerator that will generate waveforms exactly maxsize
+    // Create a waveform_generator that will generate waveforms exactly maxsize
     // waveforms. They will be spread across vectors each of size no more than
     //  chunksize.
-    explicit WaveformGenerator(WGI const& wgi);
-    WaveformGenerator(WaveformGenerator const&) = delete;
-    WaveformGenerator(WaveformGenerator&&) = delete;
-    WaveformGenerator& operator=(WaveformGenerator const&) = delete;
-    WaveformGenerator& operator=(WaveformGenerator&&) = delete;
-    ~WaveformGenerator();
+    explicit waveform_generator(WGI const& wgi);
+    waveform_generator(waveform_generator const&) = delete;
+    waveform_generator(waveform_generator&&) = delete;
+    waveform_generator& operator=(waveform_generator const&) = delete;
+    waveform_generator& operator=(waveform_generator&&) = delete;
+    ~waveform_generator();
 
     std::size_t initial_value() const;
 
@@ -33,11 +33,11 @@ namespace demo {
 
     // Generate the next chunk of waveforms, and update the count of how many
     // waveforms we have made so far.
-    std::pair<std::size_t, Waveforms> op(std::size_t made_so_far, std::size_t chunksize) const;
+    std::pair<std::size_t, waveforms> op(std::size_t made_so_far, std::size_t chunksize) const;
 
   private:
     std::size_t maxsize_; // total number of waveforms to make for the unfold
     int spill_id_;        // the id of the spill this object will process
-  }; // class WaveformGenerator
+  }; // class waveform_generator
 } // namespace demo
 #endif // TEST_DEMO_GIANTDATA_WAVEFORM_GENERATOR_HPP
diff --git a/test/demo-giantdata/waveform_generator_input.cpp b/test/demo-giantdata/waveform_generator_input.cpp
index de649083..6d708e55 100644
--- a/test/demo-giantdata/waveform_generator_input.cpp
+++ b/test/demo-giantdata/waveform_generator_input.cpp
@@ -1,29 +1,29 @@
 #include "waveform_generator_input.hpp"
 #include "log_record.hpp"
 
-demo::WaveformGeneratorInput::WaveformGeneratorInput(std::size_t size,
-                                                     std::size_t run_id,
-                                                     std::size_t subrun_id,
-                                                     std::size_t spill_id) :
+demo::waveform_generator_input::waveform_generator_input(std::size_t size,
+                                                         std::size_t run_id,
+                                                         std::size_t subrun_id,
+                                                         std::size_t spill_id) :
   size(size), run_id(run_id), subrun_id(subrun_id), spill_id(spill_id)
 {
   log_record("wgictor", run_id, subrun_id, spill_id, -1, this, mysize(*this), nullptr);
 }
 
-demo::WaveformGeneratorInput::WaveformGeneratorInput(WaveformGeneratorInput const& other) :
+demo::waveform_generator_input::waveform_generator_input(waveform_generator_input const& other) :
   size(other.size), run_id(other.run_id), subrun_id(other.subrun_id), spill_id(other.spill_id)
 {
   log_record("wgicopy", run_id, subrun_id, spill_id, -1, this, mysize(*this), &other);
 }
 
-demo::WaveformGeneratorInput::WaveformGeneratorInput(WaveformGeneratorInput&& other) :
+demo::waveform_generator_input::waveform_generator_input(waveform_generator_input&& other) :
   size(other.size), run_id(other.run_id), subrun_id(other.subrun_id), spill_id(other.spill_id)
 {
   log_record("wgimove", run_id, subrun_id, spill_id, -1, this, mysize(*this), &other);
 }
 
-demo::WaveformGeneratorInput& demo::WaveformGeneratorInput::operator=(
-  WaveformGeneratorInput const& other)
+demo::waveform_generator_input& demo::waveform_generator_input::operator=(
+  waveform_generator_input const& other)
 {
   log_record("wgicopy=", run_id, subrun_id, spill_id, -1, this, 0, &other);
   size = other.size;
@@ -31,8 +31,8 @@ demo::WaveformGeneratorInput& demo::WaveformGeneratorInput::operator=(
   return *this;
 }
 
-demo::WaveformGeneratorInput& demo::WaveformGeneratorInput::operator=(
-  WaveformGeneratorInput&& other)
+demo::waveform_generator_input& demo::waveform_generator_input::operator=(
+  waveform_generator_input&& other)
 {
   log_record("wgimove=", run_id, subrun_id, spill_id, -1, this, 0, &other);
   size = other.size;
@@ -40,7 +40,7 @@ demo::WaveformGeneratorInput& demo::WaveformGeneratorInput::operator=(
   return *this;
 }
 
-demo::WaveformGeneratorInput::~WaveformGeneratorInput()
+demo::waveform_generator_input::~waveform_generator_input()
 {
   log_record("wgidtor", run_id, subrun_id, spill_id, -1, this, mysize(*this), nullptr);
 }
diff --git a/test/demo-giantdata/waveform_generator_input.hpp b/test/demo-giantdata/waveform_generator_input.hpp
index 0cd41a16..dad3f27a 100644
--- a/test/demo-giantdata/waveform_generator_input.hpp
+++ b/test/demo-giantdata/waveform_generator_input.hpp
@@ -5,19 +5,19 @@
 
 namespace demo {
   // This is the data product that our unfold node will receive from each spill.
-  struct WaveformGeneratorInput {
+  struct waveform_generator_input {
 
-    explicit WaveformGeneratorInput(std::size_t size = -1,
-                                    std::size_t run_id = -1,
-                                    std::size_t subrun_id = -1,
-                                    std::size_t spill_id = -1);
-    WaveformGeneratorInput(WaveformGeneratorInput const& other);
-    WaveformGeneratorInput(WaveformGeneratorInput&& other);
+    explicit waveform_generator_input(std::size_t size = -1,
+                                      std::size_t run_id = -1,
+                                      std::size_t subrun_id = -1,
+                                      std::size_t spill_id = -1);
+    waveform_generator_input(waveform_generator_input const& other);
+    waveform_generator_input(waveform_generator_input&& other);
 
-    WaveformGeneratorInput& operator=(WaveformGeneratorInput const& other);
-    WaveformGeneratorInput& operator=(WaveformGeneratorInput&& other);
+    waveform_generator_input& operator=(waveform_generator_input const& other);
+    waveform_generator_input& operator=(waveform_generator_input&& other);
 
-    ~WaveformGeneratorInput();
+    ~waveform_generator_input();
 
     std::size_t size;
     std::size_t run_id;
@@ -25,8 +25,8 @@ namespace demo {
     std::size_t spill_id;
   };
 
-  using WGI = WaveformGeneratorInput;
-  inline std::size_t mysize(WaveformGeneratorInput const& w) { return sizeof(w); }
+  using WGI = waveform_generator_input;
+  inline std::size_t mysize(waveform_generator_input const& w) { return sizeof(w); }
 } // namespace demo
 
 #endif // TEST_DEMO_GIANTDATA_WAVEFORM_GENERATOR_INPUT_HPP
diff --git a/test/demo-giantdata/waveforms.cpp b/test/demo-giantdata/waveforms.cpp
index bd538af8..340fd77e 100644
--- a/test/demo-giantdata/waveforms.cpp
+++ b/test/demo-giantdata/waveforms.cpp
@@ -1,46 +1,46 @@
 #include "waveforms.hpp"
 #include "log_record.hpp"
 
-std::size_t demo::Waveforms::size() const { return waveforms.size(); }
+std::size_t demo::waveforms::size() const { return data.size(); }
 
-demo::Waveforms::Waveforms(
+demo::waveforms::waveforms(
   std::size_t n, double val, int run_id, int subrun_id, int spill_id, int apa_id) :
-  waveforms(n, {val}), run_id(run_id), subrun_id(subrun_id), spill_id(spill_id), apa_id(apa_id)
+  data(n, {val}), run_id(run_id), subrun_id(subrun_id), spill_id(spill_id), apa_id(apa_id)
 {
   log_record("wsctor", 0, 0, spill_id, apa_id, this, n, nullptr);
 }
 
-demo::Waveforms::Waveforms(Waveforms const& other) :
-  waveforms(other.waveforms), spill_id(other.spill_id), apa_id(other.apa_id)
+demo::waveforms::waveforms(waveforms const& other) :
+  data(other.data), spill_id(other.spill_id), apa_id(other.apa_id)
 {
-  log_record("wscopy", 0, 0, spill_id, apa_id, this, waveforms.size(), &other);
+  log_record("wscopy", 0, 0, spill_id, apa_id, this, data.size(), &other);
 }
 
-demo::Waveforms::Waveforms(Waveforms&& other) :
-  waveforms(std::move(other.waveforms)), spill_id(other.spill_id), apa_id(other.apa_id)
+demo::waveforms::waveforms(waveforms&& other) :
+  data(std::move(other.data)), spill_id(other.spill_id), apa_id(other.apa_id)
 {
-  log_record("wsmove", 0, 0, spill_id, apa_id, this, waveforms.size(), &other);
+  log_record("wsmove", 0, 0, spill_id, apa_id, this, data.size(), &other);
 }
 
-demo::Waveforms& demo::Waveforms::operator=(Waveforms const& other)
+demo::waveforms& demo::waveforms::operator=(waveforms const& other)
 {
-  waveforms = other.waveforms;
+  data = other.data;
   spill_id = other.spill_id;
   apa_id = other.apa_id;
-  log_record("wscopy=", 0, 0, spill_id, apa_id, this, waveforms.size(), &other);
+  log_record("wscopy=", 0, 0, spill_id, apa_id, this, data.size(), &other);
   return *this;
 }
 
-demo::Waveforms& demo::Waveforms::operator=(Waveforms&& other)
+demo::waveforms& demo::waveforms::operator=(waveforms&& other)
 {
-  waveforms = std::move(other.waveforms);
+  data = std::move(other.data);
   spill_id = other.spill_id;
   apa_id = other.apa_id;
-  log_record("wsmove=", 0, 0, spill_id, apa_id, this, waveforms.size(), &other);
+  log_record("wsmove=", 0, 0, spill_id, apa_id, this, data.size(), &other);
   return *this;
 }
 
-demo::Waveforms::~Waveforms()
+demo::waveforms::~waveforms()
 {
-  log_record("wsdtor", 0, 0, spill_id, apa_id, this, waveforms.size(), nullptr);
+  log_record("wsdtor", 0, 0, spill_id, apa_id, this, data.size(), nullptr);
 };
diff --git a/test/demo-giantdata/waveforms.hpp b/test/demo-giantdata/waveforms.hpp
index 898f0264..e63be450 100644
--- a/test/demo-giantdata/waveforms.hpp
+++ b/test/demo-giantdata/waveforms.hpp
@@ -7,13 +7,13 @@
 
 namespace demo {
 
-  struct Waveform {
+  struct waveform {
     // We should be set to the number of samples on a wire.
-    std::array<double, 3 * 1024> samples;
+    std::array<double, static_cast<std::size_t>(3 * 1024)> samples;
   };
 
-  struct Waveforms {
-    std::vector<Waveform> waveforms;
+  struct waveforms {
+    std::vector<waveform> data;
     int run_id;
     int subrun_id;
     int spill_id;
@@ -21,15 +21,15 @@ namespace demo {
 
     std::size_t size() const;
 
-    Waveforms(std::size_t n, double val, int run_id, int subrun_id, int spill_id, int apa_id);
-    Waveforms(Waveforms const& other);
-    Waveforms(Waveforms&& other);
+    waveforms(std::size_t n, double val, int run_id, int subrun_id, int spill_id, int apa_id);
+    waveforms(waveforms const& other);
+    waveforms(waveforms&& other);
 
     // instrument copy assignment and move assignment
-    Waveforms& operator=(Waveforms const& other);
-    Waveforms& operator=(Waveforms&& other);
+    waveforms& operator=(waveforms const& other);
+    waveforms& operator=(waveforms&& other);
 
-    ~Waveforms();
+    ~waveforms();
   };
 
 } // namespace demo
diff --git a/test/different_hierarchies.cpp b/test/different_hierarchies.cpp
index 9f82fdec..485af707 100644
--- a/test/different_hierarchies.cpp
+++ b/test/different_hierarchies.cpp
@@ -36,7 +36,6 @@
 #include <atomic>
 #include <ranges>
 #include <string>
-#include <vector>
 
 using namespace phlex::experimental;
 
@@ -44,11 +43,11 @@ namespace {
   void add(std::atomic<unsigned int>& counter, unsigned int number) { counter += number; }
 
   // job -> run -> event levels
-  constexpr auto index_limit = 2u;
-  constexpr auto number_limit = 5u;
+  constexpr auto index_limit = 2ull;
+  constexpr auto number_limit = 5ull;
 
   // job -> trigger primitive levels
-  constexpr auto primitive_limit = 10u;
+  constexpr auto primitive_limit = 10ull;
 
   void levels_to_process(framework_driver& driver)
   {
@@ -56,10 +55,10 @@ namespace {
     driver.yield(job_store);
 
     // job -> run -> event levels
-    for (unsigned i : std::views::iota(0u, index_limit)) {
+    for (unsigned const i : std::views::iota(0ull, index_limit)) {
       auto run_store = job_store->make_child(i, "run");
       driver.yield(run_store);
-      for (unsigned j : std::views::iota(0u, number_limit)) {
+      for (unsigned const j : std::views::iota(0ull, number_limit)) {
         auto event_store = run_store->make_child(j, "event");
         event_store->add_product("number", j);
         driver.yield(event_store);
@@ -67,7 +66,7 @@ namespace {
     }
 
     // job -> trigger primitive levels
-    for (unsigned i : std::views::iota(0u, primitive_limit)) {
+    for (unsigned const i : std::views::iota(0ull, primitive_limit)) {
       auto tp_store = job_store->make_child(i, "trigger primitive");
       tp_store->add_product("number", i);
       driver.yield(tp_store);
@@ -84,10 +83,10 @@ TEST_CASE("Different hierarchies used with fold", "[graph]")
     .output_products("run_sum");
   g.fold("job_add", add, concurrency::unlimited).input_family("number").output_products("job_sum");
 
-  g.observe("verify_run_sum", [](unsigned int actual) { CHECK(actual == 10u); })
+  g.observe("verify_run_sum", [](unsigned int const actual) { CHECK(actual == 10u); })
     .input_family("run_sum");
   g.observe("verify_job_sum",
-            [](unsigned int actual) {
+            [](unsigned int const actual) {
               CHECK(actual == 20u + 45u); // 20u from events, 45u from trigger primitives
             })
     .input_family("job_sum");
diff --git a/test/filter.cpp b/test/filter.cpp
index 5e12f236..5964399e 100644
--- a/test/filter.cpp
+++ b/test/filter.cpp
@@ -1,9 +1,17 @@
 #include "phlex/core/framework_graph.hpp"
+#include "phlex/core/fwd.hpp"
 #include "phlex/model/product_store.hpp"
 
 #include "catch2/catch_test_macros.hpp"
 #include "oneapi/tbb/concurrent_vector.h"
 
+#include <algorithm>
+#include <atomic>
+#include <cstdlib>
+#include <initializer_list>
+#include <ranges>
+#include <vector>
+
 using namespace phlex::experimental;
 using namespace oneapi::tbb;
 
@@ -12,12 +20,12 @@ namespace {
   public:
     explicit source(unsigned const max_n) : max_{max_n} {}
 
-    void operator()(framework_driver& driver)
+    void operator()(framework_driver& driver) const
     {
       auto job_store = product_store::base();
       driver.yield(job_store);
 
-      for (unsigned int i : std::views::iota(1u, max_ + 1)) {
+      for (unsigned int const i : std::views::iota(1u, max_ + 1)) {
         auto store = job_store->make_child(i, "event");
         store->add_product<unsigned int>("num", i - 1);
         store->add_product<unsigned int>("other_num", 100 + i - 1);
@@ -26,47 +34,58 @@ namespace {
     }
 
   private:
-    unsigned const max_;
+    unsigned max_;
   };
 
   constexpr bool evens_only(unsigned int const value) { return value % 2u == 0u; }
   constexpr bool odds_only(unsigned int const value) { return not evens_only(value); }
 
   // Hacky!
-  struct sum_numbers {
-    sum_numbers(unsigned int const n) : total{n} {}
-    ~sum_numbers() { CHECK(sum == total); }
-    void add(unsigned int const num) { sum += num; }
-    std::atomic<unsigned int> sum;
-    unsigned int const total;
+  class sum_numbers {
+  public:
+    sum_numbers(unsigned int const n) : total_{n} {}
+    ~sum_numbers() { CHECK(sum_ == total_); }
+    void add(unsigned int const num) { sum_ += num; }
+
+  private:
+    std::atomic<unsigned int> sum_;
+    unsigned int const total_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
   };
 
   // Hacky!
-  struct collect_numbers {
-    collect_numbers(std::initializer_list<unsigned int> numbers) : expected{numbers} {}
+  class collect_numbers {
+  public:
+    collect_numbers(std::initializer_list<unsigned int> numbers) : expected_{numbers} {}
     ~collect_numbers()
     {
-      std::vector<unsigned int> sorted_actual(std::begin(actual), std::end(actual));
-      std::sort(begin(sorted_actual), end(sorted_actual));
-      CHECK(expected == sorted_actual);
+      std::vector<unsigned int> sorted_actual(actual_.begin(), actual_.end());
+      std::ranges::sort(sorted_actual);
+      CHECK(expected_ == sorted_actual);
     }
-    void collect(unsigned int const num) { actual.push_back(num); }
-    tbb::concurrent_vector<unsigned int> actual;
-    std::vector<unsigned int> const expected;
+    void collect(unsigned int const num) { actual_.push_back(num); }
+
+  private:
+    tbb::concurrent_vector<unsigned int> actual_;
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
+    std::vector<unsigned int> const expected_;
   };
 
   // Hacky!
-  struct check_multiple_numbers {
-    check_multiple_numbers(int const n) : total{n} {}
-    ~check_multiple_numbers() { CHECK(std::abs(sum) >= std::abs(total)); }
+  class check_multiple_numbers {
+  public:
+    explicit check_multiple_numbers(int const n) : total_{n} {}
+    ~check_multiple_numbers() { CHECK(std::abs(sum_) >= std::abs(total_)); }
+
     void add_difference(unsigned int const a, unsigned int const b)
     {
       // The difference is calculated to test that add(a, b) yields a different result
       // than add(b, a).
-      sum += static_cast<int>(b) - static_cast<int>(a);
+      sum_ += static_cast<int>(b) - static_cast<int>(a);
     }
-    std::atomic<int> sum;
-    int const total;
+
+  private:
+    std::atomic<int> sum_;
+    int const total_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
   };
 
   constexpr bool in_range(unsigned int const b, unsigned int const e, unsigned int const i) noexcept
@@ -74,11 +93,14 @@ namespace {
     return i >= b and i < e;
   }
 
-  struct not_in_range {
-    explicit not_in_range(unsigned int const b, unsigned int const e) : begin{b}, end{e} {}
-    unsigned int const begin;
-    unsigned int const end;
-    bool eval(unsigned int const i) const noexcept { return not in_range(begin, end, i); }
+  class not_in_range {
+  public:
+    explicit not_in_range(unsigned int const b, unsigned int const e) : begin_{b}, end_{e} {}
+    bool eval(unsigned int const i) const noexcept { return not in_range(begin_, end_, i); }
+
+  private:
+    unsigned int begin_;
+    unsigned int end_;
   };
 }
 
@@ -141,9 +163,9 @@ TEST_CASE("Three predicates in parallel", "[filtering]")
     unsigned int begin;
     unsigned int end;
   };
-  std::vector<predicate_config> configs{{.name = "exclude_0_to_4", .begin = 0, .end = 4},
-                                        {.name = "exclude_6_to_7", .begin = 6, .end = 7},
-                                        {.name = "exclude_gt_8", .begin = 8, .end = -1u}};
+  std::vector<predicate_config> const configs{{.name = "exclude_0_to_4", .begin = 0, .end = 4},
+                                              {.name = "exclude_6_to_7", .begin = 6, .end = 7},
+                                              {.name = "exclude_gt_8", .begin = 8, .end = -1u}};
 
   framework_graph g{source{10u}};
   for (auto const& [name, b, e] : configs) {
diff --git a/test/fold.cpp b/test/fold.cpp
index 6654b9f9..79693162 100644
--- a/test/fold.cpp
+++ b/test/fold.cpp
@@ -50,10 +50,10 @@ TEST_CASE("Different levels of fold", "[graph]")
   auto levels_to_process = [index_limit, number_limit](framework_driver& driver) {
     auto job_store = product_store::base();
     driver.yield(job_store);
-    for (unsigned i : std::views::iota(0u, index_limit)) {
+    for (unsigned int const i : std::views::iota(0u, index_limit)) {
       auto run_store = job_store->make_child(i, "run");
       driver.yield(run_store);
-      for (unsigned j : std::views::iota(0u, number_limit)) {
+      for (unsigned int const j : std::views::iota(0u, number_limit)) {
         auto event_store = run_store->make_child(j, "event");
         event_store->add_product("number", j);
         driver.yield(event_store);
diff --git a/test/function_registration.cpp b/test/function_registration.cpp
index 4ec5b59f..bd32d32a 100644
--- a/test/function_registration.cpp
+++ b/test/function_registration.cpp
@@ -1,4 +1,6 @@
 #include "phlex/core/framework_graph.hpp"
+#include "phlex/core/specified_label.hpp"
+#include "phlex/model/handle.hpp"
 #include "phlex/model/product_store.hpp"
 
 #include "catch2/catch_test_macros.hpp"
@@ -11,6 +13,7 @@ using namespace phlex::experimental;
 using namespace std::string_literals;
 
 namespace {
+
   auto no_framework(int num, double temp, std::string const& name)
   {
     return std::make_tuple(num, temp, name);
@@ -48,10 +51,10 @@ namespace {
 
 TEST_CASE("Call non-framework functions", "[programming model]")
 {
-  std::array const product_names{
-    specified_label{"number"}, specified_label{"temperature"}, specified_label{"name"}};
-  std::array const oproduct_names = {"number"s, "temperature"s, "name"s};
-  std::array const result{"result"s};
+  std::array const product_names{specified_label{.name = "number"},
+                                 specified_label{.name = "temperature"},
+                                 specified_label{.name = "name"}};
+  std::array const oproduct_names{"onumber"s, "otemperature"s, "oname"s};
 
   auto store = product_store::base();
   store->add_product("number", 3);
@@ -91,7 +94,9 @@ TEST_CASE("Call non-framework functions", "[programming model]")
   }
 
   // The following is invoked for *each* section above
-  g.observe("verify_results", verify_results).input_family(product_names);
+  g.observe("verify_results", verify_results).input_family(oproduct_names);
 
   g.execute();
+
+  CHECK(g.execution_counts("verify_results") == 1ull);
 }
diff --git a/test/hierarchical_nodes.cpp b/test/hierarchical_nodes.cpp
index 588d618b..ae46154d 100644
--- a/test/hierarchical_nodes.cpp
+++ b/test/hierarchical_nodes.cpp
@@ -26,11 +26,11 @@
 #include "spdlog/spdlog.h"
 
 #include <atomic>
+#include <chrono>
 #include <cmath>
-#include <ctime>
+#include <format>
 #include <ranges>
 #include <string>
-#include <vector>
 
 using namespace phlex::experimental;
 
@@ -38,15 +38,17 @@ namespace {
   constexpr auto index_limit = 2u;
   constexpr auto number_limit = 5u;
 
+  using now_t = decltype(std::chrono::system_clock::now());
+
   void levels_to_process(framework_driver& driver)
   {
     auto job_store = product_store::base();
     driver.yield(job_store);
-    for (unsigned i : std::views::iota(0u, index_limit)) {
+    for (unsigned int const i : std::views::iota(0u, index_limit)) {
       auto run_store = job_store->make_child(i, "run", "levels_to_process");
-      run_store->add_product<std::time_t>("time", std::time(nullptr));
+      run_store->add_product<now_t>("time", std::chrono::system_clock::now());
       driver.yield(run_store);
-      for (unsigned j : std::views::iota(0u, number_limit)) {
+      for (unsigned int const j : std::views::iota(0u, number_limit)) {
         auto event_store = run_store->make_child(j, "event", "levels_to_process");
         event_store->add_product("number", i + j);
         driver.yield(event_store);
@@ -68,7 +70,8 @@ namespace {
 
   data_for_rms send(threadsafe_data_for_rms const& data)
   {
-    return {phlex::experimental::send(data.total), phlex::experimental::send(data.number)};
+    return {.total = phlex::experimental::send(data.total),
+            .number = phlex::experimental::send(data.number)};
   }
 
   void add(threadsafe_data_for_rms& redata, unsigned squared_number)
@@ -82,12 +85,7 @@ namespace {
     return std::sqrt(static_cast<double>(data.total) / data.number);
   }
 
-  std::string strtime(std::time_t tm)
-  {
-    char buffer[32];
-    std::strncpy(buffer, std::ctime(&tm), 26);
-    return buffer;
-  }
+  std::string strtime(now_t date_time) { return std::format("{:%F %T %Z}", date_time); }
 
   void print_result(handle<double> result, std::string const& stringized_time)
   {
diff --git a/test/level_counting.cpp b/test/level_counting.cpp
index 3a3726f5..255df579 100644
--- a/test/level_counting.cpp
+++ b/test/level_counting.cpp
@@ -1,11 +1,12 @@
 #include "phlex/model/level_counter.hpp"
 #include "phlex/model/level_hierarchy.hpp"
-#include "phlex/model/level_id.hpp"
 #include "phlex/model/product_store.hpp"
 #include "phlex/utilities/hashing.hpp"
 
 #include "catch2/catch_test_macros.hpp"
 
+#include <cstddef>
+
 using namespace phlex::experimental;
 
 namespace {
@@ -14,7 +15,7 @@ namespace {
 
 TEST_CASE("Counter with nothing processed", "[data model]")
 {
-  level_counter job_counter{};
+  level_counter const job_counter{};
   CHECK(job_counter.result().empty());
 }
 
diff --git a/test/mock-workflow/algorithm.hpp b/test/mock-workflow/algorithm.hpp
index c16d963e..5aa03c4a 100644
--- a/test/mock-workflow/algorithm.hpp
+++ b/test/mock-workflow/algorithm.hpp
@@ -13,6 +13,7 @@
 #include <concepts>
 #include <string>
 #include <tuple>
+#include <utility>
 
 namespace phlex::experimental::test {
   template <typename T>
@@ -40,8 +41,8 @@ namespace phlex::experimental::test {
   template <typename... Inputs, std::default_initializable Outputs>
   class algorithm<std::tuple<Inputs...>, Outputs> {
   public:
-    explicit algorithm(std::string const& label, unsigned const duration) :
-      label_{label}, duration_{duration}
+    explicit algorithm(std::string label, unsigned const duration) :
+      label_{std::move(label)}, duration_{duration}
     {
     }
 
diff --git a/test/mock-workflow/pd_fast_sim.cpp b/test/mock-workflow/pd_fast_sim.cpp
index f9d51cf1..707969b7 100644
--- a/test/mock-workflow/pd_fast_sim.cpp
+++ b/test/mock-workflow/pd_fast_sim.cpp
@@ -2,6 +2,8 @@
 #include "test/mock-workflow/algorithm.hpp"
 #include "test/mock-workflow/types.hpp"
 
+#include <tuple>
+
 using namespace phlex::experimental::test;
 
 PHLEX_EXPERIMENTAL_REGISTER_ALGORITHMS(m, config)
diff --git a/test/mock-workflow/three_tuple_algorithm.cpp b/test/mock-workflow/three_tuple_algorithm.cpp
index b78de23f..01a1c4c3 100644
--- a/test/mock-workflow/three_tuple_algorithm.cpp
+++ b/test/mock-workflow/three_tuple_algorithm.cpp
@@ -1,3 +1,4 @@
+#include "phlex/model/level_id.hpp"
 #include "phlex/module.hpp"
 #include "test/mock-workflow/algorithm.hpp"
 #include "test/mock-workflow/types.hpp"
diff --git a/test/mock-workflow/timed_busy.cpp b/test/mock-workflow/timed_busy.cpp
index c0f6f601..e6247829 100644
--- a/test/mock-workflow/timed_busy.cpp
+++ b/test/mock-workflow/timed_busy.cpp
@@ -1,5 +1,7 @@
 #include "test/mock-workflow/timed_busy.hpp"
 
+#include <chrono>
+
 void phlex::experimental::test::timed_busy(std::chrono::microseconds const& duration)
 {
   using namespace std::chrono;
diff --git a/test/mock-workflow/types.hpp b/test/mock-workflow/types.hpp
index 55b7aa6a..edce4815 100644
--- a/test/mock-workflow/types.hpp
+++ b/test/mock-workflow/types.hpp
@@ -9,6 +9,8 @@ namespace phlex::experimental {
 #define DATA_PRODUCT(name)                                                                         \
   struct name {}
 
+// NOLINTBEGIN(readability-identifier-naming)
+// We choose data-product type names that have been specified by (e.g.) LArSoft.
 namespace beam {
   DATA_PRODUCT(ProtoDUNEBeamEvents);
 }
@@ -27,6 +29,7 @@ namespace simb {
   DATA_PRODUCT(MCParticle);
   DATA_PRODUCT(MCParticles);
 }
+// NOLINTEND(readability-identifier-naming)
 
 #undef DATA_PRODUCT
 
diff --git a/test/multiple_function_registration.cpp b/test/multiple_function_registration.cpp
index 71f56403..8854cd7a 100644
--- a/test/multiple_function_registration.cpp
+++ b/test/multiple_function_registration.cpp
@@ -1,10 +1,10 @@
 #include "phlex/core/framework_graph.hpp"
-#include "phlex/model/level_hierarchy.hpp"
 #include "phlex/model/product_store.hpp"
 
 #include "catch2/catch_test_macros.hpp"
 
 #include <algorithm>
+#include <cassert>
 #include <numeric>
 #include <vector>
 
@@ -14,7 +14,7 @@ namespace {
   auto square_numbers(std::vector<unsigned> const& numbers)
   {
     std::vector<unsigned> result(size(numbers));
-    std::transform(begin(numbers), end(numbers), begin(result), [](unsigned i) { return i * i; });
+    std::ranges::transform(numbers, begin(result), [](unsigned i) { return i * i; });
     return result;
   }
 
diff --git a/test/product_handle.cpp b/test/product_handle.cpp
index 403591a3..bbb9323c 100644
--- a/test/product_handle.cpp
+++ b/test/product_handle.cpp
@@ -1,8 +1,9 @@
 #include "phlex/model/handle.hpp"
 #include "phlex/model/level_id.hpp"
-#include "phlex/model/product_store.hpp"
 
 #include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers.hpp"
+#include "catch2/matchers/catch_matchers_string.hpp"
 
 #include <concepts>
 #include <string>
@@ -11,7 +12,7 @@
 using namespace phlex::experimental;
 
 namespace {
-  struct Composer {
+  struct composer {
     std::string name;
   };
 }
@@ -101,6 +102,6 @@ TEST_CASE("Handle type conversions (run-time checks)", "[data model]")
   CHECK(num_ref == number);
   CHECK(*num_ptr == number);
 
-  Composer const composer{"Elgar"};
-  CHECK(handle{composer, level_id::base()}->name == "Elgar");
+  composer const elgar{"Elgar"};
+  CHECK(handle{elgar, level_id::base()}->name == "Elgar");
 }
diff --git a/test/product_matcher.cpp b/test/product_matcher.cpp
index 7f8bfda9..4cd93f27 100644
--- a/test/product_matcher.cpp
+++ b/test/product_matcher.cpp
@@ -2,9 +2,6 @@
 
 #include "catch2/catch_test_macros.hpp"
 
-#include <iostream>
-#include <regex>
-
 using namespace phlex::experimental;
 
 namespace {
@@ -35,7 +32,7 @@ namespace {
 TEST_CASE("Simple product matcher", "[data model]")
 {
   auto const spec = "event/loaded_module@add:sum";
-  product_matcher matcher{spec};
+  product_matcher const matcher{spec};
   CHECK(matcher.level_path() == "event");
   CHECK(matcher.module_name() == "loaded_module");
   CHECK(matcher.node_name() == "add");
@@ -45,7 +42,7 @@ TEST_CASE("Simple product matcher", "[data model]")
 
 TEST_CASE("Product matcher with default level path", "[data model]")
 {
-  product_matcher matcher{"loaded_module@add:sum"};
+  product_matcher const matcher{"loaded_module@add:sum"};
   CHECK(matcher.level_path() == "*");
   CHECK(matcher.module_name() == "loaded_module");
   CHECK(matcher.node_name() == "add");
@@ -57,7 +54,7 @@ TEST_CASE("Product matcher with default level path", "[data model]")
 
 TEST_CASE("Product matcher with multi-part level path", "[data model]")
 {
-  product_matcher matcher{"a/b/c/loaded_module@add:sum"};
+  product_matcher const matcher{"a/b/c/loaded_module@add:sum"};
   CHECK(matcher.level_path() == "a/b/c");
   CHECK(matcher.module_name() == "loaded_module");
   CHECK(matcher.node_name() == "add");
@@ -67,9 +64,9 @@ TEST_CASE("Product matcher with multi-part level path", "[data model]")
 
 TEST_CASE("Product with only node spec", "[data model]")
 {
-  product_matcher matcher{"@add:sum"};
+  product_matcher const matcher{"@add:sum"};
   CHECK(matcher.level_path() == "*");
-  CHECK(matcher.module_name() == "");
+  CHECK(matcher.module_name().empty());
   CHECK(matcher.node_name() == "add");
   CHECK(matcher.product_name() == "sum");
   CHECK(matcher.encode() == "*/@add:sum");
@@ -77,10 +74,10 @@ TEST_CASE("Product with only node spec", "[data model]")
 
 TEST_CASE("Product with only module spec", "[data model]")
 {
-  product_matcher matcher{"loaded_module:sum"};
+  product_matcher const matcher{"loaded_module:sum"};
   CHECK(matcher.level_path() == "*");
   CHECK(matcher.module_name() == "loaded_module");
-  CHECK(matcher.node_name() == "");
+  CHECK(matcher.node_name().empty());
   CHECK(matcher.product_name() == "sum");
   CHECK(matcher.encode() == "*/loaded_module@:sum");
 }
diff --git a/test/product_store.cpp b/test/product_store.cpp
index 72623126..06bf0e1f 100644
--- a/test/product_store.cpp
+++ b/test/product_store.cpp
@@ -1,7 +1,9 @@
 #include "phlex/model/product_store.hpp"
 #include "phlex/model/handle.hpp"
 
-#include "catch2/catch_all.hpp"
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers.hpp"
+#include "catch2/matchers/catch_matchers_string.hpp"
 
 #include <tuple>
 #include <vector>
diff --git a/test/serializer.cpp b/test/serializer.cpp
index ba2680fc..bc50faa4 100644
--- a/test/serializer.cpp
+++ b/test/serializer.cpp
@@ -31,7 +31,7 @@ TEST_CASE("Serialize functions based on resource", "[multithreading]")
 
   serial_node<unsigned int, 1> node1{
     g, serialized_resources.get("ROOT"), [&root_counter](unsigned int const i) {
-      thread_counter c{root_counter};
+      thread_counter const c{root_counter};
       debug("Processing from node 1 {}", i);
       return i;
     }};
@@ -39,15 +39,15 @@ TEST_CASE("Serialize functions based on resource", "[multithreading]")
   serial_node<unsigned int, 2> node2{g,
                                      serialized_resources.get("ROOT", "GENIE"),
                                      [&root_counter, &genie_counter](unsigned int const i) {
-                                       thread_counter c1{root_counter};
-                                       thread_counter c2{genie_counter};
+                                       thread_counter const c1{root_counter};
+                                       thread_counter const c2{genie_counter};
                                        debug("Processing from node 2 {}", i);
                                        return i;
                                      }};
 
   serial_node<unsigned int, 1> node3{
     g, serialized_resources.get("GENIE"), [&genie_counter](unsigned int const i) {
-      thread_counter c{genie_counter};
+      thread_counter const c{genie_counter};
       debug("Processing from node 3 {}", i);
       return i;
     }};
@@ -102,7 +102,7 @@ TEST_CASE("Serialize functions in unfold/merge graph", "[multithreading]")
   auto serial_node_for = [&root_resource, &root_counter](auto& g, int label) {
     return serial_node<unsigned int, 1>{
       g, root_resource, [&root_counter, label](unsigned int const i) {
-        thread_counter c{root_counter};
+        thread_counter const c{root_counter};
         debug("Processing from node {} {}", label, i);
         return i;
       }};
diff --git a/test/specified_label.cpp b/test/specified_label.cpp
index f86e12a4..3822b12c 100644
--- a/test/specified_label.cpp
+++ b/test/specified_label.cpp
@@ -6,14 +6,14 @@ using namespace phlex::experimental;
 
 TEST_CASE("Empty label", "[data model]")
 {
-  specified_label empty{};
+  specified_label const empty{};
   CHECK_THROWS(""_in);
   CHECK_THROWS(""_in(""));
 }
 
 TEST_CASE("Only name in label", "[data model]")
 {
-  specified_label label{"product"};
+  specified_label const label{.name = "product"};
   CHECK(label == "product"_in);
 
   // Empty family string is interpreted as a wildcard--i.e. any family.
@@ -22,6 +22,6 @@ TEST_CASE("Only name in label", "[data model]")
 
 TEST_CASE("Label with family", "[data model]")
 {
-  specified_label label{"product", {"event"}};
+  specified_label const label{.name = "product", .family = {"event"}};
   CHECK(label == "product"_in("event"));
 }
diff --git a/test/type_deduction.cpp b/test/type_deduction.cpp
index cbfca60b..da4b01d7 100644
--- a/test/type_deduction.cpp
+++ b/test/type_deduction.cpp
@@ -1,14 +1,18 @@
 #include "phlex/metaprogramming/type_deduction.hpp"
 
+#include <tuple>
+#include <type_traits>
+
 using namespace phlex::experimental;
 
 namespace {
   int transform [[maybe_unused]] (double&) { return 1; };
   void observe [[maybe_unused]] (int) {}
-  void only_void_param [[maybe_unused]] (void) {}
+  // The next function simulates a user function that specifies 'void' as an input parameter.
+  void only_void_param [[maybe_unused]] (void) {} // NOLINT(modernize-redundant-void-arg)
   std::tuple<> still_no_output [[maybe_unused]] () { return {}; }
   std::tuple<int, double> two_output_objects [[maybe_unused]] (int, double) { return {}; }
-  auto closure [[maybe_unused]] = [](int) -> double { return 2.; };
+  auto const closure [[maybe_unused]] = [](int) -> double { return 2.; };
 }
 
 int main()
diff --git a/test/unfold.cpp b/test/unfold.cpp
index 2690b1bc..807f920a 100644
--- a/test/unfold.cpp
+++ b/test/unfold.cpp
@@ -24,6 +24,8 @@
 #include <atomic>
 #include <ranges>
 #include <string>
+#include <utility>
+#include <vector>
 
 using namespace phlex::experimental;
 
@@ -87,7 +89,7 @@ TEST_CASE("Splitting the processing", "[graph]")
   auto levels_to_process = [index_limit](auto& driver) {
     auto job_store = product_store::base();
     driver.yield(job_store);
-    for (unsigned i : std::views::iota(0u, index_limit)) {
+    for (unsigned const i : std::views::iota(0u, index_limit)) {
       auto event_store = job_store->make_child(i, "event");
       event_store->add_product<unsigned>("max_number", 10u * (i + 1));
       event_store->add_product<numbers_t>("ten_numbers", numbers_t(10, i + 1));
diff --git a/test/utilities/thread_counter.cpp b/test/utilities/thread_counter.cpp
index 4a50457b..a5b1e4d7 100644
--- a/test/utilities/thread_counter.cpp
+++ b/test/utilities/thread_counter.cpp
@@ -1,7 +1,9 @@
 #include "phlex/utilities/thread_counter.hpp"
 #include "phlex/utilities/sleep_for.hpp"
 
-#include "catch2/catch_all.hpp"
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers.hpp"
+#include "catch2/matchers/catch_matchers_string.hpp"
 #include "oneapi/tbb/flow_graph.h"
 
 using namespace phlex::experimental;
diff --git a/test/vector_of_abstract_types.cpp b/test/vector_of_abstract_types.cpp
index c55bd441..1d23f045 100644
--- a/test/vector_of_abstract_types.cpp
+++ b/test/vector_of_abstract_types.cpp
@@ -1,20 +1,25 @@
 #include "phlex/core/framework_graph.hpp"
+#include "phlex/core/fwd.hpp" // FIXME:  If framework_driver is public API, it should live in an easy-to-find place.
+#include "phlex/model/product_store.hpp"
 
 #include "catch2/catch_test_macros.hpp"
 
+#include <functional>
+#include <memory>
 #include <numeric>
+#include <vector>
 
 using namespace phlex::experimental;
 
 namespace types {
-  struct Abstract {
+  struct abstract {
     virtual int value() const = 0;
-    virtual ~Abstract() = default;
+    virtual ~abstract() = default;
   };
-  struct DerivedA : Abstract {
+  struct derived_a : abstract {
     int value() const override { return 1; }
   };
-  struct DerivedB : Abstract {
+  struct derived_b : abstract {
     int value() const override { return 2; }
   };
 }
@@ -22,14 +27,14 @@ namespace types {
 namespace {
   auto make_derived_as_abstract()
   {
-    std::vector<std::unique_ptr<types::Abstract>> vec;
+    std::vector<std::unique_ptr<types::abstract>> vec;
     vec.reserve(2);
-    vec.push_back(std::make_unique<types::DerivedA>());
-    vec.push_back(std::make_unique<types::DerivedB>());
+    vec.push_back(std::make_unique<types::derived_a>());
+    vec.push_back(std::make_unique<types::derived_b>());
     return vec;
   }
 
-  int read_abstract(std::vector<std::unique_ptr<types::Abstract>> const& vec)
+  int read_abstract(std::vector<std::unique_ptr<types::abstract>> const& vec)
   {
     return std::transform_reduce(
       vec.begin(), vec.end(), 0, std::plus{}, [](auto const& ptr) -> int { return ptr->value(); });
@@ -39,12 +44,12 @@ namespace {
   public:
     explicit source(unsigned const max_n) : max_{max_n} {}
 
-    void operator()(framework_driver& driver)
+    void operator()(framework_driver& driver) const
     {
       auto job_store = phlex::experimental::product_store::base();
       driver.yield(job_store);
 
-      for (unsigned int i : std::views::iota(1u, max_ + 1)) {
+      for (unsigned int const i : std::views::iota(1u, max_ + 1)) {
         auto store = job_store->make_child(i, "event");
         store->add_product("thing", make_derived_as_abstract());
         driver.yield(store);
@@ -52,7 +57,7 @@ namespace {
     }
 
   private:
-    unsigned const max_;
+    unsigned max_;
   };
 
 }
diff --git a/test/yielding_driver.cpp b/test/yielding_driver.cpp
index de0e0490..9f6e9686 100644
--- a/test/yielding_driver.cpp
+++ b/test/yielding_driver.cpp
@@ -21,13 +21,13 @@ void levels_to_process(async_driver<level_id_ptr>& d)
 
   auto job_id = level_id::base_ptr();
   d.yield(job_id);
-  for (unsigned int r : std::views::iota(0u, num_runs)) {
+  for (unsigned int const r : std::views::iota(0u, num_runs)) {
     auto run_id = job_id->make_child(r, "run");
     d.yield(run_id);
-    for (unsigned int sr : std::views::iota(0u, num_subruns)) {
+    for (unsigned int const sr : std::views::iota(0u, num_subruns)) {
       auto subrun_id = run_id->make_child(sr, "subrun");
       d.yield(subrun_id);
-      for (unsigned int spill : std::views::iota(0u, num_spills)) {
+      for (unsigned int const spill : std::views::iota(0u, num_spills)) {
         d.yield(subrun_id->make_child(spill, "spill"));
       }
     }