diff --git a/phlex/app/load_module.cpp b/phlex/app/load_module.cpp
index dec376bbb..04286af0d 100644
--- a/phlex/app/load_module.cpp
+++ b/phlex/app/load_module.cpp
@@ -6,11 +6,11 @@
 #include "phlex/source.hpp"
 
 #include "boost/algorithm/string.hpp"
-#include "boost/dll/import.hpp"
+#include "boost/dll/shared_library.hpp"
 #include "boost/json.hpp"
 
 #include <cstdlib>
-#include <functional>
+#include <optional>
 #include <string>
 #include <string_view>
 
@@ -21,17 +21,49 @@ namespace phlex::detail {
   namespace {
     constexpr std::string_view pymodule_name{"pymodule"};
 
-    // If factory function goes out of scope, then the library is unloaded...and that's
-    // bad.
+    // The shared_library member in each wrapper struct keeps the loaded .so
+    // alive for the lifetime of the wrapper.  If it goes out of scope, the
+    // library is unloaded and the stored function pointer becomes invalid.
+    struct module_plugin {
+      boost::dll::shared_library lib;
+      internal::module_creator_t* fn{};
+
+      void operator()(module_graph_proxy<void_tag> proxy, configuration const& config) const
+      {
+        fn(std::move(proxy), config);
+      }
+    };
+
+    struct source_plugin {
+      boost::dll::shared_library lib;
+      internal::source_creator_t* fn{};
+
+      void operator()(source_bundle bundle, configuration const& config) const
+      {
+        fn(bundle, config);
+      }
+    };
+
+    struct driver_plugin {
+      boost::dll::shared_library lib;
+      internal::driver_shim_t* fn{};
+
+      void operator()(driver_proxy proxy, configuration const& config, driver_bundle* out) const
+      {
+        fn(proxy, config, out);
+      }
+    };
+
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    std::vector<std::function<internal::module_creator_t>> create_module;
+    std::vector<module_plugin> create_module;
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    std::vector<std::function<internal::source_creator_t>> create_source;
+    std::vector<source_plugin> create_source;
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    std::function<internal::driver_shim_t> create_driver;
+    std::optional<driver_plugin> create_driver;
 
     template <typename creator_t>
-    std::function<creator_t> plugin_loader(std::string const& spec, std::string const& symbol_name)
+    std::pair<boost::dll::shared_library, creator_t*> plugin_loader(std::string const& spec,
+                                                                    std::string const& symbol_name)
     {
       // Called during single-threaded graph construction
       char const* plugin_path_ptr =
@@ -39,9 +71,8 @@ namespace phlex::detail {
       if (!plugin_path_ptr)
         throw std::runtime_error("PHLEX_PLUGIN_PATH has not been set.");
 
-      using namespace boost;
       std::vector<std::string> subdirs;
-      split(subdirs, plugin_path_ptr, is_any_of(":"));
+      boost::split(subdirs, plugin_path_ptr, boost::is_any_of(":"));
 
       // FIXME: Need to test to ensure that first match wins.
       for (auto const& subdir : subdirs) {
@@ -50,9 +81,11 @@ namespace phlex::detail {
         if (exists(shared_library_path)) {
           // Load pymodule with rtld_global to make Python symbols available to extension modules
           // (e.g., NumPy). Load all other plugins with rtld_local (default) to avoid symbol collisions.
-          auto const load_mode =
-            (spec == pymodule_name) ? dll::load_mode::rtld_global : dll::load_mode::default_mode;
-          return dll::import_symbol<creator_t>(shared_library_path, symbol_name, load_mode);
+          auto const load_mode = (spec == pymodule_name) ? boost::dll::load_mode::rtld_global
+                                                         : boost::dll::load_mode::default_mode;
+          boost::dll::shared_library lib{shared_library_path, load_mode};
+          auto* fn = &lib.get<creator_t>(symbol_name);
+          return {std::move(lib), fn};
         }
       }
       throw std::runtime_error("Could not locate library with specification '"s + spec +
@@ -89,8 +122,8 @@ namespace phlex::detail {
     auto const adjusted_config = internal::adjust_config(label, std::move(raw_config));
 
     auto const& spec = value_to<std::string>(adjusted_config.at("cpp"));
-    auto& creator =
-      create_module.emplace_back(plugin_loader<internal::module_creator_t>(spec, "create_module"));
+    auto [lib, fn] = plugin_loader<internal::module_creator_t>(spec, "create_module");
+    auto& creator = create_module.emplace_back(module_plugin{std::move(lib), fn});
 
     configuration const config{adjusted_config};
     creator(g.module_proxy(config), config);
@@ -101,8 +134,8 @@ namespace phlex::detail {
     auto const adjusted_config = internal::adjust_config(label, std::move(raw_config));
 
     auto const& spec = value_to<std::string>(adjusted_config.at("cpp"));
-    auto& creator =
-      create_source.emplace_back(plugin_loader<internal::source_creator_t>(spec, "create_source"));
+    auto [lib, fn] = plugin_loader<internal::source_creator_t>(spec, "create_source");
+    auto& creator = create_source.emplace_back(source_plugin{std::move(lib), fn});
 
     // FIXME: Should probably use the parameter name (e.g.) 'plugin_label' instead of
     //        'module_label', but that requires adjusting other parts of the system
@@ -121,9 +154,10 @@ namespace phlex::detail {
     // False positive: clang-analyzer cannot trace ownership through Boost's is_any_of<char>
     // internal reference counting in classification.hpp.
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks,clang-analyzer-cplusplus.NewDelete)
-    create_driver = plugin_loader<internal::driver_shim_t>(spec, "create_driver");
+    auto [lib, fn] = plugin_loader<internal::driver_shim_t>(spec, "create_driver");
+    create_driver.emplace(driver_plugin{std::move(lib), fn});
     driver_bundle result;
-    create_driver(g.driver_proxy(required_sources), config, &result);
+    (*create_driver)(g.driver_proxy(required_sources), config, &result);
     g.add_driver(result);
   }
 }
diff --git a/phlex/core/glue.hpp b/phlex/core/glue.hpp
index e127b5e00..b9b098368 100644
--- a/phlex/core/glue.hpp
+++ b/phlex/core/glue.hpp
@@ -35,7 +35,7 @@ namespace phlex::detail {
  *
  * The glue class acts as a registration helper that allows binding user-defined functions and algorithms
  * to nodes in a TBB flow graph. It provides methods to create different types of processing nodes like
- * fold, transform, observe, predicate etc.
+ * fold, observe, output, predicate, transform, and unfold.
  *
  * @tparam T The type of the object that contains the user-defined functions/algorithms to be registered.
  *           This object is stored as a shared pointer and its methods are bound to the created nodes.
diff --git a/phlex/core/graph_proxy.hpp b/phlex/core/graph_proxy.hpp
index eb746fe33..596c488a1 100644
--- a/phlex/core/graph_proxy.hpp
+++ b/phlex/core/graph_proxy.hpp
@@ -39,10 +39,7 @@ namespace phlex::detail {
                 tbb::flow::graph& g,
                 node_catalog& nodes,
                 std::vector<std::string>& errors)
-      requires(not is_bound_object<T>)
-      : config_{&config}, graph_{g}, nodes_{nodes}, errors_{errors}
-    {
-    }
+      requires(not is_bound_object<T>);
 
     /// @brief Binds a user algorithm object of type @p U to this proxy.
     ///
@@ -51,10 +48,7 @@ namespace phlex::detail {
     /// be registered as algorithm nodes.
     template <typename U, typename... Args>
     graph_proxy<U> make(Args&&... args)
-      requires(not is_bound_object<T>)
-    {
-      return bind_to<graph_proxy, U>(std::forward<Args>(args)...);
-    }
+      requires(not is_bound_object<T>);
 
     /// @brief Registers a fold algorithm node.
     template <typename... InitArgs>
@@ -62,38 +56,19 @@ namespace phlex::detail {
               is_fold_like auto f,
               concurrency c = concurrency::serial,
               std::string partition = "job",
-              InitArgs&&... init_args)
-    {
-      return create_glue().fold(std::move(name),
-                                std::move(f),
-                                c,
-                                std::move(partition),
-                                std::forward<InitArgs>(init_args)...);
-    }
+              InitArgs&&... init_args);
 
     /// @brief Registers an observer node.
-    auto observe(std::string name, is_observer_like auto f, concurrency c = concurrency::serial)
-    {
-      return create_glue().observe(std::move(name), std::move(f), c);
-    }
+    auto observe(std::string name, is_observer_like auto f, concurrency c = concurrency::serial);
 
     /// @brief Registers a predicate node.
-    auto predicate(std::string name, is_predicate_like auto f, concurrency c = concurrency::serial)
-    {
-      return create_glue().predicate(std::move(name), std::move(f), c);
-    }
+    auto predicate(std::string name, is_predicate_like auto f, concurrency c = concurrency::serial);
 
     /// @brief Registers a provider node.
-    auto provide(std::string name, is_provider_like auto f, concurrency c = concurrency::serial)
-    {
-      return create_glue().provide(std::move(name), std::move(f), c);
-    }
+    auto provide(std::string name, is_provider_like auto f, concurrency c = concurrency::serial);
 
     /// @brief Registers a transform node.
-    auto transform(std::string name, is_transform_like auto f, concurrency c = concurrency::serial)
-    {
-      return create_glue().transform(std::move(name), std::move(f), c);
-    }
+    auto transform(std::string name, is_transform_like auto f, concurrency c = concurrency::serial);
 
     /// @brief Registers an unfold node.
     template <typename Splitter>
@@ -101,53 +76,30 @@ namespace phlex::detail {
                 is_predicate_like auto pred,
                 auto unf,
                 std::string destination_data_layer,
-                concurrency c = concurrency::serial)
-    {
-      return glue<Splitter>{graph_, nodes_, nullptr, errors_, config_}.unfold(
-        std::move(name), std::move(pred), std::move(unf), c, std::move(destination_data_layer));
-    }
+                concurrency c = concurrency::serial);
 
     /// @brief Registers a source (used by the framework to create provider nodes)
     template <std::derived_from<source> Source, typename... Args>
     void add_source(std::string name, Args&&... args)
-      requires(not is_bound_object<T>)
-    {
-      // The bound object is created when invoking source<Source>(...), so we explicitly indicate that
-      // no bound object should be used in the create_glue(...) call.
-      return create_glue(false).template add_source<Source>(std::move(name),
-                                                            std::forward<Args>(args)...);
-    }
+      requires(not is_bound_object<T>);
 
     /// @brief Registers an output node.
-    auto output(std::string name, is_output_like auto f, concurrency c = concurrency::serial)
-    {
-      return create_glue().output(std::move(name), std::move(f), c);
-    }
+    auto output(std::string name, is_output_like auto f, concurrency c = concurrency::serial);
 
   protected:
     template <template <typename> typename Proxy, typename U, typename... Args>
     Proxy<U> bind_to(Args&&... args)
-      requires(not is_bound_object<T>)
-    {
-      return Proxy<U>{
-        config_, graph_, nodes_, std::make_shared<U>(std::forward<Args>(args)...), errors_};
-    }
+      requires(not is_bound_object<T>);
 
     graph_proxy(configuration const* config,
                 tbb::flow::graph& g,
                 node_catalog& nodes,
                 std::shared_ptr<T> bound_obj,
                 std::vector<std::string>& errors)
-      requires(is_bound_object<T>)
-      : config_{config}, graph_{g}, nodes_{nodes}, bound_obj_{bound_obj}, errors_{errors}
-    {
-    }
+      requires(is_bound_object<T>);
 
   private:
-    glue<T> create_glue(bool use_bound_object = true)
-    {
-      return glue{graph_, nodes_, (use_bound_object ? bound_obj_ : nullptr), errors_, config_};
-    }
+    glue<T> create_glue(bool use_bound_object = true);
 
     configuration const* config_;
     // Non-owning references to framework-owned resources; graph_proxy<T> is a
@@ -157,6 +109,115 @@ namespace phlex::detail {
     std::shared_ptr<T> bound_obj_;
     std::vector<std::string>& errors_; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
   };
+
+  template <typename T>
+  graph_proxy<T>::graph_proxy(configuration const& config,
+                              tbb::flow::graph& g,
+                              node_catalog& nodes,
+                              std::vector<std::string>& errors)
+    requires(not is_bound_object<T>)
+    : config_{&config}, graph_{g}, nodes_{nodes}, errors_{errors}
+  {
+  }
+
+  template <typename T>
+  template <typename U, typename... Args>
+  graph_proxy<U> graph_proxy<T>::make(Args&&... args)
+    requires(not is_bound_object<T>)
+  {
+    return bind_to<graph_proxy, U>(std::forward<Args>(args)...);
+  }
+
+  template <typename T>
+  template <typename... InitArgs>
+  auto graph_proxy<T>::fold(std::string name,
+                            is_fold_like auto f,
+                            concurrency c,
+                            std::string partition,
+                            InitArgs&&... init_args)
+  {
+    return create_glue().fold(
+      std::move(name), std::move(f), c, std::move(partition), std::forward<InitArgs>(init_args)...);
+  }
+
+  template <typename T>
+  auto graph_proxy<T>::observe(std::string name, is_observer_like auto f, concurrency c)
+  {
+    return create_glue().observe(std::move(name), std::move(f), c);
+  }
+
+  template <typename T>
+  auto graph_proxy<T>::predicate(std::string name, is_predicate_like auto f, concurrency c)
+  {
+    return create_glue().predicate(std::move(name), std::move(f), c);
+  }
+
+  template <typename T>
+  auto graph_proxy<T>::provide(std::string name, is_provider_like auto f, concurrency c)
+  {
+    return create_glue().provide(std::move(name), std::move(f), c);
+  }
+
+  template <typename T>
+  auto graph_proxy<T>::transform(std::string name, is_transform_like auto f, concurrency c)
+  {
+    return create_glue().transform(std::move(name), std::move(f), c);
+  }
+
+  template <typename T>
+  template <typename Splitter>
+  auto graph_proxy<T>::unfold(std::string name,
+                              is_predicate_like auto pred,
+                              auto unf,
+                              std::string destination_data_layer,
+                              concurrency c)
+  {
+    return glue<Splitter>{graph_, nodes_, nullptr, errors_, config_}.unfold(
+      std::move(name), std::move(pred), std::move(unf), c, std::move(destination_data_layer));
+  }
+
+  template <typename T>
+  template <std::derived_from<source> Source, typename... Args>
+  void graph_proxy<T>::add_source(std::string name, Args&&... args)
+    requires(not is_bound_object<T>)
+  {
+    // The bound object is created when invoking add_source<Source>(...), so we explicitly indicate that
+    // no bound object should be used in the create_glue(...) call.
+    return create_glue(false).template add_source<Source>(std::move(name),
+                                                          std::forward<Args>(args)...);
+  }
+
+  template <typename T>
+  auto graph_proxy<T>::output(std::string name, is_output_like auto f, concurrency c)
+  {
+    return create_glue().output(std::move(name), std::move(f), c);
+  }
+
+  template <typename T>
+  template <template <typename> typename Proxy, typename U, typename... Args>
+  Proxy<U> graph_proxy<T>::bind_to(Args&&... args)
+    requires(not is_bound_object<T>)
+  {
+    return Proxy<U>{
+      config_, graph_, nodes_, std::make_shared<U>(std::forward<Args>(args)...), errors_};
+  }
+
+  template <typename T>
+  graph_proxy<T>::graph_proxy(configuration const* config,
+                              tbb::flow::graph& g,
+                              node_catalog& nodes,
+                              std::shared_ptr<T> bound_obj,
+                              std::vector<std::string>& errors)
+    requires(is_bound_object<T>)
+    : config_{config}, graph_{g}, nodes_{nodes}, bound_obj_{bound_obj}, errors_{errors}
+  {
+  }
+
+  template <typename T>
+  glue<T> graph_proxy<T>::create_glue(bool use_bound_object)
+  {
+    return glue{graph_, nodes_, (use_bound_object ? bound_obj_ : nullptr), errors_, config_};
+  }
 }
 
 #endif // PHLEX_CORE_GRAPH_PROXY_HPP
diff --git a/phlex/core/node_catalog.hpp b/phlex/core/node_catalog.hpp
index 693fbc993..bfe23ff34 100644
--- a/phlex/core/node_catalog.hpp
+++ b/phlex/core/node_catalog.hpp
@@ -21,7 +21,79 @@
 #include <vector>
 
 namespace phlex::detail {
+  // A node_catalog is the framework_graph's registry of all the algorithm nodes
+  // that make up a Phlex data-processing application.  It holds every kind of
+  // node the framework knows about (predicates, observers, outputs, folds,
+  // unfolds, transforms, and providers), grouped by type, and serves
+  // as the single source of node information used to build and run the flow
+  // graph. It also holds the sources, which are factories for creating provider
+  // nodes.
+
+  // The externally visible entry point for plugin modules is create_module,
+  // with the signature:
+  //   extern "C" void create_module(
+  //     phlex::detail::module_graph_proxy<phlex::detail::void_tag> m,
+  //     phlex::configuration const& config)
+  //
+  // User plugins define this function via the PHLEX_REGISTER_ALGORITHMS macro,
+  // which expands to the extern "C" entry point.  The body invokes module methods
+  // like transform(), predicate(), fold(), unfold(), observe(), and output() on
+  // the 'm' argument. These methods add nodes to this node_catalog.
+  //
+  // During application initialization, the framework loads each configured
+  // plugin shared library (PHLEX_PLUGIN_PATH), resolves the create_module entry
+  // point via Boost.DLL, and invokes it to populate this node_catalog before
+  // building the flow graph.
+
   struct PHLEX_CORE_EXPORT node_catalog {
+    // How nodes are added to the node_catalog
+    // ---------------------------------------
+    // The node_catalog is populated as a side effect of *registration*, i.e.
+    // when user algorithms are declared to be part of the framework_graph.
+    // There are three insertion paths, all of which ultimately insert a node
+    // into one of the simple_ptr_map members:
+    //
+    //   1. Algorithm registration (transform, predicate, observe, fold,
+    //      unfold, provide, output):  Each declaration creates a short-lived
+    //      *_api builder holding a registrar bound to the appropriate map (see
+    //      registrar_for()).  For all but output nodes, the registrar's
+    //      destructor creates the node and inserts it at the end of the
+    //      registration statement. For output nodes, an explicit call does
+    //      this.
+    //   2. Sources: glue::source() inserts directly into `sources`, bypassing
+    //      the registrar.
+    //   3. Implicit provider_node objects: make_computational_edges() creates
+    //      and inserts into `providers` later, during graph finalization, to
+    //      satisfy otherwise unrequited inputs.
+    //
+    // Module (plugin) loading time
+    // ----------------------------
+    // Most registrations originate from dynamically loaded *modules*.  At graph
+    // construction time, load_module() (phlex/app/load_module.cpp) loads each
+    // configured plugin shared library found on PHLEX_PLUGIN_PATH. For each
+    // plugin, the `create_module` entry point is found (usually defined via the
+    // macro PHLEX_REGISTER_ALGORITHMS).
+    //
+    // The framework then invokes `create_module`, passing a module_graph_proxy
+    // that forwards fold/observe/predicate/transform/unfold/output calls into
+    // this catalog.  The plugin's registration code therefore runs during
+    // single-threaded graph construction and adds its nodes here via the paths
+    // described above.
+
+    // Note: The loaded libraries' factory functions are kept alive for the
+    // lifetime of the job so the libraries are not unloaded out from under the
+    // registered nodes.
+
+    // Only the framework_graph for an application is intended to have a
+    // node_catalog; it should not get copied or assigned, so we disable copying
+    // and assignment to prevent accidental use.
+    node_catalog() = default;
+    node_catalog(node_catalog const&) = delete;
+    node_catalog(node_catalog&&) = delete;
+    node_catalog& operator=(node_catalog const&) = delete;
+    node_catalog& operator=(node_catalog&&) = delete;
+    ~node_catalog() = default;
+
     template <typename Ptr>
     auto registrar_for(std::vector<std::string>& errors)
     {
diff --git a/phlex/module.hpp b/phlex/module.hpp
index 407ad5796..9dca2e292 100644
--- a/phlex/module.hpp
+++ b/phlex/module.hpp
@@ -12,7 +12,7 @@ namespace phlex::detail {
   /// @brief Proxy for registering module algorithm nodes.
   ///
   /// Passed to @c PHLEX_REGISTER_ALGORITHMS plugin entry points. Provides
-  /// access to fold, observe, predicate, transform, and unfold registration.
+  /// access to fold, observe, output, predicate, transform, and unfold registration.
   /// Users never construct this type directly.
   template <typename T>
   class module_graph_proxy : graph_proxy<T> {
diff --git a/plugins/python/python/phlex/_typing.py b/plugins/python/python/phlex/_typing.py
index 7c08f9671..bbf8730b1 100644
--- a/plugins/python/python/phlex/_typing.py
+++ b/plugins/python/python/phlex/_typing.py
@@ -16,6 +16,7 @@
 
 try:
     import numba.core.types as nb_types
+
     has_numba = True
 except ImportError:
     has_numba = False
@@ -48,21 +49,23 @@
 }
 
 if has_numba:
-    _PY2CPP.update({
-        nb_types.bool: "bool",
-        nb_types.int8: "int8_t",
-        nb_types.int16: "int16_t",
-        nb_types.int32: "int32_t",
-        nb_types.int64: "int64_t",
-        nb_types.uint8: "uint8_t",
-        nb_types.uint16: "uint16_t",
-        nb_types.uint32: "uint32_t",
-        nb_types.uint64: "uint64_t",
-        nb_types.Float: "float",
-        nb_types.float32: "float",
-        nb_types.double: "double",
-        nb_types.void: "None",
-    })
+    _PY2CPP.update(
+        {
+            nb_types.bool: "bool",
+            nb_types.int8: "int8_t",
+            nb_types.int16: "int16_t",
+            nb_types.int32: "int32_t",
+            nb_types.int64: "int64_t",
+            nb_types.uint8: "uint8_t",
+            nb_types.uint16: "uint16_t",
+            nb_types.uint32: "uint32_t",
+            nb_types.uint64: "uint64_t",
+            nb_types.Float: "float",
+            nb_types.float32: "float",
+            nb_types.double: "double",
+            nb_types.void: "None",
+        }
+    )
 
 # ctypes types that don't map cleanly to intN_t / uintN_t
 _CTYPES_SPECIAL: dict[type, str] = {}
@@ -183,7 +186,7 @@ def normalize_type(tp: Any, globalns: Dict | None = None, localns: Dict | None =
     if origin is not None:
         args = typing.get_args(tp)
 
-        if origin in (np.ndarray, np.typing.NDArray):      # numpy arrays
+        if origin in (np.ndarray, np.typing.NDArray):  # numpy arrays
             dtype_args: tuple[Any, ...] = ()
             # origin should point to the original type type, unless it is generic; it's
             # probably debatable what it should be for numpy.ndarray, but for versions
diff --git a/test/python/adder.py b/test/python/adder.py
index 4205a5736..3760a7972 100644
--- a/test/python/adder.py
+++ b/test/python/adder.py
@@ -57,14 +57,12 @@ def PHLEX_REGISTER_ALGORITHMS(m, config):
     int_adder = Variant(add, {"i": int, "j": int, "return": int}, "iadd")
 
     try:
-      # intentional failure to check error path of missing output suffix
-      m.transform(int_adder, input_family=config["input"])
+        # intentional failure to check error path of missing output suffix
+        m.transform(int_adder, input_family=config["input"])
     except TypeError as e:
-      assert "should have an output suffix" in str(e)
+        assert "should have an output suffix" in str(e)
     else:
-      raise AssertionError(
-          "m.transform() should reject registrations without an output suffix"
-      )
+        raise AssertionError("m.transform() should reject registrations without an output suffix")
 
     # functional transform registration
     m.transform(int_adder, input_family=config["input"], output_product_suffixes=config["output"])
diff --git a/test/python/jited.py b/test/python/jited.py
index 436bda744..af6a91606 100644
--- a/test/python/jited.py
+++ b/test/python/jited.py
@@ -15,8 +15,8 @@
     ("u1", "u2", np.uint32, 1),
     ("l1", "l2", np.int64, 1),
     ("ul1", "ul2", np.uint64, 100),
-    ("f1", "f2", np.float32, 1.),
-    ("d1", "d2", np.float64, 1.),
+    ("f1", "f2", np.float32, 1.0),
+    ("d1", "d2", np.float64, 1.0),
 )
 
 
@@ -40,24 +40,28 @@ def PHLEX_REGISTER_ALGORITHMS(m, config):
     def new_o(x):
         def o(y):
             assert y == x
+
         return o
 
     for arg0, arg1, t, res in specs:
         tn = t.__name__
 
         f_a = numba.cfunc(f"{tn}({tn}, {tn})", nogil=True, nopython=True, cache=True)(add)
-        m.transform(f_a,
-                    name="add_"+tn,
-                    input_family=[{"creator": "input", "layer": "event", "suffix": arg0},
-                                  {"creator": "input", "layer": "event", "suffix": arg1}],
-                    output_product_suffixes=["sum_"+tn],
-                    concurrency=4)
+        m.transform(
+            f_a,
+            name="add_" + tn,
+            input_family=[
+                {"creator": "input", "layer": "event", "suffix": arg0},
+                {"creator": "input", "layer": "event", "suffix": arg1},
+            ],
+            output_product_suffixes=["sum_" + tn],
+            concurrency=4,
+        )
 
         f_o = numba.cfunc(f"void({tn})", nogil=True, nopython=True, cache=True)(new_o(res))
-        m.observe(f_o,
-                  name="obs_"+tn,
-                  input_family=[
-                      {"creator": "add_" + tn, "layer": "event", "suffix": "sum_"+tn}
-                  ],
-                  concurrency=4)
-
+        m.observe(
+            f_o,
+            name="obs_" + tn,
+            input_family=[{"creator": "add_" + tn, "layer": "event", "suffix": "sum_" + tn}],
+            concurrency=4,
+        )