diff --git a/include/Xsmp/Array.h b/include/Xsmp/Array.h
index bc3d5dd..86009d9 100644
--- a/include/Xsmp/Array.h
+++ b/include/Xsmp/Array.h
@@ -41,7 +41,7 @@ template <typename Tp> struct _array_traits<Tp, 0> {
   // Empty type used instead of Tp[0] for Xsmp::Array<Tp, 0>.
   struct type {
     // Indexing is undefined.
-    Tp &operator[](std::size_t) const noexcept { std::abort(); }
+    Tp &operator[](size_t) const noexcept { std::abort(); }
 
     // Conversion to a pointer produces a null pointer.
     constexpr explicit operator Tp *() const noexcept { return nullptr; }
@@ -68,7 +68,7 @@ template <typename Tp, std::size_t Nm, typename... options> struct Array {
   using const_reference = const value_type &;
   using iterator = value_type *;
   using const_iterator = const value_type *;
-  using size_type = std::size_t;
+  using size_type = size_t;
   using difference_type = std::ptrdiff_t;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
diff --git a/include/Xsmp/Collection.h b/include/Xsmp/Collection.h
index 954b0c9..9847910 100644
--- a/include/Xsmp/Collection.h
+++ b/include/Xsmp/Collection.h
@@ -21,7 +21,7 @@
 #include <Xsmp/Exception.h>
 #include <Xsmp/Object.h>
 #include <algorithm>
-#include <stddef.h>
+#include <cstddef>
 #include <string_view>
 #include <unordered_map>
 #include <vector>
@@ -64,15 +64,11 @@ template <typename T> class AbstractCollection : public ::Smp::ICollection<T> {
 
   /// Get the begin iterator
   /// @return Begin iterator
-  const_iterator begin() const override {
-    return AbstractCollection<T>::const_iterator(*this, 0);
-  }
+  const_iterator begin() const override { return {*this, 0}; }
 
   /// Get the end iterator
   /// @return End iterator
-  const_iterator end() const override {
-    return AbstractCollection<T>::const_iterator(*this, _vector.size());
-  }
+  const_iterator end() const override { return {*this, _vector.size()}; }
 
   /// Add an element to the collection
   /// @param element The element to add to the collection.
@@ -172,13 +168,11 @@ class ContainingCollection final : public ::Xsmp::Object,
 
   /// Get the begin iterator
   /// @return Begin iterator
-  const_iterator begin() const override { return const_iterator(*this, 0); }
+  const_iterator begin() const override { return {*this, 0}; }
 
   /// Get the end iterator
   /// @return End iterator
-  const_iterator end() const override {
-    return const_iterator(*this, _vector.size());
-  }
+  const_iterator end() const override { return {*this, _vector.size()}; }
 
   /// Add an element to the collection
   /// @tparam U The type of the element to add
@@ -291,15 +285,11 @@ class DelegateCollection final : public ::Xsmp::detail::AbstractCollection<T> {
 
   /// Get the begin iterator
   /// @return Begin iterator
-  const_iterator begin() const override {
-    return DelegateCollection<T>::const_iterator(*this, 0);
-  }
+  const_iterator begin() const override { return {*this, 0}; }
 
   /// Get the end iterator
   /// @return End iterator
-  const_iterator end() const override {
-    return DelegateCollection<T>::const_iterator(*this, size());
-  }
+  const_iterator end() const override { return {*this, size()}; }
 
   ::Smp::String8 GetName() const override { return _delegate->GetName(); }
   ::Smp::String8 GetDescription() const override {
diff --git a/include/Xsmp/Component.h b/include/Xsmp/Component.h
index c25fcc2..e66b6de 100644
--- a/include/Xsmp/Component.h
+++ b/include/Xsmp/Component.h
@@ -242,6 +242,8 @@ class Component : public virtual ::Smp::ILinkingComponent,
                            const ::Smp::IComponent *target) noexcept;
   static void RemoveAggregateLinks(const ::Smp::IAggregate *aggregate,
                                    const ::Smp::IComponent *target) noexcept;
+  static void RemoveFieldLinks(::Smp::IField *field,
+                               const ::Smp::IComponent *target) noexcept;
 
   ::Xsmp::cstring _name;
   ::Xsmp::cstring _description;
diff --git a/include/Xsmp/Container.h b/include/Xsmp/Container.h
index 55c259e..7cbb031 100644
--- a/include/Xsmp/Container.h
+++ b/include/Xsmp/Container.h
@@ -21,7 +21,7 @@
 #include <Xsmp/Exception.h>
 #include <Xsmp/cstring.h>
 #include <algorithm>
-#include <stddef.h>
+#include <cstddef>
 #include <stdexcept>
 #include <string_view>
 #include <vector>
diff --git a/include/Xsmp/DateTime.h b/include/Xsmp/DateTime.h
index e094936..78a4d43 100644
--- a/include/Xsmp/DateTime.h
+++ b/include/Xsmp/DateTime.h
@@ -27,11 +27,13 @@ namespace Xsmp {
 
 /**
  * @class DateTime
- * @brief This class represents a point in time that can be manipulated and compared.
+ * @brief This class represents a point in time that can be manipulated and
+ * compared.
  *
- * The DateTime class provides functionality to manage time-related operations. It allows you to initialize
- * date and time objects, format them into strings, convert between different time representations,
- * perform arithmetic operations on dates and times, and output the formatted date and time values to streams.
+ * The DateTime class provides functionality to manage time-related operations.
+ * It allows you to initialize date and time objects, format them into strings,
+ * convert between different time representations, perform arithmetic operations
+ * on dates and times, and output the formatted date and time values to streams.
  */
 struct DateTime final {
 
diff --git a/include/Xsmp/Field.h b/include/Xsmp/Field.h
index 6b76577..5736905 100644
--- a/include/Xsmp/Field.h
+++ b/include/Xsmp/Field.h
@@ -40,7 +40,6 @@
 #include <Xsmp/cstring.h>
 #include <cstddef>
 #include <iterator>
-#include <set>
 #include <type_traits>
 #include <utility>
 
@@ -179,20 +178,47 @@ class IDataflowFieldExtension : public virtual ::Smp::IDataflowField {
 public:
   /// Virtual destructor to release memory.
   ~IDataflowFieldExtension() noexcept override = default;
+
   /// Disconnect this field to a target field for direct data flow.
   /// @param   target Target field to connect to. The field type must be
   ///          compatible.
-  virtual void Disconnect(::Smp::IField *target) = 0;
+  virtual void Disconnect(const ::Smp::IField *target) = 0;
+
+  virtual const ::Smp::FieldCollection *GetInputFields() const {
+    return nullptr;
+  };
+};
+
+class InputFieldCollection final : public ::Xsmp::Object,
+                                   public ::Smp::FieldCollection {
+public:
+  using ::Xsmp::Object::Object;
+  using const_iterator = typename ::Smp::FieldCollection::const_iterator;
+  using iterator = typename ::Smp::FieldCollection::iterator;
+  ::Smp::IField *at(::Smp::String8 name) const override;
+  ::Smp::IField *at(size_t index) const override;
+  size_t size() const override;
+  virtual bool empty() const;
+  const_iterator begin() const override;
+  const_iterator end() const override;
+  bool contains(const ::Smp::IField *input) const;
+  void add(::Smp::IField *input);
+  bool remove(const ::Smp::IField *input);
+
+private:
+  std::vector<::Smp::IField *> _fields;
 };
 class ArrayDataflowField : public virtual IDataflowFieldExtension,
                            public virtual ::Smp::IArrayField {
 public:
+  ArrayDataflowField();
   void Push() final;
   void Connect(::Smp::IField *target) final;
-  void Disconnect(::Smp::IField *target) final;
+  void Disconnect(const ::Smp::IField *target) final;
+  const ::Smp::FieldCollection *GetInputFields() const final;
 
 private:
-  std::set<::Smp::IArrayField *> _connectedFields;
+  InputFieldCollection _connectedFields;
   friend class ::Xsmp::detail::FieldHelper;
 };
 
@@ -203,10 +229,12 @@ using ArrayField = std::conditional_t<
 
 class SimpleConnectableField : public virtual ::Smp::ISimpleField {
 protected:
+  SimpleConnectableField();
   void internal_push() const;
+  const ::Smp::FieldCollection *GetInputFields() const;
 
 private:
-  std::set<::Smp::ISimpleField *> _connectedFields;
+  InputFieldCollection _connectedFields;
   friend class ::Xsmp::detail::FieldHelper;
 };
 class SimpleDataflowField : public virtual SimpleConnectableField,
@@ -214,7 +242,8 @@ class SimpleDataflowField : public virtual SimpleConnectableField,
 public:
   void Push() final;
   void Connect(::Smp::IField *target) final;
-  void Disconnect(::Smp::IField *target) final;
+  void Disconnect(const ::Smp::IField *target) final;
+  const ::Smp::FieldCollection *GetInputFields() const final;
 };
 template <typename... Annotations>
 using SimpleField = std::conditional_t<
@@ -226,10 +255,12 @@ using SimpleField = std::conditional_t<
 
 class SimpleArrayConnectableField : public virtual ::Smp::ISimpleArrayField {
 protected:
+  SimpleArrayConnectableField();
   void internal_push(::Smp::UInt64 index) const;
+  const ::Smp::FieldCollection *GetInputFields() const;
 
 private:
-  std::set<::Smp::ISimpleArrayField *> _connectedFields;
+  InputFieldCollection _connectedFields;
   friend class ::Xsmp::detail::FieldHelper;
 };
 
@@ -238,7 +269,8 @@ class SimpleArrayDataflowField : public virtual SimpleArrayConnectableField,
 public:
   void Push() final;
   void Connect(::Smp::IField *target) final;
-  void Disconnect(::Smp::IField *target) final;
+  void Disconnect(const ::Smp::IField *target) final;
+  const ::Smp::FieldCollection *GetInputFields() const final;
 };
 template <typename... Annotations>
 using SimpleArrayField = std::conditional_t<
@@ -291,12 +323,14 @@ class AbstractStructureField : public virtual ::Smp::IStructureField {
 class StructureDataflowField : public ::Xsmp::detail::AbstractStructureField,
                                public virtual IDataflowFieldExtension {
 public:
+  StructureDataflowField();
   void Push() final;
   void Connect(::Smp::IField *target) final;
-  void Disconnect(::Smp::IField *target) final;
+  void Disconnect(const ::Smp::IField *target) final;
+  const ::Smp::FieldCollection *GetInputFields() const final;
 
 private:
-  std::set<::Smp::IStructureField *> _connectedFields;
+  InputFieldCollection _connectedFields;
   friend class ::Xsmp::detail::FieldHelper;
 };
 template <typename... Annotations>
@@ -503,7 +537,7 @@ class ArrayField final
     : public ::Xsmp::detail::Field<T, Annotations...>,
       public virtual ::Xsmp::detail::ArrayField<Annotations...> {
 
-  static constexpr std::size_t _size = ::Xsmp::detail::FieldTypeHelper<T>::size;
+  static constexpr size_t _size = ::Xsmp::detail::FieldTypeHelper<T>::size;
 
   template <typename... Options> struct apply_options {
     template <typename U> struct on {
@@ -596,7 +630,7 @@ class ArrayField final
   using const_reference = const value_type &;
   using iterator = value_type *;
   using const_iterator = const value_type *;
-  using size_type = std::size_t;
+  using size_type = size_t;
   using difference_type = std::ptrdiff_t;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
@@ -687,7 +721,7 @@ class ArrayField final
   }
 
 private:
-  template <std::size_t... I>
+  template <size_t... I>
   ::Xsmp::Array<value_type, _size>
   create_array_impl(::Smp::Publication::ITypeRegistry *typeRegistry,
                     const T &value, std::index_sequence<I...>) {
@@ -711,7 +745,7 @@ class SimpleArrayField final
   static_assert(
       !::Xsmp::Annotation::any_of<::Xsmp::Annotation::forcible, Annotations...>,
       "A SimpleArrayField cannot be forcible.");
-  static constexpr std::size_t _size = ::Xsmp::detail::FieldTypeHelper<T>::size;
+  static constexpr size_t _size = ::Xsmp::detail::FieldTypeHelper<T>::size;
 
 public:
   SimpleArrayField(const SimpleArrayField &) = delete;
@@ -753,7 +787,7 @@ class SimpleArrayField final
       ::Xsmp::Exception::throwInvalidArraySize(this, length);
     }
     auto _itemKind = _type->GetItemType()->GetPrimitiveTypeKind();
-    for (std::size_t i = 0; i < _size; ++i) {
+    for (size_t i = 0; i < _size; ++i) {
       values[i] =
           ::Xsmp::AnySimpleConverter<value_type>::convert(_itemKind, _value[i]);
     }
@@ -764,7 +798,7 @@ class SimpleArrayField final
       ::Xsmp::Exception::throwInvalidArraySize(this, length);
     }
     auto _itemKind = _type->GetItemType()->GetPrimitiveTypeKind();
-    for (std::size_t i = 0; i < _size; ++i) {
+    for (size_t i = 0; i < _size; ++i) {
       if (values[i].type != _itemKind) {
         ::Xsmp::Exception::throwInvalidArrayValue(this, i, values[i]);
       }
@@ -796,7 +830,7 @@ class SimpleArrayField final
 
   struct protected_reference {
     protected_reference(SimpleArrayField *parent, value_type &value,
-                        std::size_t index)
+                        size_t index)
         : _parent{parent}, _value{value}, _index{index} {}
 
     operator const T &() const noexcept { return _value; }
@@ -860,7 +894,7 @@ class SimpleArrayField final
     }
     SimpleArrayField *_parent;
     value_type &_value;
-    std::size_t _index;
+    size_t _index;
   };
 
   using reference =
@@ -868,7 +902,7 @@ class SimpleArrayField final
                              ::Xsmp::Annotation::connectable, Annotations...>,
                          protected_reference, value_type &>;
   using const_reference = const value_type &;
-  using size_type = std::size_t;
+  using size_type = size_t;
   using difference_type = std::ptrdiff_t;
   struct protected_iterator {
     using iterator_category = std::forward_iterator_tag;
@@ -878,7 +912,7 @@ class SimpleArrayField final
     using reference = SimpleArrayField::reference;
 
     protected_iterator(SimpleArrayField *parent, value_type *value,
-                       std::size_t index)
+                       size_t index)
         : _parent{parent}, _value{value}, _index{index} {}
     friend inline bool operator==(const protected_iterator &lhs,
                                   const protected_iterator &rhs) {
@@ -940,7 +974,7 @@ class SimpleArrayField final
   private:
     SimpleArrayField *_parent;
     value_type *_value;
-    std::size_t _index;
+    size_t _index;
   };
 
   using iterator =
@@ -1191,7 +1225,7 @@ struct FieldTypeHelper<::Xsmp::Array<T, Nm, TypeAnnotations...>,
   template <typename... Annotations>
   using field = ::Xsmp::ArrayField<::Xsmp::Array<T, Nm, TypeAnnotations...>,
                                    Annotations...>;
-  static constexpr std::size_t size = Nm;
+  static constexpr size_t size = Nm;
 };
 
 template <typename T, std::size_t Nm, typename... TypeAnnotations>
@@ -1203,7 +1237,7 @@ struct FieldTypeHelper<::Xsmp::Array<T, Nm, TypeAnnotations...>,
   using field =
       ::Xsmp::SimpleArrayField<::Xsmp::Array<T, Nm, TypeAnnotations...>,
                                Annotations...>;
-  static constexpr std::size_t size = Nm;
+  static constexpr size_t size = Nm;
 };
 
 } // namespace detail
diff --git a/include/Xsmp/Helper.h b/include/Xsmp/Helper.h
index 7074aef..fed4605 100644
--- a/include/Xsmp/Helper.h
+++ b/include/Xsmp/Helper.h
@@ -122,6 +122,15 @@ template <typename T>
   return nullptr;
 }
 
+/// Returns whether the second object is the same as the first object, or is
+/// directly contained by the first object, i.e., whether the second object is
+/// in the content tree of the first.
+/// @param ancestorObject The ancestor object in question.
+/// @param object The object to test.
+/// @return Whether the first object is an ancestor of the second object..
+[[nodiscard]] bool IsAncestor(const ::Smp::IObject *ancestorObject,
+                              const ::Smp::IObject *object);
+
 /// Compares two SMP fields to determine if they are equivalent based on their
 /// types.
 /// @param first The first IField object to be compared for equivalence.
diff --git a/include/Xsmp/Persist.h b/include/Xsmp/Persist.h
index 447cd0a..bcf273b 100644
--- a/include/Xsmp/Persist.h
+++ b/include/Xsmp/Persist.h
@@ -126,13 +126,13 @@ void Restore(const ::Smp::ISimulator *simulator, ::Smp::IStorageReader *reader,
 template <typename T, std::size_t N> struct Helper<T[N]> {
   static void Store(const ::Smp::ISimulator *simulator,
                     ::Smp::IStorageWriter *writer, const T (&value)[N]) {
-    for (std::size_t i = 0; i < N; ++i) {
+    for (size_t i = 0; i < N; ++i) {
       ::Xsmp::Persist::Store(simulator, writer, value[i]);
     }
   }
   static void Restore(const ::Smp::ISimulator *simulator,
                       ::Smp::IStorageReader *reader, T (&value)[N]) {
-    for (std::size_t i = 0; i < N; ++i) {
+    for (size_t i = 0; i < N; ++i) {
       ::Xsmp::Persist::Restore(simulator, reader, value[i]);
     }
   }
@@ -180,7 +180,7 @@ void Restore(const ::Smp::ISimulator *simulator, const ::Smp::IObject *sender,
              ::Smp::IStorageReader *reader, Args &...args) {
 
   auto restore = [simulator, sender, reader](auto &value) {
-    std::size_t hash = 0;
+    size_t hash = 0;
     Restore(simulator, reader, hash);
     if (hash != typeid(value).hash_code()) {
       ::Xsmp::Exception::throwCannotRestore(sender, typeid(value).name());
diff --git a/include/Xsmp/Persist/StdArray.h b/include/Xsmp/Persist/StdArray.h
index e4ac54a..0a4fb40 100644
--- a/include/Xsmp/Persist/StdArray.h
+++ b/include/Xsmp/Persist/StdArray.h
@@ -21,7 +21,7 @@
 
 namespace Xsmp::Persist {
 
-template <typename T, std::size_t N> struct Helper<std::array<T, N>> {
+template <typename T, size_t N> struct Helper<std::array<T, N>> {
   static void Store(const ::Smp::ISimulator *simulator,
                     ::Smp::IStorageWriter *writer,
                     const std::array<T, N> &value) {
@@ -31,7 +31,7 @@ template <typename T, std::size_t N> struct Helper<std::array<T, N>> {
 
   static void Restore(const ::Smp::ISimulator *simulator,
                       ::Smp::IStorageReader *reader, std::array<T, N> &value) {
-    for (std::size_t i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
       ::Xsmp::Persist::Restore(simulator, reader, value[i]);
   }
 };
diff --git a/include/Xsmp/Reference.h b/include/Xsmp/Reference.h
index e4a66b7..8d1440f 100644
--- a/include/Xsmp/Reference.h
+++ b/include/Xsmp/Reference.h
@@ -230,7 +230,7 @@ template <class T> class Reference final : public detail::AbstractReference {
   /// @throws  Smp::ReferenceFull
   void AddComponent(::Smp::IComponent *component) override {
 
-    if (size() >= static_cast<std::size_t>(GetUpper())) {
+    if (size() >= static_cast<size_t>(GetUpper())) {
       ::Xsmp::Exception::throwReferenceFull(this, this->GetCount());
     }
     // check that the component type can be casted to T
@@ -255,7 +255,7 @@ template <class T> class Reference final : public detail::AbstractReference {
     if (it == end()) {
       ::Xsmp::Exception::throwNotReferenced(this, component);
     }
-    if (size() <= static_cast<std::size_t>(GetLower())) {
+    if (size() <= static_cast<size_t>(GetLower())) {
       ::Xsmp::Exception::throwCannotRemove(this, component, GetLower());
     }
     _vector.erase(it);
diff --git a/include/Xsmp/String.h b/include/Xsmp/String.h
index 4ac5fce..2f3397a 100644
--- a/include/Xsmp/String.h
+++ b/include/Xsmp/String.h
@@ -29,7 +29,6 @@ namespace Xsmp {
 /// @class String
 /// A fixed-size string class template with support for various operations
 /// and conversions.
-
 template <std::size_t Nm> struct String {
 
   using value_type = char;
@@ -42,7 +41,7 @@ template <std::size_t Nm> struct String {
   using const_iterator = const value_type *;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using size_type = std::size_t;
+  using size_type = size_t;
   using difference_type = std::ptrdiff_t;
 
   value_type internalString[Nm + 1];
@@ -55,11 +54,9 @@ template <std::size_t Nm> struct String {
 
   constexpr String(std::string_view str) { assign(str); }
 
-  template <std::size_t S> constexpr String(const String<S> &str) {
-    assign(str);
-  }
+  template <size_t S> constexpr String(const String<S> &str) { assign(str); }
 
-  constexpr String(const char *str, std::size_t length) { assign(str, length); }
+  constexpr String(const char *str, size_t length) { assign(str, length); }
   // iterators
   [[nodiscard]] constexpr const_iterator begin() noexcept {
     return internalString;
@@ -169,7 +166,7 @@ template <std::size_t Nm> struct String {
     return data();
   }
 
-  constexpr void remove_prefix(std::size_t length) {
+  constexpr void remove_prefix(size_t length) {
     auto newLength = this->length();
     std::copy(internalString + length, internalString + newLength,
               internalString);
@@ -177,7 +174,7 @@ template <std::size_t Nm> struct String {
     internalString[newLength] = '\0';
   }
 
-  constexpr void remove_suffix(std::size_t length) noexcept {
+  constexpr void remove_suffix(size_t length) noexcept {
     auto currentLength = this->length();
     internalString[length > currentLength ? 0 : currentLength - length] = '\0';
   }
@@ -317,28 +314,28 @@ template <std::size_t Nm> struct String {
 
   constexpr void clear() noexcept { internalString[0] = '\0'; }
 
-  template <std::size_t S> constexpr String &assign(const String<S> &str) {
+  template <size_t S> constexpr String &assign(const String<S> &str) {
     return assign(str.c_str(), S);
   }
   constexpr String &assign(std::string_view str) {
-    const std::size_t length = std::min(str.length(), Nm);
+    const size_t length = std::min(str.length(), Nm);
     traits_type::copy(internalString, str.data(), length);
     internalString[length] = '\0';
     return *this;
   }
 
-  constexpr String &assign(const char *str, std::size_t length) {
+  constexpr String &assign(const char *str, size_t length) {
     return assign(std::string_view{str, length});
   }
 
-  template <std::size_t S> constexpr String &append(const String<S> &str) {
+  template <size_t S> constexpr String &append(const String<S> &str) {
     return append(str.c_str());
   }
   constexpr String &append(std::string_view str) {
     return append(str.data(), str.length());
   }
 
-  constexpr String &append(const char *str, std::size_t length) {
+  constexpr String &append(const char *str, size_t length) {
     auto currentLength = this->length();
     auto to_copy = std::min(length, Nm - currentLength);
 
@@ -351,18 +348,18 @@ template <std::size_t Nm> struct String {
     return *this;
   }
   constexpr String &operator+=(std::string_view str) { return append(str); }
-  template <std::size_t S> constexpr String &operator+=(const String<S> &str) {
+  template <size_t S> constexpr String &operator+=(const String<S> &str) {
     return append(str);
   }
 
   constexpr void push_back(char chr) { append(&chr, 1); }
   constexpr void pop_back() noexcept { remove_suffix(1); }
 
-  template <std::size_t T> constexpr String &operator=(const String<T> &str) {
+  template <size_t T> constexpr String &operator=(const String<T> &str) {
     return assign(str);
   }
 
-  template <std::size_t T>
+  template <size_t T>
   [[nodiscard]] constexpr int compare(const String<T> &str) const {
     return compare(data(), size(), str.data(), str.size());
   }
@@ -374,7 +371,7 @@ template <std::size_t Nm> struct String {
     std::swap(internalString, rhs.internalString);
   }
 
-  template <std::size_t Nm2>
+  template <size_t Nm2>
   [[nodiscard]] friend constexpr bool
   operator==(const String &_lhs, const String<Nm2> &_rhs) noexcept {
     return _lhs.compare(_rhs) == 0;
@@ -388,7 +385,7 @@ template <std::size_t Nm> struct String {
     return _lhs.compare(_rhs) == 0;
   }
 
-  template <std::size_t Nm2>
+  template <size_t Nm2>
   [[nodiscard]] friend constexpr bool
   operator!=(const String &_lhs, const String<Nm2> &_rhs) noexcept {
     return !(_lhs == _rhs);
@@ -402,7 +399,7 @@ template <std::size_t Nm> struct String {
     return !(_lhs == _rhs);
   }
 
-  template <std::size_t Nm2>
+  template <size_t Nm2>
   [[nodiscard]] friend constexpr bool
   operator<(const String &_lhs, const String<Nm2> &_rhs) noexcept {
     return _lhs.compare(_rhs) < 0;
@@ -418,7 +415,7 @@ template <std::size_t Nm> struct String {
     return _lhs.compare(_rhs) < 0;
   }
 
-  template <std::size_t Nm2>
+  template <size_t Nm2>
   [[nodiscard]] friend constexpr bool
   operator>(const String &_lhs, const String<Nm2> &_rhs) noexcept {
     return _lhs.compare(_rhs) > 0;
@@ -434,7 +431,7 @@ template <std::size_t Nm> struct String {
     return _lhs.compare(_rhs) > 0;
   }
 
-  template <std::size_t Nm2>
+  template <size_t Nm2>
   [[nodiscard]] friend constexpr bool
   operator<=(const String &_lhs, const String<Nm2> &_rhs) noexcept {
     return _lhs.compare(_rhs) <= 0;
@@ -458,7 +455,7 @@ template <std::size_t Nm> struct String {
     return _lhs.compare(_rhs) <= 0;
   }
 
-  template <std::size_t Nm2>
+  template <size_t Nm2>
   [[nodiscard]] friend constexpr bool
   operator>=(const String &_lhs, const String<Nm2> &_rhs) noexcept {
     return _lhs.compare(_rhs) >= 0;
@@ -474,8 +471,8 @@ template <std::size_t Nm> struct String {
   }
 
 private:
-  constexpr int compare(const char *str, std::size_t size, const char *ostr,
-                        std::size_t osize) const {
+  constexpr int compare(const char *str, size_t size, const char *ostr,
+                        size_t osize) const {
     const auto len = std::min(size, osize);
 
     const int result = traits_type::compare(str, ostr, len);
@@ -539,8 +536,8 @@ template <std::size_t Nm>
 
 // hash
 namespace std {
-template <std::size_t N> struct hash<::Xsmp::String<N>> {
-  std::size_t operator()(const ::Xsmp::String<N> &str) const {
+template <size_t N> struct hash<::Xsmp::String<N>> {
+  size_t operator()(const ::Xsmp::String<N> &str) const {
     return std::hash<std::string_view>()(
         static_cast<std::string_view>(str.c_str()));
   }
diff --git a/src/Smp/Uuid.cpp b/src/Smp/Uuid.cpp
index d8be286..0d40761 100644
--- a/src/Smp/Uuid.cpp
+++ b/src/Smp/Uuid.cpp
@@ -16,6 +16,7 @@
 #include <Xsmp/Exception.h>
 #include <array>
 #include <cctype>
+#include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <functional>
@@ -111,7 +112,7 @@ bool ::Smp::Uuid::operator!=(const ::Smp::Uuid & other) const {
 } // namespace Smp
 
 namespace std {
-std::size_t std::hash<::Smp::Uuid>::operator()(const ::Smp::Uuid &uuid) const {
+size_t std::hash<::Smp::Uuid>::operator()(const ::Smp::Uuid &uuid) const {
 
   const std::uint64_t left = (static_cast<std::uint64_t>(uuid.Data1) << 32) |
                              (static_cast<std::uint64_t>(uuid.Data2[0]) << 16) |
diff --git a/src/Xsmp/Component.cpp b/src/Xsmp/Component.cpp
index 0b2b241..5957815 100644
--- a/src/Xsmp/Component.cpp
+++ b/src/Xsmp/Component.cpp
@@ -14,6 +14,7 @@
 
 #include <Smp/ComponentStateKind.h>
 #include <Smp/IAggregate.h>
+#include <Smp/IArrayField.h>
 #include <Smp/IComposite.h>
 #include <Smp/IEventProvider.h>
 #include <Smp/IField.h>
@@ -21,6 +22,7 @@
 #include <Smp/IProperty.h>
 #include <Smp/IPublication.h>
 #include <Smp/IRequest.h>
+#include <Smp/IStructureField.h>
 #include <Smp/PrimitiveTypes.h>
 #include <Smp/Uuid.h>
 #include <Xsmp/Component.h>
@@ -148,6 +150,38 @@ void Component::RemoveAggregateLinks(const ::Smp::IAggregate *aggregate,
     }
   }
 }
+void Component::RemoveFieldLinks(::Smp::IField *field,
+                                 const ::Smp::IComponent *target) noexcept {
+  // disconnect a dataflow field
+  if (auto *dataflowField =
+          dynamic_cast<::Xsmp::detail::IDataflowFieldExtension *>(field)) {
+    if (const auto *inputFields = dataflowField->GetInputFields()) {
+      for (const auto *inputField : *inputFields) {
+        if (::Xsmp::Helper::IsAncestor(target, inputField)) {
+          dataflowField->Disconnect(inputField);
+        }
+      }
+    }
+  }
+  // recursively disconnect subfields of a structure field
+  else if (const auto *structureField =
+               dynamic_cast<::Smp::IStructureField *>(field)) {
+    if (const auto *fields = structureField->GetFields()) {
+      for (auto *subField : *fields) {
+        RemoveFieldLinks(subField, target);
+      }
+    }
+  }
+  // recursively disconnect items of an array field
+  else if (const auto *arrayField = dynamic_cast<::Smp::IArrayField *>(field)) {
+    const auto size = arrayField->GetSize();
+    for (::Smp::UInt64 i = 0; i < size; ++i) {
+      RemoveFieldLinks(arrayField->GetItem(i), target);
+    }
+  } else {
+    // ignore: the field is a simple field or simple array field without links
+  }
+}
 
 void Component::RemoveLinks(const ::Smp::IComponent *target) {
 
@@ -159,16 +193,12 @@ void Component::RemoveLinks(const ::Smp::IComponent *target) {
   if (auto const *aggregate = dynamic_cast<::Smp::IAggregate *>(this)) {
     RemoveAggregateLinks(aggregate, target);
   }
-  //  // disconnect fields
-  //  if (auto const *fields = GetFields()) {
-  //    for (auto *field : *fields) {
-  //      if (auto *f =
-  //              dynamic_cast<::Xsmp::detail::IDataflowFieldExtension
-  //              *>(field)) {
-  //         f->RemoveLinks(target);
-  //      }
-  //    }
-  //  }
+  // disconnect fields
+  if (auto const *fields = GetFields()) {
+    for (auto *field : *fields) {
+      RemoveFieldLinks(field, target);
+    }
+  }
 }
 
 } // namespace Xsmp
diff --git a/src/Xsmp/Container.cpp b/src/Xsmp/Container.cpp
index 9fe5d33..51c9a11 100644
--- a/src/Xsmp/Container.cpp
+++ b/src/Xsmp/Container.cpp
@@ -49,11 +49,10 @@ ::Smp::IComponent *AbstractContainer::Collection::at(size_t index) const {
 
   return _parent.GetComponent(index);
 }
-size_t AbstractContainer::Collection::size() const {
-  return static_cast<size_t>(_parent.GetCount());
+std::size_t AbstractContainer::Collection::size() const {
+  return static_cast<std::size_t>(_parent.GetCount());
 }
-bool AbstractContainer::Collection::empty() const
-{
+bool AbstractContainer::Collection::empty() const {
   return _parent.GetCount() == 0;
 }
 AbstractContainer::Collection::const_iterator
@@ -180,16 +179,16 @@ void CheckNoDuplicateName(::Smp::IContainer const *container,
 } // namespace
 
 void AbstractContainer::AddComponent(::Smp::IComponent *component) {
-  if (static_cast<size_t>(GetCount()) >=
-      static_cast<size_t>(GetUpper())) {
+  if (static_cast<std::size_t>(GetCount()) >=
+      static_cast<std::size_t>(GetUpper())) {
     ::Xsmp::Exception::throwContainerFull(this);
   }
 
   CheckNoDuplicateName(this, component);
 }
 void AbstractContainer::DeleteComponent(::Smp::IComponent *component) {
-  if (static_cast<size_t>(GetCount()) <=
-      static_cast<size_t>(GetLower())) {
+  if (static_cast<std::size_t>(GetCount()) <=
+      static_cast<std::size_t>(GetLower())) {
     ::Xsmp::Exception::throwCannotDelete(this, component);
   }
   if (component->GetState() == ::Smp::ComponentStateKind::CSK_Connected) {
diff --git a/src/Xsmp/EntryPoint.cpp b/src/Xsmp/EntryPoint.cpp
index 891b843..839e90b 100644
--- a/src/Xsmp/EntryPoint.cpp
+++ b/src/Xsmp/EntryPoint.cpp
@@ -37,7 +37,9 @@ EntryPoint::EntryPoint(::Smp::String8 name, ::Smp::String8 description,
 
 ::Smp::String8 EntryPoint::GetName() const { return _name.c_str(); }
 
-::Smp::String8 EntryPoint::GetDescription() const { return _description.c_str(); }
+::Smp::String8 EntryPoint::GetDescription() const {
+  return _description.c_str();
+}
 
 ::Smp::IObject *EntryPoint::GetParent() const { return _parent; }
 
diff --git a/src/Xsmp/FactoryCollection.cpp b/src/Xsmp/FactoryCollection.cpp
index 8c00de9..1ab8aa5 100644
--- a/src/Xsmp/FactoryCollection.cpp
+++ b/src/Xsmp/FactoryCollection.cpp
@@ -37,7 +37,7 @@ ::Smp::IFactory *FactoryCollection::at(::Smp::String8 name) const {
   return (it == _factory_map.end()) ? nullptr : it->second;
 }
 
-::Smp::IFactory *FactoryCollection::at(std::size_t index) const {
+::Smp::IFactory *FactoryCollection::at(size_t index) const {
   return (index < _factories.size() ? _factories[index] : nullptr);
 }
 
@@ -46,7 +46,7 @@ ::Smp::IFactory *FactoryCollection::at(::Smp::Uuid uuid) const {
   return (it == _uuid_map.end()) ? nullptr : it->second.get();
 }
 
-std::size_t FactoryCollection::size() const { return _factories.size(); }
+size_t FactoryCollection::size() const { return _factories.size(); }
 FactoryCollection::const_iterator FactoryCollection::begin() const {
   return {*this, 0};
 }
diff --git a/src/Xsmp/FactoryCollection.h b/src/Xsmp/FactoryCollection.h
index 39e14ef..0e5f2bc 100644
--- a/src/Xsmp/FactoryCollection.h
+++ b/src/Xsmp/FactoryCollection.h
@@ -18,8 +18,8 @@
 #include <Smp/IFactory.h>
 #include <Smp/PrimitiveTypes.h>
 #include <Smp/Uuid.h>
+#include <cstddef>
 #include <memory>
-#include <stddef.h>
 #include <string>
 #include <unordered_map>
 #include <vector>
diff --git a/src/Xsmp/Field.cpp b/src/Xsmp/Field.cpp
index 94fb920..adc3c47 100644
--- a/src/Xsmp/Field.cpp
+++ b/src/Xsmp/Field.cpp
@@ -29,41 +29,40 @@
 #include <Xsmp/Field.h>
 #include <Xsmp/Helper.h>
 #include <algorithm>
+#include <cstddef>
+#include <string_view>
 #include <utility>
 
 namespace Xsmp::detail {
 
 class FieldHelper {
 public:
-  static bool CanConnect(SimpleConnectableField *output,
-                         ::Smp::ISimpleField *input) {
-    return output->_connectedFields.find(input) ==
-           output->_connectedFields.end();
+  static bool CanConnect(const SimpleConnectableField *output,
+                         const ::Smp::ISimpleField *input) {
+    return output->_connectedFields.contains(input);
   }
   static void Connect(SimpleConnectableField *output,
                       ::Smp::ISimpleField *input) {
-    output->_connectedFields.emplace(input);
+    output->_connectedFields.add(input);
     // push value
     input->SetValue(output->GetValue());
   }
 
   static void Disconnect(SimpleConnectableField *output,
-                         ::Smp::ISimpleField *input) {
-    if (auto it = output->_connectedFields.find(input);
-        it != output->_connectedFields.end()) {
-      output->_connectedFields.erase(it);
-    }
+                         const ::Smp::ISimpleField *input) {
+    output->_connectedFields.remove(input);
+  }
+  static void Push(const SimpleConnectableField *output) {
+    output->internal_push();
   }
-  static void Push(SimpleConnectableField *output) { output->internal_push(); }
 
-  static bool CanConnect(SimpleArrayConnectableField *output,
-                         ::Smp::ISimpleArrayField *input) {
-    return output->_connectedFields.find(input) ==
-           output->_connectedFields.end();
+  static bool CanConnect(const SimpleArrayConnectableField *output,
+                         const ::Smp::ISimpleArrayField *input) {
+    return output->_connectedFields.contains(input);
   }
   static void Connect(SimpleArrayConnectableField *output,
                       ::Smp::ISimpleArrayField *input) {
-    output->_connectedFields.emplace(input);
+    output->_connectedFields.add(input);
     // push value
     const auto size = output->GetSize();
     for (::Smp::UInt64 i = 0; i < size; ++i) {
@@ -71,20 +70,17 @@ class FieldHelper {
     }
   }
   static void Disconnect(SimpleArrayConnectableField *output,
-                         ::Smp::ISimpleArrayField *input) {
-    if (auto it = output->_connectedFields.find(input);
-        it != output->_connectedFields.end()) {
-      output->_connectedFields.erase(it);
-    }
+                         const ::Smp::ISimpleArrayField *input) {
+    output->_connectedFields.remove(input);
   }
-  static void Push(SimpleArrayConnectableField *output) {
+  static void Push(const SimpleArrayConnectableField *output) {
     const auto size = output->GetSize();
     for (::Smp::UInt64 i = 0; i < size; ++i) {
       output->internal_push(i);
     }
   }
-  static bool CanConnect(::Smp::IArrayField *output,
-                         ::Smp::IArrayField *input) {
+  static bool CanConnect(const ::Smp::IArrayField *output,
+                         const ::Smp::IArrayField *input) {
     const auto size = output->GetSize();
     for (::Smp::UInt64 i = 0; i < size; ++i) {
       if (!CanConnect(output->GetItem(i), input->GetItem(i))) {
@@ -94,48 +90,46 @@ class FieldHelper {
     return true;
   }
 
-  static void Connect(::Smp::IArrayField *output, ::Smp::IArrayField *input) {
+  static void Connect(const ::Smp::IArrayField *output,
+                      const ::Smp::IArrayField *input) {
     const auto size = output->GetSize();
     for (::Smp::UInt64 i = 0; i < size; ++i) {
       Connect(output->GetItem(i), input->GetItem(i));
     }
   }
-  static void Disconnect(::Smp::IArrayField *output,
-                         ::Smp::IArrayField *input) {
+  static void Disconnect(const ::Smp::IArrayField *output,
+                         const ::Smp::IArrayField *input) {
     const auto size = output->GetSize();
     for (::Smp::UInt64 i = 0; i < size; ++i) {
       Disconnect(output->GetItem(i), input->GetItem(i));
     }
   }
-  static void Push(::Smp::IArrayField *output) {
+  static void Push(const ::Smp::IArrayField *output) {
     const auto size = output->GetSize();
     for (::Smp::UInt64 i = 0; i < size; ++i) {
       Push(output->GetItem(i));
     }
   }
 
-  static bool CanConnect(ArrayDataflowField *output,
-                         ::Smp::IArrayField *input) {
-    return output->_connectedFields.find(input) ==
-               output->_connectedFields.end() &&
-           CanConnect(static_cast<::Smp::IArrayField *>(output), input);
+  static bool CanConnect(const ArrayDataflowField *output,
+                         const ::Smp::IArrayField *input) {
+    return output->_connectedFields.contains(input) &&
+           CanConnect(static_cast<const ::Smp::IArrayField *>(output), input);
   }
   static void Connect(ArrayDataflowField *output, ::Smp::IArrayField *input) {
-    output->_connectedFields.emplace(input);
-    Connect(static_cast<::Smp::IArrayField *>(output), input);
+    output->_connectedFields.add(input);
+    Connect(static_cast<const ::Smp::IArrayField *>(output), input);
   }
 
   static void Disconnect(ArrayDataflowField *output,
-                         ::Smp::IArrayField *input) {
-    if (auto it = output->_connectedFields.find(input);
-        it != output->_connectedFields.end()) {
-      output->_connectedFields.erase(it);
-      Disconnect(static_cast<::Smp::IArrayField *>(output), input);
+                         const ::Smp::IArrayField *input) {
+    if (output->_connectedFields.remove(input)) {
+      Disconnect(static_cast<const ::Smp::IArrayField *>(output), input);
     }
   }
 
-  static bool CanConnect(::Smp::IStructureField *output,
-                         ::Smp::IStructureField *input) {
+  static bool CanConnect(const ::Smp::IStructureField *output,
+                         const ::Smp::IStructureField *input) {
     const auto *outputFields = output->GetFields();
     if (!outputFields) {
       return false;
@@ -157,8 +151,8 @@ class FieldHelper {
     return true;
   }
 
-  static void Connect(::Smp::IStructureField *output,
-                      ::Smp::IStructureField *input) {
+  static void Connect(const ::Smp::IStructureField *output,
+                      const ::Smp::IStructureField *input) {
     const auto *outputFields = output->GetFields();
     const auto *inputFields = input->GetFields();
     const ::Smp::UInt64 size = outputFields->size();
@@ -166,8 +160,8 @@ class FieldHelper {
       Connect(outputFields->at(i), inputFields->at(i));
     }
   }
-  static void Disconnect(::Smp::IStructureField *output,
-                         ::Smp::IStructureField *input) {
+  static void Disconnect(const ::Smp::IStructureField *output,
+                         const ::Smp::IStructureField *input) {
     const auto *outputFields = output->GetFields();
     const auto *inputFields = input->GetFields();
     const ::Smp::UInt64 size = outputFields->size();
@@ -175,62 +169,64 @@ class FieldHelper {
       Disconnect(outputFields->at(i), inputFields->at(i));
     }
   }
-  static void Push(::Smp::IStructureField *output) {
+  static void Push(const ::Smp::IStructureField *output) {
     const auto *outputFields = output->GetFields();
     const ::Smp::UInt64 size = outputFields->size();
     for (::Smp::UInt64 i = 0; i < size; ++i) {
       Push(outputFields->at(i));
     }
   }
-  static bool CanConnect(StructureDataflowField *output,
-                         ::Smp::IStructureField *input) {
-    return output->_connectedFields.find(input) ==
-               output->_connectedFields.end() &&
-           CanConnect(static_cast<::Smp::IStructureField *>(output), input);
+  static bool CanConnect(const StructureDataflowField *output,
+                         const ::Smp::IStructureField *input) {
+    return output->_connectedFields.contains(input) &&
+           CanConnect(static_cast<const ::Smp::IStructureField *>(output),
+                      input);
   }
   static void Connect(StructureDataflowField *output,
                       ::Smp::IStructureField *input) {
-    output->_connectedFields.emplace(input);
-    Connect(static_cast<::Smp::IStructureField *>(output), input);
+    output->_connectedFields.add(input);
+    Connect(static_cast<const ::Smp::IStructureField *>(output), input);
   }
   static void Disconnect(StructureDataflowField *output,
-                         ::Smp::IStructureField *input) {
-    if (auto it = output->_connectedFields.find(input);
-        it != output->_connectedFields.end()) {
-      output->_connectedFields.erase(it);
-      Disconnect(static_cast<::Smp::IStructureField *>(output), input);
+                         const ::Smp::IStructureField *input) {
+    if (output->_connectedFields.remove(input)) {
+      Disconnect(static_cast<const ::Smp::IStructureField *>(output), input);
     }
   }
-  static bool CanConnect(::Smp::IField *output, ::Smp::IField *input) {
+  static bool CanConnect(const ::Smp::IField *output,
+                         const ::Smp::IField *input) {
 
-    if (auto *simpleOutput = dynamic_cast<SimpleConnectableField *>(output)) {
-      auto *simpleInput = dynamic_cast<::Smp::ISimpleField *>(input);
+    if (auto *simpleOutput =
+            dynamic_cast<const SimpleConnectableField *>(output)) {
+      auto *simpleInput = dynamic_cast<const ::Smp::ISimpleField *>(input);
       return simpleInput && CanConnect(simpleOutput, simpleInput);
     }
     if (auto *simpleArrayOutput =
-            dynamic_cast<SimpleArrayConnectableField *>(output)) {
-      auto *simpleArrayInput = dynamic_cast<::Smp::ISimpleArrayField *>(input);
+            dynamic_cast<const SimpleArrayConnectableField *>(output)) {
+      auto *simpleArrayInput =
+          dynamic_cast<const ::Smp::ISimpleArrayField *>(input);
       return simpleArrayInput &&
              CanConnect(simpleArrayOutput, simpleArrayInput);
     }
-    if (auto *arrayOutput = dynamic_cast<::Smp::IArrayField *>(output)) {
-      auto *arrayInput = dynamic_cast<::Smp::IArrayField *>(input);
+    if (auto *arrayOutput = dynamic_cast<const ::Smp::IArrayField *>(output)) {
+      auto *arrayInput = dynamic_cast<const ::Smp::IArrayField *>(input);
       if (!arrayInput) {
         return false;
       }
       if (auto *arrayDataflowOutput =
-              dynamic_cast<ArrayDataflowField *>(output)) {
+              dynamic_cast<const ArrayDataflowField *>(output)) {
         return CanConnect(arrayDataflowOutput, arrayInput);
       }
       return CanConnect(arrayOutput, arrayInput);
     }
-    if (auto *structOutput = dynamic_cast<::Smp::IStructureField *>(output)) {
-      auto *structInput = dynamic_cast<::Smp::IStructureField *>(input);
+    if (auto *structOutput =
+            dynamic_cast<const ::Smp::IStructureField *>(output)) {
+      auto *structInput = dynamic_cast<const ::Smp::IStructureField *>(input);
       if (!structInput) {
         return false;
       }
       if (auto *structDataflowOutput =
-              dynamic_cast<StructureDataflowField *>(output)) {
+              dynamic_cast<const StructureDataflowField *>(output)) {
         return CanConnect(structDataflowOutput, structInput);
       }
       return CanConnect(structOutput, structInput);
@@ -244,65 +240,73 @@ class FieldHelper {
                    dynamic_cast<SimpleArrayConnectableField *>(output)) {
       Connect(simpleArrayOutput,
               dynamic_cast<::Smp::ISimpleArrayField *>(input));
-    } else if (auto *arrayOutput = dynamic_cast<::Smp::IArrayField *>(output)) {
+    } else if (const auto *arrayOutput =
+                   dynamic_cast<const ::Smp::IArrayField *>(output)) {
       if (auto *arrayDataflowOutput =
               dynamic_cast<ArrayDataflowField *>(output)) {
         Connect(arrayDataflowOutput, dynamic_cast<::Smp::IArrayField *>(input));
       } else {
         Connect(arrayOutput, dynamic_cast<::Smp::IArrayField *>(input));
       }
-    } else if (auto *structOutput =
-                   dynamic_cast<::Smp::IStructureField *>(output)) {
+    } else if (const auto *structOutput =
+                   dynamic_cast<const ::Smp::IStructureField *>(output)) {
       if (auto *structDataflowOutput =
               dynamic_cast<StructureDataflowField *>(output)) {
         Connect(structDataflowOutput,
                 dynamic_cast<::Smp::IStructureField *>(input));
       } else {
-        Connect(structOutput, dynamic_cast<::Smp::IStructureField *>(input));
+        Connect(structOutput,
+                dynamic_cast<const ::Smp::IStructureField *>(input));
       }
     } else {
       // ignore
     }
   }
-  static void Disconnect(::Smp::IField *output, ::Smp::IField *input) {
+  static void Disconnect(::Smp::IField *output, const ::Smp::IField *input) {
 
     if (auto *simpleOutput = dynamic_cast<SimpleConnectableField *>(output)) {
-      Disconnect(simpleOutput, dynamic_cast<::Smp::ISimpleField *>(input));
+      Disconnect(simpleOutput,
+                 dynamic_cast<const ::Smp::ISimpleField *>(input));
     } else if (auto *simpleArrayOutput =
                    dynamic_cast<SimpleArrayConnectableField *>(output)) {
       Disconnect(simpleArrayOutput,
-                 dynamic_cast<::Smp::ISimpleArrayField *>(input));
-    } else if (auto *arrayOutput = dynamic_cast<::Smp::IArrayField *>(output)) {
+                 dynamic_cast<const ::Smp::ISimpleArrayField *>(input));
+    } else if (const auto *arrayOutput =
+                   dynamic_cast<const ::Smp::IArrayField *>(output)) {
       if (auto *arrayDataflowOutput =
               dynamic_cast<ArrayDataflowField *>(output)) {
         Disconnect(arrayDataflowOutput,
-                   dynamic_cast<::Smp::IArrayField *>(input));
+                   dynamic_cast<const ::Smp::IArrayField *>(input));
       } else {
-        Disconnect(arrayOutput, dynamic_cast<::Smp::IArrayField *>(input));
+        Disconnect(arrayOutput,
+                   dynamic_cast<const ::Smp::IArrayField *>(input));
       }
-    } else if (auto *structOutput =
-                   dynamic_cast<::Smp::IStructureField *>(output)) {
+    } else if (const auto *structOutput =
+                   dynamic_cast<const ::Smp::IStructureField *>(output)) {
       if (auto *structDataflowOutput =
               dynamic_cast<StructureDataflowField *>(output)) {
         Disconnect(structDataflowOutput,
-                   dynamic_cast<::Smp::IStructureField *>(input));
+                   dynamic_cast<const ::Smp::IStructureField *>(input));
       } else {
-        Disconnect(structOutput, dynamic_cast<::Smp::IStructureField *>(input));
+        Disconnect(structOutput,
+                   dynamic_cast<const ::Smp::IStructureField *>(input));
       }
     } else {
       // ignore
     }
   }
-  static void Push(::Smp::IField *output) {
-    if (auto *simpleOutput = dynamic_cast<SimpleConnectableField *>(output)) {
+  static void Push(const ::Smp::IField *output) {
+    if (auto *simpleOutput =
+            dynamic_cast<const SimpleConnectableField *>(output)) {
       Push(simpleOutput);
     } else if (auto *simpleArrayOutput =
-                   dynamic_cast<SimpleArrayConnectableField *>(output)) {
+                   dynamic_cast<const SimpleArrayConnectableField *>(output)) {
       Push(simpleArrayOutput);
-    } else if (auto *arrayOutput = dynamic_cast<::Smp::IArrayField *>(output)) {
+    } else if (auto *arrayOutput =
+                   dynamic_cast<const ::Smp::IArrayField *>(output)) {
       Push(arrayOutput);
     } else if (auto *structOutput =
-                   dynamic_cast<::Smp::IStructureField *>(output)) {
+                   dynamic_cast<const ::Smp::IStructureField *>(output)) {
       Push(structOutput);
     } else {
       // ignore
@@ -348,12 +352,18 @@ void Failure::Restore(::Smp::IStorageReader *reader) {
 void Failure::Store(::Smp::IStorageWriter *writer) {
   writer->Store(&_failed, sizeof(_failed));
 }
+SimpleConnectableField::SimpleConnectableField()
+    : _connectedFields{"InputFields", "Collection of connected input Fields",
+                       this} {}
 
 void SimpleConnectableField::internal_push() const {
   for (auto *field : _connectedFields) {
-    field->SetValue(this->GetValue());
+    dynamic_cast<::Smp::ISimpleField *>(field)->SetValue(this->GetValue());
   }
 }
+const ::Smp::FieldCollection *SimpleConnectableField::GetInputFields() const {
+  return &_connectedFields;
+}
 
 void SimpleDataflowField::Connect(::Smp::IField *target) {
   if (!this->IsOutput() || !target->IsInput() || target == this ||
@@ -367,13 +377,18 @@ void SimpleDataflowField::Connect(::Smp::IField *target) {
   FieldHelper::Connect(this, simpleInput);
 }
 
-void SimpleDataflowField::Disconnect(::Smp::IField *target) {
-  if (auto *simpleInput = dynamic_cast<::Smp::ISimpleField *>(target)) {
+void SimpleDataflowField::Disconnect(const ::Smp::IField *target) {
+  if (const auto *simpleInput =
+          dynamic_cast<const ::Smp::ISimpleField *>(target)) {
     FieldHelper::Disconnect(this, simpleInput);
   }
 }
 void SimpleDataflowField::Push() { FieldHelper::Push(this); }
 
+const ::Smp::FieldCollection *SimpleDataflowField::GetInputFields() const {
+  return SimpleConnectableField::GetInputFields();
+}
+
 void SimpleArrayDataflowField::Push() { FieldHelper::Push(this); }
 
 void SimpleArrayDataflowField::Connect(::Smp::IField *target) {
@@ -388,14 +403,63 @@ void SimpleArrayDataflowField::Connect(::Smp::IField *target) {
   FieldHelper::Connect(this, simpleArrayInput);
 }
 
-void SimpleArrayDataflowField::Disconnect(::Smp::IField *target) {
+void SimpleArrayDataflowField::Disconnect(const ::Smp::IField *target) {
 
-  if (auto *simpleArrayInput =
-          dynamic_cast<::Smp::ISimpleArrayField *>(target)) {
+  if (const auto *simpleArrayInput =
+          dynamic_cast<const ::Smp::ISimpleArrayField *>(target)) {
     FieldHelper::Disconnect(this, simpleArrayInput);
   }
 }
 
+const ::Smp::FieldCollection *SimpleArrayDataflowField::GetInputFields() const {
+  return SimpleArrayConnectableField::GetInputFields();
+}
+
+::Smp::IField *InputFieldCollection::at(::Smp::String8 name) const {
+  std::string_view svName = name;
+  auto it = std::find_if(_fields.begin(), _fields.end(),
+                         [&svName](const Smp::IField *element) {
+                           return element->GetName() == svName;
+                         });
+  return (it != _fields.end()) ? *it : nullptr;
+}
+
+::Smp::IField *InputFieldCollection::at(size_t index) const {
+  return index < _fields.size() ? _fields[index] : nullptr;
+}
+
+size_t InputFieldCollection::size() const { return _fields.size(); }
+
+bool InputFieldCollection::empty() const { return _fields.empty(); };
+
+InputFieldCollection::const_iterator InputFieldCollection::begin() const {
+  return {*this, 0};
+}
+
+InputFieldCollection::const_iterator InputFieldCollection::end() const {
+  return {*this, _fields.size()};
+}
+
+bool InputFieldCollection::contains(const ::Smp::IField *input) const {
+  return std::find(_fields.begin(), _fields.end(), input) == _fields.end();
+}
+
+void InputFieldCollection::add(::Smp::IField *input) {
+  _fields.push_back(input);
+}
+bool InputFieldCollection::remove(const ::Smp::IField *input) {
+  if (auto it = std::find(_fields.begin(), _fields.end(), input);
+      it != _fields.end()) {
+    _fields.erase(it);
+    return true;
+  }
+  return false;
+}
+
+ArrayDataflowField::ArrayDataflowField()
+    : _connectedFields{"InputFields", "Collection of connected input Fields",
+                       this} {}
+
 void ArrayDataflowField::Push() { FieldHelper::Push(this); }
 
 void ArrayDataflowField::Connect(::Smp::IField *target) {
@@ -410,12 +474,21 @@ void ArrayDataflowField::Connect(::Smp::IField *target) {
   FieldHelper::Connect(this, arrayInput);
 }
 
-void ArrayDataflowField::Disconnect(::Smp::IField *target) {
-  if (auto *arrayInput = dynamic_cast<::Smp::IArrayField *>(target)) {
+void ArrayDataflowField::Disconnect(const ::Smp::IField *target) {
+  if (const auto *arrayInput =
+          dynamic_cast<const ::Smp::IArrayField *>(target)) {
     FieldHelper::Disconnect(this, arrayInput);
   }
 }
 
+const ::Smp::FieldCollection *ArrayDataflowField::GetInputFields() const {
+  return &_connectedFields;
+}
+
+StructureDataflowField::StructureDataflowField()
+    : _connectedFields{"InputFields", "Collection of connected input Fields",
+                       this} {}
+
 void StructureDataflowField::Push() { FieldHelper::Push(this); }
 void StructureDataflowField::Connect(::Smp::IField *target) {
   if (!this->IsOutput() || !target->IsInput() || target == this ||
@@ -429,18 +502,32 @@ void StructureDataflowField::Connect(::Smp::IField *target) {
   FieldHelper::Connect(this, structInput);
 }
 
-void StructureDataflowField::Disconnect(::Smp::IField *target) {
-  if (auto *structInput = dynamic_cast<::Smp::IStructureField *>(target)) {
+void StructureDataflowField::Disconnect(const ::Smp::IField *target) {
+  if (const auto *structInput =
+          dynamic_cast<const ::Smp::IStructureField *>(target)) {
     FieldHelper::Disconnect(this, structInput);
   }
 }
+const ::Smp::FieldCollection *StructureDataflowField::GetInputFields() const {
+  return &_connectedFields;
+}
+
+SimpleArrayConnectableField::SimpleArrayConnectableField()
+    : _connectedFields{"InputFields", "Collection of connected input Fields",
+                       this} {}
 
 void SimpleArrayConnectableField::internal_push(::Smp::UInt64 index) const {
   for (auto *field : _connectedFields) {
-    field->SetValue(index, this->GetValue(index));
+    dynamic_cast<::Smp::ISimpleArrayField *>(field)->SetValue(
+        index, this->GetValue(index));
   }
 }
 
+const ::Smp::FieldCollection *
+SimpleArrayConnectableField::GetInputFields() const {
+  return &_connectedFields;
+}
+
 void AbstractForcibleField::Restore(::Smp::IStorageReader *reader) {
   reader->Restore(&_forced, sizeof(_forced));
   // restore of value performed in ForcibleField
diff --git a/src/Xsmp/Helper.cpp b/src/Xsmp/Helper.cpp
index d652b43..dc323b5 100644
--- a/src/Xsmp/Helper.cpp
+++ b/src/Xsmp/Helper.cpp
@@ -39,6 +39,7 @@
 #include <Xsmp/cstring.h>
 #include <algorithm>
 #include <cctype>
+#include <cstddef>
 #include <cstdlib>
 #include <exception>
 #include <memory>
@@ -462,6 +463,20 @@ void CopyString(::Smp::Char8 *destination, std::size_t size,
   }
 }
 
+[[nodiscard]] bool IsAncestor(const ::Smp::IObject *ancestorObject,
+                              const ::Smp::IObject *object) {
+  if (!ancestorObject) {
+    return false;
+  }
+  while (object) {
+    if (object == ancestorObject) {
+      return true;
+    }
+    object = object->GetParent();
+  }
+  return false;
+}
+
 bool AreEquivalent(const ::Smp::IField *first, const ::Smp::IField *second) {
 
   // check a simple field
diff --git a/src/Xsmp/Reference.cpp b/src/Xsmp/Reference.cpp
index 5c91c28..aa4b4f5 100644
--- a/src/Xsmp/Reference.cpp
+++ b/src/Xsmp/Reference.cpp
@@ -37,11 +37,11 @@ ::Smp::IComponent *
 AbstractReference::Collection::at(::Smp::String8 name) const {
   return _parent.GetComponent(name);
 }
-::Smp::IComponent *AbstractReference::Collection::at(std::size_t index) const {
+::Smp::IComponent *AbstractReference::Collection::at(size_t index) const {
   return _parent.GetComponent(index);
 }
-std::size_t AbstractReference::Collection::size() const {
-  return static_cast<std::size_t>(_parent.GetCount());
+size_t AbstractReference::Collection::size() const {
+  return static_cast<size_t>(_parent.GetCount());
 }
 AbstractReference::Collection::const_iterator
 AbstractReference::Collection::begin() const {
diff --git a/src/Xsmp/Services/XsmpScheduler.h b/src/Xsmp/Services/XsmpScheduler.h
index b0446ad..45db1f6 100644
--- a/src/Xsmp/Services/XsmpScheduler.h
+++ b/src/Xsmp/Services/XsmpScheduler.h
@@ -395,9 +395,8 @@ class XsmpScheduler final : public XsmpSchedulerGen {
   std::map<::Smp::Duration, EventList> _zulu_events_table;
 
   // Mapping between an EventId and internal data
-  mutable std::mutex
-      _eventsMutex; // protection for _events, _immediate_events,
-                      // _events_table and _lastEventId
+  mutable std::mutex _eventsMutex; // protection for _events, _immediate_events,
+                                   // _events_table and _lastEventId
   // scheduling table for simu/epoch/mission time events
   std::map<::Smp::Duration, EventList> _events_table;
 
diff --git a/src/Xsmp/Simulator.cpp b/src/Xsmp/Simulator.cpp
index 500077d..550c0aa 100644
--- a/src/Xsmp/Simulator.cpp
+++ b/src/Xsmp/Simulator.cpp
@@ -151,7 +151,9 @@ Simulator::~Simulator() {
 }
 ::Smp::String8 Simulator::GetName() const { return _name.c_str(); }
 
-::Smp::String8 Simulator::GetDescription() const { return _description.c_str(); }
+::Smp::String8 Simulator::GetDescription() const {
+  return _description.c_str();
+}
 
 ::Smp::IObject *Simulator::GetParent() const { return nullptr; }
 
diff --git a/src/Xsmp/StorageReader.cpp b/src/Xsmp/StorageReader.cpp
index ecd0924..a7c9d8b 100644
--- a/src/Xsmp/StorageReader.cpp
+++ b/src/Xsmp/StorageReader.cpp
@@ -67,6 +67,8 @@ ::Smp::String8 StorageReader::GetStateVectorFileName() const {
   return _filename.c_str();
 }
 
-::Smp::String8 StorageReader::GetStateVectorFilePath() const { return _path.c_str(); }
+::Smp::String8 StorageReader::GetStateVectorFilePath() const {
+  return _path.c_str();
+}
 
 } // namespace Xsmp
diff --git a/src/Xsmp/StorageWriter.cpp b/src/Xsmp/StorageWriter.cpp
index ccbccbc..ba55a33 100644
--- a/src/Xsmp/StorageWriter.cpp
+++ b/src/Xsmp/StorageWriter.cpp
@@ -66,6 +66,8 @@ ::Smp::String8 StorageWriter::GetStateVectorFileName() const {
   return _filename.c_str();
 }
 
-::Smp::String8 StorageWriter::GetStateVectorFilePath() const { return _path.c_str(); }
+::Smp::String8 StorageWriter::GetStateVectorFilePath() const {
+  return _path.c_str();
+}
 
 } // namespace Xsmp
diff --git a/src/python/Smp/ICollectionBinding.h b/src/python/Smp/ICollectionBinding.h
index edab41e..cb61a43 100644
--- a/src/python/Smp/ICollectionBinding.h
+++ b/src/python/Smp/ICollectionBinding.h
@@ -32,8 +32,7 @@ inline void RegisterICollection(const py::module_ &m, ::Smp::String8 name) {
            "Get the number of objects in the sequence.")
 
       .def("at",
-           py::overload_cast<std::size_t>(&::Smp::ICollection<T>::at,
-                                          py::const_),
+           py::overload_cast<size_t>(&::Smp::ICollection<T>::at, py::const_),
            py::arg("index"), py::return_value_policy::reference,
            "Retrieve element by position in the sequence (based on order of "
            "insertion).")
diff --git a/src/python/Smp/IOperationBinding.h b/src/python/Smp/IOperationBinding.h
index cc5d1cd..6ccaf76 100644
--- a/src/python/Smp/IOperationBinding.h
+++ b/src/python/Smp/IOperationBinding.h
@@ -47,7 +47,7 @@ inline py::object callOperation(::Smp::IOperation &self, const py::args &args,
   for (auto arg : args) {
     ++index;
     request->SetParameterValue(
-        index, convert(arg, parameters->at(static_cast<std::size_t>(index))
+        index, convert(arg, parameters->at(static_cast<size_t>(index))
                                 ->GetType()
                                 ->GetPrimitiveTypeKind()));
   }
@@ -64,7 +64,7 @@ inline py::object callOperation(::Smp::IOperation &self, const py::args &args,
                            "() got multiple values for argument '" + _name +
                            "'");
     request->SetParameterValue(
-        i, convert(value, parameters->at(static_cast<std::size_t>(i))
+        i, convert(value, parameters->at(static_cast<size_t>(i))
                               ->GetType()
                               ->GetPrimitiveTypeKind()));
   }