diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5e420734b..dad564236 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -63,7 +63,6 @@ option(ENABLE_TSAN "Enable Thread Sanitizer" OFF)
 option(ENABLE_ASAN "Enable Address Sanitizer" OFF)
 option(PHLEX_USE_FORM "Enable experimental integration with FORM" OFF)
 option(ENABLE_COVERAGE "Enable code coverage instrumentation" OFF)
-option(ENABLE_CLANG_TIDY "Enable clang-tidy checks during build" OFF)
 
 add_compile_options(
   -Wall
@@ -163,22 +162,6 @@ if(ENABLE_COVERAGE)
   endif()
 endif()
 
-# Configure clang-tidy integration
-find_program(CLANG_TIDY_EXECUTABLE NAMES clang-tidy-20 clang-tidy)
-
-if(ENABLE_CLANG_TIDY)
-  if(CLANG_TIDY_EXECUTABLE)
-    message(STATUS "Found clang-tidy: ${CLANG_TIDY_EXECUTABLE}")
-    set(
-      CMAKE_CXX_CLANG_TIDY
-      ${CLANG_TIDY_EXECUTABLE}
-      --config-file=${CMAKE_SOURCE_DIR}/.clang-tidy
-    )
-  else()
-    message(WARNING "clang-tidy not found, disabling clang-tidy checks")
-  endif()
-endif()
-
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Build type" FORCE)
 endif()
@@ -202,10 +185,4 @@ if(BUILD_TESTING)
   endif()
 endif()
 
-# Report clang-tidy availability
-if(CLANG_TIDY_EXECUTABLE)
-  message(STATUS "Clang-tidy available: ${CLANG_TIDY_EXECUTABLE}")
-  message(STATUS "Use -DCMAKE_CXX_CLANG_TIDY=clang-tidy to enable automatic checks during build")
-endif()
-
 cet_cmake_config()
diff --git a/phlex/core/declared_fold.hpp b/phlex/core/declared_fold.hpp
index 4d7aa9039..624074cfd 100644
--- a/phlex/core/declared_fold.hpp
+++ b/phlex/core/declared_fold.hpp
@@ -56,10 +56,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 num_inputs = std::tuple_size_v<input_parameter_types>;
+    using r = 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 num_outputs = 1; // hard-coded for now
     using function_t = typename AlgorithmBits::bound_type;
 
   public:
@@ -74,7 +74,7 @@ namespace phlex::experimental {
               std::string partition) :
       declared_fold{std::move(name), std::move(predicates), std::move(product_labels)},
       initializer_{std::move(initializer)},
-      output_{to_product_specifications(full_name(), std::move(output), make_type_ids<R>())},
+      output_{to_product_specifications(full_name(), std::move(output), make_type_ids<r>())},
       partition_{std::move(partition)},
       flush_receiver_{g,
                       tbb::flow::unlimited,
@@ -88,32 +88,33 @@ namespace phlex::experimental {
                         emit_and_evict_if_done(index);
                         return {};
                       }},
-      join_{make_join_or_none<N>(
+      join_{make_join_or_none<num_inputs>(
         g, full_name(), layers())}, // FIXME: This should change to include result product!
-      fold_{
-        g, concurrency, [this, ft = alg.release_algorithm()](messages_t<N> const& messages, auto&) {
-          // 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.
-          auto const& msg = most_derived(messages);
-          auto const& index = msg.store->index();
+      fold_{g,
+            concurrency,
+            [this, ft = alg.release_algorithm()](messages_t<num_inputs> const& messages, auto&) {
+              // 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.
+              auto const& msg = most_derived(messages);
+              auto const& index = msg.store->index();
 
-          auto fold_index = index->parent(partition_);
-          if (not fold_index) {
-            return;
-          }
+              auto fold_index = index->parent(partition_);
+              if (not fold_index) {
+                return;
+              }
 
-          auto const& index_hash_for_counter = fold_index->hash();
+              auto const& index_hash_for_counter = fold_index->hash();
 
-          call(ft, messages, std::make_index_sequence<N>{});
-          ++calls_;
+              call(ft, messages, std::make_index_sequence<num_inputs>{});
+              ++calls_;
 
-          counter_for(index_hash_for_counter).increment(index->layer_hash());
+              counter_for(index_hash_for_counter).increment(index->layer_hash());
 
-          emit_and_evict_if_done(fold_index);
-        }}
+              emit_and_evict_if_done(fold_index);
+            }}
     {
-      if constexpr (N > 1ull) {
+      if constexpr (num_inputs > 1ull) {
         make_edge(join_, fold_);
       }
     }
@@ -123,7 +124,7 @@ namespace phlex::experimental {
     {
       if (auto counter = done_with(fold_index->hash())) {
         auto parent = std::make_shared<product_store>(fold_index, this->full_name());
-        commit_(parent);
+        commit(parent);
         ++product_count_;
         tbb::flow::output_port<0>(fold_).try_put(
           {.store = parent, .id = counter->original_message_id()});
@@ -132,12 +133,12 @@ namespace phlex::experimental {
 
     tbb::flow::receiver<message>& port_for(product_query const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label, fold_);
+      return receiver_for<num_inputs>(join_, input(), product_label, fold_);
     }
 
     std::vector<tbb::flow::receiver<message>*> ports() override
     {
-      return input_ports<N>(join_, fold_);
+      return input_ports<num_inputs>(join_, fold_);
     }
 
     tbb::flow::receiver<flush_message>& flush_port() override { return flush_receiver_; }
@@ -145,7 +146,9 @@ namespace phlex::experimental {
     product_specifications 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<num_inputs> const& messages,
+              std::index_sequence<Is...>)
     {
       auto const parent_index = most_derived(messages).store->index()->parent(partition_);
 
@@ -160,7 +163,7 @@ namespace phlex::experimental {
             .first;
       }
 
-      if constexpr (N == 1ull) {
+      if constexpr (num_inputs == 1ull) {
         std::invoke(ft, *it->second, std::get<Is>(input_).retrieve(messages)...);
       } else {
         std::invoke(ft, *it->second, std::get<Is>(input_).retrieve(std::get<Is>(messages))...);
@@ -174,11 +177,11 @@ namespace phlex::experimental {
     template <size_t... Is>
     auto initialized_object(InitTuple&& tuple, 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<r>{
+        new r{std::forward<std::tuple_element_t<Is, InitTuple>>(std::get<Is>(tuple))...}};
     }
 
-    auto commit_(product_store_ptr& store)
+    auto commit(product_store_ptr& store)
     {
       auto& result = results_.at(store->index()->hash());
       if constexpr (requires { send(*result); }) {
@@ -196,9 +199,9 @@ namespace phlex::experimental {
     product_specifications output_;
     std::string partition_;
     tbb::flow::function_node<flush_message> flush_receiver_;
-    join_or_none_t<N> join_;
-    tbb::flow::multifunction_node<messages_t<N>, message_tuple<1>> fold_;
-    tbb::concurrent_unordered_map<data_cell_index::hash_type, std::unique_ptr<R>> results_;
+    join_or_none_t<num_inputs> join_;
+    tbb::flow::multifunction_node<messages_t<num_inputs>, message_tuple<1>> fold_;
+    tbb::concurrent_unordered_map<data_cell_index::hash_type, std::unique_ptr<r>> 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 f9d8287a4..d1bea85e8 100644
--- a/phlex/core/declared_observer.hpp
+++ b/phlex/core/declared_observer.hpp
@@ -45,9 +45,9 @@ namespace phlex::experimental {
 
   template <typename AlgorithmBits>
   class observer_node : public declared_observer {
-    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 num_inputs = AlgorithmBits::number_inputs;
 
   public:
     static constexpr auto number_output_products = 0;
@@ -60,17 +60,17 @@ namespace phlex::experimental {
                   AlgorithmBits alg,
                   product_queries input_products) :
       declared_observer{std::move(name), std::move(predicates), std::move(input_products)},
-      join_{make_join_or_none<N>(g, full_name(), layers())},
+      join_{make_join_or_none<num_inputs>(g, full_name(), layers())},
       observer_{g,
                 concurrency,
                 [this, ft = alg.release_algorithm()](
-                  messages_t<N> const& messages) -> oneapi::tbb::flow::continue_msg {
-                  call(ft, messages, std::make_index_sequence<N>{});
+                  messages_t<num_inputs> const& messages) -> oneapi::tbb::flow::continue_msg {
+                  call(ft, messages, std::make_index_sequence<num_inputs>{});
                   ++calls_;
                   return {};
                 }}
     {
-      if constexpr (N > 1ull) {
+      if constexpr (num_inputs > 1ull) {
         make_edge(join_, observer_);
       }
     }
@@ -78,18 +78,20 @@ namespace phlex::experimental {
   private:
     tbb::flow::receiver<message>& port_for(product_query const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label, observer_);
+      return receiver_for<num_inputs>(join_, input(), product_label, observer_);
     }
 
     std::vector<tbb::flow::receiver<message>*> ports() override
     {
-      return input_ports<N>(join_, observer_);
+      return input_ports<num_inputs>(join_, observer_);
     }
 
     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<num_inputs> const& messages,
+              std::index_sequence<Is...>)
     {
-      if constexpr (N == 1ull) {
+      if constexpr (num_inputs == 1ull) {
         std::invoke(ft, std::get<Is>(input_).retrieve(messages)...);
       } else {
         std::invoke(ft, std::get<Is>(input_).retrieve(std::get<Is>(messages))...);
@@ -99,9 +101,9 @@ namespace phlex::experimental {
     named_index_ports index_ports() final { return join_.index_ports(); }
     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<num_inputs> join_;
+    tbb::flow::function_node<messages_t<num_inputs>> observer_;
     std::atomic<std::size_t> calls_;
   };
 }
diff --git a/phlex/core/declared_predicate.hpp b/phlex/core/declared_predicate.hpp
index dfc847839..72643c7da 100644
--- a/phlex/core/declared_predicate.hpp
+++ b/phlex/core/declared_predicate.hpp
@@ -49,9 +49,9 @@ namespace phlex::experimental {
 
   template <typename AlgorithmBits>
   class predicate_node : public declared_predicate {
-    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 num_inputs = AlgorithmBits::number_inputs;
 
   public:
     static constexpr auto number_output_products = 0ull;
@@ -64,20 +64,20 @@ namespace phlex::experimental {
                    AlgorithmBits alg,
                    product_queries input_products) :
       declared_predicate{std::move(name), std::move(predicates), std::move(input_products)},
-      join_{make_join_or_none<N>(g, full_name(), layers())},
-      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);
-
-          bool const rc = call(ft, messages, std::make_index_sequence<N>{});
-          ++calls_;
-          return {message_id, rc};
-        }}
+      join_{make_join_or_none<num_inputs>(g, full_name(), layers())},
+      predicate_{g,
+                 concurrency,
+                 [this, ft = alg.release_algorithm()](
+                   messages_t<num_inputs> const& messages) -> predicate_result {
+                   auto const& msg = most_derived(messages);
+                   auto const& [store, message_id] = std::tie(msg.store, msg.id);
+
+                   bool const rc = call(ft, messages, std::make_index_sequence<num_inputs>{});
+                   ++calls_;
+                   return {message_id, rc};
+                 }}
     {
-      if constexpr (N > 1ull) {
+      if constexpr (num_inputs > 1ull) {
         make_edge(join_, predicate_);
       }
     }
@@ -85,19 +85,21 @@ namespace phlex::experimental {
   private:
     tbb::flow::receiver<message>& port_for(product_query const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label, predicate_);
+      return receiver_for<num_inputs>(join_, input(), product_label, predicate_);
     }
 
     std::vector<tbb::flow::receiver<message>*> ports() override
     {
-      return input_ports<N>(join_, predicate_);
+      return input_ports<num_inputs>(join_, predicate_);
     }
     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<num_inputs> const& messages,
+              std::index_sequence<Is...>)
     {
-      if constexpr (N == 1ull) {
+      if constexpr (num_inputs == 1ull) {
         return std::invoke(ft, std::get<Is>(input_).retrieve(messages)...);
       } else {
         return std::invoke(ft, std::get<Is>(input_).retrieve(std::get<Is>(messages))...);
@@ -107,9 +109,9 @@ namespace phlex::experimental {
     named_index_ports index_ports() final { return join_.index_ports(); }
     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<num_inputs> join_;
+    tbb::flow::function_node<messages_t<num_inputs>, predicate_result> predicate_;
     std::atomic<std::size_t> calls_;
   };
 
diff --git a/phlex/core/declared_transform.hpp b/phlex/core/declared_transform.hpp
index 8ce6c656c..34358cd8d 100644
--- a/phlex/core/declared_transform.hpp
+++ b/phlex/core/declared_transform.hpp
@@ -58,12 +58,12 @@ 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 num_inputs = AlgorithmBits::number_inputs;
+    static constexpr auto num_outputs = number_output_objects<function_t>;
 
   public:
     using node_ptr_type = declared_transform_ptr;
-    static constexpr auto number_output_products = M;
+    static constexpr auto number_output_products = num_outputs;
 
     transform_node(algorithm_name name,
                    std::size_t concurrency,
@@ -75,26 +75,27 @@ namespace phlex::experimental {
       declared_transform{std::move(name), std::move(predicates), std::move(input_products)},
       output_{to_product_specifications(
         full_name(), std::move(output), make_output_type_ids<function_t>())},
-      join_{make_join_or_none<N>(g, full_name(), layers())},
-      transform_{g,
-                 concurrency,
-                 [this, ft = alg.release_algorithm()](messages_t<N> const& messages, auto& output) {
-                   auto const& msg = most_derived(messages);
-                   auto const& [store, message_id] = std::tie(msg.store, msg.id);
-
-                   auto result = call(ft, messages, std::make_index_sequence<N>{});
-                   ++calls_;
-                   ++product_count_[store->index()->layer_hash()];
-
-                   products new_products;
-                   new_products.add_all(output_, std::move(result));
-                   auto new_store = std::make_shared<product_store>(
-                     store->index(), this->full_name(), std::move(new_products));
-
-                   std::get<0>(output).try_put({.store = std::move(new_store), .id = message_id});
-                 }}
+      join_{make_join_or_none<num_inputs>(g, full_name(), layers())},
+      transform_{
+        g,
+        concurrency,
+        [this, ft = alg.release_algorithm()](messages_t<num_inputs> const& messages, auto& output) {
+          auto const& msg = most_derived(messages);
+          auto const& [store, message_id] = std::tie(msg.store, msg.id);
+
+          auto result = call(ft, messages, std::make_index_sequence<num_inputs>{});
+          ++calls_;
+          ++product_count_[store->index()->layer_hash()];
+
+          products new_products;
+          new_products.add_all(output_, std::move(result));
+          auto new_store = std::make_shared<product_store>(
+            store->index(), this->full_name(), std::move(new_products));
+
+          std::get<0>(output).try_put({.store = std::move(new_store), .id = message_id});
+        }}
     {
-      if constexpr (N > 1ull) {
+      if constexpr (num_inputs > 1ull) {
         make_edge(join_, transform_);
       }
     }
@@ -102,12 +103,12 @@ namespace phlex::experimental {
   private:
     tbb::flow::receiver<message>& port_for(product_query const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label, transform_);
+      return receiver_for<num_inputs>(join_, input(), product_label, transform_);
     }
 
     std::vector<tbb::flow::receiver<message>*> ports() override
     {
-      return input_ports<N>(join_, transform_);
+      return input_ports<num_inputs>(join_, transform_);
     }
 
     tbb::flow::sender<message>& output_port() override
@@ -117,9 +118,11 @@ namespace phlex::experimental {
     product_specifications 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<num_inputs> const& messages,
+              std::index_sequence<Is...>)
     {
-      if constexpr (N == 1ull) {
+      if constexpr (num_inputs == 1ull) {
         return std::invoke(ft, std::get<Is>(input_).retrieve(messages)...);
       } else {
         return std::invoke(ft, std::get<Is>(input_).retrieve(std::get<Is>(messages))...);
@@ -139,8 +142,8 @@ namespace phlex::experimental {
 
     input_retriever_types<input_parameter_types> input_{input_arguments<input_parameter_types>()};
     product_specifications output_;
-    join_or_none_t<N> join_;
-    tbb::flow::multifunction_node<messages_t<N>, message_tuple<1u>> transform_;
+    join_or_none_t<num_inputs> join_;
+    tbb::flow::multifunction_node<messages_t<num_inputs>, message_tuple<1u>> transform_;
     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 d64621f1d..6349637c7 100644
--- a/phlex/core/declared_unfold.hpp
+++ b/phlex/core/declared_unfold.hpp
@@ -79,9 +79,9 @@ namespace phlex::experimental {
 
   template <typename Object, typename Predicate, typename Unfold>
   class unfold_node : public declared_unfold {
-    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 num_inputs = std::tuple_size_v<input_args>;
+    static constexpr std::size_t num_outputs = number_output_objects<Unfold>;
 
   public:
     unfold_node(algorithm_name name,
@@ -100,17 +100,17 @@ namespace phlex::experimental {
       output_{to_product_specifications(full_name(),
                                         std::move(output_products),
                                         make_type_ids<skip_first_type<return_type<Unfold>>>())},
-      join_{make_join_or_none<N>(g, full_name(), layers())},
+      join_{make_join_or_none<num_inputs>(g, full_name(), layers())},
       unfold_{g,
               concurrency,
               [this, p = std::move(predicate), ufold = std::move(unfold)](
-                messages_t<N> const& messages, auto&) {
+                messages_t<num_inputs> const& messages, auto&) {
                 auto const& msg = most_derived(messages);
                 auto const& store = msg.store;
 
                 std::size_t const original_message_id{msg_counter_};
                 generator g{store, this->full_name(), child_layer()};
-                call(p, ufold, store->index(), g, messages, std::make_index_sequence<N>{});
+                call(p, ufold, store->index(), g, messages, std::make_index_sequence<num_inputs>{});
 
                 flusher_.try_put({.index = store->index(),
                                   .counts = g.flush_result(),
@@ -118,7 +118,7 @@ namespace phlex::experimental {
               }},
       flusher_{g}
     {
-      if constexpr (N > 1ull) {
+      if constexpr (num_inputs > 1ull) {
         make_edge(join_, unfold_);
       }
     }
@@ -126,11 +126,11 @@ namespace phlex::experimental {
   private:
     tbb::flow::receiver<message>& port_for(product_query const& product_label) override
     {
-      return receiver_for<N>(join_, input(), product_label, unfold_);
+      return receiver_for<num_inputs>(join_, input(), product_label, unfold_);
     }
     std::vector<tbb::flow::receiver<message>*> ports() override
     {
-      return input_ports<N>(join_, unfold_);
+      return input_ports<num_inputs>(join_, unfold_);
     }
 
     tbb::flow::sender<message>& output_port() override
@@ -149,12 +149,12 @@ namespace phlex::experimental {
               Unfold const& unfold,
               data_cell_index_ptr const& unfolded_id,
               generator& g,
-              messages_t<N> const& messages,
+              messages_t<num_inputs> const& messages,
               std::index_sequence<Is...>)
     {
       ++calls_;
       Object obj = [this, &messages]() {
-        if constexpr (N == 1ull) {
+        if constexpr (num_inputs == 1ull) {
           return Object(std::get<Is>(input_).retrieve(messages)...);
         } else {
           return Object(std::get<Is>(input_).retrieve(std::get<Is>(messages))...);
@@ -187,10 +187,11 @@ 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>()};
     product_specifications output_;
-    join_or_none_t<N> join_;
-    tbb::flow::multifunction_node<messages_t<N>, std::tuple<message, data_cell_index_ptr>> unfold_;
+    join_or_none_t<num_inputs> join_;
+    tbb::flow::multifunction_node<messages_t<num_inputs>, std::tuple<message, data_cell_index_ptr>>
+      unfold_;
     flusher_t flusher_;
     std::atomic<std::size_t> msg_counter_{}; // Is this sufficient?  Probably not.
     std::atomic<std::size_t> calls_{};
diff --git a/phlex/core/input_arguments.hpp b/phlex/core/input_arguments.hpp
index 4e7e429e1..1ad1b5c29 100644
--- a/phlex/core/input_arguments.hpp
+++ b/phlex/core/input_arguments.hpp
@@ -36,9 +36,9 @@ namespace phlex::experimental {
   template <typename InputTypes>
   auto form_input_arguments(std::string const& algorithm_name, product_queries const& args)
   {
-    constexpr auto N = std::tuple_size_v<InputTypes>;
+    constexpr auto num_inputs = 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<num_inputs>{});
   }
 
   template <typename InputTypes>
diff --git a/phlex/core/multilayer_join_node.hpp b/phlex/core/multilayer_join_node.hpp
index 0d281d7c2..b1743de44 100644
--- a/phlex/core/multilayer_join_node.hpp
+++ b/phlex/core/multilayer_join_node.hpp
@@ -43,14 +43,14 @@ namespace phlex::experimental {
   //               ├──► join_node ──► message tuple
   //   data[N-1] ──┘
 
-  template <std::size_t n_inputs>
-    requires(n_inputs > 1)
-  class multilayer_join_node : public multilayer_join_node_base_t<message_tuple<n_inputs>> {
-    using base_t = multilayer_join_node_base_t<message_tuple<n_inputs>>;
+  template <std::size_t NInputs>
+    requires(NInputs > 1)
+  class multilayer_join_node : public multilayer_join_node_base_t<message_tuple<NInputs>> {
+    using base_t = multilayer_join_node_base_t<message_tuple<NInputs>>;
     using input_t = typename base_t::input_ports_type;
     using output_t = typename base_t::output_ports_type;
 
-    using args_t = message_tuple<n_inputs>;
+    using args_t = message_tuple<NInputs>;
 
     template <std::size_t... Is>
     static auto make_join(tbb::flow::graph& g, std::index_sequence<Is...>)
@@ -68,11 +68,11 @@ namespace phlex::experimental {
                          std::string const& node_name,
                          std::vector<identifier> layer_names) :
       base_t{g},
-      join_{make_join(g, std::make_index_sequence<n_inputs>{})},
+      join_{make_join(g, std::make_index_sequence<NInputs>{})},
       name_{node_name},
       layers_{std::move(layer_names)}
     {
-      assert(n_inputs == layers_.size());
+      assert(NInputs == layers_.size());
 
       // Collapse to the set of distinct layer names.  More than one distinct layer means
       // at least one input crosses a layer boundary and therefore every input stream
@@ -81,7 +81,7 @@ namespace phlex::experimental {
 
       // Add repeaters only if the inputs span more than one distinct layer.
       if (collapsed_layers.size() > 1) {
-        repeaters_.reserve(n_inputs);
+        repeaters_.reserve(NInputs);
         for (auto const& layer : layers_) {
           repeaters_.push_back(std::make_unique<detail::repeater_node>(g, name_, layer));
         }
@@ -99,7 +99,7 @@ namespace phlex::experimental {
         }
       };
 
-      set_ports(std::make_index_sequence<n_inputs>{});
+      set_ports(std::make_index_sequence<NInputs>{});
     }
 
     // Returns one named_index_port per repeater so that the index router can deliver
diff --git a/phlex/core/registrar.hpp b/phlex/core/registrar.hpp
index 92ef9e55b..45c6dab2b 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 = 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& nodes, std::vector<std::string>& errors) :
       nodes_{&nodes}, errors_{&errors}
     {
     }
@@ -116,7 +116,7 @@ namespace phlex::experimental {
       }
     }
 
-    Nodes* nodes_;
+    nodes* nodes_;
     std::vector<std::string>* errors_;
     node_creator creator_{};
     std::optional<std::vector<std::string>> predicates_;
diff --git a/phlex/core/registration_api.hpp b/phlex/core/registration_api.hpp
index e11bb6b36..ce4d8e5b4 100644
--- a/phlex/core/registration_api.hpp
+++ b/phlex/core/registration_api.hpp
@@ -27,11 +27,11 @@ 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;
     using input_parameter_types = typename AlgorithmBits::input_parameter_types;
 
-    static constexpr auto N = AlgorithmBits::number_inputs;
-    static constexpr auto M = hof_type::number_output_products;
+    static constexpr auto num_inputs = AlgorithmBits::number_inputs;
+    static constexpr auto num_outputs = hof_type::number_output_products;
 
   public:
     registration_api(configuration const* config,
@@ -46,15 +46,15 @@ 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<product_query, N> input_args)
+    auto input_family(std::array<product_query, num_inputs> input_args)
     {
       populate_types<input_parameter_types>(input_args);
 
-      if constexpr (M == 0ull) {
+      if constexpr (num_outputs == 0ull) {
         registrar_.set_creator(
           [this, inputs = std::move(input_args)](auto predicates, auto /* output_products */) {
             return std::make_unique<hof_type>(std::move(name_),
@@ -76,12 +76,12 @@ namespace phlex::experimental {
                                               std::move(output_products));
           });
       }
-      return upstream_predicates<NodePtr, M>{std::move(registrar_), config_};
+      return upstream_predicates<node_ptr, num_outputs>{std::move(registrar_), config_};
     }
 
     auto input_family(std::same_as<product_query> auto... input_args)
     {
-      static_assert(N == sizeof...(input_args),
+      static_assert(num_inputs == sizeof...(input_args),
                     "The number of function parameters is not the same as the number of specified "
                     "input arguments.");
       return input_family({std::move(input_args)...});
@@ -93,7 +93,7 @@ namespace phlex::experimental {
     AlgorithmBits alg_;
     concurrency concurrency_;
     tbb::flow::graph& graph_;
-    registrar<NodePtr> registrar_;
+    registrar<node_ptr> registrar_;
   };
 
   template <template <typename...> typename HOF, typename AlgorithmBits>
@@ -159,11 +159,11 @@ namespace phlex::experimental {
 
   template <typename AlgorithmBits, typename... InitArgs>
   class fold_api {
-    using InitTuple = std::tuple<InitArgs...>;
+    using init_tuple = std::tuple<InitArgs...>;
     using input_parameter_types = skip_first_type<typename AlgorithmBits::input_parameter_types>;
 
-    static constexpr auto N = AlgorithmBits::number_inputs;
-    static constexpr auto M = 1; // For now
+    static constexpr auto num_inputs = AlgorithmBits::number_inputs;
+    static constexpr auto num_outputs = 1; // For now
 
   public:
     fold_api(configuration const* config,
@@ -186,13 +186,13 @@ namespace phlex::experimental {
     {
     }
 
-    auto input_family(std::array<product_query, N - 1> input_args)
+    auto input_family(std::array<product_query, num_inputs - 1> input_args)
     {
       populate_types<input_parameter_types>(input_args);
 
       registrar_.set_creator(
         [this, inputs = std::move(input_args)](auto predicates, auto output_products) {
-          return std::make_unique<fold_node<AlgorithmBits, InitTuple>>(
+          return std::make_unique<fold_node<AlgorithmBits, init_tuple>>(
             std::move(name_),
             concurrency_.value,
             std::move(predicates),
@@ -203,12 +203,12 @@ 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, num_outputs>{std::move(registrar_), config_};
     }
 
     auto input_family(std::same_as<product_query> auto... input_args)
     {
-      static_assert(N - 1 == sizeof...(input_args),
+      static_assert(num_inputs - 1 == sizeof...(input_args),
                     "The number of function parameters is not the same as the number of specified "
                     "input arguments.");
       return input_family({std::move(input_args)...});
@@ -221,7 +221,7 @@ namespace phlex::experimental {
     concurrency concurrency_;
     tbb::flow::graph& graph_;
     std::string partition_;
-    InitTuple init_;
+    init_tuple init_;
     registrar<declared_fold_ptr> registrar_;
   };
 
@@ -232,8 +232,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 num_inputs = std::tuple_size_v<input_parameter_types>;
+    static constexpr std::size_t num_outputs = 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.
@@ -262,7 +262,7 @@ namespace phlex::experimental {
     {
     }
 
-    auto input_family(std::array<product_query, N> input_args)
+    auto input_family(std::array<product_query, num_inputs> input_args)
     {
       populate_types<input_parameter_types>(input_args);
 
@@ -279,12 +279,12 @@ 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, num_outputs>{std::move(registrar_), config_};
     }
 
     auto input_family(std::same_as<product_query> auto... input_args)
     {
-      static_assert(N == sizeof...(input_args),
+      static_assert(num_inputs == sizeof...(input_args),
                     "The number of function parameters is not the same as the number of specified "
                     "input arguments.");
       return input_family({std::move(input_args)...});
diff --git a/phlex/model/product_store.hpp b/phlex/model/product_store.hpp
index c7fc1b4cc..480ff96a6 100644
--- a/phlex/model/product_store.hpp
+++ b/phlex/model/product_store.hpp
@@ -62,8 +62,8 @@ namespace phlex::experimental {
   template <std::size_t I, typename Tuple>
   auto const& get_most_derived(Tuple const& tup, std::tuple_element_t<I - 1, Tuple> const& element)
   {
-    constexpr auto N = std::tuple_size_v<Tuple>;
-    if constexpr (I == N - 1) {
+    constexpr auto num_inputs = std::tuple_size_v<Tuple>;
+    if constexpr (I == num_inputs - 1) {
       return more_derived(element, std::get<I>(tup));
     } else {
       return get_most_derived<I + 1>(tup, more_derived(element, std::get<I>(tup)));
diff --git a/phlex/model/type_id.hpp b/phlex/model/type_id.hpp
index 3230b2f26..fc13fd9b7 100644
--- a/phlex/model/type_id.hpp
+++ b/phlex/model/type_id.hpp
@@ -109,23 +109,23 @@ namespace phlex::experimental {
       } else {
         id = 0x0;
       }
-      using SignedT = std::make_signed_t<T>;
+      using signed_t = std::make_signed_t<T>;
 
-      if constexpr (std::is_same_v<signed char, SignedT>) {
+      if constexpr (std::is_same_v<signed char, signed_t>) {
         // We're choosing to treat signed char and char identically
         return id | static_cast<unsigned char>(type_id::builtin::char_v);
-      } else if constexpr (std::is_same_v<int, SignedT>) {
+      } else if constexpr (std::is_same_v<int, signed_t>) {
         // ints are generally either long or long long, depending on implementation
         // Treating them separately here to reduce confusion
         id |= static_cast<unsigned char>(type_id::builtin::int_v);
         return id;
-      } else if constexpr (std::is_same_v<short, SignedT>) {
+      } else if constexpr (std::is_same_v<short, signed_t>) {
         id |= static_cast<unsigned char>(type_id::builtin::short_v);
         return id;
-      } else if constexpr (std::is_same_v<long, SignedT>) {
+      } else if constexpr (std::is_same_v<long, signed_t>) {
         id |= static_cast<unsigned char>(type_id::builtin::long_v);
         return id;
-      } else if constexpr (std::is_same_v<long long, SignedT>) {
+      } else if constexpr (std::is_same_v<long long, signed_t>) {
         id |= static_cast<unsigned char>(type_id::builtin::long_long_v);
         return id;
       } else {
diff --git a/phlex/utilities/simple_ptr_map.hpp b/phlex/utilities/simple_ptr_map.hpp
index 162d34f0d..09f09d943 100644
--- a/phlex/utilities/simple_ptr_map.hpp
+++ b/phlex/utilities/simple_ptr_map.hpp
@@ -28,8 +28,8 @@ 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 = std::unique_ptr<T>;
+    std::map<std::string, ptr> data_;
 
   public:
     // std::map<std::string, Ptr> has a default constructor that does
@@ -43,7 +43,7 @@ namespace phlex::experimental {
     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)
+    auto try_emplace(std::string node_name, ptr ptr)
     {
       return data_.try_emplace(std::move(node_name), std::move(ptr));
     }
@@ -51,7 +51,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::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/test/demo-giantdata/unfold_transform_fold.cpp b/test/demo-giantdata/unfold_transform_fold.cpp
index 1987815d2..3d1426e34 100644
--- a/test/demo-giantdata/unfold_transform_fold.cpp
+++ b/test/demo-giantdata/unfold_transform_fold.cpp
@@ -16,7 +16,7 @@ using namespace phlex;
 namespace {
   // Tracks pipeline execution to verify that fold operations begin before all unfold
   // operations complete (pipelined execution rather than batched execution).
-  struct ExecutionTracker {
+  struct execution_tracker {
     // Total number of unfold operations completed
     std::atomic<std::size_t> unfold_completed{0};
 
@@ -41,7 +41,7 @@ TEST_CASE("Unfold-transform-fold pipeline", "[concurrency][unfold][fold]")
   constexpr std::size_t wires_per_spill = apas_per_spill * 256ull;
   constexpr std::size_t chunksize = 256;
 
-  ExecutionTracker tracker;
+  execution_tracker tracker;
   tracker.total_expected = n_spills * apas_per_spill;
 
   // Create data layers using layer generator