diff --git a/docs/dev/clang-tidy-fixes-2026-04.md b/docs/dev/clang-tidy-fixes-2026-04.md
index 14429afa5..85d9194da 100644
--- a/docs/dev/clang-tidy-fixes-2026-04.md
+++ b/docs/dev/clang-tidy-fixes-2026-04.md
@@ -118,7 +118,8 @@
   - [PR #733](https://github.com/Framework-R-D/phlex/pull/733)
 - [x] [modernize-use-emplace](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-emplace.html) (1)
   - [PR #793](https://github.com/Framework-R-D/phlex/pull/793)
-- [ ] [modernize-use-designated-initializers](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-designated-initializers.html) (69)
+- [x] [modernize-use-designated-initializers](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-designated-initializers.html) (69)
+  - [PR #835](https://github.com/Framework-R-D/phlex/pull/835)
 - [x] [modernize-use-equals-default](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-equals-default.html) (7)
   - [PR #784](https://github.com/Framework-R-D/phlex/pull/784)
 - [x] [modernize-use-integer-sign-comparison](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-integer-sign-comparison.html) (7)
diff --git a/form/core/technology.hpp b/form/core/technology.hpp
index 9a084ee52..ebb70b59c 100644
--- a/form/core/technology.hpp
+++ b/form/core/technology.hpp
@@ -28,9 +28,9 @@ namespace form::technology {
   };
 
   // Backends: valid (major, minor) pairs, stable numeric values as a future Token may persist them
-  inline constexpr Id ROOT_TTREE{Major::root, 1};
-  inline constexpr Id ROOT_RNTUPLE{Major::root, 2};
-  inline constexpr Id HDF5{Major::hdf5, 1};
+  inline constexpr Id ROOT_TTREE{.major = Major::root, .minor = 1};
+  inline constexpr Id ROOT_RNTUPLE{.major = Major::root, .minor = 2};
+  inline constexpr Id HDF5{.major = Major::hdf5, .minor = 1};
 
   // Canonical string -> technology mapping: the single place a technology string is parsed, replacing the copies that used to live in each module/source/test
   inline Id from_string(std::string_view name)
diff --git a/form/form/form_source_type_registry.cpp b/form/form/form_source_type_registry.cpp
index 2a2b8a378..b8a5e5b98 100644
--- a/form/form/form_source_type_registry.cpp
+++ b/form/form/form_source_type_registry.cpp
@@ -39,7 +39,9 @@ namespace form::experimental {
 
     std::scoped_lock lock(form_type_registry_mutex());
     mutable_form_type_registry()[std::move(product_type)] =
-      form_source_type_entry{std::move(type), &cpp_type, std::move(product_from_data_fn)};
+      form_source_type_entry{.type_id = std::move(type),
+                             .cpp_type = &cpp_type,
+                             .product_from_data_fn = std::move(product_from_data_fn)};
   }
 
   // Returns a pointer to the registry entry. The registry is is immutable after the first call to this function.
diff --git a/form/form_source.cpp b/form/form_source.cpp
index 9daab17ca..e11764df5 100644
--- a/form/form_source.cpp
+++ b/form/form_source.cpp
@@ -143,7 +143,8 @@ namespace {
       form::experimental::form_source_type_entry const* entry =
         form::experimental::find_form_product_type(product_type);
       if (entry && entry->cpp_type && entry->product_from_data_fn) {
-        form::experimental::product_with_name pb{product_name, nullptr, entry->cpp_type};
+        form::experimental::product_with_name pb{
+          .label = product_name, .data = nullptr, .type = entry->cpp_type};
         reader_->read(creator, index_str, pb);
         return entry->product_from_data_fn(pb.data, product_name, index_str);
       }
diff --git a/phlex/app/load_module.cpp b/phlex/app/load_module.cpp
index 35c96e46e..3f28b9c32 100644
--- a/phlex/app/load_module.cpp
+++ b/phlex/app/load_module.cpp
@@ -126,7 +126,7 @@ namespace phlex::detail {
 
     auto const& spec = value_to<std::string>(adjusted_config.at("cpp"));
     auto [lib, fn] = plugin_loader<internal::module_creator_t>(spec, "create_module");
-    auto& creator = create_module.emplace_back(module_plugin{std::move(lib), fn});
+    auto& creator = create_module.emplace_back(module_plugin{.lib = std::move(lib), .fn = fn});
 
     configuration const config{adjusted_config};
     creator(g.module_proxy(config), config);
@@ -138,7 +138,7 @@ namespace phlex::detail {
 
     auto const& spec = value_to<std::string>(adjusted_config.at("cpp"));
     auto [lib, fn] = plugin_loader<internal::source_creator_t>(spec, "create_source");
-    auto& creator = create_source.emplace_back(source_plugin{std::move(lib), fn});
+    auto& creator = create_source.emplace_back(source_plugin{.lib = std::move(lib), .fn = 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
@@ -158,7 +158,7 @@ namespace phlex::detail {
     // internal reference counting in classification.hpp.
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks,clang-analyzer-cplusplus.NewDelete)
     auto [lib, fn] = plugin_loader<internal::driver_shim_t>(spec, "create_driver");
-    create_driver.emplace(driver_plugin{std::move(lib), fn});
+    create_driver.emplace(driver_plugin{.lib = std::move(lib), .fn = fn});
     driver_bundle result;
     (*create_driver)(g.driver_proxy(required_sources), config, &result);
     g.add_driver(result);
diff --git a/phlex/core/filter.cpp b/phlex/core/filter.cpp
index 0321e07da..3c0eed564 100644
--- a/phlex/core/filter.cpp
+++ b/phlex/core/filter.cpp
@@ -71,7 +71,7 @@ namespace phlex::detail {
         return {};
       }
       for (auto const& [port, store] : std::views::zip(downstream_ports_, stores)) {
-        port->try_put({store, msg_id});
+        port->try_put({.store = store, .id = msg_id});
       }
       // Decision must be erased while access is claimed
       decisions_.erase(a);
diff --git a/phlex/core/framework_graph.hpp b/phlex/core/framework_graph.hpp
index c70aa6cc6..d01670d19 100644
--- a/phlex/core/framework_graph.hpp
+++ b/phlex/core/framework_graph.hpp
@@ -76,7 +76,10 @@ namespace phlex::detail {
 
     source_bundle source_proxy(configuration const& config)
     {
-      return {config, graph_, nodes_, registration_errors_};
+      return {.config = config,
+              .graph = graph_,
+              .nodes = nodes_,
+              .registration_errors = registration_errors_};
     }
 
     phlex::detail::driver_proxy driver_proxy(std::vector<std::string> const& strings = {})
diff --git a/phlex/core/make_computational_edges.cpp b/phlex/core/make_computational_edges.cpp
index f787068be..35530cbba 100644
--- a/phlex/core/make_computational_edges.cpp
+++ b/phlex/core/make_computational_edges.cpp
@@ -60,7 +60,8 @@ namespace phlex::detail {
                           input_product.to_string());
             make_edge(matched_provider->output_port(), *port);
           } else {
-            unconsumed_head_ports[node_name].push_back({input_product, port});
+            unconsumed_head_ports[node_name].push_back(
+              {.input_product = input_product, .port = port});
           }
         }
       }
@@ -92,7 +93,8 @@ namespace phlex::detail {
           // If we have a source node that can produce this product, use it.
           auto bundles = find_matching_implicit_providers(sources, input_product);
           if (bundles.empty()) {
-            unconsumed_head_ports[node_name].push_back({input_product, port});
+            unconsumed_head_ports[node_name].push_back(
+              {.input_product = input_product, .port = port});
             continue;
           }
 
@@ -142,7 +144,7 @@ namespace phlex::detail {
           auto const* producer = producers.find_producer(query, node->name());
           if (not producer) {
             // Is there a way to detect mis-specified product dependencies?
-            result[node_name].push_back({query, receiver_port});
+            result[node_name].push_back({.input_product = query, .port = receiver_port});
             continue;
           }
 
diff --git a/plugins/generate_layers.cpp b/plugins/generate_layers.cpp
index 779254724..89a32d74f 100644
--- a/plugins/generate_layers.cpp
+++ b/plugins/generate_layers.cpp
@@ -33,9 +33,9 @@ PHLEX_REGISTER_DRIVER(d, config)
   for (auto const& key : layers.keys()) {
     auto const layer_config = layers.get<configuration>(key);
     gen->add_layer(key,
-                   {.parent_layer_name = layer_config.get<std::string>("parent", "job"),
-                    .total_per_parent_data_cell = layer_config.get<unsigned int>("total"),
-                    .starting_value = layer_config.get<unsigned int>("starting_number", 0)});
+                   {.parent_layer = layer_config.get<std::string>("parent", "job"),
+                    .count = layer_config.get<unsigned int>("total"),
+                    .start_at = layer_config.get<unsigned int>("starting_number", 0)});
   }
 
   return d.driver(gen);
diff --git a/plugins/layer_generator.cpp b/plugins/layer_generator.cpp
index d9c5c38e6..3544ede99 100644
--- a/plugins/layer_generator.cpp
+++ b/plugins/layer_generator.cpp
@@ -93,9 +93,9 @@ namespace phlex::experimental {
 
       auto layer_handle = layers_.extract(old_layer_path);
       layer_handle.key() = new_layer_path;
-      auto const old_parent_path = layer_handle.mapped().parent_layer_name;
+      auto const old_parent_path = layer_handle.mapped().parent_layer;
       auto const new_parent_path = new_layer_path.substr(0, new_layer_path.find_last_of('/'));
-      layer_handle.mapped().parent_layer_name = new_parent_path;
+      layer_handle.mapped().parent_layer = new_parent_path;
       layers_.insert(std::move(layer_handle));
 
       auto emitted_handle = emitted_cells_.extract(old_layer_path);
@@ -110,7 +110,7 @@ namespace phlex::experimental {
 
   void layer_generator::add_layer(std::string layer_name, layer_spec lspec)
   {
-    auto const parent_full_path = parent_path(layer_name, lspec.parent_layer_name);
+    auto const parent_full_path = parent_path(layer_name, lspec.parent_layer);
 
     // We need to make sure that we can distinguish between (e.g.) /events and /run/events.
     // When a layer is added, the parent layers are also included as part of the path.
@@ -118,7 +118,7 @@ namespace phlex::experimental {
 
     auto full_path = parent_full_path + "/" + layer_name;
 
-    lspec.parent_layer_name = parent_full_path;
+    lspec.parent_layer = parent_full_path;
     layers_[full_path] = std::move(lspec);
     emitted_cells_[full_path] = 0ull;
     parent_to_children_[parent_full_path].push_back(std::move(layer_name));
@@ -154,9 +154,9 @@ namespace phlex::experimental {
 
     for (auto const& child : it->second) {
       auto const full_child_path = fmt::format("{}/{}", cell_lp, child);
-      auto const& [_, total_per_parent, starting_value] = layers_.at(full_child_path);
+      auto const& [_, count, start_at] = layers_.at(full_child_path);
       bool const has_children = parent_to_children_.contains(full_child_path);
-      for (unsigned int i : std::views::iota(starting_value, total_per_parent + starting_value)) {
+      for (unsigned int i : std::views::iota(start_at, count + start_at)) {
         auto child_cell = cell->make_child(child, i);
         ++emitted_cells_.at(full_child_path);
         co_yield child_cell;
diff --git a/plugins/layer_generator.hpp b/plugins/layer_generator.hpp
index f87343f2d..6a0c68a61 100644
--- a/plugins/layer_generator.hpp
+++ b/plugins/layer_generator.hpp
@@ -40,9 +40,9 @@
 
 namespace phlex::experimental {
   struct layer_spec {
-    std::string parent_layer_name;
-    std::size_t total_per_parent_data_cell{};
-    std::size_t starting_value = 0;
+    std::string parent_layer;
+    std::size_t count{};
+    std::size_t start_at = 0;
   };
 
   // Inherit enable_shared_from_this so driver_function can capture a shared_ptr to this,
diff --git a/plugins/python/src/configwrap.cpp b/plugins/python/src/configwrap.cpp
index 833822806..1249097c4 100644
--- a/plugins/python/src/configwrap.cpp
+++ b/plugins/python/src/configwrap.cpp
@@ -221,75 +221,69 @@ static PyObject* pcm_subscript(py_config_map* pycmap, PyObject* pykey)
 
 // PyMappingMethods must be non-const; tp_as_mapping in PyTypeObject takes a non-const pointer.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static PyMappingMethods pcm_as_mapping = {
-  nullptr, reinterpret_cast<binaryfunc>(pcm_subscript), nullptr};
+static PyMappingMethods pcm_as_mapping = {.mp_length = nullptr,
+                                          .mp_subscript =
+                                            reinterpret_cast<binaryfunc>(pcm_subscript),
+                                          .mp_ass_subscript = nullptr};
 
-// clang-format off
 // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 PyTypeObject phlex::experimental::PhlexConfig_Type = {
-  PyVarObject_HEAD_INIT(&PyType_Type, 0)
-  "pyphlex.configuration",                           // tp_name
-  sizeof(py_config_map),                             // tp_basicsize
-  0,                                                 // tp_itemsize
-  reinterpret_cast<destructor>(pcm_dealloc),         // tp_dealloc
-  0,                                                 // tp_vectorcall_offset / tp_print
-  nullptr,                                           // tp_getattr
-  nullptr,                                           // tp_setattr
-  nullptr,                                           // tp_as_async / tp_compare
-  nullptr,                                           // tp_repr
-  nullptr,                                           // tp_as_number
-  nullptr,                                           // tp_as_sequence
-  &pcm_as_mapping,                                   // tp_as_mapping
-  nullptr,                                           // tp_hash
-  nullptr,                                           // tp_call
-  nullptr,                                           // tp_str
-  nullptr,                                           // tp_getattro
-  nullptr,                                           // tp_setattro
-  nullptr,                                           // tp_as_buffer
-  Py_TPFLAGS_DEFAULT,                                // tp_flags
-  "phlex configuration object-as-dictionary",        // tp_doc
-  nullptr,                                           // tp_traverse
-  nullptr,                                           // tp_clear
-  nullptr,                                           // tp_richcompare
-  0,                                                 // tp_weaklistoffset
-  nullptr,                                           // tp_iter
-  nullptr,                                           // tp_iternext
-  nullptr,                                           // tp_methods
-  nullptr,                                           // tp_members
-  nullptr,                                           // tp_getset
-  nullptr,                                           // tp_base
-  nullptr,                                           // tp_dict
-  nullptr,                                           // tp_descr_get
-  nullptr,                                           // tp_descr_set
-  offsetof(py_config_map, ph_config_cache),          // tp_dictoffset
-  nullptr,                                           // tp_init
-  nullptr,                                           // tp_alloc
-  reinterpret_cast<newfunc>(pcm_new),                // tp_new
-  nullptr,                                           // tp_free
-  nullptr,                                           // tp_is_gc
-  nullptr,                                           // tp_bases
-  nullptr,                                           // tp_mro
-  nullptr,                                           // tp_cache
-  nullptr,                                           // tp_subclasses
-  nullptr                                            // tp_weaklist
-#if PY_VERSION_HEX >= 0x02030000
-  , nullptr                                          // tp_del
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-  , 0                                                // tp_version_tag
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-  , nullptr                                          // tp_finalize
-#endif
-#if PY_VERSION_HEX >= 0x03080000
-  , nullptr                                          // tp_vectorcall
-#endif
+  // clang-format off
+  .ob_base = PyVarObject_HEAD_INIT(&PyType_Type, 0)
+  .tp_name = "pyphlex.configuration",
+  // clang-format on
+  .tp_basicsize = sizeof(py_config_map),
+  .tp_itemsize = 0,
+  .tp_dealloc = reinterpret_cast<destructor>(pcm_dealloc),
+  .tp_vectorcall_offset = 0,
+  .tp_getattr = nullptr,
+  .tp_setattr = nullptr,
+  .tp_as_async = nullptr,
+  .tp_repr = nullptr,
+  .tp_as_number = nullptr,
+  .tp_as_sequence = nullptr,
+  .tp_as_mapping = &pcm_as_mapping,
+  .tp_hash = nullptr,
+  .tp_call = nullptr,
+  .tp_str = nullptr,
+  .tp_getattro = nullptr,
+  .tp_setattro = nullptr,
+  .tp_as_buffer = nullptr,
+  .tp_flags = Py_TPFLAGS_DEFAULT,
+  .tp_doc = "phlex configuration object-as-dictionary",
+  .tp_traverse = nullptr,
+  .tp_clear = nullptr,
+  .tp_richcompare = nullptr,
+  .tp_weaklistoffset = 0,
+  .tp_iter = nullptr,
+  .tp_iternext = nullptr,
+  .tp_methods = nullptr,
+  .tp_members = nullptr,
+  .tp_getset = nullptr,
+  .tp_base = nullptr,
+  .tp_dict = nullptr,
+  .tp_descr_get = nullptr,
+  .tp_descr_set = nullptr,
+  .tp_dictoffset = offsetof(py_config_map, ph_config_cache),
+  .tp_init = nullptr,
+  .tp_alloc = nullptr,
+  .tp_new = reinterpret_cast<newfunc>(pcm_new),
+  .tp_free = nullptr,
+  .tp_is_gc = nullptr,
+  .tp_bases = nullptr,
+  .tp_mro = nullptr,
+  .tp_cache = nullptr,
+  .tp_subclasses = nullptr,
+  .tp_weaklist = nullptr,
+  .tp_del = nullptr,
+  .tp_version_tag = 0,
+  .tp_finalize = nullptr,
+  .tp_vectorcall = nullptr,
 #if PY_VERSION_HEX >= 0x030c0000
-  , 0                                                // tp_watched
+  .tp_watched = 0,
 #endif
 #if PY_VERSION_HEX >= 0x030d0000
-  , 0                                                // tp_versions_used
+  .tp_versions_used = 0,
 #endif
 };
-// clang-format on
diff --git a/plugins/python/src/dciwrap.cpp b/plugins/python/src/dciwrap.cpp
index 2baa1bc7f..f27d412c3 100644
--- a/plugins/python/src/dciwrap.cpp
+++ b/plugins/python/src/dciwrap.cpp
@@ -33,75 +33,70 @@ static PyObject* dci_number(py_data_cell_index* pydci)
 // PyMethodDef arrays must be non-const; tp_methods in PyTypeObject takes a non-const pointer.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static std::array<PyMethodDef, 2> dci_methods{
-  {{"number", reinterpret_cast<PyCFunction>(dci_number), METH_NOARGS, "index number"},
-   {nullptr, nullptr, 0, nullptr}}};
+  {{.ml_name = "number",
+    .ml_meth = reinterpret_cast<PyCFunction>(dci_number),
+    .ml_flags = METH_NOARGS,
+    .ml_doc = "index number"},
+   {.ml_name = nullptr, .ml_meth = nullptr, .ml_flags = 0, .ml_doc = nullptr}}};
 
-// clang-format off
 // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 PyTypeObject phlex::experimental::PhlexDataCellIndex_Type = {
-  PyVarObject_HEAD_INIT(&PyType_Type, 0)
-  "pyphlex.data_cell_index",                         // tp_name
-  sizeof(py_data_cell_index),                        // tp_basicsize
-  0,                                                 // tp_itemsize
-  nullptr,                                           // tp_dealloc
-  0,                                                 // tp_vectorcall_offset / tp_print
-  nullptr,                                           // tp_getattr
-  nullptr,                                           // tp_setattr
-  nullptr,                                           // tp_as_async / tp_compare
-  nullptr,                                           // tp_repr
-  nullptr,                                           // tp_as_number
-  nullptr,                                           // tp_as_sequence
-  nullptr,                                           // tp_as_mapping
-  nullptr,                                           // tp_hash
-  nullptr,                                           // tp_call
-  nullptr,                                           // tp_str
-  nullptr,                                           // tp_getattro
-  nullptr,                                           // tp_setattro
-  nullptr,                                           // tp_as_buffer
-  Py_TPFLAGS_DEFAULT,                                // tp_flags
-  "phlex data_cell_index",                           // tp_doc
-  nullptr,                                           // tp_traverse
-  nullptr,                                           // tp_clear
-  nullptr,                                           // tp_richcompare
-  0,                                                 // tp_weaklistoffset
-  nullptr,                                           // tp_iter
-  nullptr,                                           // tp_iternext
-  dci_methods.data(),                                // tp_methods
-  nullptr,                                           // tp_members
-  nullptr,                                           // tp_getset
-  nullptr,                                           // tp_base
-  nullptr,                                           // tp_dict
-  nullptr,                                           // tp_descr_get
-  nullptr,                                           // tp_descr_set
-  0,                                                 // tp_dictoffset
-  nullptr,                                           // tp_init
-  nullptr,                                           // tp_alloc
-  nullptr,                                           // tp_new
-  nullptr,                                           // tp_free
-  nullptr,                                           // tp_is_gc
-  nullptr,                                           // tp_bases
-  nullptr,                                           // tp_mro
-  nullptr,                                           // tp_cache
-  nullptr,                                           // tp_subclasses
-  nullptr                                            // tp_weaklist
-#if PY_VERSION_HEX >= 0x02030000
-  , nullptr                                          // tp_del
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-  , 0                                                // tp_version_tag
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-  , nullptr                                          // tp_finalize
-#endif
-#if PY_VERSION_HEX >= 0x03080000
-  , nullptr                                          // tp_vectorcall
-#endif
+  // clang-format off
+  .ob_base = PyVarObject_HEAD_INIT(&PyType_Type, 0)
+  .tp_name = "pyphlex.data_cell_index",
+  // clang-format on
+  .tp_basicsize = sizeof(py_data_cell_index),
+  .tp_itemsize = 0,
+  .tp_dealloc = nullptr,
+  .tp_vectorcall_offset = 0,
+  .tp_getattr = nullptr,
+  .tp_setattr = nullptr,
+  .tp_as_async = nullptr,
+  .tp_repr = nullptr,
+  .tp_as_number = nullptr,
+  .tp_as_sequence = nullptr,
+  .tp_as_mapping = nullptr,
+  .tp_hash = nullptr,
+  .tp_call = nullptr,
+  .tp_str = nullptr,
+  .tp_getattro = nullptr,
+  .tp_setattro = nullptr,
+  .tp_as_buffer = nullptr,
+  .tp_flags = Py_TPFLAGS_DEFAULT,
+  .tp_doc = "phlex data_cell_index",
+  .tp_traverse = nullptr,
+  .tp_clear = nullptr,
+  .tp_richcompare = nullptr,
+  .tp_weaklistoffset = 0,
+  .tp_iter = nullptr,
+  .tp_iternext = nullptr,
+  .tp_methods = dci_methods.data(),
+  .tp_members = nullptr,
+  .tp_getset = nullptr,
+  .tp_base = nullptr,
+  .tp_dict = nullptr,
+  .tp_descr_get = nullptr,
+  .tp_descr_set = nullptr,
+  .tp_dictoffset = 0,
+  .tp_init = nullptr,
+  .tp_alloc = nullptr,
+  .tp_new = nullptr,
+  .tp_free = nullptr,
+  .tp_is_gc = nullptr,
+  .tp_bases = nullptr,
+  .tp_mro = nullptr,
+  .tp_cache = nullptr,
+  .tp_subclasses = nullptr,
+  .tp_weaklist = nullptr,
+  .tp_del = nullptr,
+  .tp_version_tag = 0,
+  .tp_finalize = nullptr,
+  .tp_vectorcall = nullptr,
 #if PY_VERSION_HEX >= 0x030c0000
-  , 0                                                // tp_watched
+  .tp_watched = 0,
 #endif
 #if PY_VERSION_HEX >= 0x030d0000
-  , 0                                                // tp_versions_used
+  .tp_versions_used = 0,
 #endif
 };
-// clang-format on
diff --git a/plugins/python/src/lifelinewrap.cpp b/plugins/python/src/lifelinewrap.cpp
index 57a38f3d5..df0f066ca 100644
--- a/plugins/python/src/lifelinewrap.cpp
+++ b/plugins/python/src/lifelinewrap.cpp
@@ -43,72 +43,64 @@ static void ll_dealloc(py_lifeline_t* pyobj)
   Py_TYPE(pyobj)->tp_free(reinterpret_cast<PyObject*>(pyobj));
 }
 
-// clang-format off
 // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 PyTypeObject phlex::experimental::PhlexLifeline_Type = {
-  PyVarObject_HEAD_INIT(&PyType_Type, 0)
-  "pyphlex.lifeline",                                // tp_name
-  sizeof(py_lifeline_t),                             // tp_basicsize
-  0,                                                 // tp_itemsize
-  reinterpret_cast<destructor>(ll_dealloc),          // tp_dealloc
-  0,                                                 // tp_vectorcall_offset / tp_print
-  nullptr,                                           // tp_getattr
-  nullptr,                                           // tp_setattr
-  nullptr,                                           // tp_as_async / tp_compare
-  nullptr,                                           // tp_repr
-  nullptr,                                           // tp_as_number
-  nullptr,                                           // tp_as_sequence
-  nullptr,                                           // tp_as_mapping
-  nullptr,                                           // tp_hash
-  nullptr,                                           // tp_call
-  nullptr,                                           // tp_str
-  nullptr,                                           // tp_getattro
-  nullptr,                                           // tp_setattro
-  nullptr,                                           // tp_as_buffer
-  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,           // tp_flags
-  "internal",                                        // tp_doc
-  reinterpret_cast<traverseproc>(ll_traverse),       // tp_traverse
-  reinterpret_cast<inquiry>(ll_clear),               // tp_clear
-  nullptr,                                           // tp_richcompare
-  0,                                                 // tp_weaklistoffset
-  nullptr,                                           // tp_iter
-  nullptr,                                           // tp_iternext
-  nullptr,                                           // tp_methods
-  nullptr,                                           // tp_members
-  nullptr,                                           // tp_getset
-  nullptr,                                           // tp_base
-  nullptr,                                           // tp_dict
-  nullptr,                                           // tp_descr_get
-  nullptr,                                           // tp_descr_set
-  0,                                                 // tp_dictoffset
-  nullptr,                                           // tp_init
-  nullptr,                                           // tp_alloc
-  reinterpret_cast<newfunc>(ll_new),                 // tp_new
-  nullptr,                                           // tp_free
-  nullptr,                                           // tp_is_gc
-  nullptr,                                           // tp_bases
-  nullptr,                                           // tp_mro
-  nullptr,                                           // tp_cache
-  nullptr,                                           // tp_subclasses
-  nullptr                                            // tp_weaklist
-#if PY_VERSION_HEX >= 0x02030000
-  , nullptr                                          // tp_del
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-  , 0                                                // tp_version_tag
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-  , nullptr                                          // tp_finalize
-#endif
-#if PY_VERSION_HEX >= 0x03080000
-  , nullptr                                          // tp_vectorcall
-#endif
+  // clang-format off
+  .ob_base = PyVarObject_HEAD_INIT(&PyType_Type, 0)
+  .tp_name = "pyphlex.lifeline",
+  // clang-format on
+  .tp_basicsize = sizeof(py_lifeline_t),
+  .tp_itemsize = 0,
+  .tp_dealloc = reinterpret_cast<destructor>(ll_dealloc),
+  .tp_vectorcall_offset = 0,
+  .tp_getattr = nullptr,
+  .tp_setattr = nullptr,
+  .tp_as_async = nullptr,
+  .tp_repr = nullptr,
+  .tp_as_number = nullptr,
+  .tp_as_sequence = nullptr,
+  .tp_as_mapping = nullptr,
+  .tp_hash = nullptr,
+  .tp_call = nullptr,
+  .tp_str = nullptr,
+  .tp_getattro = nullptr,
+  .tp_setattro = nullptr,
+  .tp_as_buffer = nullptr,
+  .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+  .tp_doc = "internal",
+  .tp_traverse = reinterpret_cast<traverseproc>(ll_traverse),
+  .tp_clear = reinterpret_cast<inquiry>(ll_clear),
+  .tp_richcompare = nullptr,
+  .tp_weaklistoffset = 0,
+  .tp_iter = nullptr,
+  .tp_iternext = nullptr,
+  .tp_methods = nullptr,
+  .tp_members = nullptr,
+  .tp_getset = nullptr,
+  .tp_base = nullptr,
+  .tp_dict = nullptr,
+  .tp_descr_get = nullptr,
+  .tp_descr_set = nullptr,
+  .tp_dictoffset = 0,
+  .tp_init = nullptr,
+  .tp_alloc = nullptr,
+  .tp_new = reinterpret_cast<newfunc>(ll_new),
+  .tp_free = nullptr,
+  .tp_is_gc = nullptr,
+  .tp_bases = nullptr,
+  .tp_mro = nullptr,
+  .tp_cache = nullptr,
+  .tp_subclasses = nullptr,
+  .tp_weaklist = nullptr,
+  .tp_del = nullptr,
+  .tp_version_tag = 0,
+  .tp_finalize = nullptr,
+  .tp_vectorcall = nullptr,
 #if PY_VERSION_HEX >= 0x030c0000
-  , 0                                                // tp_watched
+  .tp_watched = 0,
 #endif
 #if PY_VERSION_HEX >= 0x030d0000
-  , 0                                                // tp_versions_used
+  .tp_versions_used = 0,
 #endif
 };
-// clang-format on
diff --git a/plugins/python/src/modulewrap.cpp b/plugins/python/src/modulewrap.cpp
index 517e0873c..3e9026c18 100644
--- a/plugins/python/src/modulewrap.cpp
+++ b/plugins/python/src/modulewrap.cpp
@@ -1268,85 +1268,78 @@ static PyObject* md_observe(py_phlex_module* mod, PyObject* args, PyObject* kwds
 
 // PyMethodDef arrays must be non-const; tp_methods in PyTypeObject takes a non-const pointer.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static std::array<PyMethodDef, 3> md_methods{{{"transform",
-                                               reinterpret_cast<PyCFunction>(md_transform),
-                                               METH_VARARGS | METH_KEYWORDS,
-                                               "register a Python transform"},
-                                              {"observe",
-                                               reinterpret_cast<PyCFunction>(md_observe),
-                                               METH_VARARGS | METH_KEYWORDS,
-                                               "register a Python observer"},
-                                              {nullptr, nullptr, 0, nullptr}}};
+static std::array<PyMethodDef, 3> md_methods{
+  {{.ml_name = "transform",
+    .ml_meth = reinterpret_cast<PyCFunction>(md_transform),
+    .ml_flags = METH_VARARGS | METH_KEYWORDS,
+    .ml_doc = "register a Python transform"},
+   {.ml_name = "observe",
+    .ml_meth = reinterpret_cast<PyCFunction>(md_observe),
+    .ml_flags = METH_VARARGS | METH_KEYWORDS,
+    .ml_doc = "register a Python observer"},
+   {.ml_name = nullptr, .ml_meth = nullptr, .ml_flags = 0, .ml_doc = nullptr}}};
 
-// clang-format off
 // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 PyTypeObject phlex::experimental::PhlexModule_Type = {
-  PyVarObject_HEAD_INIT(&PyType_Type, 0)
-  "pyphlex.module",              // tp_name
-  sizeof(py_phlex_module),       // tp_basicsize
-  0,                             // tp_itemsize
-  nullptr,                       // tp_dealloc
-  0,                             // tp_vectorcall_offset / tp_print
-  nullptr,                       // tp_getattr
-  nullptr,                       // tp_setattr
-  nullptr,                       // tp_as_async / tp_compare
-  nullptr,                       // tp_repr
-  nullptr,                       // tp_as_number
-  nullptr,                       // tp_as_sequence
-  nullptr,                       // tp_as_mapping
-  nullptr,                       // tp_hash
-  nullptr,                       // tp_call
-  nullptr,                       // tp_str
-  nullptr,                       // tp_getattro
-  nullptr,                       // tp_setattro
-  nullptr,                       // tp_as_buffer
-  Py_TPFLAGS_DEFAULT,            // tp_flags
-  "phlex module wrapper",        // tp_doc
-  nullptr,                       // tp_traverse
-  nullptr,                       // tp_clear
-  nullptr,                       // tp_richcompare
-  0,                             // tp_weaklistoffset
-  nullptr,                       // tp_iter
-  nullptr,                       // tp_iternext
-  md_methods.data(),             // tp_methods
-  nullptr,                       // tp_members
-  nullptr,                       // tp_getset
-  nullptr,                       // tp_base
-  nullptr,                       // tp_dict
-  nullptr,                       // tp_descr_get
-  nullptr,                       // tp_descr_set
-  0,                             // tp_dictoffset
-  nullptr,                       // tp_init
-  nullptr,                       // tp_alloc
-  nullptr,                       // tp_new
-  nullptr,                       // tp_free
-  nullptr,                       // tp_is_gc
-  nullptr,                       // tp_bases
-  nullptr,                       // tp_mro
-  nullptr,                       // tp_cache
-  nullptr,                       // tp_subclasses
-  nullptr                        // tp_weaklist
-#if PY_VERSION_HEX >= 0x02030000
-  , nullptr                      // tp_del
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-  , 0                            // tp_version_tag
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-  , nullptr                      // tp_finalize
-#endif
-#if PY_VERSION_HEX >= 0x03080000
-  , nullptr                      // tp_vectorcall
-#endif
+  // clang-format off
+  .ob_base = PyVarObject_HEAD_INIT(&PyType_Type, 0)
+  .tp_name = "pyphlex.module",
+  // clang-format on
+  .tp_basicsize = sizeof(py_phlex_module),
+  .tp_itemsize = 0,
+  .tp_dealloc = nullptr,
+  .tp_vectorcall_offset = 0,
+  .tp_getattr = nullptr,
+  .tp_setattr = nullptr,
+  .tp_as_async = nullptr,
+  .tp_repr = nullptr,
+  .tp_as_number = nullptr,
+  .tp_as_sequence = nullptr,
+  .tp_as_mapping = nullptr,
+  .tp_hash = nullptr,
+  .tp_call = nullptr,
+  .tp_str = nullptr,
+  .tp_getattro = nullptr,
+  .tp_setattro = nullptr,
+  .tp_as_buffer = nullptr,
+  .tp_flags = Py_TPFLAGS_DEFAULT,
+  .tp_doc = "phlex module wrapper",
+  .tp_traverse = nullptr,
+  .tp_clear = nullptr,
+  .tp_richcompare = nullptr,
+  .tp_weaklistoffset = 0,
+  .tp_iter = nullptr,
+  .tp_iternext = nullptr,
+  .tp_methods = md_methods.data(),
+  .tp_members = nullptr,
+  .tp_getset = nullptr,
+  .tp_base = nullptr,
+  .tp_dict = nullptr,
+  .tp_descr_get = nullptr,
+  .tp_descr_set = nullptr,
+  .tp_dictoffset = 0,
+  .tp_init = nullptr,
+  .tp_alloc = nullptr,
+  .tp_new = nullptr,
+  .tp_free = nullptr,
+  .tp_is_gc = nullptr,
+  .tp_bases = nullptr,
+  .tp_mro = nullptr,
+  .tp_cache = nullptr,
+  .tp_subclasses = nullptr,
+  .tp_weaklist = nullptr,
+  .tp_del = nullptr,
+  .tp_version_tag = 0,
+  .tp_finalize = nullptr,
+  .tp_vectorcall = nullptr,
 #if PY_VERSION_HEX >= 0x030c0000
-  , 0                            // tp_watched
+  .tp_watched = 0,
 #endif
 #if PY_VERSION_HEX >= 0x030d0000
-  , 0                            // tp_versions_used
+  .tp_versions_used = 0,
 #endif
 };
-// clang-format on
 
 //
 // TODO: source wrapper lives here for now to re-use the converter functions;
@@ -1505,80 +1498,73 @@ static PyObject* sc_provide(py_phlex_source* src, PyObject* args, PyObject* kwds
 
 // PyMethodDef arrays must be non-const; tp_methods in PyTypeObject takes a non-const pointer.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static std::array<PyMethodDef, 2> sc_methods{{{"provide",
-                                               reinterpret_cast<PyCFunction>(sc_provide),
-                                               METH_VARARGS | METH_KEYWORDS,
-                                               "register a Python provider"},
-                                              {nullptr, nullptr, 0, nullptr}}};
+static std::array<PyMethodDef, 2> sc_methods{
+  {{.ml_name = "provide",
+    .ml_meth = reinterpret_cast<PyCFunction>(sc_provide),
+    .ml_flags = METH_VARARGS | METH_KEYWORDS,
+    .ml_doc = "register a Python provider"},
+   {.ml_name = nullptr, .ml_meth = nullptr, .ml_flags = 0, .ml_doc = nullptr}}};
 
-// clang-format off
 // PyType_Ready() modifies PyTypeObject in-place; the Python C API requires non-const.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 PyTypeObject phlex::experimental::PhlexSource_Type = {
-  PyVarObject_HEAD_INIT(&PyType_Type, 0)
-  "pyphlex.source",              // tp_name
-  sizeof(py_phlex_source),       // tp_basicsize
-  0,                             // tp_itemsize
-  nullptr,                       // tp_dealloc
-  0,                             // tp_vectorcall_offset / tp_print
-  nullptr,                       // tp_getattr
-  nullptr,                       // tp_setattr
-  nullptr,                       // tp_as_async / tp_compare
-  nullptr,                       // tp_repr
-  nullptr,                       // tp_as_number
-  nullptr,                       // tp_as_sequence
-  nullptr,                       // tp_as_mapping
-  nullptr,                       // tp_hash
-  nullptr,                       // tp_call
-  nullptr,                       // tp_str
-  nullptr,                       // tp_getattro
-  nullptr,                       // tp_setattro
-  nullptr,                       // tp_as_buffer
-  Py_TPFLAGS_DEFAULT,            // tp_flags
-  "phlex source wrapper",        // tp_doc
-  nullptr,                       // tp_traverse
-  nullptr,                       // tp_clear
-  nullptr,                       // tp_richcompare
-  0,                             // tp_weaklistoffset
-  nullptr,                       // tp_iter
-  nullptr,                       // tp_iternext
-  sc_methods.data(),             // tp_methods
-  nullptr,                       // tp_members
-  nullptr,                       // tp_getset
-  nullptr,                       // tp_base
-  nullptr,                       // tp_dict
-  nullptr,                       // tp_descr_get
-  nullptr,                       // tp_descr_set
-  0,                             // tp_dictoffset
-  nullptr,                       // tp_init
-  nullptr,                       // tp_alloc
-  nullptr,                       // tp_new
-  nullptr,                       // tp_free
-  nullptr,                       // tp_is_gc
-  nullptr,                       // tp_bases
-  nullptr,                       // tp_mro
-  nullptr,                       // tp_cache
-  nullptr,                       // tp_subclasses
-  nullptr                        // tp_weaklist
-#if PY_VERSION_HEX >= 0x02030000
-  , nullptr                      // tp_del
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-  , 0                            // tp_version_tag
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-  , nullptr                      // tp_finalize
-#endif
-#if PY_VERSION_HEX >= 0x03080000
-  , nullptr                      // tp_vectorcall
-#endif
+  // clang-format off
+  .ob_base = PyVarObject_HEAD_INIT(&PyType_Type, 0)
+  .tp_name = "pyphlex.source",
+  // clang-format on
+  .tp_basicsize = sizeof(py_phlex_source),
+  .tp_itemsize = 0,
+  .tp_dealloc = nullptr,
+  .tp_vectorcall_offset = 0,
+  .tp_getattr = nullptr,
+  .tp_setattr = nullptr,
+  .tp_as_async = nullptr,
+  .tp_repr = nullptr,
+  .tp_as_number = nullptr,
+  .tp_as_sequence = nullptr,
+  .tp_as_mapping = nullptr,
+  .tp_hash = nullptr,
+  .tp_call = nullptr,
+  .tp_str = nullptr,
+  .tp_getattro = nullptr,
+  .tp_setattro = nullptr,
+  .tp_as_buffer = nullptr,
+  .tp_flags = Py_TPFLAGS_DEFAULT,
+  .tp_doc = "phlex source wrapper",
+  .tp_traverse = nullptr,
+  .tp_clear = nullptr,
+  .tp_richcompare = nullptr,
+  .tp_weaklistoffset = 0,
+  .tp_iter = nullptr,
+  .tp_iternext = nullptr,
+  .tp_methods = sc_methods.data(),
+  .tp_members = nullptr,
+  .tp_getset = nullptr,
+  .tp_base = nullptr,
+  .tp_dict = nullptr,
+  .tp_descr_get = nullptr,
+  .tp_descr_set = nullptr,
+  .tp_dictoffset = 0,
+  .tp_init = nullptr,
+  .tp_alloc = nullptr,
+  .tp_new = nullptr,
+  .tp_free = nullptr,
+  .tp_is_gc = nullptr,
+  .tp_bases = nullptr,
+  .tp_mro = nullptr,
+  .tp_cache = nullptr,
+  .tp_subclasses = nullptr,
+  .tp_weaklist = nullptr,
+  .tp_del = nullptr,
+  .tp_version_tag = 0,
+  .tp_finalize = nullptr,
+  .tp_vectorcall = nullptr,
 #if PY_VERSION_HEX >= 0x030c0000
-  , 0                            // tp_watched
+  .tp_watched = 0,
 #endif
 #if PY_VERSION_HEX >= 0x030d0000
-  , 0                            // tp_versions_used
+  .tp_versions_used = 0,
 #endif
 };
-// clang-format on
 
 // NOLINTEND(performance-no-int-to-ptr)
diff --git a/test/allowed_families.cpp b/test/allowed_families.cpp
index 09722dd15..9d5d80b83 100644
--- a/test/allowed_families.cpp
+++ b/test/allowed_families.cpp
@@ -35,9 +35,9 @@ namespace {
 TEST_CASE("Testing families", "[data model]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("run", {"job", 1});
-  gen->add_layer("subrun", {"run", 1});
-  gen->add_layer("event", {"subrun", 1});
+  gen->add_layer("run", {.parent_layer = "job", .count = 1});
+  gen->add_layer("subrun", {.parent_layer = "run", .count = 1});
+  gen->add_layer("event", {.parent_layer = "subrun", .count = 1});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/cached_execution.cpp b/test/cached_execution.cpp
index c4d0ef923..cdfee1941 100644
--- a/test/cached_execution.cpp
+++ b/test/cached_execution.cpp
@@ -53,9 +53,9 @@ TEST_CASE("Cached function calls", "[data model]")
   constexpr unsigned int n_events{5000u};
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("run", {"job", n_runs});
-  gen->add_layer("subrun", {"run", n_subruns});
-  gen->add_layer("event", {"subrun", n_events});
+  gen->add_layer("run", {.parent_layer = "job", .count = n_runs});
+  gen->add_layer("subrun", {.parent_layer = "run", .count = n_subruns});
+  gen->add_layer("event", {.parent_layer = "subrun", .count = n_events});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/demo-giantdata/unfold_transform_fold.cpp b/test/demo-giantdata/unfold_transform_fold.cpp
index bf5e39757..f0dc5bbed 100644
--- a/test/demo-giantdata/unfold_transform_fold.cpp
+++ b/test/demo-giantdata/unfold_transform_fold.cpp
@@ -46,9 +46,9 @@ TEST_CASE("Unfold-transform-fold pipeline", "[concurrency][unfold][fold]")
 
   // Create data layers using layer generator
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("run", {"job", n_runs});
-  gen->add_layer("subrun", {"run", n_subruns});
-  gen->add_layer("spill", {"subrun", n_spills});
+  gen->add_layer("run", {.parent_layer = "job", .count = n_runs});
+  gen->add_layer("subrun", {.parent_layer = "run", .count = n_subruns});
+  gen->add_layer("spill", {.parent_layer = "subrun", .count = n_spills});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/filter.cpp b/test/filter.cpp
index ddd0c9553..62c80e500 100644
--- a/test/filter.cpp
+++ b/test/filter.cpp
@@ -105,7 +105,7 @@ namespace {
 TEST_CASE("Two predicates", "[filtering]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", 10, 1});
+  gen->add_layer("event", {.parent_layer = "job", .count = 10, .start_at = 1});
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
@@ -132,7 +132,7 @@ TEST_CASE("Two predicates", "[filtering]")
 TEST_CASE("Two predicates in series", "[filtering]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", 10, 1});
+  gen->add_layer("event", {.parent_layer = "job", .count = 10, .start_at = 1});
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
@@ -155,7 +155,7 @@ TEST_CASE("Two predicates in series", "[filtering]")
 TEST_CASE("Two predicates in parallel", "[filtering]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", 10, 1});
+  gen->add_layer("event", {.parent_layer = "job", .count = 10, .start_at = 1});
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
@@ -186,7 +186,7 @@ TEST_CASE("Three predicates in parallel", "[filtering]")
                                         {.name = "exclude_gt_8", .begin = 8, .end = -1u}};
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", 10, 1});
+  gen->add_layer("event", {.parent_layer = "job", .count = 10, .start_at = 1});
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
@@ -213,7 +213,7 @@ TEST_CASE("Three predicates in parallel", "[filtering]")
 TEST_CASE("Two predicates in parallel (each with multiple arguments)", "[filtering]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", 10, 1});
+  gen->add_layer("event", {.parent_layer = "job", .count = 10, .start_at = 1});
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
diff --git a/test/filter_impl.cpp b/test/filter_impl.cpp
index 6f33dfde4..501b9d5cc 100644
--- a/test/filter_impl.cpp
+++ b/test/filter_impl.cpp
@@ -19,7 +19,7 @@ TEST_CASE("Filter decision", "[filtering]")
 
   SECTION("Test short-circuiting if false predicate result")
   {
-    decisions.update({1, false});
+    decisions.update({.msg_id = 1, .result = false});
     {
       auto const value = decisions.value(1);
       CHECK(is_complete(value));
@@ -29,12 +29,12 @@ TEST_CASE("Filter decision", "[filtering]")
 
   SECTION("Verify once a complete decision is made")
   {
-    decisions.update({3, true});
+    decisions.update({.msg_id = 3, .result = true});
     {
       auto const value = decisions.value(3);
       CHECK(not is_complete(value));
     }
-    decisions.update({3, true});
+    decisions.update({.msg_id = 3, .result = true});
     {
       auto const value = decisions.value(3);
       CHECK(is_complete(value));
diff --git a/test/fold.cpp b/test/fold.cpp
index 88f7f976b..f24620b4c 100644
--- a/test/fold.cpp
+++ b/test/fold.cpp
@@ -61,8 +61,8 @@ TEST_CASE("Different data layers of fold", "[graph]")
   constexpr auto number_limit = 5u;
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("run", {"job", index_limit});
-  gen->add_layer("event", {"run", number_limit});
+  gen->add_layer("run", {.parent_layer = "job", .count = index_limit});
+  gen->add_layer("event", {.parent_layer = "run", .count = number_limit});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
@@ -105,8 +105,8 @@ TEST_CASE("Fold output without send consumed downstream", "[graph]")
   constexpr auto number_limit = 5u;
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("run", {"job", index_limit});
-  gen->add_layer("event", {"run", number_limit});
+  gen->add_layer("run", {.parent_layer = "job", .count = index_limit});
+  gen->add_layer("event", {.parent_layer = "run", .count = number_limit});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/fold_duplicate_layer_name_test.cpp b/test/fold_duplicate_layer_name_test.cpp
index 6b1685a76..fd8a2dbe5 100644
--- a/test/fold_duplicate_layer_name_test.cpp
+++ b/test/fold_duplicate_layer_name_test.cpp
@@ -58,9 +58,9 @@ TEST_CASE("Fold different layer paths with same trailing name", "[graph]")
   constexpr auto top_level_event_limit = 10u;
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("run", {"job", index_limit});
-  gen->add_layer("event", {"run", number_limit});
-  gen->add_layer("event", {"job", top_level_event_limit});
+  gen->add_layer("run", {.parent_layer = "job", .count = index_limit});
+  gen->add_layer("event", {.parent_layer = "run", .count = number_limit});
+  gen->add_layer("event", {.parent_layer = "job", .count = top_level_event_limit});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/form/form_basics_test.cpp b/test/form/form_basics_test.cpp
index 0e2340929..ff27de868 100644
--- a/test/form/form_basics_test.cpp
+++ b/test/form/form_basics_test.cpp
@@ -194,8 +194,9 @@ TEST_CASE("Factories fallback", "[form]")
 
   // A major FORM doesn't recognize at all must also fail loudly
   // Major has a fixed underlying type, so an out-of-range value is legal at runtime
-  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
-  auto const unknown_major = form::technology::Id{static_cast<form::technology::Major>(99), 0};
+  auto const unknown_major =
+    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
+    form::technology::Id{.major = static_cast<form::technology::Major>(99), .minor = 0};
   CHECK_THROWS_AS(createFile(unknown_major, "test.dat", 'o'), std::runtime_error);
   CHECK_THROWS_AS(createReadContainer(unknown_major, "cont"), std::runtime_error);
   CHECK_THROWS_AS(createWriteAssociation(unknown_major, "assoc"), std::runtime_error);
@@ -214,7 +215,8 @@ TEST_CASE("Factories ROOT storage dispatch", "[form]")
   auto wc_ttree = createWriteContainer(form::technology::ROOT_TTREE, "cont");
   CHECK(dynamic_cast<ROOT_TBranch_Write_ContainerImp*>(wc_ttree.get()) != nullptr);
 
-  auto const unsupported_root = form::technology::Id{form::technology::Major::root, 99};
+  auto const unsupported_root =
+    form::technology::Id{.major = form::technology::Major::root, .minor = 99};
   CHECK_THROWS_AS(createReadContainer(unsupported_root, "cont"), std::runtime_error);
   CHECK_THROWS_AS(createWriteAssociation(unsupported_root, "assoc"), std::runtime_error);
   CHECK_THROWS_AS(createWriteContainer(unsupported_root, "cont"), std::runtime_error);
@@ -423,7 +425,8 @@ TEST_CASE("form_reader_interface::read throws for missing product config", "[for
   cfg.addItem("prod", "dummy_reader_test.root", form::technology::Id{});
   form::experimental::form_reader_interface reader{cfg, tech_setting_config{}};
 
-  form::experimental::product_with_name product{"missing", nullptr, &typeid(int)};
+  form::experimental::product_with_name product{
+    .label = "missing", .data = nullptr, .type = &typeid(int)};
   CHECK_THROWS_AS(reader.read("creator", "segment", product), std::runtime_error);
 }
 
@@ -435,7 +438,8 @@ TEST_CASE("form_writer_interface handles missing product config without crashing
   cfg.addItem("prod", "dummy_writer_test.root", form::technology::Id{});
   form::experimental::form_writer_interface writer{cfg, tech_setting_config{}};
 
-  form::experimental::product_with_name product{"missing", nullptr, &typeid(int)};
+  form::experimental::product_with_name product{
+    .label = "missing", .data = nullptr, .type = &typeid(int)};
   CHECK_NOTHROW(writer.write("creator", "segment", product));
 }
 
diff --git a/test/form/reader.cpp b/test/form/reader.cpp
index e6e343973..f4e8d3818 100644
--- a/test/form/reader.cpp
+++ b/test/form/reader.cpp
@@ -97,7 +97,7 @@ int main(int argc, char** argv)
       std::string const creator = "Toy_Tracker";
 
       form::experimental::product_with_name pb = {
-        "trackStart", rawPtr, &typeid(std::vector<float>)};
+        .label = "trackStart", .data = rawPtr, .type = &typeid(std::vector<float>)};
 
       form.read(creator, segment_id, pb);
       std::unique_ptr<std::vector<float> const> track_start_x(
@@ -105,7 +105,7 @@ int main(int argc, char** argv)
 
       rawPtr = nullptr;
       form::experimental::product_with_name pb_int = {
-        "trackNumberHits", rawPtr, &typeid(std::vector<int>)};
+        .label = "trackNumberHits", .data = rawPtr, .type = &typeid(std::vector<int>)};
 
       form.read(creator, segment_id, pb_int);
       std::unique_ptr<std::vector<int> const> track_n_hits(
@@ -113,7 +113,7 @@ int main(int argc, char** argv)
 
       rawPtr = nullptr;
       form::experimental::product_with_name pb_points = {
-        "trackStartPoints", rawPtr, &typeid(std::vector<TrackStart>)};
+        .label = "trackStartPoints", .data = rawPtr, .type = &typeid(std::vector<TrackStart>)};
 
       form.read(creator, segment_id, pb_points);
       std::unique_ptr<std::vector<TrackStart> const> start_points(
@@ -169,7 +169,7 @@ int main(int argc, char** argv)
 
     void const* rawEvtPtr = nullptr;
     form::experimental::product_with_name pb = {
-      "trackStartX", rawEvtPtr, &typeid(std::vector<float>)};
+      .label = "trackStartX", .data = rawEvtPtr, .type = &typeid(std::vector<float>)};
 
     form.read(creator, event_id, pb);
     track_x.reset(static_cast<std::vector<float> const*>(pb.data));
diff --git a/test/form/writer.cpp b/test/form/writer.cpp
index 48923d67f..efbe23813 100644
--- a/test/form/writer.cpp
+++ b/test/form/writer.cpp
@@ -101,7 +101,7 @@ int main(int argc, char** argv)
       std::string const creator = "Toy_Tracker";
 
       form::experimental::product_with_name pb = {
-        "trackStart", &track_start_x, &typeid(std::vector<float>)};
+        .label = "trackStart", .data = &track_start_x, .type = &typeid(std::vector<float>)};
       products.push_back(pb);
 
       std::vector<int> track_n_hits(std::from_range, std::views::iota(0, 100));
@@ -112,7 +112,7 @@ int main(int argc, char** argv)
                 << ", check = " << check << '\n';
 
       form::experimental::product_with_name pb_int = {
-        "trackNumberHits", &track_n_hits, &typeid(std::vector<int>)};
+        .label = "trackNumberHits", .data = &track_n_hits, .type = &typeid(std::vector<int>)};
       products.push_back(pb_int);
 
       std::vector<TrackStart> start_points = tracker();
@@ -123,8 +123,9 @@ int main(int argc, char** argv)
       std::cout << "PHLEX: Segment = " << nseg << ": seg_id_text = " << seg_id_text
                 << ", checkPoints = " << checkPoints << '\n';
 
-      form::experimental::product_with_name pb_points = {
-        "trackStartPoints", &start_points, &typeid(std::vector<TrackStart>)};
+      form::experimental::product_with_name pb_points = {.label = "trackStartPoints",
+                                                         .data = &start_points,
+                                                         .type = &typeid(std::vector<TrackStart>)};
       products.push_back(pb_points);
 
       form.write(creator, segment_id, products);
@@ -150,7 +151,7 @@ int main(int argc, char** argv)
     std::string const creator = "Toy_Tracker_Event";
 
     form::experimental::product_with_name pb = {
-      "trackStartX", &track_x, &typeid(std::vector<float>)};
+      .label = "trackStartX", .data = &track_x, .type = &typeid(std::vector<float>)};
     std::cout << "PHLEX: Event = " << nevent << ": evt_id_text = " << evt_id_text
               << ", check = " << check << '\n';
 
diff --git a/test/framework_graph.cpp b/test/framework_graph.cpp
index 798a7efda..c7c64f9ea 100644
--- a/test/framework_graph.cpp
+++ b/test/framework_graph.cpp
@@ -49,21 +49,22 @@ namespace {
 TEST_CASE("Catch STL exceptions", "[graph]")
 {
   auto g = phlex::detail::framework_graph::without_driver();
-  g.add_driver(driver_bundle{[](framework_driver&) { throw std::runtime_error("STL error"); }, {}});
+  g.add_driver(driver_bundle{
+    .driver = [](framework_driver&) { throw std::runtime_error("STL error"); }, .hierarchy = {}});
   CHECK_THROWS_AS(g.execute(), std::exception);
 }
 
 TEST_CASE("Catch other exceptions", "[graph]")
 {
   auto g = phlex::detail::framework_graph::without_driver();
-  g.add_driver(driver_bundle{[](framework_driver&) { throw 2.5; }, {}});
+  g.add_driver(driver_bundle{.driver = [](framework_driver&) { throw 2.5; }, .hierarchy = {}});
   CHECK_THROWS_AS(g.execute(), double);
 }
 
 TEST_CASE("Make progress with one thread", "[graph]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("spill", {"job", 1000});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 1000});
 
   auto g = phlex::detail::framework_graph::without_driver(1);
   g.add_driver(gen);
@@ -85,7 +86,7 @@ TEST_CASE("Make progress with one thread", "[graph]")
 TEST_CASE("Stop driver when workflow throws exception", "[graph]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("spill", {"job", 1000});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 1000});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
@@ -123,7 +124,7 @@ TEST_CASE("Stop driver when workflow throws exception", "[graph]")
 TEST_CASE("Throw when predicate specified by consumer does not exist", "[graph]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", 1, 1});
+  gen->add_layer("event", {.parent_layer = "job", .count = 1, .start_at = 1});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
@@ -218,7 +219,7 @@ TEST_CASE("Throw on duplicate node registration", "[graph]")
 TEST_CASE("Allow late driver configuration", "[graph]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("spill", {"job", 3});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 3});
 
   auto g = phlex::detail::framework_graph::without_driver();
 
diff --git a/test/hierarchical_nodes.cpp b/test/hierarchical_nodes.cpp
index b515c5883..101dbf938 100644
--- a/test/hierarchical_nodes.cpp
+++ b/test/hierarchical_nodes.cpp
@@ -51,7 +51,7 @@ namespace {
 
   data_for_rms send(threadsafe_data_for_rms const& data)
   {
-    return {experimental::send(data.total), experimental::send(data.number)};
+    return {.total = experimental::send(data.total), .number = experimental::send(data.number)};
   }
 
   void add(threadsafe_data_for_rms& redata, unsigned squared_number)
@@ -79,8 +79,8 @@ namespace {
 TEST_CASE("Hierarchical nodes", "[graph]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("run", {"job", index_limit});
-  gen->add_layer("event", {"run", number_limit});
+  gen->add_layer("run", {.parent_layer = "job", .count = index_limit});
+  gen->add_layer("event", {.parent_layer = "run", .count = number_limit});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/layer_generator.cpp b/test/layer_generator.cpp
index 9fd84ae70..6fc737e88 100644
--- a/test/layer_generator.cpp
+++ b/test/layer_generator.cpp
@@ -23,7 +23,7 @@ TEST_CASE("Only job layer", "[layer-generation]")
 TEST_CASE("One non-job layer", "[layer-generation]")
 {
   auto gen = layer_generator::make();
-  gen->add_layer("spill", {"job", 16});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 16});
 
   auto g = framework_graph::without_driver();
   g.add_driver(gen);
@@ -37,8 +37,8 @@ TEST_CASE("One non-job layer", "[layer-generation]")
 TEST_CASE("Two non-job layers", "[layer-generation]")
 {
   auto gen = layer_generator::make();
-  gen->add_layer("spill", {"job", 16});
-  gen->add_layer("APA", {"spill", 16});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 16});
+  gen->add_layer("APA", {.parent_layer = "spill", .count = 16});
 
   auto g = framework_graph::without_driver();
   g.add_driver(gen);
@@ -53,8 +53,8 @@ TEST_CASE("Two non-job layers", "[layer-generation]")
 TEST_CASE("Test rebasing layers", "[layer-generation]")
 {
   auto gen = layer_generator::make();
-  gen->add_layer("APA", {"spill", 16});
-  gen->add_layer("spill", {"job", 16});
+  gen->add_layer("APA", {.parent_layer = "spill", .count = 16});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 16});
 
   auto g = framework_graph::without_driver();
   g.add_driver(gen);
@@ -69,9 +69,9 @@ TEST_CASE("Test rebasing layers", "[layer-generation]")
 TEST_CASE("Ambiguous layers", "[layer-generation]")
 {
   auto gen = layer_generator::make();
-  gen->add_layer("run", {"job", 16});
-  gen->add_layer("spill", {"run", 16});
-  gen->add_layer("spill", {"job", 16});
+  gen->add_layer("run", {.parent_layer = "job", .count = 16});
+  gen->add_layer("spill", {.parent_layer = "run", .count = 16});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 16});
 
   CHECK_THROWS_WITH(gen->add_layer("APA", {"spill", 16}),
                     ContainsSubstring("Ambiguous: two parent layers found for data layer 'APA'") &&
@@ -83,10 +83,12 @@ TEST_CASE("Ambiguous layers", "[layer-generation]")
 TEST_CASE("Avoid ambiguous layers", "[layer-generation]")
 {
   auto gen = layer_generator::make();
-  gen->add_layer("run", {"job", 16});
-  gen->add_layer("spill", {"run", 16});
-  gen->add_layer("spill", {"job", 16});
-  gen->add_layer("APA", {"/run/spill", 16}); // More complete parent path used to disambiguate
+  gen->add_layer("run", {.parent_layer = "job", .count = 16});
+  gen->add_layer("spill", {.parent_layer = "run", .count = 16});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 16});
+  gen->add_layer(
+    "APA",
+    {.parent_layer = "/run/spill", .count = 16}); // More complete parent path used to disambiguate
 
   auto g = framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/memory-checks/many_events.cpp b/test/memory-checks/many_events.cpp
index 32fd85134..9a42198a6 100644
--- a/test/memory-checks/many_events.cpp
+++ b/test/memory-checks/many_events.cpp
@@ -15,7 +15,7 @@ try {
   constexpr auto max_events{100'000u};
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", max_events, 1u});
+  gen->add_layer("event", {.parent_layer = "job", .count = max_events, .start_at = 1u});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/output_products.cpp b/test/output_products.cpp
index 3a43fae4b..1ae9a462c 100644
--- a/test/output_products.cpp
+++ b/test/output_products.cpp
@@ -68,7 +68,7 @@ namespace {
 TEST_CASE("Output data products", "[graph]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("spill", {"job", 1u});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 1u});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/product_selecting.cpp b/test/product_selecting.cpp
index efd4f0478..9fbf68f86 100644
--- a/test/product_selecting.cpp
+++ b/test/product_selecting.cpp
@@ -32,7 +32,7 @@ TEST_CASE("Querying products in different ways", "[graph]")
 {
   constexpr int num_events = 25;
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {.parent_layer_name = "job", .total_per_parent_data_cell = num_events});
+  gen->add_layer("event", {.parent_layer = "job", .count = num_events});
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
 
diff --git a/test/provider_test.cpp b/test/provider_test.cpp
index f0618ad4c..226148f23 100644
--- a/test/provider_test.cpp
+++ b/test/provider_test.cpp
@@ -78,7 +78,7 @@ TEST_CASE("Explicit providers")
   constexpr auto num_spills{3u};
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("spill", {"job", num_spills, 1u});
+  gen->add_layer("spill", {.parent_layer = "job", .count = num_spills, .start_at = 1u});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
@@ -107,7 +107,7 @@ TEST_CASE("Implicit providers")
   constexpr auto num_spills{3u};
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("spill", {"job", num_spills, 1u});
+  gen->add_layer("spill", {.parent_layer = "job", .count = num_spills, .start_at = 1u});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
@@ -178,7 +178,7 @@ TEST_CASE("Throw when two implicit providers are found for the same product")
 TEST_CASE("Throw when implicit provider insertion fails")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("spill", {"job", 1u});
+  gen->add_layer("spill", {.parent_layer = "job", .count = 1u});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(std::move(gen));
diff --git a/test/type_distinction.cpp b/test/type_distinction.cpp
index 0829f8fe0..373ab73f2 100644
--- a/test/type_distinction.cpp
+++ b/test/type_distinction.cpp
@@ -44,7 +44,7 @@ namespace {
 TEST_CASE("Distinguish products with same name and different types", "[programming model]")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", 10, 1});
+  gen->add_layer("event", {.parent_layer = "job", .count = 10, .start_at = 1});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/unfold.cpp b/test/unfold.cpp
index 2379fb8df..64f53d472 100644
--- a/test/unfold.cpp
+++ b/test/unfold.cpp
@@ -105,7 +105,7 @@ TEST_CASE("Splitting the processing", "[graph]")
   constexpr auto index_limit = 2u;
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", index_limit});
+  gen->add_layer("event", {.parent_layer = "job", .count = index_limit});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
@@ -173,7 +173,7 @@ TEST_CASE("Multi-layer transform with one input from an unfold", "[graph]")
   constexpr auto index_limit = 2u;
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", index_limit});
+  gen->add_layer("event", {.parent_layer = "job", .count = index_limit});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
@@ -206,7 +206,7 @@ TEST_CASE("Unfold deduplicates same-layer inputs for bookkeeping", "[graph]")
   constexpr auto index_limit = 2u;
 
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", index_limit});
+  gen->add_layer("event", {.parent_layer = "job", .count = index_limit});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);
diff --git a/test/vector_of_abstract_types.cpp b/test/vector_of_abstract_types.cpp
index f63dfe585..40e9753e7 100644
--- a/test/vector_of_abstract_types.cpp
+++ b/test/vector_of_abstract_types.cpp
@@ -40,7 +40,7 @@ namespace {
 TEST_CASE("Test vector of abstract types")
 {
   auto gen = experimental::layer_generator::make();
-  gen->add_layer("event", {"job", 1u, 1u});
+  gen->add_layer("event", {.parent_layer = "job", .count = 1u, .start_at = 1u});
 
   auto g = phlex::detail::framework_graph::without_driver();
   g.add_driver(gen);