diff --git a/bench/bm_case1.cpp b/bench/bm_case1.cpp
index 33ce8f550..6b229f9ff 100644
--- a/bench/bm_case1.cpp
+++ b/bench/bm_case1.cpp
@@ -19,7 +19,7 @@ inline constexpr std::size_t N_ITER = 10;
 inline constexpr std::size_t N_SAMPLES = gr::util::round_up(10'000, 1024);
 
 template<typename T, char op>
-struct math_op : public fg::node<math_op<T, op>, fg::IN<T, 0, N_MAX, "in">, fg::OUT<T, 0, N_MAX, "out">> {
+struct math_op : public fg::node<math_op<T, op>, fg::PortInNamed<T, "in">, fg::PortOutNamed<T, "out">> {
     T factor = static_cast<T>(1.0f);
 
     // public:
@@ -58,7 +58,7 @@ static_assert(fg::traits::node::can_process_one_simd<multiply<float>>);
 #endif
 
 template<typename T, char op>
-class math_bulk_op : public fg::node<math_bulk_op<T, op>, fg::IN<T, 0, N_MAX, "in">, fg::OUT<T, 0, N_MAX, "out">> {
+class math_bulk_op : public fg::node<math_bulk_op<T, op>, fg::PortInNamed<T, "in", fg::RequiredSamples<1, N_MAX>>, fg::PortOutNamed<T, "out", fg::RequiredSamples<1, N_MAX>>> {
     T _factor = static_cast<T>(1.0f);
 
 public:
@@ -126,8 +126,8 @@ class converting_multiply : public fg::node<converting_multiply<T, R>> {
     T _factor = static_cast<T>(1.0f);
 
 public:
-    fg::IN<T>  in;
-    fg::OUT<R> out;
+    fg::PortIn<T>  in;
+    fg::PortOut<R> out;
 
     converting_multiply() = delete;
 
@@ -160,8 +160,8 @@ static_assert(fg::traits::node::can_process_one_simd<converting_multiply<float,
 template<typename T, int addend>
 class add : public fg::node<add<T, addend>> {
 public:
-    fg::IN<T>  in;
-    fg::OUT<T> out;
+    fg::PortIn<T>  in;
+    fg::PortOut<T> out;
 
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr V
@@ -183,7 +183,7 @@ static_assert(fg::traits::node::can_process_one_simd<add<float, 1>>);
 // It doesn't need to be enabled for reflection.
 //
 template<typename T, char op>
-class gen_operation_SIMD : public fg::node<gen_operation_SIMD<T, op>, fg::IN<T, 0, N_MAX, "in">, fg::OUT<T, 0, N_MAX, "out">> {
+class gen_operation_SIMD : public fg::node<gen_operation_SIMD<T, op>, fg::PortInNamed<T, "in", fg::RequiredSamples<1, N_MAX>>, fg::PortOutNamed<T, "out", fg::RequiredSamples<1, N_MAX>>> {
     T _value = static_cast<T>(1.0f);
 
 public:
@@ -270,11 +270,11 @@ using multiply_SIMD = gen_operation_SIMD<T, '*'>;
 template<typename T>
 using add_SIMD = gen_operation_SIMD<T, '+'>;
 
-template<typename T, std::size_t N_MIN = 0, std::size_t N_MAX = N_MAX, bool use_bulk_operation = false, bool use_memcopy = true>
+template<typename T, std::size_t N_MIN = 1, std::size_t N_MAX = N_MAX, bool use_bulk_operation = false, bool use_memcopy = true>
 class copy : public fg::node<copy<T, N_MIN, N_MAX, use_bulk_operation, use_memcopy>> {
 public:
-    fg::IN<T, N_MIN, N_MAX>  in;
-    fg::OUT<T, N_MIN, N_MAX> out;
+    fg::PortIn<T, fg::RequiredSamples<N_MIN, N_MAX>>  in;
+    fg::PortOut<T, fg::RequiredSamples<N_MIN, N_MAX>> out;
 
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr V
@@ -336,8 +336,8 @@ simd_size() noexcept {
 
 namespace stdx = vir::stdx;
 
-template<typename From, typename To, std::size_t N_MIN = 0 /* SIMD size */, std::size_t N_MAX = N_MAX>
-class convert : public fg::node<convert<From, To, N_MIN, N_MAX>, fg::IN<From, N_MIN, N_MAX, "in">, fg::OUT<To, N_MIN, N_MAX, "out">> {
+template<typename From, typename To, std::size_t N_MIN = 1 /* SIMD size */, std::size_t N_MAX = N_MAX>
+class convert : public fg::node<convert<From, To, N_MIN, N_MAX>, fg::PortInNamed<From, "in", fg::RequiredSamples<N_MIN, N_MAX>>, fg::PortOutNamed<To, "out", fg::RequiredSamples<N_MIN, N_MAX>>> {
     static_assert(stdx::is_simd_v<From> != stdx::is_simd_v<To>, "either input xor output must be SIMD capable");
     constexpr static std::size_t from_simd_size = detail::simd_size<From>();
     constexpr static std::size_t to_simd_size   = detail::simd_size<To>();
@@ -451,7 +451,7 @@ inline const boost::ut::suite _constexpr_bm = [] {
     }
 
     {
-        auto merged_node = merge<"out", "in">(merge<"out", "in">(merge<"out", "in">(merge<"out", "in">(test::source<float, 1024, 1024>(N_SAMPLES), copy<float, 0, 128>()), copy<float, 0, 1024>()),
+        auto merged_node = merge<"out", "in">(merge<"out", "in">(merge<"out", "in">(merge<"out", "in">(test::source<float, 1024, 1024>(N_SAMPLES), copy<float, 1, 128>()), copy<float, 1, 1024>()),
                                                                  copy<float, 32, 128>()),
                                               test::sink<float>());
         "merged src(N=1024)->b1(N≤128)->b2(N=1024)->b3(N=32...128)->sink"_benchmark.repeat<N_ITER>(N_SAMPLES) = [&merged_node]() { loop_over_process_one(merged_node); };
@@ -521,7 +521,7 @@ inline const boost::ut::suite _runtime_tests = [] {
         auto     &src  = flow_graph.make_node<test::source<float>>(N_SAMPLES);
         auto     &sink = flow_graph.make_node<test::sink<float>>();
 
-        using copy     = ::copy<float, 0, N_MAX, true, true>;
+        using copy     = ::copy<float, 1, N_MAX, true, true>;
         std::vector<copy *> cpy(10);
         for (std::size_t i = 0; i < cpy.size(); i++) {
             cpy[i] = std::addressof(flow_graph.make_node<copy>({ { "name", fmt::format("copy {} at {}", i, fair::graph::this_source_location()) } }));
@@ -542,8 +542,8 @@ inline const boost::ut::suite _runtime_tests = [] {
 
     {
         fg::graph flow_graph;
-        auto     &src  = flow_graph.make_node<test::source<float, 0, 1024>>(N_SAMPLES);
-        auto     &b1   = flow_graph.make_node<copy<float, 0, 128>>();
+        auto     &src  = flow_graph.make_node<test::source<float, 1, 1024>>(N_SAMPLES);
+        auto     &b1   = flow_graph.make_node<copy<float, 1, 128>>();
         auto     &b2   = flow_graph.make_node<copy<float, 1024, 1024>>();
         auto     &b3   = flow_graph.make_node<copy<float, 32, 128>>();
         auto     &sink = flow_graph.make_node<test::sink<float>>();
diff --git a/bench/bm_scheduler.cpp b/bench/bm_scheduler.cpp
index 400966d3c..610b6ef2c 100644
--- a/bench/bm_scheduler.cpp
+++ b/bench/bm_scheduler.cpp
@@ -14,7 +14,7 @@ inline constexpr std::size_t N_SAMPLES = gr::util::round_up(10'000'000, 1024);
 inline constexpr std::size_t N_NODES   = 5;
 
 template<typename T, char op>
-class math_op : public fg::node<math_op<T, op>, fg::IN<T, 0, N_MAX, "in">, fg::OUT<T, 0, N_MAX, "out">> {
+class math_op : public fg::node<math_op<T, op>, fg::PortInNamed<T, "in">, fg::PortOutNamed<T, "out">> {
     T _factor = static_cast<T>(1.0f);
 
 public:
diff --git a/bench/bm_test_helper.hpp b/bench/bm_test_helper.hpp
index c725228ff..a1592f0d3 100644
--- a/bench/bm_test_helper.hpp
+++ b/bench/bm_test_helper.hpp
@@ -18,9 +18,9 @@ inline static std::size_t n_samples_produced = 0_UZ;
 template<typename T, std::size_t min = 0_UZ, std::size_t count = N_MAX, bool use_bulk_operation = true>
 class source : public fg::node<source<T, min, count>> {
 public:
-    uint64_t    _n_samples_max;
-    std::size_t _n_tag_offset;
-    fg::OUT<T>  out;
+    uint64_t       _n_samples_max;
+    std::size_t    _n_tag_offset;
+    fg::PortOut<T> out;
 
     source() = delete;
 
@@ -87,11 +87,11 @@ class source : public fg::node<source<T, min, count>> {
 
 inline static std::size_t n_samples_consumed = 0_UZ;
 
-template<typename T, std::size_t N_MIN = 0_UZ, std::size_t N_MAX = N_MAX>
+template<typename T, std::size_t N_MIN = 1_UZ, std::size_t N_MAX = N_MAX>
 struct sink : public fg::node<sink<T, N_MIN, N_MAX>> {
-    fg::IN<T, N_MIN, N_MAX> in;
-    std::size_t             should_receive_n_samples = 0;
-    int64_t                 _last_tag_position       = -1;
+    fg::PortIn<T, fg::RequiredSamples<N_MIN, N_MAX>> in;
+    std::size_t                                      should_receive_n_samples = 0;
+    int64_t                                          _last_tag_position       = -1;
 
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr auto
diff --git a/include/README.md b/include/README.md
index 62090efc2..1a1438a70 100644
--- a/include/README.md
+++ b/include/README.md
@@ -19,10 +19,10 @@ continuously improve this document.
   through a general `work()` function. Blocks are the building blocks of a flow-graph and can be thought of as vertices
   in a graph, and *ports* are their input/output connections to neighboring blocks for data streaming, streaming tags,
   and asynchronous messages. For the specific implementation, see [node.hpp](node.hpp).
-* [port](#Ports) is an interface through which data flows into or out of a block. Each block may have zero, one or
-  more input ports, and zero, one or more output ports. Data is passed between blocks by connecting the output port of
-  one block to the input port of another. For the specific implementation, see [port.hpp](port.hpp).
-* [buffer](#Buffer)  is an area of memory where data is temporarily stored in the runtime-connected graph. Each port
+* [Port](#Ports) is an interface through which data flows into or out of a block. Each block may have zero, one or
+  more input ports, and zero, one or more output ports. Data is passed between blocks by connecting the output Port of
+  one block to the input Port of another. For the specific implementation, see [port.hpp](port.hpp).
+* [buffer](#Buffer)  is an area of memory where data is temporarily stored in the runtime-connected graph. Each Port
   has its own buffer to store the data, tags, or other messages it needs to perform its computations. Buffer
   implementations are typically domain-specific (e.g. for blocks/ports implemented on the CPU, GPU, etc.) and are often,
   but not necessarily, implemented as circular buffers. For the specific interface see [Buffer.hpp](Buffer.hpp) and one
@@ -54,31 +54,36 @@ switch and adopt the provided low-level graph algorithms.
 
 ### Ports
 
-Ports in this framework are designed to interconnect blocks in a graph, similar to RF connectors. The port class
+Ports in this framework are designed to interconnect blocks in a graph, similar to RF connectors. The Port class
 template has several parameters that define its behaviour, including the type of data it handles (`T`), its
-name (`PortName`), type (`PortType`), direction (`PortDirection` <-> input/output), and the minimum and maximum number
-of samples (`MIN_SAMPLES` and `MAX_SAMPLES`) the user requires for a given block before the `work()` is invoked by the
-scheduler. The buffer type used by the port can also be specified using the `BufferType` parameter,
-with `gr::circular_buffer<T>` being the default:
-
+name (`PortName`), type (`PortType`), direction (`PortDirection` <-> input/output), and optional list of `Arguments`
+that may constrain the port behaviour on the `Block` or `Scheduler` level::
 ```cpp
-template<typename T, fixed_string PortName, port_type_t PortType, port_direction_t PortDirection, // TODO: sort default arguments
-         std::size_t MIN_SAMPLES = std::dynamic_extent, std::size_t MAX_SAMPLES = std::dynamic_extent,
-         gr::Buffer BufferType = gr::circular_buffer<T>>
-class port { /* ... */ };
+class template<typename T, fixed_string PortName, port_type_t PortType, port_direction_t PortDirection, typename... Arguments>
+struct Port { /* ... */ };
 ```
 
+Some of the possible optional port annotation attributes are:
+
+* `RequiredSamples` to describe the min/max number of samples required from this port before invoking the blocks work
+  function,
+* `Optional` informing the graph/scheduler that a given port does not require to be connected,
+* `PortDomain<fixed_string>` described whether the port can be handled within the same scheduling domain (e.g. `CPU`
+  or `GPU`),
+* `StreamBufferType` and `TagBufferType` to inject specific user-provided buffer implementations to the port, or
+* `Async` for making a port asynchronous in a signal flow-graph block.
+
 When connecting ports, either a single-step or a two-step connection method can be used:
 
 1. single-step connection: which allocates a buffer and passes the corresponding `BufferWriter` and `BufferReader`
-   instances to the source and destination port. The buffer size is determined only once based on
+   instances to the source and destination Port. The buffer size is determined only once based on
    the `[MIN, MAX]_SAMPLES` constraints and is inherited/fixed for further connected input ports.
 2. two-step connection (usually done by the graph):
     * register all ports that shall be connected to each other
-    * determine the minimum buffer size required by the set of connected port and then perform the actual connections as
+    * determine the minimum buffer size required by the set of connected Port and then perform the actual connections as
       outlined in the single-step connection method.
 
-Each port belongs to a single computing domain, which is specified using the port_domain_t enumeration:
+Each Port belongs to a single computing domain, which is specified using the port_domain_t enumeration:
 
 ```cpp
 enum class port_domain_t { CPU, GPU, NET, FPGA, DSP, MLU /*, ...*/ };
@@ -97,8 +102,8 @@ favour low-latency execution (e.g. few bytes) to keep the data and L1/L2/L3 cach
 including, for example, GPUs this choice would cause significant overhead when copying data from the CPU to GPU that
 favour DMA-type block-transfer to exchange data for best efficiency.
 
-Additionally, the usage of one buffer type and port per computation domain, along with explicit data conversion, enables
-users to easily extend the framework. This approach provides the flexibility for users to define custom buffer and port
+Additionally, the usage of one buffer type and Port per computation domain, along with explicit data conversion, enables
+users to easily extend the framework. This approach provides the flexibility for users to define custom buffer and Port
 implementations that cater to the specific requirements of their applications, thus offering optimal performance and
 scalability. The ability to create specialized implementations for specific use cases, coupled with the framework's
 openness to user-defined extensions, makes it a versatile and customizable solution.
@@ -113,8 +118,8 @@ For example:
 
 ```cpp
 struct user_defined_block : node<user_defined_block> {
-  IN<float> in;
-  OUT<float> out;
+  PortIn<float> in;
+  PortOut<float> out;
   // implement either:
   [[nodiscard]] constexpr work_return_t work() noexcept {...}
   // or one of the convenience functions outlined below
@@ -127,7 +132,7 @@ types through templating the input 'T' and return type 'R':
 
 ```cpp
 template<typename T, typename R>
-struct user_defined_block : node<user_defined_block, IN<T, 0, N_MAX, "in">, OUT<R, 0, N_MAX, "out">> {
+struct user_defined_block : node<user_defined_block, PortIn<T, 0, N_MAX, "in">, PortOut<R, 0, N_MAX, "out">> {
   // implement either:
   [[nodiscard]] constexpr work_return_t work() noexcept {...}
   // or one of the convenience functions outlined below
@@ -146,7 +151,7 @@ The following defaults are defined for one of the two 'user_defined_block' block
 * **case 1a** - non-decimating N-in->N-out mechanic and automatic handling of streaming tags and settings changes:
   ```cpp
   template<typename T, typename R>
-  struct user_defined_block : node<user_defined_block, IN<T, 0, N_MAX, "in">, OUT<R, 0, N_MAX, "out">> {
+  struct user_defined_block : node<user_defined_block, PortIn<T, 0, N_MAX, "in">, PortOut<R, 0, N_MAX, "out">> {
     T _factor = T{1};
     // constuctor setting _factor etc.
 
@@ -155,12 +160,12 @@ The following defaults are defined for one of the two 'user_defined_block' block
     }
   };
   ```
-  The number, type, and ordering of input and arguments of `process_one(..)` are defined by the port definitions.
+  The number, type, and ordering of input and arguments of `process_one(..)` are defined by the Port definitions.
 * **case 1b** - non-decimating N-in->N-out mechanic providing bulk access to the input/output data and automatic
   handling of streaming tags and settings changes:
   ```cpp
   template<typename T, typename R>
-  struct user_defined_block : node<user_defined_block, IN<T, 0, N_MAX, "in">, OUT<R, 0, N_MAX, "out">> {
+  struct user_defined_block : node<user_defined_block, PortIn<T, 0, N_MAX, "in">, PortOut<R, 0, N_MAX, "out">> {
     T _factor = T{1};
     // constuctor setting _factor etc.
 
diff --git a/include/data_sink.hpp b/include/data_sink.hpp
index 34512dde2..58d255c81 100644
--- a/include/data_sink.hpp
+++ b/include/data_sink.hpp
@@ -144,7 +144,7 @@ class data_sink_registry {
 
     template<typename T, TriggerMatcher M>
     std::shared_ptr<typename data_sink<T>::dataset_poller>
-    get_trigger_poller(const data_sink_query &query, M&& matcher, std::size_t pre_samples, std::size_t post_samples, blocking_mode block = blocking_mode::Blocking) {
+    get_trigger_poller(const data_sink_query &query, M &&matcher, std::size_t pre_samples, std::size_t post_samples, blocking_mode block = blocking_mode::Blocking) {
         std::lock_guard lg{ _mutex };
         auto            sink = find_sink<T>(query);
         return sink ? sink->get_trigger_poller(std::forward<M>(matcher), pre_samples, post_samples, block) : nullptr;
@@ -152,7 +152,7 @@ class data_sink_registry {
 
     template<typename T, TriggerMatcher M>
     std::shared_ptr<typename data_sink<T>::dataset_poller>
-    get_multiplexed_poller(const data_sink_query &query, M&& matcher, std::size_t maximum_window_size, blocking_mode block = blocking_mode::Blocking) {
+    get_multiplexed_poller(const data_sink_query &query, M &&matcher, std::size_t maximum_window_size, blocking_mode block = blocking_mode::Blocking) {
         std::lock_guard lg{ _mutex };
         auto            sink = find_sink<T>(query);
         return sink ? sink->get_multiplexed_poller(std::forward<M>(matcher), maximum_window_size, block) : nullptr;
@@ -160,7 +160,7 @@ class data_sink_registry {
 
     template<typename T, TriggerMatcher M>
     std::shared_ptr<typename data_sink<T>::dataset_poller>
-    get_snapshot_poller(const data_sink_query &query, M&& matcher, std::chrono::nanoseconds delay, blocking_mode block = blocking_mode::Blocking) {
+    get_snapshot_poller(const data_sink_query &query, M &&matcher, std::chrono::nanoseconds delay, blocking_mode block = blocking_mode::Blocking) {
         std::lock_guard lg{ _mutex };
         auto            sink = find_sink<T>(query);
         return sink ? sink->get_snapshot_poller(std::forward<M>(matcher), delay, block) : nullptr;
@@ -168,7 +168,7 @@ class data_sink_registry {
 
     template<typename T, StreamCallback<T> Callback>
     bool
-    register_streaming_callback(const data_sink_query &query, std::size_t max_chunk_size, Callback&& callback) {
+    register_streaming_callback(const data_sink_query &query, std::size_t max_chunk_size, Callback &&callback) {
         std::lock_guard lg{ _mutex };
         auto            sink = find_sink<T>(query);
         if (!sink) {
@@ -181,7 +181,7 @@ class data_sink_registry {
 
     template<typename T, DataSetCallback<T> Callback, TriggerMatcher M>
     bool
-    register_trigger_callback(const data_sink_query &query, M&& matcher, std::size_t pre_samples, std::size_t post_samples, Callback&& callback) {
+    register_trigger_callback(const data_sink_query &query, M &&matcher, std::size_t pre_samples, std::size_t post_samples, Callback &&callback) {
         std::lock_guard lg{ _mutex };
         auto            sink = find_sink<T>(query);
         if (!sink) {
@@ -194,7 +194,7 @@ class data_sink_registry {
 
     template<typename T, DataSetCallback<T> Callback, TriggerMatcher M>
     bool
-    register_multiplexed_callback(const data_sink_query &query, M&& matcher, std::size_t maximum_window_size, Callback&& callback) {
+    register_multiplexed_callback(const data_sink_query &query, M &&matcher, std::size_t maximum_window_size, Callback &&callback) {
         std::lock_guard lg{ _mutex };
         auto            sink = find_sink<T>(query);
         if (!sink) {
@@ -207,7 +207,7 @@ class data_sink_registry {
 
     template<typename T, DataSetCallback<T> Callback, TriggerMatcher M>
     bool
-    register_snapshot_callback(const data_sink_query &query, M&& matcher, std::chrono::nanoseconds delay, Callback&& callback) {
+    register_snapshot_callback(const data_sink_query &query, M &&matcher, std::chrono::nanoseconds delay, Callback &&callback) {
         std::lock_guard lg{ _mutex };
         auto            sink = find_sink<T>(query);
         if (!sink) {
@@ -319,7 +319,7 @@ class data_sink : public node<data_sink<T>> {
     Annotated<T, "signal min", Doc<"signal physical min. (e.g. DAQ) limit">>         signal_min  = std::numeric_limits<T>::lowest();
     Annotated<T, "signal max", Doc<"signal physical max. (e.g. DAQ) limit">>         signal_max  = std::numeric_limits<T>::max();
 
-    IN<T, std::dynamic_extent, _listener_buffer_size>                                in;
+    PortIn<T, RequiredSamples<std::dynamic_extent, _listener_buffer_size>>           in;
 
     struct poller {
         // TODO consider whether reusing port<T> here makes sense
@@ -409,7 +409,7 @@ class data_sink : public node<data_sink<T>> {
 
     template<TriggerMatcher M>
     std::shared_ptr<dataset_poller>
-    get_trigger_poller(M&& matcher, std::size_t pre_samples, std::size_t post_samples, blocking_mode block_mode = blocking_mode::Blocking) {
+    get_trigger_poller(M &&matcher, std::size_t pre_samples, std::size_t post_samples, blocking_mode block_mode = blocking_mode::Blocking) {
         const auto      block   = block_mode == blocking_mode::Blocking;
         auto            handler = std::make_shared<dataset_poller>();
         std::lock_guard lg(_listener_mutex);
@@ -420,7 +420,7 @@ class data_sink : public node<data_sink<T>> {
 
     template<TriggerMatcher M>
     std::shared_ptr<dataset_poller>
-    get_multiplexed_poller(M&& matcher, std::size_t maximum_window_size, blocking_mode block_mode = blocking_mode::Blocking) {
+    get_multiplexed_poller(M &&matcher, std::size_t maximum_window_size, blocking_mode block_mode = blocking_mode::Blocking) {
         std::lock_guard lg(_listener_mutex);
         const auto      block   = block_mode == blocking_mode::Blocking;
         auto            handler = std::make_shared<dataset_poller>();
@@ -430,7 +430,7 @@ class data_sink : public node<data_sink<T>> {
 
     template<TriggerMatcher M>
     std::shared_ptr<dataset_poller>
-    get_snapshot_poller(M&& matcher, std::chrono::nanoseconds delay, blocking_mode block_mode = blocking_mode::Blocking) {
+    get_snapshot_poller(M &&matcher, std::chrono::nanoseconds delay, blocking_mode block_mode = blocking_mode::Blocking) {
         const auto      block   = block_mode == blocking_mode::Blocking;
         auto            handler = std::make_shared<dataset_poller>();
         std::lock_guard lg(_listener_mutex);
@@ -440,27 +440,27 @@ class data_sink : public node<data_sink<T>> {
 
     template<StreamCallback<T> Callback>
     void
-    register_streaming_callback(std::size_t max_chunk_size, Callback&& callback) {
+    register_streaming_callback(std::size_t max_chunk_size, Callback &&callback) {
         add_listener(std::make_unique<continuous_listener<Callback>>(max_chunk_size, std::forward<Callback>(callback), *this), false);
     }
 
     template<TriggerMatcher M, DataSetCallback<T> Callback>
     void
-    register_trigger_callback(M&& matcher, std::size_t pre_samples, std::size_t post_samples, Callback&& callback) {
+    register_trigger_callback(M &&matcher, std::size_t pre_samples, std::size_t post_samples, Callback &&callback) {
         add_listener(std::make_unique<trigger_listener<Callback, M>>(std::forward<M>(matcher), pre_samples, post_samples, std::forward<Callback>(callback)), false);
         ensure_history_size(pre_samples);
     }
 
     template<TriggerMatcher M, DataSetCallback<T> Callback>
     void
-    register_multiplexed_callback(M&& matcher, std::size_t maximum_window_size, Callback&& callback) {
+    register_multiplexed_callback(M &&matcher, std::size_t maximum_window_size, Callback &&callback) {
         std::lock_guard lg(_listener_mutex);
         add_listener(std::make_unique<multiplexed_listener<Callback, M>>(std::forward<M>(matcher), maximum_window_size, std::forward<Callback>(callback)), false);
     }
 
     template<TriggerMatcher M, DataSetCallback<T> Callback>
     void
-    register_snapshot_callback(M&& matcher, std::chrono::nanoseconds delay, Callback&& callback) {
+    register_snapshot_callback(M &&matcher, std::chrono::nanoseconds delay, Callback &&callback) {
         std::lock_guard lg(_listener_mutex);
         add_listener(std::make_unique<snapshot_listener<Callback, M>>(std::forward<M>(matcher), delay, std::forward<Callback>(callback)), false);
     }
@@ -634,7 +634,7 @@ class data_sink : public node<data_sink<T>> {
         Callback              callback;
 
         template<typename CallbackFW>
-        explicit continuous_listener(std::size_t max_chunk_size, CallbackFW&& c, const data_sink<T> &parent) : parent_sink(parent), buffer(max_chunk_size), callback{ std::forward<CallbackFW>(c) } {}
+        explicit continuous_listener(std::size_t max_chunk_size, CallbackFW &&c, const data_sink<T> &parent) : parent_sink(parent), buffer(max_chunk_size), callback{ std::forward<CallbackFW>(c) } {}
 
         explicit continuous_listener(std::shared_ptr<poller> poller, bool do_block, const data_sink<T> &parent) : parent_sink(parent), block(do_block), polling_handler{ std::move(poller) } {}
 
@@ -760,11 +760,12 @@ class data_sink : public node<data_sink<T>> {
         Callback                      callback;
 
         template<TriggerMatcher Matcher>
-        explicit trigger_listener(Matcher&& matcher, std::shared_ptr<dataset_poller> handler, std::size_t pre, std::size_t post, bool do_block)
+        explicit trigger_listener(Matcher &&matcher, std::shared_ptr<dataset_poller> handler, std::size_t pre, std::size_t post, bool do_block)
             : block(do_block), pre_samples(pre), post_samples(post), trigger_matcher(std::forward<Matcher>(matcher)), polling_handler{ std::move(handler) } {}
 
         template<typename CallbackFW, TriggerMatcher Matcher>
-        explicit trigger_listener(Matcher&& matcher, std::size_t pre, std::size_t post, CallbackFW&& cb) : pre_samples(pre), post_samples(post), trigger_matcher(std::forward<Matcher>(matcher)), callback{ std::forward<CallbackFW>(cb) } {}
+        explicit trigger_listener(Matcher &&matcher, std::size_t pre, std::size_t post, CallbackFW &&cb)
+            : pre_samples(pre), post_samples(post), trigger_matcher(std::forward<Matcher>(matcher)), callback{ std::forward<CallbackFW>(cb) } {}
 
         void
         set_dataset_template(DataSet<T> dst) override {
@@ -850,11 +851,11 @@ class data_sink : public node<data_sink<T>> {
         Callback                      callback;
 
         template<typename CallbackFW, TriggerMatcher Matcher>
-        explicit multiplexed_listener(Matcher&& matcher_, std::size_t max_window_size, CallbackFW&& cb)
+        explicit multiplexed_listener(Matcher &&matcher_, std::size_t max_window_size, CallbackFW &&cb)
             : matcher(std::forward<Matcher>(matcher_)), maximum_window_size(max_window_size), callback(std::forward<CallbackFW>(cb)) {}
 
         template<TriggerMatcher Matcher>
-        explicit multiplexed_listener(Matcher&& matcher_, std::size_t max_window_size, std::shared_ptr<dataset_poller> handler, bool do_block)
+        explicit multiplexed_listener(Matcher &&matcher_, std::size_t max_window_size, std::shared_ptr<dataset_poller> handler, bool do_block)
             : block(do_block), matcher(std::forward<Matcher>(matcher_)), maximum_window_size(max_window_size), polling_handler{ std::move(handler) } {}
 
         void
@@ -949,11 +950,12 @@ class data_sink : public node<data_sink<T>> {
         Callback                      callback;
 
         template<TriggerMatcher Matcher>
-        explicit snapshot_listener(Matcher&& matcher, std::chrono::nanoseconds delay, std::shared_ptr<dataset_poller> poller, bool do_block)
+        explicit snapshot_listener(Matcher &&matcher, std::chrono::nanoseconds delay, std::shared_ptr<dataset_poller> poller, bool do_block)
             : block(do_block), time_delay(delay), trigger_matcher(std::forward<Matcher>(matcher)), polling_handler{ std::move(poller) } {}
 
         template<typename CallbackFW, TriggerMatcher Matcher>
-        explicit snapshot_listener(Matcher&& matcher, std::chrono::nanoseconds delay, CallbackFW&& cb) : time_delay(delay), trigger_matcher(std::forward<Matcher>(matcher)), callback(std::forward<CallbackFW>(cb)) {}
+        explicit snapshot_listener(Matcher &&matcher, std::chrono::nanoseconds delay, CallbackFW &&cb)
+            : time_delay(delay), trigger_matcher(std::forward<Matcher>(matcher)), callback(std::forward<CallbackFW>(cb)) {}
 
         void
         set_dataset_template(DataSet<T> dst) override {
diff --git a/include/graph.hpp b/include/graph.hpp
index b7f8b259f..88a9e810e 100644
--- a/include/graph.hpp
+++ b/include/graph.hpp
@@ -738,9 +738,10 @@ operator<<(std::ostream &os, const port_direction_t &value) {
     return os << static_cast<int>(value);
 }
 
+template<PortDomainType T>
 inline std::ostream &
-operator<<(std::ostream &os, const port_domain_t &value) {
-    return os << static_cast<int>(value);
+operator<<(std::ostream &os, const T &value) {
+    return os << value.Name;
 }
 
 #if HAVE_SOURCE_LOCATION
diff --git a/include/node.hpp b/include/node.hpp
index 1bbb1eca3..57b36d88c 100644
--- a/include/node.hpp
+++ b/include/node.hpp
@@ -378,7 +378,7 @@ struct node : protected std::tuple<Arguments...> {
     update_ports_status() {
         ports_status = ports_status_t();
         meta::tuple_for_each(
-                [&ps = ports_status](Port auto &port) {
+                [&ps = ports_status](PortType auto &port) {
                     ps.in_min_samples                = std::max(ps.in_min_samples, port.min_buffer_size());
                     ps.in_max_samples                = std::min(ps.in_max_samples, port.max_buffer_size());
                     ps.in_available                  = std::min(ps.in_available, port.streamReader().available());
@@ -389,7 +389,7 @@ struct node : protected std::tuple<Arguments...> {
                 input_ports(&self()));
 
         meta::tuple_for_each(
-                [&ps = ports_status](Port auto &port) {
+                [&ps = ports_status](PortType auto &port) {
                     ps.out_min_samples = std::max(ps.out_min_samples, port.min_buffer_size());
                     ps.out_max_samples = std::min(ps.out_max_samples, port.max_buffer_size());
                     ps.out_available   = std::min(ps.out_available, port.streamWriter().available());
@@ -1320,8 +1320,12 @@ merge(A &&a, B &&b) {
 }
 
 #if !DISABLE_SIMD
-namespace test {
-struct copy : public node<copy, IN<float, 0, std::numeric_limits<std::size_t>::max(), "in">, OUT<float, 0, std::numeric_limits<std::size_t>::max(), "out">> {
+namespace test { // TODO: move to dedicated tests
+
+struct copy : public node<copy> {
+    PortIn<float>  in;
+    PortOut<float> out;
+
 public:
     template<meta::t_or_simd<float> V>
     [[nodiscard]] constexpr V
@@ -1329,7 +1333,18 @@ struct copy : public node<copy, IN<float, 0, std::numeric_limits<std::size_t>::m
         return a;
     }
 };
+} // namespace test
+#endif
+} // namespace fair::graph
 
+#if !DISABLE_SIMD
+ENABLE_REFLECTION(fair::graph::test::copy, in, out);
+#endif
+
+namespace fair::graph {
+
+#if !DISABLE_SIMD
+namespace test {
 static_assert(traits::node::input_port_types<copy>::size() == 1);
 static_assert(std::same_as<traits::node::return_type<copy>, float>);
 static_assert(traits::node::can_process_one_scalar<copy>);
diff --git a/include/port.hpp b/include/port.hpp
index a5d48bee0..0af4d1d66 100644
--- a/include/port.hpp
+++ b/include/port.hpp
@@ -1,44 +1,77 @@
 #ifndef GNURADIO_PORT_HPP
 #define GNURADIO_PORT_HPP
 
-#include "circular_buffer.hpp"
-#include "tag.hpp"
-#include "utils.hpp"
 #include <complex>
 #include <dataset.hpp>
 #include <node.hpp>
 #include <span>
 #include <variant>
 
+#include <annotated.hpp>
+#include <circular_buffer.hpp>
+#include <tag.hpp>
+#include <utils.hpp>
+
 namespace fair::graph {
 
 using fair::meta::fixed_string;
 using namespace fair::literals;
 
-// #### default supported types -- TODO: to be replaced by pmt::pmtv declaration
+#ifndef PMT_SUPPORTED_TYPE // // #### default supported types -- TODO: to be replaced by pmt::pmtv declaration
+#define PMT_SUPPORTED_TYPE
 // Only DataSet<double> and DataSet<float> are added => consider to support more Dataset<T>
-using supported_type = std::variant<uint8_t, uint32_t, int8_t, int16_t, int32_t, float, double, std::complex<float>, std::complex<double>, DataSet<double>, DataSet<float> /*, ...*/>;
+using supported_type = std::variant<uint8_t, uint32_t, int8_t, int16_t, int32_t, float, double, std::complex<float>, std::complex<double>, DataSet<float>, DataSet<double> /*, ...*/>;
+#endif
 
 enum class port_direction_t { INPUT, OUTPUT, ANY }; // 'ANY' only for query and not to be used for port declarations
+
 enum class connection_result_t { SUCCESS, FAILED };
+
 enum class port_type_t {
     STREAM, /*!< used for single-producer-only ond usually synchronous one-to-one or one-to-many communications */
     MESSAGE /*!< used for multiple-producer one-to-one, one-to-many, many-to-one, or many-to-many communications */
 };
-enum class port_domain_t { CPU, GPU, NET, FPGA, DSP, MLU };
+
+/**
+ * @brief optional port annotation argument to described whether the port can be handled within the same scheduling domain.
+ *
+ * @tparam PortDomainName the unique name of the domain, name shouldn't clash with other existing definitions (e.g. 'CPU' and 'GPU')
+ */
+template<fixed_string PortDomainName>
+struct PortDomain {
+    static constexpr fixed_string Name = PortDomainName;
+};
+
+template<typename T>
+concept PortDomainType = requires { T::Name; } && std::is_base_of_v<PortDomain<T::Name>, T>;
+
+template<typename T>
+using is_port_domain = std::bool_constant<PortDomainType<T>>;
+
+struct CPU : public PortDomain<"CPU"> {};
+
+struct GPU : public PortDomain<"GPU"> {};
+
+static_assert(is_port_domain<CPU>::value);
+static_assert(is_port_domain<GPU>::value);
+static_assert(!is_port_domain<int>::value);
 
 template<class T>
-concept Port = requires(T t, const std::size_t n_items) { // dynamic definitions
+concept PortType = requires(T t, const std::size_t n_items, const supported_type &newDefault) { // dynamic definitions
     typename T::value_type;
-    { t.pmt_type() } -> std::same_as<supported_type>;
+    { t.defaultValue() } -> std::same_as<supported_type>;
+    { t.setDefaultValue(newDefault) } -> std::same_as<bool>;
     { t.name } -> std::convertible_to<std::string_view>;
     { t.priority } -> std::convertible_to<std::int32_t>;
     { t.min_samples } -> std::convertible_to<std::size_t>;
     { t.max_samples } -> std::convertible_to<std::size_t>;
     { t.type() } -> std::same_as<port_type_t>;
     { t.direction() } -> std::same_as<port_direction_t>;
+    { t.domain() } -> std::same_as<std::string_view>;
     { t.resize_buffer(n_items) } -> std::same_as<connection_result_t>;
     { t.disconnect() } -> std::same_as<connection_result_t>;
+    { t.isSynchronous() } -> std::same_as<bool>;
+    { t.isOptional() } -> std::same_as<bool>;
 };
 
 /**
@@ -51,6 +84,95 @@ struct internal_port_buffers {
     void *tagHandler;
 };
 
+/**
+ * @brief optional port annotation argument to describe the min/max number of samples required from this port before invoking the blocks work function.
+ *
+ * @tparam MIN_SAMPLES (>0) specifies the minimum number of samples the port/block requires for processing in one scheduler iteration
+ * @tparam MAX_SAMPLES specifies the maximum number of samples the port/block can process in one scheduler iteration
+ */
+template<std::size_t MIN_SAMPLES = std::dynamic_extent, std::size_t MAX_SAMPLES = std::dynamic_extent>
+struct RequiredSamples {
+    static_assert(MIN_SAMPLES > 0, "Port<T, ..., RequiredSamples::MIN_SAMPLES, ...>, ..> must be >= 0");
+    static constexpr std::size_t MinSamples = MIN_SAMPLES;
+    static constexpr std::size_t MaxSamples = MAX_SAMPLES;
+};
+
+template<typename T>
+concept IsRequiredSamples = requires {
+    T::MinSamples;
+    T::MaxSamples;
+} && std::is_base_of_v<RequiredSamples<T::MinSamples, T::MaxSamples>, T>;
+
+template<typename T>
+using is_required_samples = std::bool_constant<IsRequiredSamples<T>>;
+
+static_assert(is_required_samples<RequiredSamples<1, 1024>>::value);
+static_assert(!is_required_samples<int>::value);
+
+/**
+ * @brief optional port annotation argument informing the graph/scheduler that a given port does not require to be connected
+ */
+struct Optional {};
+
+/**
+ * @brief optional port annotation argument to define the buffer implementation to be used for streaming data
+ *
+ * @tparam BufferType user-extendable buffer implementation for the streaming data
+ */
+template<gr::Buffer BufferType>
+struct StreamBufferType {
+    using type = BufferType;
+};
+
+/**
+ * @brief optional port annotation argument to define the buffer implementation to be used for tag data
+ *
+ * @tparam BufferType user-extendable buffer implementation for the tag data
+ */
+template<gr::Buffer BufferType>
+struct TagBufferType {
+    using type = BufferType;
+};
+
+template<typename T>
+concept IsStreamBufferAttribute = requires { typename T::type; } && gr::Buffer<typename T::type> && std::is_base_of_v<StreamBufferType<typename T::type>, T>;
+;
+
+template<typename T>
+concept IsTagBufferAttribute = requires { typename T::type; } && gr::Buffer<typename T::type> && std::is_base_of_v<TagBufferType<typename T::type>, T>;
+
+template<typename T>
+using is_stream_buffer_attribute = std::bool_constant<IsStreamBufferAttribute<T>>;
+
+template<typename T>
+using is_tag_buffer_attribute = std::bool_constant<IsTagBufferAttribute<T>>;
+
+template<typename T>
+struct DefaultStreamBuffer : StreamBufferType<gr::circular_buffer<T>> {};
+
+struct DefaultTagBuffer : TagBufferType<gr::circular_buffer<tag_t>> {};
+
+static_assert(is_stream_buffer_attribute<DefaultStreamBuffer<int>>::value);
+static_assert(!is_stream_buffer_attribute<DefaultTagBuffer>::value);
+static_assert(!is_tag_buffer_attribute<DefaultStreamBuffer<int>>::value);
+static_assert(is_tag_buffer_attribute<DefaultTagBuffer>::value);
+
+/**
+ * @brief Annotation for making a port asynchronous in a signal flow-graph block.
+ *
+ * In a standard block, the processing function is invoked based on the least common number of samples
+ * available across all input and output ports. When a port is annotated with `Async`, it is excluded from this
+ * least common number calculation.
+ *
+ * Applying `Async` as an optional template argument of the Port class essentially marks the port as "optional" for the
+ * synchronization mechanism. The block's processing function will be invoked regardless of the number of samples
+ * available at this specific port, relying solely on the state of other ports that are not marked as asynchronous.
+ *
+ * Use this annotation to create ports that do not constrain the block's ability to process data, making it
+ * asynchronous relative to the other ports in the block.
+ */
+struct Async {};
+
 /**
  * @brief 'ports' are interfaces that allows data to flow between blocks in a graph, similar to RF connectors.
  * Each block can have zero or more input/output ports. When connecting ports, either a single-step or a two-step
@@ -73,38 +195,41 @@ struct internal_port_buffers {
  * @tparam PortName a string to identify the port, notably to be used in an UI- and hand-written explicit code context.
  * @tparam PortType STREAM  or MESSAGE
  * @tparam PortDirection either input or output
- * @tparam MIN_SAMPLES specifies the minimum number of samples the port/block requires for processing in one scheduler iteration
- * @tparam MAX_SAMPLES specifies the maximum number of samples the port/block can process in one scheduler iteration
- * @tparam BufferType user-extendable buffer implementation for the streaming data
- * @tparam TagBufferType user-extendable buffer implementation for the tag data
+ * @tparam Arguments optional: default to 'DefaultStreamBuffer' and DefaultTagBuffer' based on 'gr::circular_buffer', and CPU domain
  */
-template<typename T, fixed_string PortName, port_type_t PortType, port_direction_t PortDirection, // TODO: sort default arguments
-         std::size_t MIN_SAMPLES = std::dynamic_extent, std::size_t MAX_SAMPLES = std::dynamic_extent, gr::Buffer BufferType = gr::circular_buffer<T>,
-         gr::Buffer TagBufferType = gr::circular_buffer<tag_t>>
-class port {
-public:
-    static_assert(PortDirection != port_direction_t::ANY, "ANY reserved for queries and not port direction declarations");
-
-    using value_type                = T;
-
-    static constexpr bool IS_INPUT  = PortDirection == port_direction_t::INPUT;
-    static constexpr bool IS_OUTPUT = PortDirection == port_direction_t::OUTPUT;
-
+template<typename T, fixed_string PortName, port_type_t PortType, port_direction_t PortDirection, typename... Arguments>
+struct Port {
     template<fixed_string NewName>
-    using with_name     = port<T, NewName, PortType, PortDirection, MIN_SAMPLES, MAX_SAMPLES, BufferType>;
+    using with_name = Port<T, NewName, PortType, PortDirection, Arguments...>;
+
+    static_assert(PortDirection != port_direction_t::ANY, "ANY reserved for queries and not port direction declarations");
 
-    using ReaderType    = decltype(std::declval<BufferType>().new_reader());
-    using WriterType    = decltype(std::declval<BufferType>().new_writer());
-    using IoType        = std::conditional_t<IS_INPUT, ReaderType, WriterType>;
-    using TagReaderType = decltype(std::declval<TagBufferType>().new_reader());
-    using TagWriterType = decltype(std::declval<TagBufferType>().new_writer());
-    using TagIoType     = std::conditional_t<IS_INPUT, TagReaderType, TagWriterType>;
+    using value_type                            = T;
+    using ArgumentsTypeList                     = typename fair::meta::typelist<Arguments...>;
+    using Domain                                = ArgumentsTypeList::template find_or_default<is_port_domain, CPU>;
+    using Required                              = ArgumentsTypeList::template find_or_default<is_required_samples, RequiredSamples<std::dynamic_extent, std::dynamic_extent>>;
+    using BufferType                            = ArgumentsTypeList::template find_or_default<is_stream_buffer_attribute, DefaultStreamBuffer<T>>::type;
+    using TagBufferType                         = ArgumentsTypeList::template find_or_default<is_tag_buffer_attribute, DefaultTagBuffer>::type;
+    static constexpr port_direction_t Direction = PortDirection;
+    static constexpr bool             IS_INPUT  = PortDirection == port_direction_t::INPUT;
+    static constexpr bool             IS_OUTPUT = PortDirection == port_direction_t::OUTPUT;
+    static constexpr fixed_string     Name      = PortName;
+
+    using ReaderType                            = decltype(std::declval<BufferType>().new_reader());
+    using WriterType                            = decltype(std::declval<BufferType>().new_writer());
+    using IoType                                = std::conditional_t<IS_INPUT, ReaderType, WriterType>;
+    using TagReaderType                         = decltype(std::declval<TagBufferType>().new_reader());
+    using TagWriterType                         = decltype(std::declval<TagBufferType>().new_writer());
+    using TagIoType                             = std::conditional_t<IS_INPUT, TagReaderType, TagWriterType>;
 
     // public properties
-    const std::string name        = static_cast<std::string>(PortName);
-    std::int16_t      priority    = 0; // → dependents of a higher-prio port should be scheduled first (Q: make this by order of ports?)
-    std::size_t       min_samples = (MIN_SAMPLES == std::dynamic_extent ? 1 : MIN_SAMPLES);
-    std::size_t       max_samples = MAX_SAMPLES;
+    constexpr static bool synchronous   = !std::disjunction_v<std::is_same<Async, Arguments>...>;
+    constexpr static bool optional      = std::disjunction_v<std::is_same<Optional, Arguments>...>;
+    std::string           name          = static_cast<std::string>(PortName);
+    std::int16_t          priority      = 0; // → dependents of a higher-prio port should be scheduled first (Q: make this by order of ports?)
+    std::size_t           min_samples   = (Required::MinSamples == std::dynamic_extent ? 1 : Required::MinSamples);
+    std::size_t           max_samples   = Required::MaxSamples;
+    T                     default_value = T{};
 
 private:
     bool      _connected    = false;
@@ -112,21 +237,30 @@ class port {
     TagIoType _tagIoHandler = new_tag_io_handler();
 
 public:
+    [[nodiscard]] constexpr bool
+    initBuffer(std::size_t nSamples = 0) noexcept {
+        if constexpr (IS_OUTPUT) {
+            // write one default value into output -- needed for cyclic graph initialisation
+            return _ioHandler.try_publish([val = default_value](std::span<T> &out) { std::ranges::fill(out, val); }, nSamples);
+        }
+        return true;
+    }
+
     [[nodiscard]] constexpr auto
-    new_io_handler() const noexcept {
+    new_io_handler(std::size_t buffer_size = 65536) const noexcept {
         if constexpr (IS_INPUT) {
-            return BufferType(65536).new_reader();
+            return BufferType(buffer_size).new_reader();
         } else {
-            return BufferType(65536).new_writer();
+            return BufferType(buffer_size).new_writer();
         }
     }
 
     [[nodiscard]] constexpr auto
-    new_tag_io_handler() const noexcept {
+    new_tag_io_handler(std::size_t buffer_size = 65536) const noexcept {
         if constexpr (IS_INPUT) {
-            return TagBufferType(65536).new_reader();
+            return TagBufferType(buffer_size).new_reader();
         } else {
-            return TagBufferType(65536).new_writer();
+            return TagBufferType(buffer_size).new_writer();
         }
     }
 
@@ -157,23 +291,22 @@ class port {
         return true;
     }
 
-public:
-    port()             = default;
-    port(const port &) = delete;
+    constexpr Port()   = default;
+    Port(const Port &) = delete;
     auto
-    operator=(const port &)
+    operator=(const Port &)
             = delete;
 
-    port(std::string port_name, std::int16_t priority_ = 0, std::size_t min_samples_ = 0_UZ, std::size_t max_samples_ = SIZE_MAX) noexcept
+    Port(std::string port_name, std::int16_t priority_ = 0, std::size_t min_samples_ = 0_UZ, std::size_t max_samples_ = SIZE_MAX) noexcept
         : name(std::move(port_name)), priority{ priority_ }, min_samples(min_samples_), max_samples(max_samples_) {
         static_assert(PortName.empty(), "port name must be exclusively declared via NTTP or constructor parameter");
     }
 
-    constexpr port(port &&other) noexcept : name(std::move(other.name)), priority{ other.priority }, min_samples(other.min_samples), max_samples(other.max_samples) {}
+    constexpr Port(Port &&other) noexcept : name(std::move(other.name)), priority{ other.priority }, min_samples(other.min_samples), max_samples(other.max_samples) {}
 
-    constexpr port &
-    operator=(port &&other) {
-        port tmp(std::move(other));
+    constexpr Port &
+    operator=(Port &&other) noexcept {
+        Port tmp(std::move(other));
         std::swap(name, tmp._name);
         std::swap(min_samples, tmp._min_samples);
         std::swap(max_samples, tmp._max_samples);
@@ -185,6 +318,8 @@ class port {
         return *this;
     }
 
+    ~Port() = default;
+
     [[nodiscard]] constexpr static port_type_t
     type() noexcept {
         return PortType;
@@ -195,6 +330,21 @@ class port {
         return PortDirection;
     }
 
+    [[nodiscard]] constexpr static std::string_view
+    domain() noexcept {
+        return std::string_view(Domain::Name);
+    }
+
+    [[nodiscard]] constexpr static bool
+    isSynchronous() noexcept {
+        return synchronous;
+    }
+
+    [[nodiscard]] constexpr static bool
+    isOptional() noexcept {
+        return optional;
+    }
+
     [[nodiscard]] constexpr static decltype(PortName)
     static_name() noexcept
         requires(!PortName.empty())
@@ -208,8 +358,17 @@ class port {
 #else
     [[nodiscard]] constexpr supported_type
 #endif
-    pmt_type() const noexcept {
-        return T();
+    defaultValue() const noexcept {
+        return default_value;
+    }
+
+    bool
+    setDefaultValue(const supported_type &newDefault) noexcept {
+        if (std::holds_alternative<T>(newDefault)) {
+            default_value = std::get<T>(newDefault);
+            return true;
+        }
+        return false;
     }
 
     [[nodiscard]] constexpr static std::size_t
@@ -219,35 +378,36 @@ class port {
 
     [[nodiscard]] constexpr std::size_t
     min_buffer_size() const noexcept {
-        if constexpr (MIN_SAMPLES == std::dynamic_extent) {
+        if constexpr (Required::MinSamples == std::dynamic_extent) {
             return min_samples;
         } else {
-            return MIN_SAMPLES;
+            return Required::MinSamples;
         }
     }
 
     [[nodiscard]] constexpr std::size_t
     max_buffer_size() const noexcept {
-        if constexpr (MAX_SAMPLES == std::dynamic_extent) {
+        if constexpr (Required::MaxSamples == std::dynamic_extent) {
             return max_samples;
         } else {
-            return MAX_SAMPLES;
+            return Required::MaxSamples;
         }
     }
 
     [[nodiscard]] constexpr connection_result_t
     resize_buffer(std::size_t min_size) noexcept {
+        using enum fair::graph::connection_result_t;
         if constexpr (IS_INPUT) {
-            return connection_result_t::SUCCESS;
+            return SUCCESS;
         } else {
             try {
                 _ioHandler    = BufferType(min_size).new_writer();
                 _tagIoHandler = TagBufferType(min_size).new_writer();
             } catch (...) {
-                return connection_result_t::FAILED;
+                return FAILED;
             }
         }
-        return connection_result_t::SUCCESS;
+        return SUCCESS;
     }
 
     [[nodiscard]] auto
@@ -346,39 +506,52 @@ namespace detail {
 template<typename T, auto>
 using just_t = T;
 
-template<typename T, std::size_t... Is>
-consteval fair::meta::typelist<just_t<T, Is>...>
+template<typename T, fixed_string BaseName, port_type_t PortType, port_direction_t PortDirection, typename... Arguments, std::size_t... Is>
+consteval fair::meta::typelist<just_t<Port<T, BaseName + meta::make_fixed_string<Is>(), PortType, PortDirection, Arguments...>, Is>...>
 repeated_ports_impl(std::index_sequence<Is...>) {
     return {};
 }
 } // namespace detail
 
-// TODO: Add port index to BaseName
-template<std::size_t Count, typename T, fixed_string BaseName, port_type_t PortType, port_direction_t PortDirection, std::size_t MIN_SAMPLES = std::dynamic_extent,
-         std::size_t MAX_SAMPLES = std::dynamic_extent>
-using repeated_ports = decltype(detail::repeated_ports_impl<port<T, BaseName, PortType, PortDirection, MIN_SAMPLES, MAX_SAMPLES>>(std::make_index_sequence<Count>()));
-
-template<typename T, std::size_t MIN_SAMPLES = std::dynamic_extent, std::size_t MAX_SAMPLES = std::dynamic_extent, fixed_string PortName = "">
-using IN = port<T, PortName, port_type_t::STREAM, port_direction_t::INPUT, MIN_SAMPLES, MAX_SAMPLES>;
-template<typename T, std::size_t MIN_SAMPLES = std::dynamic_extent, std::size_t MAX_SAMPLES = std::dynamic_extent, fixed_string PortName = "">
-using OUT = port<T, PortName, port_type_t::STREAM, port_direction_t::OUTPUT, MIN_SAMPLES, MAX_SAMPLES>;
-template<typename T, std::size_t MIN_SAMPLES = std::dynamic_extent, std::size_t MAX_SAMPLES = std::dynamic_extent, fixed_string PortName = "">
-using IN_MSG = port<T, PortName, port_type_t::MESSAGE, port_direction_t::INPUT, MIN_SAMPLES, MAX_SAMPLES>;
-template<typename T, std::size_t MIN_SAMPLES = std::dynamic_extent, std::size_t MAX_SAMPLES = std::dynamic_extent, fixed_string PortName = "">
-using OUT_MSG = port<T, PortName, port_type_t::MESSAGE, port_direction_t::OUTPUT, MIN_SAMPLES, MAX_SAMPLES>;
-
-static_assert(Port<IN<float>>);
-static_assert(Port<decltype(IN<float>())>);
-static_assert(Port<OUT<float>>);
-static_assert(Port<IN_MSG<float>>);
-static_assert(Port<OUT_MSG<float>>);
-
-static_assert(IN<float, 0, 0, "in">::static_name() == fixed_string("in"));
-static_assert(requires { IN<float>("in").name; });
-
-static_assert(OUT_MSG<float, 0, 0, "out_msg">::static_name() == fixed_string("out_msg"));
-static_assert(!(OUT_MSG<float, 0, 0, "out_msg">::with_name<"out_message">::static_name() == fixed_string("out_msg")));
-static_assert(OUT_MSG<float, 0, 0, "out_msg">::with_name<"out_message">::static_name() == fixed_string("out_message"));
+template<std::size_t Count, typename T, fixed_string BaseName, port_type_t PortType, port_direction_t PortDirection, typename... Arguments>
+using repeated_ports = decltype(detail::repeated_ports_impl<T, BaseName, PortType, PortDirection, Arguments...>(std::make_index_sequence<Count>()));
+
+static_assert(repeated_ports<3, float, "out", port_type_t::STREAM, port_direction_t::OUTPUT, Optional>::at<0>::Name == fixed_string("out0"));
+static_assert(repeated_ports<3, float, "out", port_type_t::STREAM, port_direction_t::OUTPUT, Optional>::at<1>::Name == fixed_string("out1"));
+static_assert(repeated_ports<3, float, "out", port_type_t::STREAM, port_direction_t::OUTPUT, Optional>::at<2>::Name == fixed_string("out2"));
+
+template<typename T, typename... Arguments>
+using PortIn = Port<T, "", port_type_t::STREAM, port_direction_t::INPUT, Arguments...>;
+template<typename T, typename... Arguments>
+using PortOut = Port<T, "", port_type_t::STREAM, port_direction_t::OUTPUT, Arguments...>;
+template<typename... Arguments>
+using MsgPortIn = Port<property_map, "", port_type_t::MESSAGE, port_direction_t::INPUT, Arguments...>;
+template<typename... Arguments>
+using MsgPortOut = Port<property_map, "", port_type_t::MESSAGE, port_direction_t::OUTPUT, Arguments...>;
+
+template<typename T, fixed_string PortName, typename... Arguments>
+using PortInNamed = Port<T, PortName, port_type_t::STREAM, port_direction_t::INPUT, Arguments...>;
+template<typename T, fixed_string PortName, typename... Arguments>
+using PortOutNamed = Port<T, PortName, port_type_t::STREAM, port_direction_t::OUTPUT, Arguments...>;
+template<fixed_string PortName, typename... Arguments>
+using MsgPortInNamed = Port<property_map, PortName, port_type_t::STREAM, port_direction_t::INPUT, Arguments...>;
+template<fixed_string PortName, typename... Arguments>
+using MsgPortOutNamed = Port<property_map, PortName, port_type_t::STREAM, port_direction_t::OUTPUT, Arguments...>;
+
+static_assert(PortType<PortIn<float>>);
+static_assert(PortType<decltype(PortIn<float>())>);
+static_assert(PortType<PortOut<float>>);
+static_assert(PortType<MsgPortIn<float>>);
+static_assert(PortType<MsgPortOut<float>>);
+
+static_assert(PortIn<float, RequiredSamples<1, 2>>::Required::MinSamples == 1);
+static_assert(PortIn<float, RequiredSamples<1, 2>>::Required::MaxSamples == 2);
+static_assert(std::same_as<PortIn<float, RequiredSamples<1, 2>>::Domain, CPU>);
+static_assert(std::same_as<PortIn<float, RequiredSamples<1, 2>, GPU>::Domain, GPU>);
+
+static_assert(MsgPortOutNamed<"out_msg">::static_name() == fixed_string("out_msg"));
+static_assert(!(MsgPortOutNamed<"out_msg">::with_name<"out_message">::static_name() == fixed_string("out_msg")));
+static_assert(MsgPortOutNamed<"out_msg">::with_name<"out_message">::static_name() == fixed_string("out_message"));
 
 /**
  *  Runtime capable wrapper to be used within a block. It's primary purpose is to allow the runtime
@@ -404,7 +577,11 @@ class dynamic_port {
         virtual ~model() = default;
 
         [[nodiscard]] virtual supported_type
-        pmt_type() const noexcept
+        defaultValue() const noexcept
+                = 0;
+
+        [[nodiscard]] virtual bool
+        setDefaultValue(const supported_type &val) noexcept
                 = 0;
 
         [[nodiscard]] virtual port_type_t
@@ -415,6 +592,18 @@ class dynamic_port {
         direction() const noexcept
                 = 0;
 
+        [[nodiscard]] virtual std::string_view
+        domain() const noexcept
+                = 0;
+
+        [[nodiscard]] virtual bool
+        isSynchronous() noexcept
+                = 0;
+
+        [[nodiscard]] virtual bool
+        isOptional() noexcept
+                = 0;
+
         [[nodiscard]] virtual connection_result_t
         resize_buffer(std::size_t min_size) noexcept
                 = 0;
@@ -435,7 +624,7 @@ class dynamic_port {
 
     std::unique_ptr<model> _accessor;
 
-    template<Port T, bool owning>
+    template<PortType T, bool owning>
     class wrapper final : public model {
         using PortType = std::decay_t<T>;
         std::conditional_t<owning, PortType, PortType &> _value;
@@ -489,15 +678,20 @@ class dynamic_port {
         }
 
         ~wrapper() override = default;
-        
+
         // TODO revisit: constexpr was removed because emscripten does not support constexpr function for non literal type, like DataSet<T>
 #if defined(__EMSCRIPTEN__)
         [[nodiscard]] supported_type
 #else
         [[nodiscard]] constexpr supported_type
 #endif
-        pmt_type() const noexcept override {
-            return _value.pmt_type();
+        defaultValue() const noexcept override {
+            return _value.defaultValue();
+        }
+
+        [[nodiscard]] bool
+        setDefaultValue(const supported_type &val) noexcept override {
+            return _value.setDefaultValue(val);
         }
 
         [[nodiscard]] constexpr port_type_t
@@ -510,6 +704,21 @@ class dynamic_port {
             return _value.direction();
         }
 
+        [[nodiscard]] constexpr std::string_view
+        domain() const noexcept override {
+            return _value.domain();
+        }
+
+        [[nodiscard]] bool
+        isSynchronous() noexcept override {
+            return _value.isSynchronous();
+        }
+
+        [[nodiscard]] bool
+        isOptional() noexcept override {
+            return _value.isOptional();
+        }
+
         [[nodiscard]] connection_result_t
         resize_buffer(std::size_t min_size) noexcept override {
             return _value.resize_buffer(min_size);
@@ -522,12 +731,13 @@ class dynamic_port {
 
         [[nodiscard]] connection_result_t
         connect(dynamic_port &dst_port) override {
+            using enum fair::graph::connection_result_t;
             if constexpr (T::IS_OUTPUT) {
                 auto src_buffer = _value.writer_handler_internal();
-                return dst_port.update_reader_internal(src_buffer) ? connection_result_t::SUCCESS : connection_result_t::FAILED;
+                return dst_port.update_reader_internal(src_buffer) ? SUCCESS : FAILED;
             } else {
                 assert(false && "This works only on input ports");
-                return connection_result_t::FAILED;
+                return FAILED;
             }
         }
     };
@@ -553,17 +763,22 @@ class dynamic_port {
             = delete;
 
     // TODO: Make owning versus non-owning API more explicit
-    template<Port T>
+    template<PortType T>
     explicit constexpr dynamic_port(T &arg) noexcept
         : name(arg.name), priority(arg.priority), min_samples(arg.min_samples), max_samples(arg.max_samples), _accessor{ std::make_unique<wrapper<T, false>>(arg) } {}
 
-    template<Port T>
+    template<PortType T>
     explicit constexpr dynamic_port(T &&arg) noexcept
         : name(arg.name), priority(arg.priority), min_samples(arg.min_samples), max_samples(arg.max_samples), _accessor{ std::make_unique<wrapper<T, true>>(std::forward<T>(arg)) } {}
 
     [[nodiscard]] supported_type
-    pmt_type() const noexcept {
-        return _accessor->pmt_type();
+    defaultValue() const noexcept {
+        return _accessor->defaultValue();
+    }
+
+    [[nodiscard]] bool
+    setDefaultValue(const supported_type &val) noexcept {
+        return _accessor->setDefaultValue(val);
     }
 
     [[nodiscard]] port_type_t
@@ -576,6 +791,21 @@ class dynamic_port {
         return _accessor->direction();
     }
 
+    [[nodiscard]] std::string_view
+    domain() const noexcept {
+        return _accessor->domain();
+    }
+
+    [[nodiscard]] bool
+    isSynchronous() noexcept {
+        return _accessor->isSynchronous();
+    }
+
+    [[nodiscard]] bool
+    isOptional() noexcept {
+        return _accessor->isOptional();
+    }
+
     [[nodiscard]] connection_result_t
     resize_buffer(std::size_t min_size) {
         if (direction() == port_direction_t::OUTPUT) {
@@ -595,10 +825,10 @@ class dynamic_port {
     }
 };
 
-static_assert(Port<dynamic_port>);
+static_assert(PortType<dynamic_port>);
 
 constexpr void
-publish_tag(Port auto &port, property_map &&tag_data, std::size_t tag_offset = 0) noexcept {
+publish_tag(PortType auto &port, property_map &&tag_data, std::size_t tag_offset = 0) noexcept {
     port.tagWriter().publish(
             [&port, data = std::move(tag_data), &tag_offset](std::span<fair::graph::tag_t> tag_output) {
                 tag_output[0].index = port.streamWriter().position() + std::make_signed_t<std::size_t>(tag_offset);
@@ -608,7 +838,7 @@ publish_tag(Port auto &port, property_map &&tag_data, std::size_t tag_offset = 0
 }
 
 constexpr void
-publish_tag(Port auto &port, const property_map &tag_data, std::size_t tag_offset = 0) noexcept {
+publish_tag(PortType auto &port, const property_map &tag_data, std::size_t tag_offset = 0) noexcept {
     port.tagWriter().publish(
             [&port, &tag_data, &tag_offset](std::span<fair::graph::tag_t> tag_output) {
                 tag_output[0].index = port.streamWriter().position() + tag_offset;
@@ -618,7 +848,7 @@ publish_tag(Port auto &port, const property_map &tag_data, std::size_t tag_offse
 }
 
 constexpr std::size_t
-samples_to_next_tag(const Port auto &port) {
+samples_to_next_tag(const PortType auto &port) {
     if (port.tagReader().available() == 0) [[likely]] {
         return std::numeric_limits<std::size_t>::max(); // default: no tags in sight
     }
@@ -626,7 +856,7 @@ samples_to_next_tag(const Port auto &port) {
     // at least one tag is present -> if tag is not on the first tag position read up to the tag position
     const auto &tagData           = port.tagReader().get();
     const auto &readPosition      = port.streamReader().position();
-    const auto  future_tags_begin = std::find_if(tagData.begin(), tagData.end(), [&readPosition](const auto &tag) noexcept { return tag.index > readPosition + 1; });
+    const auto  future_tags_begin = std::ranges::find_if(tagData, [&readPosition](const auto &tag) noexcept { return tag.index > readPosition + 1; });
 
     if (future_tags_begin == tagData.begin()) {
         const auto        first_future_tag_index   = static_cast<std::size_t>(future_tags_begin->index);
diff --git a/include/port_traits.hpp b/include/port_traits.hpp
index 9ae32d5c8..11b9b7d1e 100644
--- a/include/port_traits.hpp
+++ b/include/port_traits.hpp
@@ -8,11 +8,11 @@ namespace fair::graph::traits::port {
 
 template<typename T>
 concept has_fixed_info_v = requires {
-                                    typename T::value_type;
-                                    { T::static_name() };
-                                    { T::direction() } -> std::same_as<port_direction_t>;
-                                    { T::type() } -> std::same_as<port_type_t>;
-                                };
+    typename T::value_type;
+    { T::static_name() };
+    { T::direction() } -> std::same_as<port_direction_t>;
+    { T::type() } -> std::same_as<port_type_t>;
+};
 
 template<typename T>
 using has_fixed_info = std::integral_constant<bool, has_fixed_info_v<T>>;
@@ -43,25 +43,15 @@ using is_output = std::integral_constant<bool, Port::direction() == port_directi
 template<typename Port>
 concept is_output_v = is_output<Port>::value;
 
-template <typename Type>
+template<typename Type>
 concept is_port_v = is_output_v<Type> || is_input_v<Type>;
 
 template<typename... Ports>
-struct min_samples : std::integral_constant<std::size_t, std::max({ min_samples<Ports>::value... })> {};
-
-template<typename T, fixed_string PortName, port_type_t PortType, port_direction_t PortDirection,
-         std::size_t MIN_SAMPLES, std::size_t MAX_SAMPLES, gr::Buffer BufferType>
-struct min_samples<fair::graph::port<T, PortName, PortType, PortDirection, MIN_SAMPLES, MAX_SAMPLES, BufferType>>
-    : std::integral_constant<std::size_t, MIN_SAMPLES> {};
+struct min_samples : std::integral_constant<std::size_t, std::max({ Ports::RequiredSamples::MinSamples... })> {};
 
 template<typename... Ports>
-struct max_samples : std::integral_constant<std::size_t, std::min({ max_samples<Ports>::value... })> {};
-
-template<typename T, fixed_string PortName, port_type_t PortType, port_direction_t PortDirection,
-         std::size_t MIN_SAMPLES, std::size_t MAX_SAMPLES, gr::Buffer BufferType>
-struct max_samples<fair::graph::port<T, PortName, PortType, PortDirection, MIN_SAMPLES, MAX_SAMPLES, BufferType>>
-    : std::integral_constant<std::size_t, MAX_SAMPLES> {};
+struct max_samples : std::integral_constant<std::size_t, std::max({ Ports::RequiredSamples::MaxSamples... })> {};
 
-} // namespace port
+} // namespace fair::graph::traits::port
 
 #endif // include guard
diff --git a/include/typelist.hpp b/include/typelist.hpp
index 749fb18b6..bf789677a 100644
--- a/include/typelist.hpp
+++ b/include/typelist.hpp
@@ -428,6 +428,9 @@ struct typelist {
     }())>;
 };
 
+template<typename T, typename... Ts>
+constexpr bool is_any_of_v = std::disjunction_v<std::is_same<T, Ts>...>;
+
 namespace detail {
 template<template<typename...> typename OtherTypelist, typename... Args>
 meta::typelist<Args...>
diff --git a/include/utils.hpp b/include/utils.hpp
index 778cdffcc..32316d5c2 100644
--- a/include/utils.hpp
+++ b/include/utils.hpp
@@ -104,6 +104,44 @@ operator+(const fixed_string<CharT, N1> &lhs, const fixed_string<CharT, N2> &rhs
     return result;
 }
 
+namespace detail {
+constexpr int
+log10(int n) noexcept {
+    if (n < 10) return 0;
+    return 1 + log10(n / 10);
+}
+
+constexpr int
+pow10(int n) noexcept {
+    if (n == 0) return 1;
+    return 10 * pow10(n - 1);
+}
+
+template<int N, std::size_t... Idx>
+constexpr fixed_string<char, sizeof...(Idx)>
+make_fixed_string_impl(std::index_sequence<Idx...>) {
+    constexpr auto numDigits = sizeof...(Idx);
+    return { { ('0' + (N / pow10(numDigits - Idx - 1) % 10))..., 0 } };
+}
+} // namespace detail
+
+template<int N>
+constexpr auto
+make_fixed_string() noexcept {
+    if constexpr (N == 0) {
+        return fixed_string{ "0" };
+    } else {
+        constexpr std::size_t digits = 1U + static_cast<std::size_t>(detail::log10(N));
+        return detail::make_fixed_string_impl<N>(std::make_index_sequence<digits>());
+    }
+}
+
+static_assert(fixed_string("0") == make_fixed_string<0>());
+static_assert(fixed_string("1") == make_fixed_string<1>());
+static_assert(fixed_string("2") == make_fixed_string<2>());
+static_assert(fixed_string("123") == make_fixed_string<123>());
+static_assert((fixed_string("out") + make_fixed_string<123>()) == fixed_string("out123"));
+
 template<typename T>
 [[nodiscard]] std::string
 type_name() noexcept {
diff --git a/src/main.cpp b/src/main.cpp
index 5b1dbe313..c2d086f0f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -8,26 +8,34 @@
 namespace fg = fair::graph;
 
 template<typename T>
-class count_source : public fg::node<count_source<T>, fg::OUT<T, 0, std::numeric_limits<std::size_t>::max(), "random">> {
-public:
+struct count_source : public fg::node<count_source<T>> {
+    fg::PortOut<T> random;
+
     constexpr T
     process_one() {
         return 42;
     }
 };
 
+ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T), (count_source<T>), random);
+
 template<typename T>
-class expect_sink : public fg::node<expect_sink<T>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "sink">> {
-public:
+struct expect_sink : public fg::node<expect_sink<T>> {
+    fg::PortIn<T> sink;
+
     void
     process_one(T value) {
         std::cout << value << std::endl;
     }
 };
 
+ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T), (expect_sink<T>), sink);
+
 template<typename T, T Scale, typename R = decltype(std::declval<T>() * std::declval<T>())>
-class scale : public fg::node<scale<T, Scale, R>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "original">, fg::OUT<R, 0, std::numeric_limits<std::size_t>::max(), "scaled">> {
-public:
+struct scale : public fg::node<scale<T, Scale, R>> {
+    fg::PortIn<T>  original;
+    fg::PortOut<R> scaled;
+
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr auto
     process_one(V a) const noexcept {
@@ -35,9 +43,14 @@ class scale : public fg::node<scale<T, Scale, R>, fg::IN<T, 0, std::numeric_limi
     }
 };
 
+ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T, T Scale, typename R), (scale<T, Scale, R>), original, scaled);
+
 template<typename T, typename R = decltype(std::declval<T>() + std::declval<T>())>
-class adder : public fg::node<adder<T>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "addend0">, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "addend1">, fg::OUT<R, 0, std::numeric_limits<std::size_t>::max(), "sum">> {
-public:
+struct adder : public fg::node<adder<T>> {
+    fg::PortIn<T>  addend0;
+    fg::PortIn<T>  addend1;
+    fg::PortOut<R> sum;
+
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr auto
     process_one(V a, V b) const noexcept {
@@ -45,31 +58,35 @@ class adder : public fg::node<adder<T>, fg::IN<T, 0, std::numeric_limits<std::si
     }
 };
 
+ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T, typename R), (adder<T, R>), addend0, addend1, sum);
+
+using fg::port_type_t::STREAM, fg::port_direction_t::INPUT, fg::port_direction_t::OUTPUT;
+
 template<typename T, std::size_t Count = 2>
-class duplicate : public fg::node<duplicate<T, Count>, fair::meta::typelist<fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "in">>, fg::repeated_ports<Count, T, "out", fg::port_type_t::STREAM, fg::port_direction_t::OUTPUT>> {
-    using base = fg::node<duplicate<T, Count>, fair::meta::typelist<fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "in">>, fg::repeated_ports<Count, T, "out", fg::port_type_t::STREAM, fg::port_direction_t::OUTPUT>>;
+class duplicate : public fg::node<duplicate<T, Count>, fair::meta::typelist<fg::PortInNamed<T, "in">>, fg::repeated_ports<Count, T, "out", STREAM, OUTPUT>> {
+    using base = fg::node<duplicate<T, Count>, fair::meta::typelist<fg::PortInNamed<T, "in">>, fg::repeated_ports<Count, T, "out", STREAM, OUTPUT>>;
 
 public:
     using return_type = typename fg::traits::node::return_type<base>;
 
     [[nodiscard]] constexpr return_type
     process_one(T a) const noexcept {
-        return [&a]<std::size_t... Is>(std::index_sequence<Is...>) { return std::make_tuple(((void) Is, a)...); }
-        (std::make_index_sequence<Count>());
+        return [&a]<std::size_t... Is>(std::index_sequence<Is...>) { return std::make_tuple(((void) Is, a)...); }(std::make_index_sequence<Count>());
     }
 };
 
 template<typename T, std::size_t Depth>
     requires(Depth > 0)
-class delay : public fg::node<delay<T, Depth>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "in">, fg::OUT<T, 0, std::numeric_limits<std::size_t>::max(), "out">> {
+struct delay : public fg::node<delay<T, Depth>> {
+    fg::PortIn<T>        in;
+    fg::PortOut<T>       out;
     std::array<T, Depth> buffer = {};
     int                  pos    = 0;
 
-public:
     [[nodiscard]] constexpr T
-    process_one(T in) noexcept {
+    process_one(T val) noexcept {
         T ret       = buffer[pos];
-        buffer[pos] = in;
+        buffer[pos] = val;
         if (pos == Depth - 1) {
             pos = 0;
         } else {
@@ -79,6 +96,8 @@ class delay : public fg::node<delay<T, Depth>, fg::IN<T, 0, std::numeric_limits<
     }
 };
 
+ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T, std::size_t Depth), (delay<T, Depth>), in, out);
+
 int
 main() {
     using fg::merge;
diff --git a/test/blocklib/core/fft/fft.hpp b/test/blocklib/core/fft/fft.hpp
index eb946622b..a9920cfd9 100644
--- a/test/blocklib/core/fft/fft.hpp
+++ b/test/blocklib/core/fft/fft.hpp
@@ -114,8 +114,8 @@ struct fft : node<fft<T>> {
     using OutUniquePtr  = typename fftw<T>::OutUniquePtr;
     using PlanUniquePtr = typename fftw<T>::PlanUniquePtr;
 
-    IN<T>                         in;
-    OUT<DataSet<U>>               out;
+    PortIn<T>                     in;
+    PortOut<DataSet<U>>           out;
 
     std::size_t                   fftSize{ 1024 };
     int                           window{ static_cast<int>(WindowFunction::None) };
diff --git a/test/blocklib/core/filter/time_domain_filter.hpp b/test/blocklib/core/filter/time_domain_filter.hpp
index 04d9426ea..470073437 100644
--- a/test/blocklib/core/filter/time_domain_filter.hpp
+++ b/test/blocklib/core/filter/time_domain_filter.hpp
@@ -17,8 +17,8 @@ struct fir_filter : node<fir_filter<T>, Doc<R""(
 The transfer function of an FIR filter is given by:
 H(z) = b[0] + b[1]*z^-1 + b[2]*z^-2 + ... + b[N]*z^-N
 )"">> {
-    IN<T>             in;
-    OUT<T>            out;
+    PortIn<T>         in;
+    PortOut<T>        out;
     std::vector<T>    b{}; // feedforward coefficients
     history_buffer<T> inputHistory{ 32 };
 
@@ -51,8 +51,8 @@ struct iir_filter : node<iir_filter<T, form>, Doc<R""(
 b are the feed-forward coefficients (N.B. b[0] denoting the newest and n[-1] the previous sample)
 a are the feedback coefficients
 )"">> {
-    IN<T>             in;
-    OUT<T>            out;
+    PortIn<T>         in;
+    PortOut<T>        out;
     std::vector<T>    b{ 1 }; // feed-forward coefficients
     std::vector<T>    a{ 1 }; // feedback coefficients
     history_buffer<T> inputHistory{ 32 };
diff --git a/test/blocklib/core/sources/clock_source.hpp b/test/blocklib/core/sources/clock_source.hpp
index b87e0c236..cf534e7e6 100644
--- a/test/blocklib/core/sources/clock_source.hpp
+++ b/test/blocklib/core/sources/clock_source.hpp
@@ -30,7 +30,7 @@ ClockSource Documentation -- add here
 )"">> {
     std::chrono::time_point<ClockSourceType> nextTimePoint = ClockSourceType::now();
     //
-    OUT<T>             out;
+    PortOut<T>         out;
     std::vector<tag_t> tags{};
     std::size_t        next_tag{ 0 };
     //
diff --git a/test/blocklib/core/unit-test/common_nodes.hpp b/test/blocklib/core/unit-test/common_nodes.hpp
index 2fc2f9794..1b95a9b89 100644
--- a/test/blocklib/core/unit-test/common_nodes.hpp
+++ b/test/blocklib/core/unit-test/common_nodes.hpp
@@ -17,8 +17,8 @@ class builtin_multiply : public fair::graph::node<builtin_multiply<T>> {
     T _factor = static_cast<T>(1.0f);
 
 public:
-    fair::graph::IN<T>  in;
-    fair::graph::OUT<T> out;
+    fair::graph::PortIn<T>  in;
+    fair::graph::PortOut<T> out;
 
     builtin_multiply() = delete;
 
@@ -40,10 +40,10 @@ ENABLE_REFLECTION_FOR_TEMPLATE(builtin_multiply, in, out);
 template<typename T>
 class builtin_counter : public fair::graph::node<builtin_counter<T>> {
 public:
-    static std::size_t  s_event_count;
+    static std::size_t      s_event_count;
 
-    fair::graph::IN<T>  in;
-    fair::graph::OUT<T> out;
+    fair::graph::PortIn<T>  in;
+    fair::graph::PortOut<T> out;
 
     [[nodiscard]] constexpr auto
     process_one(T a) const noexcept {
@@ -69,11 +69,11 @@ class multi_adder : public fair::graph::node_model {
     const std::string unique_name_ = fmt::format("multi_adder#{}", unique_id); // TODO: resolve symbol duplication
 
 protected:
-    using in_port_t = fair::graph::IN<T>;
+    using in_port_t = fair::graph::PortIn<T>;
     // std::list because ports don't like to change in-memory address
     // after connection is established, and vector might reallocate
-    std::list<in_port_t> _input_ports;
-    fair::graph::OUT<T>  _output_port;
+    std::list<in_port_t>    _input_ports;
+    fair::graph::PortOut<T> _output_port;
 
 protected:
     using setting_map                                      = std::map<std::string, int, std::less<>>;
diff --git a/test/blocklib/core/unit-test/tag_monitors.hpp b/test/blocklib/core/unit-test/tag_monitors.hpp
index 0abef7c4d..8bd958f5c 100644
--- a/test/blocklib/core/unit-test/tag_monitors.hpp
+++ b/test/blocklib/core/unit-test/tag_monitors.hpp
@@ -81,7 +81,7 @@ equal_tag_lists(const std::vector<tag_t> &tags1, const std::vector<tag_t> &tags2
 
 template<typename T, ProcessFunction UseProcessOne>
 struct TagSource : public node<TagSource<T, UseProcessOne>> {
-    OUT<T>             out;
+    PortOut<T>         out;
     std::vector<tag_t> tags{};
     std::size_t        next_tag{ 0 };
     std::int64_t       n_samples_max = 1024;
@@ -139,8 +139,8 @@ struct TagSource : public node<TagSource<T, UseProcessOne>> {
 
 template<typename T, ProcessFunction UseProcessOne>
 struct TagMonitor : public node<TagMonitor<T, UseProcessOne>> {
-    IN<T>              in;
-    OUT<T>             out;
+    PortIn<T>          in;
+    PortOut<T>         out;
     std::vector<tag_t> tags{};
     std::int64_t       n_samples_produced{ 0 };
 
@@ -179,7 +179,7 @@ struct TagMonitor : public node<TagMonitor<T, UseProcessOne>> {
 template<typename T, ProcessFunction UseProcessOne>
 struct TagSink : public node<TagSink<T, UseProcessOne>> {
     using ClockSourceType = std::chrono::system_clock;
-    IN<T>                                    in;
+    PortIn<T>                                in;
     std::vector<tag_t>                       tags{};
     std::int64_t                             n_samples_produced{ 0 };
     std::chrono::time_point<ClockSourceType> timeFirstSample = ClockSourceType::now();
diff --git a/test/plugins/good_base_plugin.cpp b/test/plugins/good_base_plugin.cpp
index f0931776a..bb54b165d 100644
--- a/test/plugins/good_base_plugin.cpp
+++ b/test/plugins/good_base_plugin.cpp
@@ -27,7 +27,7 @@ read_total_count(const fair::graph::property_map &params) {
 }
 
 template<typename T>
-class cout_sink : public fg::node<cout_sink<T>, fg::IN<T, 0, 1024, "in">> {
+class cout_sink : public fg::node<cout_sink<T>, fg::PortInNamed<T, "in">> {
 public:
     std::size_t total_count = -1_UZ;
 
@@ -45,7 +45,7 @@ class cout_sink : public fg::node<cout_sink<T>, fg::IN<T, 0, 1024, "in">> {
 };
 
 template<typename T>
-class fixed_source : public fg::node<fixed_source<T>, fg::OUT<T, 0, 1024, "out">> {
+class fixed_source : public fg::node<fixed_source<T>, fg::PortOutNamed<T, "out">> {
 public:
     std::size_t event_count = -1_UZ; // infinite count by default
 
diff --git a/test/plugins/good_conversion_plugin.cpp b/test/plugins/good_conversion_plugin.cpp
index ac99acdb4..1d779d9a5 100644
--- a/test/plugins/good_conversion_plugin.cpp
+++ b/test/plugins/good_conversion_plugin.cpp
@@ -11,8 +11,8 @@ namespace fg = fair::graph;
 template<typename From, typename To>
 class convert : public fg::node<convert<From, To>> {
 public:
-    fg::IN<From> in;
-    fg::OUT<To>  out;
+    fg::PortIn<From> in;
+    fg::PortOut<To>  out;
 
     [[nodiscard]] constexpr auto
     process_one(From value) const noexcept {
diff --git a/test/plugins/good_math_plugin.cpp b/test/plugins/good_math_plugin.cpp
index ad96b0dba..49bd08121 100644
--- a/test/plugins/good_math_plugin.cpp
+++ b/test/plugins/good_math_plugin.cpp
@@ -28,8 +28,8 @@ class math_base {
     T _factor = static_cast<T>(1.0f);
 
 public:
-    fg::IN<T, 0, 1024>  in;
-    fg::OUT<T, 0, 1024> out;
+    fg::PortIn<T, fg::RequiredSamples<1, 1024>>  in;
+    fg::PortOut<T, fg::RequiredSamples<1, 1024>> out;
 
     math_base() = delete;
 
diff --git a/test/qa_data_sink.cpp b/test/qa_data_sink.cpp
index 78b14e47d..a6b8154cb 100644
--- a/test/qa_data_sink.cpp
+++ b/test/qa_data_sink.cpp
@@ -37,7 +37,7 @@ namespace fair::graph::data_sink_test {
 
 template<typename T>
 struct Source : public node<Source<T>> {
-    OUT<T>             out;
+    PortOut<T>         out;
     std::int32_t       n_samples_produced = 0;
     std::int32_t       n_samples_max      = 1024;
     std::size_t        n_tag_offset       = 0;
@@ -322,7 +322,7 @@ const boost::ut::suite DataSinkTests = [] {
 
         expect(eq(connection_result_t::SUCCESS, flow_graph.connect<"out">(src).to<"in">(sink)));
 
-        auto                     poller_data_only = data_sink_registry::instance().get_streaming_poller<float>(data_sink_query::sink_name("test_sink"), blocking_mode::Blocking);
+        auto poller_data_only = data_sink_registry::instance().get_streaming_poller<float>(data_sink_query::sink_name("test_sink"), blocking_mode::Blocking);
         expect(neq(poller_data_only, nullptr));
 
         auto poller_with_tags = data_sink_registry::instance().get_streaming_poller<float>(data_sink_query::sink_name("test_sink"), blocking_mode::Blocking);
diff --git a/test/qa_dynamic_node.cpp b/test/qa_dynamic_node.cpp
index 3a96bcbe3..47fb475be 100644
--- a/test/qa_dynamic_node.cpp
+++ b/test/qa_dynamic_node.cpp
@@ -10,7 +10,7 @@ template<typename T>
 std::atomic_size_t multi_adder<T>::_unique_id_counter = 0;
 
 template<typename T>
-struct fixed_source : public fg::node<fixed_source<T>, fg::OUT<T, 0, 1024, "out">> {
+struct fixed_source : public fg::node<fixed_source<T>, fg::PortOutNamed<T, "out">> {
     T value = 1;
 
     fg::work_return_t
@@ -30,7 +30,7 @@ struct fixed_source : public fg::node<fixed_source<T>, fg::OUT<T, 0, 1024, "out"
 static_assert(fair::graph::NodeType<fixed_source<int>>);
 
 template<typename T>
-struct cout_sink : public fg::node<cout_sink<T>, fg::IN<T, 0, 1024, "in">> {
+struct cout_sink : public fg::node<cout_sink<T>, fg::PortInNamed<T, "in">> {
     std::size_t remaining = 0;
 
     void
diff --git a/test/qa_dynamic_port.cpp b/test/qa_dynamic_port.cpp
index 108ba81cf..576eb89d7 100644
--- a/test/qa_dynamic_port.cpp
+++ b/test/qa_dynamic_port.cpp
@@ -29,8 +29,8 @@ class dynamic_node : public fg::node<dynamic_node> {
 template<typename T, T Scale, typename R = decltype(std::declval<T>() * std::declval<T>())>
 class scale : public fg::node<scale<T, Scale, R>> {
 public:
-    fg::IN<T>  original;
-    fg::OUT<R> scaled;
+    fg::PortIn<T>  original;
+    fg::PortOut<R> scaled;
 
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr auto
@@ -44,9 +44,9 @@ ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T, T Scale, typename R), (scale<T,
 template<typename T, typename R = decltype(std::declval<T>() + std::declval<T>())>
 class adder : public fg::node<adder<T>> {
 public:
-    fg::IN<T>  addend0;
-    fg::IN<T>  addend1;
-    fg::OUT<T> sum;
+    fg::PortIn<T>  addend0;
+    fg::PortIn<T>  addend1;
+    fg::PortOut<T> sum;
 
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr auto
@@ -60,7 +60,7 @@ ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T, typename R), (adder<T, R>), add
 template<typename T>
 class cout_sink : public fg::node<cout_sink<T>> {
 public:
-    fg::IN<T> sink;
+    fg::PortIn<T> sink;
 
     void
     process_one(T value) {
@@ -74,8 +74,8 @@ ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T), (cout_sink<T>), sink);
 template<typename T, T val, std::size_t count = 10_UZ>
 class repeater_source : public fg::node<repeater_source<T, val>> {
 public:
-    fg::OUT<T>  value;
-    std::size_t _counter = 0;
+    fg::PortOut<T> value;
+    std::size_t    _counter = 0;
 
     fair::graph::work_return_t
     work(std::size_t requested_work) {
@@ -103,24 +103,33 @@ const boost::ut::suite PortApiTests = [] {
     using namespace fair::graph;
 
     "PortApi"_test = [] {
-        static_assert(Port<IN<float, 0, 0, "in">>);
-        static_assert(Port<decltype(IN<float>("in"))>);
-        static_assert(Port<OUT<float, 0, 0, "out">>);
-        static_assert(Port<IN_MSG<float, 0, 0, "in_msg">>);
-        static_assert(Port<OUT_MSG<float, 0, 0, "out_msg">>);
-
-        static_assert(IN<float, 0, 0, "in">::static_name() == fixed_string("in"));
-        static_assert(requires { IN<float>("in").name; });
+        static_assert(PortType<PortIn<float>>);
+        static_assert(PortType<decltype(PortIn<float>())>);
+        static_assert(PortType<PortOut<float>>);
+        static_assert(PortType<MsgPortIn<float>>);
+        static_assert(PortType<MsgPortOut<float>>);
+
+        static_assert(PortType<PortInNamed<float, "in">>);
+        static_assert(PortType<decltype(PortInNamed<float, "">("in"))>);
+        static_assert(PortType<PortOutNamed<float, "out">>);
+        static_assert(PortType<MsgPortInNamed<"in_msg">>);
+        static_assert(PortType<MsgPortOutNamed<"out_msg">>);
+
+        static_assert(PortIn<float, RequiredSamples<1, 2>>::Required::MinSamples == 1);
+        static_assert(PortIn<float, RequiredSamples<1, 2>>::Required::MaxSamples == 2);
+        static_assert(PortIn<float>::direction() == port_direction_t::INPUT);
+        static_assert(PortOut<float>::direction() == port_direction_t::OUTPUT);
     };
 
     "PortBufferApi"_test = [] {
-        OUT<float, 0, std::numeric_limits<std::size_t>::max(), "out0"> output_port;
-        BufferWriter auto                                             &writer = output_port.streamWriter();
+        PortOut<float>     output_port;
+        BufferWriter auto &writer = output_port.streamWriter();
         // BufferWriter auto                                             &tagWriter = output_port.tagWriter();
         expect(ge(writer.available(), 32_UZ));
 
-        IN<float, 0, std::numeric_limits<std::size_t>::max(), "int0"> input_port;
-        const BufferReader auto                                      &reader = input_port.streamReader();
+        using ExplicitUnlimitedSize = RequiredSamples<1, std::numeric_limits<std::size_t>::max()>;
+        PortIn<float, ExplicitUnlimitedSize> input_port;
+        const BufferReader auto             &reader = input_port.streamReader();
         expect(eq(reader.available(), 0_UZ));
         auto buffers = output_port.buffer();
         input_port.setBuffer(buffers.streamBuffer, buffers.tagBufferType);
@@ -139,9 +148,10 @@ const boost::ut::suite PortApiTests = [] {
 
     "RuntimePortApi"_test = [] {
         // declare in block
-        OUT<float, 0, std::numeric_limits<std::size_t>::max(), "out"> out;
-        IN<float, 0, std::numeric_limits<std::size_t>::max(), "in">   in;
-        std::vector<dynamic_port>                                     port_list;
+        using ExplicitUnlimitedSize = RequiredSamples<1, std::numeric_limits<std::size_t>::max()>;
+        PortOut<float, ExplicitUnlimitedSize> out;
+        PortIn<float, ExplicitUnlimitedSize>  in;
+        std::vector<dynamic_port>             port_list;
 
         port_list.emplace_back(out);
         port_list.emplace_back(in);
diff --git a/test/qa_fft.cpp b/test/qa_fft.cpp
index 62df8365c..87b978da9 100644
--- a/test/qa_fft.cpp
+++ b/test/qa_fft.cpp
@@ -17,9 +17,9 @@ namespace fg = fair::graph;
 
 template<typename T>
 struct CountSource : public fg::node<CountSource<T>> {
-    fg::OUT<T> out{};
-    int        count{ 0 };
-    int        nSamples{ 1024 };
+    fg::PortOut<T> out{};
+    int            count{ 0 };
+    int            nSamples{ 1024 };
 
     constexpr std::make_signed_t<std::size_t>
     available_samples(const CountSource & /*d*/) noexcept {
diff --git a/test/qa_hier_node.cpp b/test/qa_hier_node.cpp
index efe942a98..a8e8c174e 100644
--- a/test/qa_hier_node.cpp
+++ b/test/qa_hier_node.cpp
@@ -6,7 +6,7 @@
 namespace fg = fair::graph;
 
 template<typename T, typename R = decltype(std::declval<T>() * std::declval<T>())>
-struct scale : public fg::node<scale<T, R>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "original">, fg::OUT<R, 0, std::numeric_limits<std::size_t>::max(), "scaled">> {
+struct scale : public fg::node<scale<T, R>, fg::PortInNamed<T, "original">, fg::PortOutNamed<R, "scaled">> {
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr auto
     process_one(V a) const noexcept {
@@ -15,8 +15,7 @@ struct scale : public fg::node<scale<T, R>, fg::IN<T, 0, std::numeric_limits<std
 };
 
 template<typename T, typename R = decltype(std::declval<T>() + std::declval<T>())>
-struct adder : public fg::node<adder<T>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "addend0">, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "addend1">,
-                               fg::OUT<R, 0, std::numeric_limits<std::size_t>::max(), "sum">> {
+struct adder : public fg::node<adder<T>, fg::PortInNamed<T, "addend0">, fg::PortInNamed<T, "addend1">, fg::PortOutNamed<R, "sum">> {
     template<fair::meta::t_or_simd<T> V>
     [[nodiscard]] constexpr auto
     process_one(V a, V b) const noexcept {
@@ -42,7 +41,7 @@ class hier_node : public fg::node_model {
     std::vector<fg::property_map>      _tags_at_output;
     std::unique_ptr<fg::settings_base> _settings = std::make_unique<fg::basic_settings<hier_node<T>>>(*this);
 
-    using in_port_t                              = fg::IN<T>;
+    using in_port_t                              = fg::PortIn<T>;
 
     fg::scheduler::simple<> _scheduler;
 
@@ -136,17 +135,17 @@ template<typename T>
 std::atomic_size_t hier_node<T>::_unique_id_counter = 0;
 
 template<typename T>
-struct fixed_source : public fg::node<fixed_source<T>, fg::OUT<T, 0, 1024, "out">> {
-    std::size_t remaining_events_count;
+struct fixed_source : public fg::node<fixed_source<T>> {
+    fg::PortOut<T, fg::RequiredSamples<1, 1024>> out;
+    std::size_t                                  remaining_events_count;
 
-    T           value = 1;
+    T                                            value = 1;
 
     fg::work_return_t
     work(std::size_t requested_work) {
         if (remaining_events_count != 0) {
             using namespace fair::literals;
-            auto &port   = fg::output_port<0>(this);
-            auto &writer = port.streamWriter();
+            auto &writer = out.streamWriter();
             auto  data   = writer.reserve_output_range(1_UZ);
             data[0]      = value;
             data.publish(1_UZ);
@@ -165,11 +164,12 @@ struct fixed_source : public fg::node<fixed_source<T>, fg::OUT<T, 0, 1024, "out"
     }
 };
 
-ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T), (fixed_source<T>), remaining_events_count);
+ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T), (fixed_source<T>), out, remaining_events_count);
 
 template<typename T>
-struct cout_sink : public fg::node<cout_sink<T>, fg::IN<T, 0, 1024, "in">> {
-    std::size_t remaining = 0;
+struct cout_sink : public fg::node<cout_sink<T>> {
+    fg::PortIn<T, fg::RequiredSamples<1, 1024>> in;
+    std::size_t                                 remaining = 0;
 
     void
     process_one(T value) {
@@ -180,7 +180,7 @@ struct cout_sink : public fg::node<cout_sink<T>, fg::IN<T, 0, 1024, "in">> {
     }
 };
 
-ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T), (cout_sink<T>), remaining);
+ENABLE_REFLECTION_FOR_TEMPLATE_FULL((typename T), (cout_sink<T>), in, remaining);
 
 fg::graph
 make_graph(std::size_t events_count) {
diff --git a/test/qa_node.cpp b/test/qa_node.cpp
index ff7b80252..11be29bc9 100644
--- a/test/qa_node.cpp
+++ b/test/qa_node.cpp
@@ -63,9 +63,9 @@ struct StrideTestData {
 
 template<typename T>
 struct CountSource : public fg::node<CountSource<T>> {
-    fg::OUT<T> out{};
-    int        count{ 0 };
-    int        n_samples{ 1024 };
+    fg::PortOut<T> out{};
+    int            count{ 0 };
+    int            n_samples{ 1024 };
 
     constexpr std::make_signed_t<std::size_t>
     available_samples(const CountSource & /*d*/) noexcept {
@@ -81,11 +81,11 @@ struct CountSource : public fg::node<CountSource<T>> {
 
 template<typename T>
 struct IntDecBlock : public fg::node<IntDecBlock<T>, fg::PerformDecimationInterpolation, fg::PerformStride> {
-    fg::IN<T>     in{};
-    fg::OUT<T>    out{};
+    fg::PortIn<T>  in{};
+    fg::PortOut<T> out{};
 
-    ProcessStatus status{};
-    bool          write_to_vector{ false };
+    ProcessStatus  status{};
+    bool           write_to_vector{ false };
 
     fg::work_return_status_t
     process_bulk(std::span<const T> input, std::span<T> output) noexcept {
diff --git a/test/qa_plugins_test.cpp b/test/qa_plugins_test.cpp
index ab7124f40..3fe538804 100644
--- a/test/qa_plugins_test.cpp
+++ b/test/qa_plugins_test.cpp
@@ -40,8 +40,8 @@ class builtin_multiply : public fg::node<builtin_multiply<T>> {
     T _factor = static_cast<T>(1.0f);
 
 public:
-    fg::IN<T>  in;
-    fg::OUT<T> out;
+    fg::PortIn<T>  in;
+    fg::PortOut<T> out;
 
     builtin_multiply() = delete;
 
diff --git a/test/qa_scheduler.cpp b/test/qa_scheduler.cpp
index 65a64a285..0aba69306 100644
--- a/test/qa_scheduler.cpp
+++ b/test/qa_scheduler.cpp
@@ -34,7 +34,7 @@ class tracer {
 
 // define some example graph nodes
 template<typename T, std::size_t N>
-class count_source : public fg::node<count_source<T, N>, fg::OUT<T, 0, std::numeric_limits<std::size_t>::max(), "out">> {
+class count_source : public fg::node<count_source<T, N>, fg::PortOutNamed<T, "out">> {
     tracer     &_tracer;
     std::size_t _count = 0;
 
@@ -57,7 +57,7 @@ class count_source : public fg::node<count_source<T, N>, fg::OUT<T, 0, std::nume
 static_assert(fg::NodeType<count_source<float, 10U>>);
 
 template<typename T, std::int64_t N>
-class expect_sink : public fg::node<expect_sink<T, N>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "in">> {
+class expect_sink : public fg::node<expect_sink<T, N>, fg::PortInNamed<T, "in">> {
     tracer                                         &_tracer;
     std::int64_t                                    _count = 0;
     std::function<void(std::int64_t, std::int64_t)> _checker;
@@ -84,7 +84,7 @@ class expect_sink : public fg::node<expect_sink<T, N>, fg::IN<T, 0, std::numeric
 };
 
 template<typename T, T Scale, typename R = decltype(std::declval<T>() * std::declval<T>())>
-class scale : public fg::node<scale<T, Scale, R>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "original">, fg::OUT<R, 0, std::numeric_limits<std::size_t>::max(), "scaled">> {
+class scale : public fg::node<scale<T, Scale, R>, fg::PortInNamed<T, "original">, fg::PortOutNamed<R, "scaled">> {
     tracer &_tracer;
 
 public:
@@ -99,8 +99,7 @@ class scale : public fg::node<scale<T, Scale, R>, fg::IN<T, 0, std::numeric_limi
 };
 
 template<typename T, typename R = decltype(std::declval<T>() + std::declval<T>())>
-class adder : public fg::node<adder<T>, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "addend0">, fg::IN<T, 0, std::numeric_limits<std::size_t>::max(), "addend1">,
-                              fg::OUT<R, 0, std::numeric_limits<std::size_t>::max(), "sum">> {
+class adder : public fg::node<adder<T>, fg::PortInNamed<T, "addend0">, fg::PortInNamed<T, "addend1">, fg::PortOutNamed<R, "sum">> {
     tracer &_tracer;
 
 public:
diff --git a/test/qa_settings.cpp b/test/qa_settings.cpp
index 314f9c59a..61be8773c 100644
--- a/test/qa_settings.cpp
+++ b/test/qa_settings.cpp
@@ -85,7 +85,7 @@ printChanges(const property_map &oldMap, const property_map &newMap) noexcept {
 
 template<typename T>
 struct Source : public node<Source<T>> {
-    OUT<T>       out;
+    PortOut<T>   out;
     std::int32_t n_samples_produced = 0;
     std::int32_t n_samples_max      = 1024;
     std::int32_t n_tag_offset       = 0;
@@ -121,8 +121,8 @@ some test doc documentation
 
 template<typename T>
 struct TestBlock : public node<TestBlock<T>, BlockingIO<true>, TestBlockDoc, SupportedTypes<float, double>> {
-    IN<T>  in{};
-    OUT<T> out{};
+    PortIn<T>  in{};
+    PortOut<T> out{};
     // parameters
     A<T, "scaling factor", Visible, Doc<"y = a * x">, Unit<"As">>                    scaling_factor = static_cast<T>(1); // N.B. unit 'As' = 'Coulomb'
     A<std::string, "context information", Visible>                                   context{};
@@ -165,8 +165,8 @@ template<typename T, bool Average = false>
 struct Decimate : public node<Decimate<T, Average>, SupportedTypes<float, double>, PerformDecimationInterpolation, Doc<R""(
 @brief reduces sample rate by given fraction controlled by denominator
 )"">> {
-    IN<T>                            in{};
-    OUT<T>                           out{};
+    PortIn<T>                        in{};
+    PortOut<T>                       out{};
     A<float, "sample rate", Visible> sample_rate = 1.f;
 
     void
@@ -205,7 +205,7 @@ static_assert(NodeType<Decimate<double>>);
 
 template<typename T>
 struct Sink : public node<Sink<T>> {
-    IN<T>        in;
+    PortIn<T>    in;
     std::int32_t n_samples_consumed = 0;
     std::int32_t n_samples_max      = -1;
     int64_t      last_tag_position  = -1;