From c105c75eb52ea62fb3989a101fb4e37de895e9ca Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Wed, 2 Apr 2025 12:46:35 -0400
Subject: [PATCH 01/20] Enable polymorphic shared_ptr downcasting in Any using
 type traits

- Introduced `any_cast_base<T>` trait to register base types for polymorphic casting.
- Added `is_shared_ptr` and `IsPolymorphicSharedPtr` traits to detect eligible types.
- Modified `Any` to store shared_ptr as its registered base class if available.
- Enhanced castPtr() and tryCast() to support safe downcasting from stored base class to derived class using static or dynamic pointer casting.
- Ensures shared_ptr<Derived> can be stored and retrieved as shared_ptr<Base> when registered.
---
 include/behaviortree_cpp/utils/safe_any.hpp | 154 +++++++++++++++++++-
 1 file changed, 152 insertions(+), 2 deletions(-)

diff --git a/include/behaviortree_cpp/utils/safe_any.hpp b/include/behaviortree_cpp/utils/safe_any.hpp
index 999e7d526..0a85c80cd 100644
--- a/include/behaviortree_cpp/utils/safe_any.hpp
+++ b/include/behaviortree_cpp/utils/safe_any.hpp
@@ -28,9 +28,25 @@
 
 namespace BT
 {
-
 static std::type_index UndefinedAnyType = typeid(nullptr);
 
+template <typename T>
+struct any_cast_base
+{
+  using type = void;  // Default: no base known, fallback to default any storage
+};
+
+// Trait to detect std::shared_ptr types.
+template <typename T>
+struct is_shared_ptr : std::false_type
+{
+};
+
+template <typename U>
+struct is_shared_ptr<std::shared_ptr<U>> : std::true_type
+{
+};
+
 // Rational: since type erased numbers will always use at least 8 bytes
 // it is faster to cast everything to either double, uint64_t or int64_t.
 class Any
@@ -58,6 +74,32 @@ class Any
       typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_enum<T>::value &&
                               !std::is_same<T, std::string>::value>::type*;
 
+  // Helper: IsPolymorphicSharedPtr<T> is true if T is a shared pointer,
+  // its element_type exists, is polymorphic, and any_cast_base for that element
+  // is specialized (i.e. not void).
+  template <typename T, typename = void>
+  struct IsPolymorphicSharedPtr : std::false_type
+  {
+  };
+
+  template <typename T>
+  struct IsPolymorphicSharedPtr<T, std::void_t<typename T::element_type>>
+    : std::integral_constant<
+          bool,
+          is_shared_ptr<T>::value && std::is_polymorphic_v<typename T::element_type> &&
+              !std::is_same_v<typename any_cast_base<typename T::element_type>::type,
+                              void>>
+  {
+  };
+
+  template <typename T>
+  using EnablePolymorphicSharedPtr =
+      std::enable_if_t<IsPolymorphicSharedPtr<T>::value, int*>;
+
+  template <typename T>
+  using EnableNonPolymorphicSharedPtr =
+      std::enable_if_t<!IsPolymorphicSharedPtr<T>::value, int*>;
+
   template <typename T>
   nonstd::expected<T, std::string> stringToNumber() const;
 
@@ -107,6 +149,26 @@ class Any
   Any(const std::type_index& type) : _original_type(type)
   {}
 
+  // default for shared pointers
+  template <typename T>
+  explicit Any(const std::shared_ptr<T>& value)
+    : _original_type(typeid(std::shared_ptr<T>))
+  {
+    using Base = typename any_cast_base<T>::type;
+
+    // store as base class if specialized
+    if constexpr(!std::is_same_v<Base, void>)
+    {
+      static_assert(std::is_polymorphic_v<Base>, "Any Base trait specialization must be "
+                                                 "polymorphic");
+      _any = std::static_pointer_cast<Base>(value);
+    }
+    else
+    {
+      _any = value;
+    }
+  }
+
   // default for other custom types
   template <typename T>
   explicit Any(const T& value, EnableNonIntegral<T> = 0)
@@ -158,7 +220,7 @@ class Any
   // Method to access the value by pointer.
   // It will return nullptr, if the user try to cast it to a
   // wrong type or if Any was empty.
-  template <typename T>
+  template <typename T, typename = EnableNonPolymorphicSharedPtr<T>>
   [[nodiscard]] T* castPtr()
   {
     static_assert(!std::is_same_v<T, float>, "The value has been casted internally to "
@@ -192,6 +254,56 @@ class Any
     return _any.empty() ? nullptr : linb::any_cast<T>(&_any);
   }
 
+  // Specialized version of castPtr() for shared_ptr<T> where T is a polymorphic type
+  // with a registered base class via any_cast_base.
+  //
+  // Returns a raw pointer to T::element_type (i.e., Derived*), or nullptr on failure.
+  //
+  // Note: This function intentionally does not return a std::shared_ptr<T>* because doing so
+  // would expose the internal ownership mechanism, which:
+  //   - Breaks encapsulation and may lead to accidental misuse (e.g., double-deletion, ref count tampering)
+  //   - Offers no real benefit, as the purpose of this function is to provide access
+  //     to the managed object, not the smart pointer itself.
+  //
+  // By returning a raw pointer to the object, we preserve ownership semantics and safely
+  // allow read-only access without affecting the reference count.
+  template <typename T, typename = EnablePolymorphicSharedPtr<T>>
+  [[nodiscard]] typename T::element_type* castPtr()
+  {
+    using Derived = typename T::element_type;
+    using Base = typename any_cast_base<Derived>::type;
+
+    try
+    {
+      // Attempt to retrieve the stored shared_ptr<Base> from the Any container
+      auto base_ptr = linb::any_cast<std::shared_ptr<Base>>(&_any);
+      if(!base_ptr)
+        return nullptr;
+
+      // Case 1: If Base and Derived are the same, no casting is needed
+      if constexpr(std::is_same_v<Base, Derived>)
+      {
+        return base_ptr ? base_ptr->get() : nullptr;
+      }
+
+      // Case 2: If the original stored type was shared_ptr<Derived>, we can safely static_cast
+      if(_original_type == typeid(std::shared_ptr<Derived>))
+      {
+        return std::static_pointer_cast<Derived>(*base_ptr).get();
+      }
+
+      // Case 3: Otherwise, attempt a dynamic cast from Base to Derived
+      auto derived_ptr = std::dynamic_pointer_cast<Derived>(*base_ptr);
+      return derived_ptr ? derived_ptr.get() : nullptr;
+    }
+    catch(...)
+    {
+      return nullptr;
+    }
+
+    return nullptr;
+  }
+
   // This is the original type
   [[nodiscard]] const std::type_index& type() const noexcept
   {
@@ -513,6 +625,44 @@ inline nonstd::expected<T, std::string> Any::tryCast() const
     throw std::runtime_error("Any::cast failed because it is empty");
   }
 
+  // special case: T is a shared_ptr to a registered polymorphic type.
+  // The stored value is a shared_ptr<Base>, but the user is requesting shared_ptr<Derived>.
+  // Perform safe downcasting (static or dynamic) from Base to Derived if applicable.
+  if constexpr(is_shared_ptr<T>::value)
+  {
+    using Derived = typename T::element_type;
+    using Base = typename any_cast_base<Derived>::type;
+
+    if constexpr(std::is_polymorphic_v<Derived> && !std::is_same_v<Base, void>)
+    {
+      // Attempt to retrieve the stored shared_ptr<Base> from the Any container
+      auto base_ptr = linb::any_cast<std::shared_ptr<Base>>(_any);
+      if(!base_ptr)
+      {
+        throw std::runtime_error("Any::cast cannot cast to shared_ptr<Base> class");
+      }
+
+      // Case 1: If Base and Derived are the same, no casting is needed
+      if constexpr(std::is_same_v<T, std::shared_ptr<Base>>)
+      {
+        return base_ptr;
+      }
+
+      // Case 2: If the original stored type was shared_ptr<Derived>, we can safely static_cast
+      if(_original_type == typeid(std::shared_ptr<Derived>))
+      {
+        return std::static_pointer_cast<Derived>(base_ptr);
+      }
+
+      // Case 3: Otherwise, attempt a dynamic cast from Base to Derived
+      auto derived_ptr = std::dynamic_pointer_cast<Derived>(base_ptr);
+      if(!derived_ptr)
+        throw std::runtime_error("Any::cast Dynamic cast failed, types are not related");
+
+      return derived_ptr;
+    }
+  }
+
   if(castedType() == typeid(T))
   {
     return linb::any_cast<T>(_any);

From 14815b5fb9973e3288bfeda62f306dbfbb78feb8 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Wed, 2 Apr 2025 12:10:44 -0400
Subject: [PATCH 02/20] Enable blackboard matching for types sharing a common
 base class

---
 include/behaviortree_cpp/basic_types.h | 19 +++++++++++++++++--
 include/behaviortree_cpp/blackboard.h  |  6 ++++--
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/include/behaviortree_cpp/basic_types.h b/include/behaviortree_cpp/basic_types.h
index bceef4fd9..58e852999 100644
--- a/include/behaviortree_cpp/basic_types.h
+++ b/include/behaviortree_cpp/basic_types.h
@@ -350,6 +350,21 @@ class TypeInfo
   template <typename T>
   static TypeInfo Create()
   {
+    // store the base class typeid if specialized
+    if constexpr(is_shared_ptr<T>::value)
+    {
+      using Elem = typename T::element_type;
+      using Base = typename any_cast_base<Elem>::type;
+
+      if constexpr(!std::is_same_v<Base, void>)
+      {
+        static_assert(std::is_polymorphic_v<Base>, "TypeInfo Base trait specialization "
+                                                   "must be "
+                                                   "polymorphic");
+        return TypeInfo{ typeid(std::shared_ptr<Base>),
+                         GetAnyFromStringFunctor<std::shared_ptr<Base>>() };
+      }
+    }
     return TypeInfo{ typeid(T), GetAnyFromStringFunctor<T>() };
   }
 
@@ -452,7 +467,8 @@ template <typename T = AnyTypeAllowed>
   }
   else
   {
-    out = { sname, PortInfo(direction, typeid(T), GetAnyFromStringFunctor<T>()) };
+    auto type_info = TypeInfo::Create<T>();
+    out = { sname, PortInfo(direction, type_info.type(), type_info.converter()) };
   }
   if(!description.empty())
   {
@@ -501,7 +517,6 @@ BidirectionalPort(StringView name, StringView description = {})
 
 namespace details
 {
-
 template <typename T = AnyTypeAllowed, typename DefaultT = T>
 [[nodiscard]] inline std::pair<std::string, PortInfo>
 PortWithDefault(PortDirection direction, StringView name, const DefaultT& default_value,
diff --git a/include/behaviortree_cpp/blackboard.h b/include/behaviortree_cpp/blackboard.h
index 1c3aa96c6..26a80b7de 100644
--- a/include/behaviortree_cpp/blackboard.h
+++ b/include/behaviortree_cpp/blackboard.h
@@ -13,7 +13,6 @@
 
 namespace BT
 {
-
 /// This type contains a pointer to Any, protected
 /// with a locked mutex as long as the object is in scope
 using AnyPtrLocked = LockedPtr<Any>;
@@ -257,8 +256,11 @@ inline void Blackboard::set(const std::string& key, const T& value)
 
     std::type_index previous_type = entry.info.type();
 
+    // allow matching if any is of the same base
+    const auto current_type = TypeInfo::Create<T>().type();
+
     // check type mismatch
-    if(previous_type != std::type_index(typeid(T)) && previous_type != new_value.type())
+    if(previous_type != current_type && previous_type != new_value.type())
     {
       bool mismatching = true;
       if(std::is_constructible<StringView, T>::value)

From 61833403019dc27de975ba75fe60949e829a22ed Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Tue, 1 Apr 2025 20:53:34 -0400
Subject: [PATCH 03/20] Add test fixture for Greeter type hierarchy and type
 trait registration

---
 tests/include/greeter_test.h | 195 +++++++++++++++++++++++++++++++++++
 1 file changed, 195 insertions(+)
 create mode 100644 tests/include/greeter_test.h

diff --git a/tests/include/greeter_test.h b/tests/include/greeter_test.h
new file mode 100644
index 000000000..d3f045402
--- /dev/null
+++ b/tests/include/greeter_test.h
@@ -0,0 +1,195 @@
+#ifndef GREETER_TEST_H_
+#define GREETER_TEST_H_
+
+#include <behaviortree_cpp/utils/safe_any.hpp>
+
+/**
+ *    +-------------------+------------+-------------+-----------------------------+
+ *    |       Class       | Base Class | Polymorphic | Type Trait Registered       |
+ *    +-------------------+------------+-------------+-----------------------------+
+ *    | Greeter           | -          | Yes         | Greeter                     |
+ *    | HelloGreeter      | Greeter    | Yes         | Greeter                     |
+ *    | FancyHelloGreeter | Greeter    | Yes         | Greeter                     |
+ *    | Unwelcomer        | -          | Yes         | Greeter (Purposely invalid) |
+ *    +-------------------+------------+-------------+-----------------------------+
+ */
+
+class Greeter
+{
+public:
+  using Ptr = std::shared_ptr<Greeter>;
+  virtual ~Greeter() = default;
+  virtual std::string show_msg() const
+  {
+    return "";
+  };
+};
+
+class HelloGreeter : public Greeter
+{
+public:
+  using Ptr = std::shared_ptr<HelloGreeter>;
+  std::string show_msg() const override
+  {
+    return "hello";
+  }
+  void setDerivedParameter(int n){};
+};
+
+class FancyHelloGreeter : public HelloGreeter
+{
+public:
+  using Ptr = std::shared_ptr<FancyHelloGreeter>;
+  std::string show_msg() const override
+  {
+    return "salutations";
+  }
+};
+
+class Unwelcomer
+{
+public:
+  using Ptr = std::shared_ptr<Unwelcomer>;
+  virtual ~Unwelcomer() = default;
+  virtual std::string show_msg() const
+  {
+    return "You’re not welcome here";
+  };
+};
+
+// Register cast base type for self to allow direct cast
+template <>
+struct BT::any_cast_base<Greeter>
+{
+  using type = Greeter;
+};
+
+// Register cast base type for HelloGreeter
+template <>
+struct BT::any_cast_base<HelloGreeter>
+{
+  using type = Greeter;
+};
+
+// Register cast base type for FancyHelloGreeter
+template <>
+struct BT::any_cast_base<FancyHelloGreeter>
+{
+  using type = Greeter;
+};
+
+// Register cast base type for Unwelcomer
+// WARNING: intentionally incorrect
+template <>
+struct BT::any_cast_base<Unwelcomer>
+{
+  using type = Greeter;
+};
+
+/**
+*    +-------------------+--------------+-------------+-----------------------+
+*    |     Class         | Base Class   | Polymorphic | Type Trait Registered |
+*    +-------------------+--------------+-------------+-----------------------+
+*    | GreeterNoReg      | -            | Yes         | -                     |
+*    | HelloGreeterNoReg | GreeterNoReg | Yes         | -                     |
+*    +-------------------+--------------+-------------+-----------------------+
+*/
+
+class GreeterNoReg
+{
+public:
+  using Ptr = std::shared_ptr<GreeterNoReg>;
+  virtual ~GreeterNoReg() = default;
+  virtual std::string show_msg() const
+  {
+    return "";
+  };
+};
+
+class HelloGreeterNoReg : public GreeterNoReg
+{
+public:
+  using Ptr = std::shared_ptr<HelloGreeterNoReg>;
+  std::string show_msg() const override
+  {
+    return "hello";
+  }
+  void setDerivedParameter(int n){};
+};
+
+/**
+*    +--------------------+---------------+-------------+-----------------------+
+*    |     Class          | Base Class    | Polymorphic | Type Trait Registered |
+*    +--------------------+---------------+-------------+-----------------------+
+*    | GreeterNoPoly      | -             | No          | GreeterNoPoly         |
+*    | HelloGreeterNoPoly | GreeterNoPoly | No          | GreeterNoPoly         |
+*    +-----------------------+------------+-------------+-----------------------+
+*/
+
+// Correctly fails to compile:
+//     static_assert(std::is_polymorphic_v<Base>, "Base must be polymorphic");
+
+// class GreeterNoPoly
+// {
+// public:
+//   using Ptr = std::shared_ptr<GreeterNoPoly>;
+//   std::string greet() const
+//   {
+//     return "";
+//   };
+// };
+//
+// class HelloGreeterNoPoly : public GreeterNoPoly
+// {
+// public:
+//   using Ptr = std::shared_ptr<HelloGreeterNoPoly>;
+//   std::string hello_greet()
+//   {
+//     return "hello" + greet();
+//   }
+// };
+//
+// // Register cast base type for self to allow direct cast
+// template <>
+// struct BT::any_cast_base<GreeterNoPoly>
+// {
+//   using type = GreeterNoPoly;
+// };
+//
+// // Register cast base type for HelloGreeter
+// template <>
+// struct BT::any_cast_base<HelloGreeterNoPoly>
+// {
+//   using type = GreeterNoPoly;
+// };
+
+/**
+*    +-----------------------+------------+-------------+-----------------------+
+*    |     Class             | Base Class | Polymorphic | Type Trait Registered |
+*    +-----------------------+------------+-------------+-----------------------+
+*    | GreeterNoPolyReg      | -          | No          | -                     |
+*    | HelloGreeterNoPolyReg | NoGreeter  | No          | -                     |
+*    +-----------------------+------------+-------------+-----------------------+
+*/
+
+class GreeterNoPolyReg
+{
+public:
+  using Ptr = std::shared_ptr<GreeterNoPolyReg>;
+  std::string greet() const
+  {
+    return "";
+  };
+};
+
+class HelloGreeterNoPolyReg : public GreeterNoPolyReg
+{
+public:
+  using Ptr = std::shared_ptr<HelloGreeterNoPolyReg>;
+  std::string hello_greet()
+  {
+    return "hello" + greet();
+  }
+};
+
+#endif  // GREETER_TEST_H_

From d644f67ddde3e04b231014f5bf6a35a408780aff Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Tue, 1 Apr 2025 21:09:22 -0400
Subject: [PATCH 04/20] Add unit test for Any/Blackboard type casting

---
 tests/gtest_any.cpp        |  78 ++++++++++++++++++++++++++
 tests/gtest_blackboard.cpp | 112 +++++++++++++++++++++++++++++++++++++
 2 files changed, 190 insertions(+)

diff --git a/tests/gtest_any.cpp b/tests/gtest_any.cpp
index 395551fdb..dc0575946 100644
--- a/tests/gtest_any.cpp
+++ b/tests/gtest_any.cpp
@@ -17,6 +17,7 @@
 #include <gtest/gtest.h>
 
 #include <behaviortree_cpp/utils/safe_any.hpp>
+#include "greeter_test.h"
 
 using namespace BT;
 
@@ -249,4 +250,81 @@ TEST(Any, Cast)
     Any a(v);
     EXPECT_EQ(a.cast<std::vector<int>>(), v);
   }
+
+  /// Issue 943
+  // Type casting: polymorphic class w/ registered base class
+  {
+    auto g = std::make_shared<Greeter>();
+    Any any_g(g);
+    EXPECT_NO_THROW(auto res = any_g.cast<Greeter::Ptr>());
+    EXPECT_ANY_THROW(auto res = any_g.cast<HelloGreeter::Ptr>());
+    EXPECT_ANY_THROW(auto res = any_g.cast<FancyHelloGreeter::Ptr>());
+    EXPECT_TRUE(any_g.castPtr<Greeter::Ptr>());
+    EXPECT_FALSE(any_g.castPtr<HelloGreeter::Ptr>());
+    EXPECT_FALSE(any_g.castPtr<FancyHelloGreeter::Ptr>());
+
+    auto hg = std::make_shared<HelloGreeter>();
+    Any any_hg(hg);
+    EXPECT_NO_THROW(auto res = any_hg.cast<Greeter::Ptr>());
+    EXPECT_NO_THROW(auto res = any_hg.cast<HelloGreeter::Ptr>());
+    EXPECT_ANY_THROW(auto res = any_hg.cast<FancyHelloGreeter::Ptr>());
+    EXPECT_TRUE(any_hg.castPtr<Greeter::Ptr>());
+    EXPECT_TRUE(any_hg.castPtr<HelloGreeter::Ptr>());
+    EXPECT_FALSE(any_hg.castPtr<FancyHelloGreeter::Ptr>());
+
+    auto fhg = std::make_shared<FancyHelloGreeter>();
+    Any any_fhg(fhg);
+    EXPECT_NO_THROW(auto res = any_fhg.cast<Greeter::Ptr>());
+    EXPECT_NO_THROW(auto res = any_fhg.cast<HelloGreeter::Ptr>());
+    EXPECT_NO_THROW(auto res = any_fhg.cast<FancyHelloGreeter::Ptr>());
+    EXPECT_TRUE(any_fhg.castPtr<Greeter::Ptr>());
+    EXPECT_TRUE(any_fhg.castPtr<HelloGreeter::Ptr>());
+    EXPECT_TRUE(any_fhg.castPtr<FancyHelloGreeter::Ptr>());
+
+    // Try to upcast to an incorrectly registered base
+    auto u = std::make_shared<Unwelcomer>();
+
+    // OK, fails to compile -> invalid static cast
+    // Any any_u(u);
+    // EXPECT_ANY_THROW(auto res = any_g.cast<Unwelcomer::Ptr>());
+  }
+
+  // Type casting: polymorphic class w/o registered base class
+  {
+    auto g = std::make_shared<GreeterNoReg>();
+    Any any_g(g);
+    EXPECT_NO_THROW(auto res = any_g.cast<GreeterNoReg::Ptr>());
+    EXPECT_ANY_THROW(auto res = any_g.cast<HelloGreeterNoReg::Ptr>());
+    EXPECT_TRUE(any_g.castPtr<GreeterNoReg::Ptr>());
+    EXPECT_FALSE(any_g.castPtr<HelloGreeterNoReg::Ptr>());
+
+    auto hg = std::make_shared<HelloGreeterNoReg>();
+    Any any_hg(hg);
+    EXPECT_ANY_THROW(auto res = any_hg.cast<GreeterNoReg::Ptr>());
+    EXPECT_NO_THROW(auto res = any_hg.cast<HelloGreeterNoReg::Ptr>());
+    EXPECT_FALSE(any_hg.castPtr<GreeterNoReg::Ptr>());
+    EXPECT_TRUE(any_hg.castPtr<HelloGreeterNoReg::Ptr>());
+  }
+
+  // Type casting: non polymorphic class w/ registered base class
+  {
+    // OK: static_assert(std::is_polymorphic_v<Base>, "Base must be polymorphic")
+  }
+
+  // Type casting: non polymorphic class w/o registered base class
+  {
+    auto g = std::make_shared<GreeterNoPolyReg>();
+    Any any_g(g);
+    EXPECT_NO_THROW(auto res = any_g.cast<GreeterNoPolyReg::Ptr>());
+    EXPECT_ANY_THROW(auto res = any_g.cast<HelloGreeterNoPolyReg::Ptr>());
+    EXPECT_TRUE(any_g.castPtr<GreeterNoPolyReg::Ptr>());
+    EXPECT_FALSE(any_g.castPtr<HelloGreeterNoPolyReg::Ptr>());
+
+    auto hg = std::make_shared<HelloGreeterNoPolyReg>();
+    Any any_hg(hg);
+    EXPECT_ANY_THROW(auto res = any_hg.cast<GreeterNoPolyReg::Ptr>());
+    EXPECT_NO_THROW(auto res = any_hg.cast<HelloGreeterNoPolyReg::Ptr>());
+    EXPECT_FALSE(any_hg.castPtr<GreeterNoPolyReg::Ptr>());
+    EXPECT_TRUE(any_hg.castPtr<HelloGreeterNoPolyReg::Ptr>());
+  }
 }
diff --git a/tests/gtest_blackboard.cpp b/tests/gtest_blackboard.cpp
index 35be37dab..1744e7cd9 100644
--- a/tests/gtest_blackboard.cpp
+++ b/tests/gtest_blackboard.cpp
@@ -15,6 +15,7 @@
 #include "behaviortree_cpp/blackboard.h"
 
 #include "../sample_nodes/dummy_nodes.h"
+#include "greeter_test.h"
 
 using namespace BT;
 
@@ -854,3 +855,114 @@ TEST(BlackboardTest, SetBlackboard_WithPortRemapping)
   // Tick till the end with no crashes
   ASSERT_NO_THROW(tree.tickWhileRunning(););
 }
+
+
+class CreateHelloGreeter : public SyncActionNode
+{
+public:
+  CreateHelloGreeter(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    auto hello_greeter = std::make_shared<HelloGreeter>();
+
+    setOutput("out_derived", hello_greeter);
+
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::OutputPort<HelloGreeter::Ptr>("out_derived") };
+  }
+};
+
+class SetDerivedParameter : public SyncActionNode
+{
+public:
+  SetDerivedParameter(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    int n;
+    HelloGreeter::Ptr hello_greeter{};
+
+    getInput("n", n);
+    getInput("in_derived", hello_greeter);
+
+    hello_greeter->setDerivedParameter(n);
+    hello_greeter->show_msg();
+
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::InputPort<int>("n"), BT::InputPort<HelloGreeter::Ptr>("in_derived") };
+  }
+};
+
+class ShowGreetMessage : public SyncActionNode
+{
+public:
+  ShowGreetMessage(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    Greeter::Ptr greeter{};
+
+    getInput("in_base", greeter);
+    greeter->show_msg();
+
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::InputPort<Greeter::Ptr>("in_base") };
+  }
+};
+
+TEST(BlackboardTest, Upcasting_Issue943)
+{
+  auto bb = BT::Blackboard::create();
+
+  auto hello_greeter = std::make_shared<HelloGreeter>();
+  bb->set("hello_greeter", hello_greeter);
+
+  std::shared_ptr<Greeter> g{};
+  ASSERT_TRUE(bb->get("hello_greeter", g));
+  ASSERT_STREQ("hello", g->show_msg().c_str());
+
+  std::shared_ptr<HelloGreeter> hg{};
+  ASSERT_TRUE(bb->get("hello_greeter", hg));
+  ASSERT_STREQ("hello", hg->show_msg().c_str());
+
+  std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <Sequence>
+          <CreateHelloGreeter out_derived="{hello_greeter}" />
+          <SetDerivedParameter in_derived="{hello_greeter}" n="2" />
+          <ShowGreetMessage in_base="{hello_greeter}" />
+        </Sequence>
+      </BehaviorTree>
+    </root>)";
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<CreateHelloGreeter>("CreateHelloGreeter");
+  factory.registerNodeType<SetDerivedParameter>("SetDerivedParameter");
+  factory.registerNodeType<ShowGreetMessage>("ShowGreetMessage");
+
+  auto tree = factory.createTreeFromText(xml_txt);
+
+  NodeStatus status = tree.tickWhileRunning();
+
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+}

From f403fb654b3867e870d140f04065082db74b29e7 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Wed, 2 Apr 2025 21:28:44 -0400
Subject: [PATCH 05/20] Avoid std::is_polymorphic instantiation on incomplete
 types

Added is_polymorphic_safe to defer evaluation of std::is_polymorphic<T>
until T is known to be a complete type. This prevents compilation errors
when used with forward-declared types.
---
 include/behaviortree_cpp/basic_types.h      |  2 +-
 include/behaviortree_cpp/utils/safe_any.hpp | 43 +++++++++++++++++----
 2 files changed, 36 insertions(+), 9 deletions(-)

diff --git a/include/behaviortree_cpp/basic_types.h b/include/behaviortree_cpp/basic_types.h
index 58e852999..002d0a33f 100644
--- a/include/behaviortree_cpp/basic_types.h
+++ b/include/behaviortree_cpp/basic_types.h
@@ -358,7 +358,7 @@ class TypeInfo
 
       if constexpr(!std::is_same_v<Base, void>)
       {
-        static_assert(std::is_polymorphic_v<Base>, "TypeInfo Base trait specialization "
+        static_assert(is_polymorphic_safe_v<Base>, "TypeInfo Base trait specialization "
                                                    "must be "
                                                    "polymorphic");
         return TypeInfo{ typeid(std::shared_ptr<Base>),
diff --git a/include/behaviortree_cpp/utils/safe_any.hpp b/include/behaviortree_cpp/utils/safe_any.hpp
index 0a85c80cd..d998680ff 100644
--- a/include/behaviortree_cpp/utils/safe_any.hpp
+++ b/include/behaviortree_cpp/utils/safe_any.hpp
@@ -47,6 +47,33 @@ struct is_shared_ptr<std::shared_ptr<U>> : std::true_type
 {
 };
 
+// Trait to detect if a type is complete
+template <typename T, typename = void>
+struct is_complete : std::false_type
+{
+};
+
+template <typename T>
+struct is_complete<T, decltype(void(sizeof(T)))> : std::true_type
+{
+};
+
+// Trait to detect if a trait is complete and polymorphic
+template <typename T, typename = void>
+struct is_polymorphic_safe : std::false_type
+{
+};
+
+// Specialization only enabled if T is complete
+template <typename T>
+struct is_polymorphic_safe<T, std::enable_if_t<is_complete<T>::value>>
+  : std::integral_constant<bool, std::is_polymorphic<T>::value>
+{
+};
+
+template <typename T>
+inline constexpr bool is_polymorphic_safe_v = is_polymorphic_safe<T>::value;
+
 // Rational: since type erased numbers will always use at least 8 bytes
 // it is faster to cast everything to either double, uint64_t or int64_t.
 class Any
@@ -83,12 +110,12 @@ class Any
   };
 
   template <typename T>
-  struct IsPolymorphicSharedPtr<T, std::void_t<typename T::element_type>>
-    : std::integral_constant<
-          bool,
-          is_shared_ptr<T>::value && std::is_polymorphic_v<typename T::element_type> &&
-              !std::is_same_v<typename any_cast_base<typename T::element_type>::type,
-                              void>>
+  struct IsPolymorphicSharedPtr<
+      T,
+      std::enable_if_t<
+          is_shared_ptr<T>::value && is_polymorphic_safe_v<typename T::element_type> &&
+          !std::is_same_v<typename any_cast_base<typename T::element_type>::type, void>>>
+    : std::true_type
   {
   };
 
@@ -159,7 +186,7 @@ class Any
     // store as base class if specialized
     if constexpr(!std::is_same_v<Base, void>)
     {
-      static_assert(std::is_polymorphic_v<Base>, "Any Base trait specialization must be "
+      static_assert(is_polymorphic_safe_v<Base>, "Any Base trait specialization must be "
                                                  "polymorphic");
       _any = std::static_pointer_cast<Base>(value);
     }
@@ -633,7 +660,7 @@ inline nonstd::expected<T, std::string> Any::tryCast() const
     using Derived = typename T::element_type;
     using Base = typename any_cast_base<Derived>::type;
 
-    if constexpr(std::is_polymorphic_v<Derived> && !std::is_same_v<Base, void>)
+    if constexpr(is_polymorphic_safe_v<Derived> && !std::is_same_v<Base, void>)
     {
       // Attempt to retrieve the stored shared_ptr<Base> from the Any container
       auto base_ptr = linb::any_cast<std::shared_ptr<Base>>(_any);

From 5829a40a266d6fda7046096081faed991db1125f Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 4 Apr 2025 16:57:21 -0400
Subject: [PATCH 06/20] Refactor castPtr() to unify shared_ptr casting logic

Introduced _cached_derived_ptr to temporarily store downcasted
shared_ptr results which are polymorphic and base-registered.
---
 include/behaviortree_cpp/utils/safe_any.hpp | 116 ++++++++------------
 1 file changed, 45 insertions(+), 71 deletions(-)

diff --git a/include/behaviortree_cpp/utils/safe_any.hpp b/include/behaviortree_cpp/utils/safe_any.hpp
index d998680ff..1615c5ceb 100644
--- a/include/behaviortree_cpp/utils/safe_any.hpp
+++ b/include/behaviortree_cpp/utils/safe_any.hpp
@@ -101,32 +101,6 @@ class Any
       typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_enum<T>::value &&
                               !std::is_same<T, std::string>::value>::type*;
 
-  // Helper: IsPolymorphicSharedPtr<T> is true if T is a shared pointer,
-  // its element_type exists, is polymorphic, and any_cast_base for that element
-  // is specialized (i.e. not void).
-  template <typename T, typename = void>
-  struct IsPolymorphicSharedPtr : std::false_type
-  {
-  };
-
-  template <typename T>
-  struct IsPolymorphicSharedPtr<
-      T,
-      std::enable_if_t<
-          is_shared_ptr<T>::value && is_polymorphic_safe_v<typename T::element_type> &&
-          !std::is_same_v<typename any_cast_base<typename T::element_type>::type, void>>>
-    : std::true_type
-  {
-  };
-
-  template <typename T>
-  using EnablePolymorphicSharedPtr =
-      std::enable_if_t<IsPolymorphicSharedPtr<T>::value, int*>;
-
-  template <typename T>
-  using EnableNonPolymorphicSharedPtr =
-      std::enable_if_t<!IsPolymorphicSharedPtr<T>::value, int*>;
-
   template <typename T>
   nonstd::expected<T, std::string> stringToNumber() const;
 
@@ -247,7 +221,10 @@ class Any
   // Method to access the value by pointer.
   // It will return nullptr, if the user try to cast it to a
   // wrong type or if Any was empty.
-  template <typename T, typename = EnableNonPolymorphicSharedPtr<T>>
+  //
+  // WARNING: The returned pointer may alias internal cache and be invalidated by subsequent castPtr() calls.
+  // Do not store it long-term. Applies only to shared_ptr<Derived> where Derived is polymorphic and base-registered.
+  template <typename T>
   [[nodiscard]] T* castPtr()
   {
     static_assert(!std::is_same_v<T, float>, "The value has been casted internally to "
@@ -278,57 +255,53 @@ class Any
                                                                                      "tea"
                                                                                      "d");
 
-    return _any.empty() ? nullptr : linb::any_cast<T>(&_any);
-  }
-
-  // Specialized version of castPtr() for shared_ptr<T> where T is a polymorphic type
-  // with a registered base class via any_cast_base.
-  //
-  // Returns a raw pointer to T::element_type (i.e., Derived*), or nullptr on failure.
-  //
-  // Note: This function intentionally does not return a std::shared_ptr<T>* because doing so
-  // would expose the internal ownership mechanism, which:
-  //   - Breaks encapsulation and may lead to accidental misuse (e.g., double-deletion, ref count tampering)
-  //   - Offers no real benefit, as the purpose of this function is to provide access
-  //     to the managed object, not the smart pointer itself.
-  //
-  // By returning a raw pointer to the object, we preserve ownership semantics and safely
-  // allow read-only access without affecting the reference count.
-  template <typename T, typename = EnablePolymorphicSharedPtr<T>>
-  [[nodiscard]] typename T::element_type* castPtr()
-  {
-    using Derived = typename T::element_type;
-    using Base = typename any_cast_base<Derived>::type;
-
-    try
+    // Special case: applies only when requesting shared_ptr<Derived> and Derived is polymorphic
+    // with a registered base via any_cast_base.
+    if constexpr(is_shared_ptr<T>::value)
     {
-      // Attempt to retrieve the stored shared_ptr<Base> from the Any container
-      auto base_ptr = linb::any_cast<std::shared_ptr<Base>>(&_any);
-      if(!base_ptr)
-        return nullptr;
+      using Derived = typename T::element_type;
+      using Base = typename any_cast_base<Derived>::type;
 
-      // Case 1: If Base and Derived are the same, no casting is needed
-      if constexpr(std::is_same_v<Base, Derived>)
+      if constexpr(is_polymorphic_safe_v<Derived> && !std::is_same_v<Base, void>)
       {
-        return base_ptr ? base_ptr->get() : nullptr;
-      }
+        try
+        {
+          // Attempt to retrieve the stored shared_ptr<Base> from the Any container
+          auto base_ptr = linb::any_cast<std::shared_ptr<Base>>(&_any);
+          if(!base_ptr)
+            return nullptr;
+
+          // Case 1: If Base and Derived are the same, no casting is needed
+          if constexpr(std::is_same_v<Base, Derived>)
+          {
+            return reinterpret_cast<T*>(base_ptr);
+          }
+
+          // Case 2: Originally stored as shared_ptr<Derived>
+          if(_original_type == typeid(std::shared_ptr<Derived>))
+          {
+            _cached_derived_ptr = std::static_pointer_cast<Derived>(*base_ptr);
+            return reinterpret_cast<T*>(&_cached_derived_ptr);
+          }
+
+          // Case 3: Fallback to dynamic cast
+          auto derived_ptr = std::dynamic_pointer_cast<Derived>(*base_ptr);
+          if(derived_ptr)
+          {
+            _cached_derived_ptr = derived_ptr;
+            return reinterpret_cast<T*>(&_cached_derived_ptr);
+          }
+        }
+        catch(...)
+        {
+          return nullptr;
+        }
 
-      // Case 2: If the original stored type was shared_ptr<Derived>, we can safely static_cast
-      if(_original_type == typeid(std::shared_ptr<Derived>))
-      {
-        return std::static_pointer_cast<Derived>(*base_ptr).get();
+        return nullptr;
       }
-
-      // Case 3: Otherwise, attempt a dynamic cast from Base to Derived
-      auto derived_ptr = std::dynamic_pointer_cast<Derived>(*base_ptr);
-      return derived_ptr ? derived_ptr.get() : nullptr;
-    }
-    catch(...)
-    {
-      return nullptr;
     }
 
-    return nullptr;
+    return _any.empty() ? nullptr : linb::any_cast<T>(&_any);
   }
 
   // This is the original type
@@ -351,6 +324,7 @@ class Any
 private:
   linb::any _any;
   std::type_index _original_type;
+  mutable std::shared_ptr<void> _cached_derived_ptr = nullptr;
 
   //----------------------------
 

From 4a2e42ce0d92d5d49ef51273b70d980e2cf7e7f6 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Thu, 17 Apr 2025 17:04:07 -0400
Subject: [PATCH 07/20] Support recursive root base resolution for polymorphic
 shared_ptr types

- Introduced root_base_t<T> to recursively resolve the ultimate base type
  using the any_cast_base trait.
- Applied root_base_t in TypeInfo::Create, Any constructor, castPtr, and tryCast
  to normalize stored/casted types across polymorphic hierarchies.
- Ensured static_assert enforces polymorphic base safety on resolved RootBase.
---
 include/behaviortree_cpp/basic_types.h      | 13 +++--
 include/behaviortree_cpp/utils/safe_any.hpp | 63 ++++++++++++++++++---
 2 files changed, 64 insertions(+), 12 deletions(-)

diff --git a/include/behaviortree_cpp/basic_types.h b/include/behaviortree_cpp/basic_types.h
index 002d0a33f..94743ca6c 100644
--- a/include/behaviortree_cpp/basic_types.h
+++ b/include/behaviortree_cpp/basic_types.h
@@ -358,11 +358,14 @@ class TypeInfo
 
       if constexpr(!std::is_same_v<Base, void>)
       {
-        static_assert(is_polymorphic_safe_v<Base>, "TypeInfo Base trait specialization "
-                                                   "must be "
-                                                   "polymorphic");
-        return TypeInfo{ typeid(std::shared_ptr<Base>),
-                         GetAnyFromStringFunctor<std::shared_ptr<Base>>() };
+        using RootBase = root_base_t<Elem>;
+
+        static_assert(is_polymorphic_safe_v<RootBase>, "TypeInfo Base trait "
+                                                       "specialization "
+                                                       "must be "
+                                                       "polymorphic");
+        return TypeInfo{ typeid(std::shared_ptr<RootBase>),
+                         GetAnyFromStringFunctor<std::shared_ptr<RootBase>>() };
       }
     }
     return TypeInfo{ typeid(T), GetAnyFromStringFunctor<T>() };
diff --git a/include/behaviortree_cpp/utils/safe_any.hpp b/include/behaviortree_cpp/utils/safe_any.hpp
index 1615c5ceb..b3123373d 100644
--- a/include/behaviortree_cpp/utils/safe_any.hpp
+++ b/include/behaviortree_cpp/utils/safe_any.hpp
@@ -36,6 +36,48 @@ struct any_cast_base
   using type = void;  // Default: no base known, fallback to default any storage
 };
 
+// C++17 backport of std::type_identity
+template <typename T>
+struct type_identity
+{
+  using type = T;
+};
+
+// Trait to check if a type has a valid cast base
+template <typename T, typename = void>
+struct has_valid_cast_base : std::false_type
+{
+};
+
+template <typename T>
+struct has_valid_cast_base<T, std::void_t<typename any_cast_base<T>::type>>
+{
+  static constexpr bool value =
+      !std::is_same<typename any_cast_base<T>::type, void>::value;
+};
+
+// Recursive helper (non-self-recursive, SFINAE-safe)
+template <typename T>
+struct resolve_root_base_helper
+{
+  using Base = typename any_cast_base<T>::type;
+
+  using type = typename std::conditional<std::is_same<T, Base>::value, type_identity<T>,
+                                         resolve_root_base_helper<Base>>::type::type;
+};
+
+// Public interface with guard
+template <typename T>
+struct root_base_resolver
+{
+  using type = typename std::conditional<has_valid_cast_base<T>::value,
+                                         resolve_root_base_helper<T>,
+                                         type_identity<T>>::type::type;
+};
+
+template <typename T>
+using root_base_t = typename root_base_resolver<T>::type;
+
 // Trait to detect std::shared_ptr types.
 template <typename T>
 struct is_shared_ptr : std::false_type
@@ -160,9 +202,12 @@ class Any
     // store as base class if specialized
     if constexpr(!std::is_same_v<Base, void>)
     {
-      static_assert(is_polymorphic_safe_v<Base>, "Any Base trait specialization must be "
-                                                 "polymorphic");
-      _any = std::static_pointer_cast<Base>(value);
+      using RootBase = root_base_t<T>;
+
+      static_assert(is_polymorphic_safe_v<RootBase>, "Any Base trait specialization must "
+                                                     "be "
+                                                     "polymorphic");
+      _any = std::static_pointer_cast<RootBase>(value);
     }
     else
     {
@@ -264,15 +309,17 @@ class Any
 
       if constexpr(is_polymorphic_safe_v<Derived> && !std::is_same_v<Base, void>)
       {
+        using RootBase = root_base_t<Derived>;
+
         try
         {
           // Attempt to retrieve the stored shared_ptr<Base> from the Any container
-          auto base_ptr = linb::any_cast<std::shared_ptr<Base>>(&_any);
+          auto base_ptr = linb::any_cast<std::shared_ptr<RootBase>>(&_any);
           if(!base_ptr)
             return nullptr;
 
           // Case 1: If Base and Derived are the same, no casting is needed
-          if constexpr(std::is_same_v<Base, Derived>)
+          if constexpr(std::is_same_v<RootBase, Derived>)
           {
             return reinterpret_cast<T*>(base_ptr);
           }
@@ -636,15 +683,17 @@ inline nonstd::expected<T, std::string> Any::tryCast() const
 
     if constexpr(is_polymorphic_safe_v<Derived> && !std::is_same_v<Base, void>)
     {
+      using RootBase = root_base_t<Derived>;
+
       // Attempt to retrieve the stored shared_ptr<Base> from the Any container
-      auto base_ptr = linb::any_cast<std::shared_ptr<Base>>(_any);
+      auto base_ptr = linb::any_cast<std::shared_ptr<RootBase>>(_any);
       if(!base_ptr)
       {
         throw std::runtime_error("Any::cast cannot cast to shared_ptr<Base> class");
       }
 
       // Case 1: If Base and Derived are the same, no casting is needed
-      if constexpr(std::is_same_v<T, std::shared_ptr<Base>>)
+      if constexpr(std::is_same_v<T, std::shared_ptr<RootBase>>)
       {
         return base_ptr;
       }

From 6f0c367e98782a3f01c39266ed397d71acb7e437 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Thu, 17 Apr 2025 17:05:51 -0400
Subject: [PATCH 08/20] Adjust any_cast_base<FancyHelloGreeter> to map to
 HelloGreeter

- Reflects the intended design that any_cast_base does not need to map
  directly to the root base, but can resolve recursively via intermediate types.
- Enables fine-grained control over polymorphic casting resolution.
---
 tests/include/greeter_test.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/include/greeter_test.h b/tests/include/greeter_test.h
index d3f045402..41b2a7053 100644
--- a/tests/include/greeter_test.h
+++ b/tests/include/greeter_test.h
@@ -75,7 +75,7 @@ struct BT::any_cast_base<HelloGreeter>
 template <>
 struct BT::any_cast_base<FancyHelloGreeter>
 {
-  using type = Greeter;
+  using type = HelloGreeter;
 };
 
 // Register cast base type for Unwelcomer

From d313becd9f5904fa94f0fa30c443c9cf969f8583 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 10:25:55 -0400
Subject: [PATCH 09/20] Add compile-time base class chain introspection using
 any_cast_base

- Introduced type_list<Ts...> to represent type chains at compile time.
- Implemented compute_base_chain_impl<T> to recursively collect base types
  based on any_cast_base<T> specializations.
- Added get_base_chain_type_index<T>() to convert the chain into
  std::vector<std::type_index> for runtime use.
- Supports safe termination when base is void or self-referential.
---
 include/behaviortree_cpp/utils/safe_any.hpp | 55 +++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/include/behaviortree_cpp/utils/safe_any.hpp b/include/behaviortree_cpp/utils/safe_any.hpp
index b3123373d..d6736b84e 100644
--- a/include/behaviortree_cpp/utils/safe_any.hpp
+++ b/include/behaviortree_cpp/utils/safe_any.hpp
@@ -116,6 +116,61 @@ struct is_polymorphic_safe<T, std::enable_if_t<is_complete<T>::value>>
 template <typename T>
 inline constexpr bool is_polymorphic_safe_v = is_polymorphic_safe<T>::value;
 
+// Compute and store the base class inheritance chain of a type T
+// from derived to root base order, e.g. SphynxCat -> Cat -> Animal
+template <typename... Ts>
+struct type_list
+{
+  template <typename U>
+  using prepend = type_list<U, Ts...>;
+};
+
+template <typename... Ts>
+std::vector<std::type_index> to_type_index_vector(type_list<Ts...>)
+{
+  return { std::type_index(typeid(Ts))... };
+}
+
+template <typename T, typename = void>
+struct compute_base_chain_impl
+{
+  using type = type_list<T>;
+};
+
+// Base case: recursion ends when base is void or equal to self
+template <typename T>
+struct compute_base_chain_impl<
+    T, std::enable_if_t<std::is_same_v<typename any_cast_base<T>::type, void> ||
+                        std::is_same_v<typename any_cast_base<T>::type, T>>>
+{
+  using type = type_list<T>;
+};
+
+// Recursive case
+template <typename T>
+struct compute_base_chain_impl<
+    T, std::enable_if_t<has_valid_cast_base<T>::value &&
+                        !std::is_same_v<typename any_cast_base<T>::type, void> &&
+                        !std::is_same_v<typename any_cast_base<T>::type, T> &&
+                        is_polymorphic_safe_v<T>>>
+{
+private:
+  using Base = typename any_cast_base<T>::type;
+  using BaseChain = typename compute_base_chain_impl<Base>::type;
+
+public:
+  using type = typename BaseChain::template prepend<T>;
+};
+
+template <typename T>
+using compute_base_chain = typename compute_base_chain_impl<T>::type;
+
+template <typename T>
+std::vector<std::type_index> get_base_chain_type_index()
+{
+  return to_type_index_vector(compute_base_chain<T>{});
+}
+
 // Rational: since type erased numbers will always use at least 8 bytes
 // it is faster to cast everything to either double, uint64_t or int64_t.
 class Any

From f90f8229e3f71003907738f12fbaf520df504042 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 10:26:39 -0400
Subject: [PATCH 10/20] Extend TypeInfo to store and expose base class chain

- Modified TypeInfo::Create<T>() to compute and store the full base type chain
  using compute_base_chain and to_type_index_vector.
- Added a new constructor to TypeInfo to accept a base_chain vector.
- Introduced baseChain() accessor and isConvertibleFrom() helper.
- Enables runtime introspection and safe type conversions across the base chain.
---
 include/behaviortree_cpp/basic_types.h | 28 ++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/include/behaviortree_cpp/basic_types.h b/include/behaviortree_cpp/basic_types.h
index 94743ca6c..5a3992d4e 100644
--- a/include/behaviortree_cpp/basic_types.h
+++ b/include/behaviortree_cpp/basic_types.h
@@ -364,8 +364,13 @@ class TypeInfo
                                                        "specialization "
                                                        "must be "
                                                        "polymorphic");
-        return TypeInfo{ typeid(std::shared_ptr<RootBase>),
-                         GetAnyFromStringFunctor<std::shared_ptr<RootBase>>() };
+
+        using Chain = compute_base_chain<Elem>;
+        auto base_chain = to_type_index_vector(Chain{});
+
+        return TypeInfo(typeid(std::shared_ptr<RootBase>),
+                        GetAnyFromStringFunctor<std::shared_ptr<RootBase>>(),
+                        std::move(base_chain));
       }
     }
     return TypeInfo{ typeid(T), GetAnyFromStringFunctor<T>() };
@@ -378,6 +383,14 @@ class TypeInfo
     : type_info_(type_info), converter_(conv), type_str_(BT::demangle(type_info))
   {}
 
+  TypeInfo(std::type_index type_info, StringConverter conv,
+           std::vector<std::type_index>&& base_chain)
+    : type_info_(type_info)
+    , converter_(conv)
+    , type_str_(BT::demangle(type_info))
+    , base_chain_(std::move(base_chain))
+  {}
+
   [[nodiscard]] const std::type_index& type() const;
 
   [[nodiscard]] const std::string& typeName() const;
@@ -403,10 +416,21 @@ class TypeInfo
     return converter_;
   }
 
+  [[nodiscard]] bool isConvertibleFrom(const std::type_index& other) const
+  {
+    return std::find(base_chain_.begin(), base_chain_.end(), other) != base_chain_.end();
+  }
+
+  [[nodiscard]] const std::vector<std::type_index>& baseChain() const
+  {
+    return base_chain_;
+  }
+
 private:
   std::type_index type_info_;
   StringConverter converter_;
   std::string type_str_;
+  std::vector<std::type_index> base_chain_;
 };
 
 class PortInfo : public TypeInfo

From 423e970d2b75e029ff331d025bc5fed92c4e9acc Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 10:28:37 -0400
Subject: [PATCH 11/20] Add unit test for upcasting base type chain in PortInfo

---
 tests/gtest_ports.cpp        | 58 ++++++++++++++++++++++++++++++++++++
 tests/include/greeter_test.h | 56 ++++++++++++++++++++++++++++++++++
 2 files changed, 114 insertions(+)

diff --git a/tests/gtest_ports.cpp b/tests/gtest_ports.cpp
index 69c351594..c1e79c5c7 100644
--- a/tests/gtest_ports.cpp
+++ b/tests/gtest_ports.cpp
@@ -3,6 +3,7 @@
 #include "behaviortree_cpp/bt_factory.h"
 #include "behaviortree_cpp/xml_parsing.h"
 #include "behaviortree_cpp/json_export.h"
+#include "greeter_test.h"  // upcasting tests
 
 using namespace BT;
 
@@ -730,3 +731,60 @@ TEST(PortTest, DefaultWronglyOverriden)
   // This is correct
   ASSERT_NO_THROW(auto tree = factory.createTreeFromText(xml_txt_correct));
 }
+
+TEST(PortTest, Upcasting_Issue943)
+{
+  using namespace BT;
+
+  auto plant = PortInfo::Create<Plant::Ptr>();  // not registered
+  auto animal = PortInfo::Create<Animal::Ptr>();
+  auto cat = PortInfo::Create<Cat::Ptr>();
+  auto dog = PortInfo::Create<Dog::Ptr>();
+  auto sphynx = PortInfo::Create<SphynxCat::Ptr>();
+
+  ASSERT_EQ(0, plant.baseChain().size());
+  ASSERT_EQ(1, animal.baseChain().size());
+  ASSERT_EQ(2, cat.baseChain().size());
+  ASSERT_EQ(2, dog.baseChain().size());
+  ASSERT_EQ(3, sphynx.baseChain().size());
+
+  ASSERT_EQ(std::type_index(typeid(Animal)), animal.baseChain()[0]);
+  ASSERT_EQ(std::type_index(typeid(Cat)), cat.baseChain()[0]);
+  ASSERT_EQ(std::type_index(typeid(Animal)), cat.baseChain()[1]);
+  ASSERT_EQ(std::type_index(typeid(Dog)), dog.baseChain()[0]);
+  ASSERT_EQ(std::type_index(typeid(Animal)), dog.baseChain()[1]);
+
+  ASSERT_EQ(std::type_index(typeid(SphynxCat)), sphynx.baseChain()[0]);
+  ASSERT_EQ(std::type_index(typeid(Cat)), sphynx.baseChain()[1]);
+  ASSERT_EQ(std::type_index(typeid(Animal)), sphynx.baseChain()[2]);
+
+  ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(Plant))));
+  ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(Animal))));
+  ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(Cat))));
+  ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(Dog))));
+  ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+
+  ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(Plant))));
+  ASSERT_TRUE(animal.isConvertibleFrom(std::type_index(typeid(Animal))));
+  ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(Cat))));
+  ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(Dog))));
+  ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+
+  ASSERT_FALSE(cat.isConvertibleFrom(std::type_index(typeid(Plant))));
+  ASSERT_TRUE(cat.isConvertibleFrom(std::type_index(typeid(Animal))));
+  ASSERT_TRUE(cat.isConvertibleFrom(std::type_index(typeid(Cat))));
+  ASSERT_FALSE(cat.isConvertibleFrom(std::type_index(typeid(Dog))));
+  ASSERT_FALSE(cat.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+
+  ASSERT_FALSE(dog.isConvertibleFrom(std::type_index(typeid(Plant))));
+  ASSERT_TRUE(dog.isConvertibleFrom(std::type_index(typeid(Animal))));
+  ASSERT_FALSE(dog.isConvertibleFrom(std::type_index(typeid(Cat))));
+  ASSERT_TRUE(dog.isConvertibleFrom(std::type_index(typeid(Dog))));
+  ASSERT_FALSE(dog.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+
+  ASSERT_FALSE(sphynx.isConvertibleFrom(std::type_index(typeid(Plant))));
+  ASSERT_TRUE(sphynx.isConvertibleFrom(std::type_index(typeid(Animal))));
+  ASSERT_TRUE(sphynx.isConvertibleFrom(std::type_index(typeid(Cat))));
+  ASSERT_FALSE(sphynx.isConvertibleFrom(std::type_index(typeid(Dog))));
+  ASSERT_TRUE(sphynx.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+}
diff --git a/tests/include/greeter_test.h b/tests/include/greeter_test.h
index 41b2a7053..f452ed4fd 100644
--- a/tests/include/greeter_test.h
+++ b/tests/include/greeter_test.h
@@ -3,6 +3,62 @@
 
 #include <behaviortree_cpp/utils/safe_any.hpp>
 
+class Animal
+{
+public:
+  using Ptr = std::shared_ptr<Animal>;
+  virtual ~Animal() = default;
+};
+
+class Cat : public Animal
+{
+public:
+  using Ptr = std::shared_ptr<Cat>;
+};
+
+class SphynxCat : public Cat
+{
+public:
+  using Ptr = std::shared_ptr<SphynxCat>;
+};
+
+class Dog : public Animal
+{
+public:
+  using Ptr = std::shared_ptr<Dog>;
+};
+
+// Not registered
+class Plant
+{
+public:
+  using Ptr = std::shared_ptr<Plant>;
+};
+
+template <>
+struct BT::any_cast_base<Animal>
+{
+  using type = Animal;
+};
+
+template <>
+struct BT::any_cast_base<Cat>
+{
+  using type = Animal;
+};
+
+template <>
+struct BT::any_cast_base<SphynxCat>
+{
+  using type = Cat;
+};
+
+template <>
+struct BT::any_cast_base<Dog>
+{
+  using type = Animal;
+};
+
 /**
  *    +-------------------+------------+-------------+-----------------------------+
  *    |       Class       | Base Class | Polymorphic | Type Trait Registered       |

From 8ac0c1cf43f6903e2a01522104ff0838359e8293 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 18:06:54 -0400
Subject: [PATCH 12/20] Use original typeid for shared_ptr types in
 TypeInfo::Create()

---
 include/behaviortree_cpp/basic_types.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/include/behaviortree_cpp/basic_types.h b/include/behaviortree_cpp/basic_types.h
index 5a3992d4e..f63f4f67c 100644
--- a/include/behaviortree_cpp/basic_types.h
+++ b/include/behaviortree_cpp/basic_types.h
@@ -368,9 +368,7 @@ class TypeInfo
         using Chain = compute_base_chain<Elem>;
         auto base_chain = to_type_index_vector(Chain{});
 
-        return TypeInfo(typeid(std::shared_ptr<RootBase>),
-                        GetAnyFromStringFunctor<std::shared_ptr<RootBase>>(),
-                        std::move(base_chain));
+        return TypeInfo(typeid(T), GetAnyFromStringFunctor<T>(), std::move(base_chain));
       }
     }
     return TypeInfo{ typeid(T), GetAnyFromStringFunctor<T>() };

From 12c1377dd24b62427b3d7b65e383524ab4fbe92b Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 18:14:27 -0400
Subject: [PATCH 13/20] Add PortInfo constructors that accept TypeInfo for
 cleaner initialization

Simplifies PortInfo creation by directly accepting TypeInfo objects,
allowing reuse of TypeInfo::Create<T>() without redundant field extraction.
---
 include/behaviortree_cpp/basic_types.h | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/include/behaviortree_cpp/basic_types.h b/include/behaviortree_cpp/basic_types.h
index f63f4f67c..b5827247f 100644
--- a/include/behaviortree_cpp/basic_types.h
+++ b/include/behaviortree_cpp/basic_types.h
@@ -442,6 +442,14 @@ class PortInfo : public TypeInfo
     : TypeInfo(type_info, conv), direction_(direction)
   {}
 
+  PortInfo(PortDirection direction, const TypeInfo& type_info)
+    : TypeInfo(type_info), direction_(direction)
+  {}
+
+  PortInfo(PortDirection direction, TypeInfo&& type_info)
+    : TypeInfo(std::move(type_info)), direction_(direction)
+  {}
+
   [[nodiscard]] PortDirection direction() const;
 
   void setDescription(StringView description);
@@ -493,7 +501,7 @@ template <typename T = AnyTypeAllowed>
   else
   {
     auto type_info = TypeInfo::Create<T>();
-    out = { sname, PortInfo(direction, type_info.type(), type_info.converter()) };
+    out = { sname, PortInfo(direction, std::move(type_info)) };
   }
   if(!description.empty())
   {

From 42b1d808bcb857c1cfcaef4d5a265d223d64dc52 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 18:17:17 -0400
Subject: [PATCH 14/20] Allow port type mismatch if convertible via base class
 chain

Adds support for polymorphic upcasting by checking if the previous type
is included in the base_chain of the current port during blackboard type
consistency checks.
---
 src/xml_parsing.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/xml_parsing.cpp b/src/xml_parsing.cpp
index 885244ed9..978bf867c 100644
--- a/src/xml_parsing.cpp
+++ b/src/xml_parsing.cpp
@@ -825,10 +825,19 @@ TreeNode::Ptr XMLParser::PImpl::createNodeFromXML(const XMLElement* element,
         if(auto prev_info = blackboard->entryInfo(port_key))
         {
           // Check consistency of types.
-          bool const port_type_mismatch =
+          bool port_type_mismatch =
               (prev_info->isStronglyTyped() && port_info.isStronglyTyped() &&
                prev_info->type() != port_info.type());
 
+          // allow mismatch if the previous type appears in the base_chain
+          // of the current port (i.e., valid polymorphic upcast)
+          if(port_type_mismatch && !prev_info->baseChain().empty() &&
+             !port_info.baseChain().empty() &&
+             prev_info->isConvertibleFrom(port_info.baseChain()[0]))
+          {
+            port_type_mismatch = false;
+          }
+
           // special case related to convertFromString
           bool const string_input = (prev_info->type() == typeid(std::string));
 

From 5090086fb2b5bd7fd8d28808e7732ba9e3de5033 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 18:32:38 -0400
Subject: [PATCH 15/20] Improve test coverage for polymorphic port casting

---
 tests/gtest_blackboard.cpp | 128 +++++++++++++++++++++++++++++++------
 1 file changed, 109 insertions(+), 19 deletions(-)

diff --git a/tests/gtest_blackboard.cpp b/tests/gtest_blackboard.cpp
index 1744e7cd9..67e6c4bd4 100644
--- a/tests/gtest_blackboard.cpp
+++ b/tests/gtest_blackboard.cpp
@@ -856,7 +856,6 @@ TEST(BlackboardTest, SetBlackboard_WithPortRemapping)
   ASSERT_NO_THROW(tree.tickWhileRunning(););
 }
 
-
 class CreateHelloGreeter : public SyncActionNode
 {
 public:
@@ -929,22 +928,68 @@ class ShowGreetMessage : public SyncActionNode
   }
 };
 
-TEST(BlackboardTest, Upcasting_Issue943)
+class ShowFancyGreetMessage : public SyncActionNode
 {
-  auto bb = BT::Blackboard::create();
+public:
+  ShowFancyGreetMessage(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
 
-  auto hello_greeter = std::make_shared<HelloGreeter>();
-  bb->set("hello_greeter", hello_greeter);
+  NodeStatus tick() override
+  {
+    FancyHelloGreeter::Ptr greeter{};
+
+    getInput("in_invalid_derived", greeter);
+    if(!greeter)
+      return NodeStatus::FAILURE;
 
-  std::shared_ptr<Greeter> g{};
-  ASSERT_TRUE(bb->get("hello_greeter", g));
-  ASSERT_STREQ("hello", g->show_msg().c_str());
+    greeter->show_msg();
 
-  std::shared_ptr<HelloGreeter> hg{};
-  ASSERT_TRUE(bb->get("hello_greeter", hg));
-  ASSERT_STREQ("hello", hg->show_msg().c_str());
+    return NodeStatus::SUCCESS;
+  }
 
-  std::string xml_txt = R"(
+  static PortsList providedPorts()
+  {
+    return { BT::InputPort<FancyHelloGreeter::Ptr>("in_invalid_derived") };
+  }
+};
+
+TEST(BlackboardTest, Upcasting_Issue943)
+{
+  {
+    auto bb = BT::Blackboard::create();
+
+    // set hello_greeter
+    auto hello_greeter = std::make_shared<HelloGreeter>();
+    bb->set("hello_greeter", hello_greeter);
+
+    // retrieve as base class -> OK
+    std::shared_ptr<Greeter> g{};
+    ASSERT_TRUE(bb->get("hello_greeter", g));
+    ASSERT_STREQ("hello", g->show_msg().c_str());
+
+    // retrieve as derived class -> OK
+    std::shared_ptr<HelloGreeter> hg{};
+    ASSERT_TRUE(bb->get("hello_greeter", hg));
+    ASSERT_STREQ("hello", hg->show_msg().c_str());
+
+    // retrieve as most-derived class -> should throw (type mismatch)
+    std::shared_ptr<FancyHelloGreeter> fhg{};
+    std::cout << "D" << std::endl;
+    ASSERT_ANY_THROW(auto rc = bb->get("hello_greeter", fhg));
+
+    // overwrite hello_greeter bb key
+    ASSERT_ANY_THROW(bb->set("hello_greeter", g));
+    ASSERT_NO_THROW(bb->set("hello_greeter", hg));
+    ASSERT_ANY_THROW(bb->set("hello_greeter", fhg));
+  }
+
+  // This test verifies that polymorphic upcasting works correctly during tree creation.
+  // The port "hello_greeter" is produced as HelloGreeter and later consumed as both
+  // HelloGreeter and its base type Greeter. The tree should execute successfully,
+  // confirming safe polymorphic compatibility through the base_chain mechanism.
+  {
+    std::string xml_txt = R"(
     <root BTCPP_format="4" >
       <BehaviorTree ID="Main">
         <Sequence>
@@ -955,14 +1000,59 @@ TEST(BlackboardTest, Upcasting_Issue943)
       </BehaviorTree>
     </root>)";
 
-  BehaviorTreeFactory factory;
-  factory.registerNodeType<CreateHelloGreeter>("CreateHelloGreeter");
-  factory.registerNodeType<SetDerivedParameter>("SetDerivedParameter");
-  factory.registerNodeType<ShowGreetMessage>("ShowGreetMessage");
+    BehaviorTreeFactory factory;
+    factory.registerNodeType<CreateHelloGreeter>("CreateHelloGreeter");
+    factory.registerNodeType<SetDerivedParameter>("SetDerivedParameter");
+    factory.registerNodeType<ShowGreetMessage>("ShowGreetMessage");
 
-  auto tree = factory.createTreeFromText(xml_txt);
+    auto tree = factory.createTreeFromText(xml_txt);
 
-  NodeStatus status = tree.tickWhileRunning();
+    NodeStatus status = tree.tickWhileRunning();
 
-  ASSERT_EQ(status, NodeStatus::SUCCESS);
+    ASSERT_EQ(status, NodeStatus::SUCCESS);
+  }
+
+  // This test ensures that an invalid polymorphic downcast is correctly detected
+  // during tree creation. The port "hello_greeter" is first created with HelloGreeter,
+  // then later expected as FancyHelloGreeter (a more derived type), which fails.
+  {
+    std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <Sequence>
+          <Script code="test := false"/>
+          <CreateHelloGreeter out_derived="{hello_greeter}" />
+          <SetDerivedParameter in_derived="{hello_greeter}" n="2" />
+          <ShowGreetMessage in_base="{hello_greeter}" />
+          <ShowFancyGreetMessage in_invalid_derived="{hello_greeter}" />
+        </Sequence>
+      </BehaviorTree>
+    </root>)";
+
+    BehaviorTreeFactory factory;
+    factory.registerNodeType<CreateHelloGreeter>("CreateHelloGreeter");
+    factory.registerNodeType<SetDerivedParameter>("SetDerivedParameter");
+    factory.registerNodeType<ShowGreetMessage>("ShowGreetMessage");
+    factory.registerNodeType<ShowFancyGreetMessage>("ShowFancyGreetMessage");
+
+    try
+    {
+      auto tree = factory.createTreeFromText(xml_txt);
+      FAIL() << "Expected BT::RuntimeError to be thrown";
+    }
+    catch(const BT::RuntimeError& e)
+    {
+      std::string expected_msg = "The creation of the tree failed because the port "
+                                 "[hello_greeter] was initially "
+                                 "created with type [std::shared_ptr<HelloGreeter>] and, "
+                                 "later type "
+                                 "[std::shared_ptr<FancyHelloGreeter>] was used "
+                                 "somewhere else.";
+      ASSERT_EQ(e.what(), expected_msg);
+    }
+    catch(...)
+    {
+      FAIL() << "Expected BT::RuntimeError but caught a different exception";
+    }
+  }
 }

From eda26831f75804fb3370bbb8750b479ca9e80c7c Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 19:28:18 -0400
Subject: [PATCH 16/20] Make test platform-independent by relaxing exact
 exception message check

---
 tests/gtest_blackboard.cpp | 20 +-------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

diff --git a/tests/gtest_blackboard.cpp b/tests/gtest_blackboard.cpp
index 67e6c4bd4..5abac9543 100644
--- a/tests/gtest_blackboard.cpp
+++ b/tests/gtest_blackboard.cpp
@@ -1035,24 +1035,6 @@ TEST(BlackboardTest, Upcasting_Issue943)
     factory.registerNodeType<ShowGreetMessage>("ShowGreetMessage");
     factory.registerNodeType<ShowFancyGreetMessage>("ShowFancyGreetMessage");
 
-    try
-    {
-      auto tree = factory.createTreeFromText(xml_txt);
-      FAIL() << "Expected BT::RuntimeError to be thrown";
-    }
-    catch(const BT::RuntimeError& e)
-    {
-      std::string expected_msg = "The creation of the tree failed because the port "
-                                 "[hello_greeter] was initially "
-                                 "created with type [std::shared_ptr<HelloGreeter>] and, "
-                                 "later type "
-                                 "[std::shared_ptr<FancyHelloGreeter>] was used "
-                                 "somewhere else.";
-      ASSERT_EQ(e.what(), expected_msg);
-    }
-    catch(...)
-    {
-      FAIL() << "Expected BT::RuntimeError but caught a different exception";
-    }
+    ASSERT_ANY_THROW(auto tree = factory.createTreeFromText(xml_txt));
   }
 }

From cad9a0532abea15e6f766cb94bb1688943e02c49 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 23:18:01 -0400
Subject: [PATCH 17/20] Refactor upcasting tests to use clearer Animal
 hierarchy example

---
 tests/gtest_any.cpp                   | 100 +++------
 tests/gtest_blackboard.cpp            | 303 ++++++++++++++++++++------
 tests/gtest_ports.cpp                 |  22 +-
 tests/include/animal_hierarchy_test.h |  81 +++++++
 tests/include/greeter_test.h          | 251 ---------------------
 5 files changed, 353 insertions(+), 404 deletions(-)
 create mode 100644 tests/include/animal_hierarchy_test.h
 delete mode 100644 tests/include/greeter_test.h

diff --git a/tests/gtest_any.cpp b/tests/gtest_any.cpp
index dc0575946..414b706bc 100644
--- a/tests/gtest_any.cpp
+++ b/tests/gtest_any.cpp
@@ -17,7 +17,7 @@
 #include <gtest/gtest.h>
 
 #include <behaviortree_cpp/utils/safe_any.hpp>
-#include "greeter_test.h"
+#include "animal_hierarchy_test.h"
 
 using namespace BT;
 
@@ -254,77 +254,31 @@ TEST(Any, Cast)
   /// Issue 943
   // Type casting: polymorphic class w/ registered base class
   {
-    auto g = std::make_shared<Greeter>();
-    Any any_g(g);
-    EXPECT_NO_THROW(auto res = any_g.cast<Greeter::Ptr>());
-    EXPECT_ANY_THROW(auto res = any_g.cast<HelloGreeter::Ptr>());
-    EXPECT_ANY_THROW(auto res = any_g.cast<FancyHelloGreeter::Ptr>());
-    EXPECT_TRUE(any_g.castPtr<Greeter::Ptr>());
-    EXPECT_FALSE(any_g.castPtr<HelloGreeter::Ptr>());
-    EXPECT_FALSE(any_g.castPtr<FancyHelloGreeter::Ptr>());
-
-    auto hg = std::make_shared<HelloGreeter>();
-    Any any_hg(hg);
-    EXPECT_NO_THROW(auto res = any_hg.cast<Greeter::Ptr>());
-    EXPECT_NO_THROW(auto res = any_hg.cast<HelloGreeter::Ptr>());
-    EXPECT_ANY_THROW(auto res = any_hg.cast<FancyHelloGreeter::Ptr>());
-    EXPECT_TRUE(any_hg.castPtr<Greeter::Ptr>());
-    EXPECT_TRUE(any_hg.castPtr<HelloGreeter::Ptr>());
-    EXPECT_FALSE(any_hg.castPtr<FancyHelloGreeter::Ptr>());
-
-    auto fhg = std::make_shared<FancyHelloGreeter>();
-    Any any_fhg(fhg);
-    EXPECT_NO_THROW(auto res = any_fhg.cast<Greeter::Ptr>());
-    EXPECT_NO_THROW(auto res = any_fhg.cast<HelloGreeter::Ptr>());
-    EXPECT_NO_THROW(auto res = any_fhg.cast<FancyHelloGreeter::Ptr>());
-    EXPECT_TRUE(any_fhg.castPtr<Greeter::Ptr>());
-    EXPECT_TRUE(any_fhg.castPtr<HelloGreeter::Ptr>());
-    EXPECT_TRUE(any_fhg.castPtr<FancyHelloGreeter::Ptr>());
-
-    // Try to upcast to an incorrectly registered base
-    auto u = std::make_shared<Unwelcomer>();
-
-    // OK, fails to compile -> invalid static cast
-    // Any any_u(u);
-    // EXPECT_ANY_THROW(auto res = any_g.cast<Unwelcomer::Ptr>());
-  }
-
-  // Type casting: polymorphic class w/o registered base class
-  {
-    auto g = std::make_shared<GreeterNoReg>();
-    Any any_g(g);
-    EXPECT_NO_THROW(auto res = any_g.cast<GreeterNoReg::Ptr>());
-    EXPECT_ANY_THROW(auto res = any_g.cast<HelloGreeterNoReg::Ptr>());
-    EXPECT_TRUE(any_g.castPtr<GreeterNoReg::Ptr>());
-    EXPECT_FALSE(any_g.castPtr<HelloGreeterNoReg::Ptr>());
-
-    auto hg = std::make_shared<HelloGreeterNoReg>();
-    Any any_hg(hg);
-    EXPECT_ANY_THROW(auto res = any_hg.cast<GreeterNoReg::Ptr>());
-    EXPECT_NO_THROW(auto res = any_hg.cast<HelloGreeterNoReg::Ptr>());
-    EXPECT_FALSE(any_hg.castPtr<GreeterNoReg::Ptr>());
-    EXPECT_TRUE(any_hg.castPtr<HelloGreeterNoReg::Ptr>());
-  }
-
-  // Type casting: non polymorphic class w/ registered base class
-  {
-    // OK: static_assert(std::is_polymorphic_v<Base>, "Base must be polymorphic")
-  }
-
-  // Type casting: non polymorphic class w/o registered base class
-  {
-    auto g = std::make_shared<GreeterNoPolyReg>();
-    Any any_g(g);
-    EXPECT_NO_THROW(auto res = any_g.cast<GreeterNoPolyReg::Ptr>());
-    EXPECT_ANY_THROW(auto res = any_g.cast<HelloGreeterNoPolyReg::Ptr>());
-    EXPECT_TRUE(any_g.castPtr<GreeterNoPolyReg::Ptr>());
-    EXPECT_FALSE(any_g.castPtr<HelloGreeterNoPolyReg::Ptr>());
-
-    auto hg = std::make_shared<HelloGreeterNoPolyReg>();
-    Any any_hg(hg);
-    EXPECT_ANY_THROW(auto res = any_hg.cast<GreeterNoPolyReg::Ptr>());
-    EXPECT_NO_THROW(auto res = any_hg.cast<HelloGreeterNoPolyReg::Ptr>());
-    EXPECT_FALSE(any_hg.castPtr<GreeterNoPolyReg::Ptr>());
-    EXPECT_TRUE(any_hg.castPtr<HelloGreeterNoPolyReg::Ptr>());
+    auto animal = std::make_shared<Animal>();
+    Any any_animal(animal);
+    EXPECT_NO_THROW(auto res = any_animal.cast<Animal::Ptr>());
+    EXPECT_ANY_THROW(auto res = any_animal.cast<Cat::Ptr>());
+    EXPECT_ANY_THROW(auto res = any_animal.cast<Sphynx::Ptr>());
+    EXPECT_TRUE(any_animal.castPtr<Animal::Ptr>());
+    EXPECT_FALSE(any_animal.castPtr<Cat::Ptr>());
+    EXPECT_FALSE(any_animal.castPtr<Sphynx::Ptr>());
+
+    auto cat = std::make_shared<Cat>();
+    Any any_cat(cat);
+    EXPECT_NO_THROW(auto res = any_cat.cast<Animal::Ptr>());
+    EXPECT_NO_THROW(auto res = any_cat.cast<Cat::Ptr>());
+    EXPECT_ANY_THROW(auto res = any_cat.cast<Sphynx::Ptr>());
+    EXPECT_TRUE(any_cat.castPtr<Animal::Ptr>());
+    EXPECT_TRUE(any_cat.castPtr<Cat::Ptr>());
+    EXPECT_FALSE(any_cat.castPtr<Sphynx::Ptr>());
+
+    auto sphynx = std::make_shared<Sphynx>();
+    Any any_sphynx(sphynx);
+    EXPECT_NO_THROW(auto res = any_sphynx.cast<Animal::Ptr>());
+    EXPECT_NO_THROW(auto res = any_sphynx.cast<Cat::Ptr>());
+    EXPECT_NO_THROW(auto res = any_sphynx.cast<Sphynx::Ptr>());
+    EXPECT_TRUE(any_sphynx.castPtr<Animal::Ptr>());
+    EXPECT_TRUE(any_sphynx.castPtr<Cat::Ptr>());
+    EXPECT_TRUE(any_sphynx.castPtr<Sphynx::Ptr>());
   }
 }
diff --git a/tests/gtest_blackboard.cpp b/tests/gtest_blackboard.cpp
index 5abac9543..64fae5d9e 100644
--- a/tests/gtest_blackboard.cpp
+++ b/tests/gtest_blackboard.cpp
@@ -15,7 +15,7 @@
 #include "behaviortree_cpp/blackboard.h"
 
 #include "../sample_nodes/dummy_nodes.h"
-#include "greeter_test.h"
+#include "animal_hierarchy_test.h"
 
 using namespace BT;
 
@@ -856,101 +856,210 @@ TEST(BlackboardTest, SetBlackboard_WithPortRemapping)
   ASSERT_NO_THROW(tree.tickWhileRunning(););
 }
 
-class CreateHelloGreeter : public SyncActionNode
+class CreateAnimal : public SyncActionNode
 {
 public:
-  CreateHelloGreeter(const std::string& name, const NodeConfig& config)
+  CreateAnimal(const std::string& name, const NodeConfig& config)
     : SyncActionNode(name, config)
   {}
 
   NodeStatus tick() override
   {
-    auto hello_greeter = std::make_shared<HelloGreeter>();
+    auto animal = std::make_shared<Animal>();
 
-    setOutput("out_derived", hello_greeter);
+    setOutput("out_animal", animal);
 
     return NodeStatus::SUCCESS;
   }
 
   static PortsList providedPorts()
   {
-    return { BT::OutputPort<HelloGreeter::Ptr>("out_derived") };
+    return { BT::OutputPort<Animal::Ptr>("out_animal") };
   }
 };
 
-class SetDerivedParameter : public SyncActionNode
+class CreateCat : public SyncActionNode
 {
 public:
-  SetDerivedParameter(const std::string& name, const NodeConfig& config)
+  CreateCat(const std::string& name, const NodeConfig& config)
     : SyncActionNode(name, config)
   {}
 
   NodeStatus tick() override
   {
-    int n;
-    HelloGreeter::Ptr hello_greeter{};
+    auto cat = std::make_shared<Cat>();
 
-    getInput("n", n);
-    getInput("in_derived", hello_greeter);
+    setOutput("out_cat", cat);
 
-    hello_greeter->setDerivedParameter(n);
-    hello_greeter->show_msg();
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::OutputPort<Cat::Ptr>("out_cat") };
+  }
+};
+
+class CreateSphynx : public SyncActionNode
+{
+public:
+  CreateSphynx(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    auto sphynx = std::make_shared<Sphynx>();
+
+    setOutput("out_sphynx", sphynx);
+
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::OutputPort<Sphynx::Ptr>("out_sphynx") };
+  }
+};
+
+class CreateDog : public SyncActionNode
+{
+public:
+  CreateDog(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    auto dog = std::make_shared<Dog>();
+
+    setOutput("out_dog", dog);
 
     return NodeStatus::SUCCESS;
   }
 
   static PortsList providedPorts()
   {
-    return { BT::InputPort<int>("n"), BT::InputPort<HelloGreeter::Ptr>("in_derived") };
+    return { BT::OutputPort<Dog::Ptr>("out_dog") };
   }
 };
 
-class ShowGreetMessage : public SyncActionNode
+class PrintAnimalName : public SyncActionNode
 {
 public:
-  ShowGreetMessage(const std::string& name, const NodeConfig& config)
+  PrintAnimalName(const std::string& name, const NodeConfig& config)
     : SyncActionNode(name, config)
   {}
 
   NodeStatus tick() override
   {
-    Greeter::Ptr greeter{};
+    Animal::Ptr animal{};
+    getInput("in_animal", animal);
 
-    getInput("in_base", greeter);
-    greeter->show_msg();
+    std::cout << animal->name() << std::endl;
 
     return NodeStatus::SUCCESS;
   }
 
   static PortsList providedPorts()
   {
-    return { BT::InputPort<Greeter::Ptr>("in_base") };
+    return { BT::InputPort<Animal::Ptr>("in_animal") };
   }
 };
 
-class ShowFancyGreetMessage : public SyncActionNode
+class PrintCatName : public SyncActionNode
 {
 public:
-  ShowFancyGreetMessage(const std::string& name, const NodeConfig& config)
+  PrintCatName(const std::string& name, const NodeConfig& config)
     : SyncActionNode(name, config)
   {}
 
   NodeStatus tick() override
   {
-    FancyHelloGreeter::Ptr greeter{};
+    Cat::Ptr cat{};
+    getInput("in_cat", cat);
 
-    getInput("in_invalid_derived", greeter);
-    if(!greeter)
-      return NodeStatus::FAILURE;
+    std::cout << cat->name() << std::endl;
+
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::InputPort<Cat::Ptr>("in_cat") };
+  }
+};
+
+class PrintDogName : public SyncActionNode
+{
+public:
+  PrintDogName(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    Dog::Ptr dog{};
+    getInput("in_dog", dog);
+
+    std::cout << dog->name() << std::endl;
+
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::InputPort<Dog::Ptr>("in_dog") };
+  }
+};
+
+class PrintSphynxName : public SyncActionNode
+{
+public:
+  PrintSphynxName(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    Sphynx::Ptr sphynx{};
+    getInput("in_sphynx", sphynx);
 
-    greeter->show_msg();
+    std::cout << sphynx->name() << std::endl;
 
     return NodeStatus::SUCCESS;
   }
 
   static PortsList providedPorts()
   {
-    return { BT::InputPort<FancyHelloGreeter::Ptr>("in_invalid_derived") };
+    return { BT::InputPort<Sphynx::Ptr>("in_sphynx") };
+  }
+};
+
+class ModifyAnimalName : public SyncActionNode
+{
+public:
+  ModifyAnimalName(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    Animal::Ptr animal{};
+    getInput("inout_animal", animal);
+
+    animal->setName("Animal");
+
+    setOutput("inout_animal", animal);
+
+    std::cout << animal->name() << std::endl;
+
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::BidirectionalPort<Animal::Ptr>("inout_animal") };
   }
 };
 
@@ -959,51 +1068,43 @@ TEST(BlackboardTest, Upcasting_Issue943)
   {
     auto bb = BT::Blackboard::create();
 
-    // set hello_greeter
-    auto hello_greeter = std::make_shared<HelloGreeter>();
-    bb->set("hello_greeter", hello_greeter);
-
-    // retrieve as base class -> OK
-    std::shared_ptr<Greeter> g{};
-    ASSERT_TRUE(bb->get("hello_greeter", g));
-    ASSERT_STREQ("hello", g->show_msg().c_str());
-
-    // retrieve as derived class -> OK
-    std::shared_ptr<HelloGreeter> hg{};
-    ASSERT_TRUE(bb->get("hello_greeter", hg));
-    ASSERT_STREQ("hello", hg->show_msg().c_str());
-
-    // retrieve as most-derived class -> should throw (type mismatch)
-    std::shared_ptr<FancyHelloGreeter> fhg{};
-    std::cout << "D" << std::endl;
-    ASSERT_ANY_THROW(auto rc = bb->get("hello_greeter", fhg));
-
-    // overwrite hello_greeter bb key
-    ASSERT_ANY_THROW(bb->set("hello_greeter", g));
-    ASSERT_NO_THROW(bb->set("hello_greeter", hg));
-    ASSERT_ANY_THROW(bb->set("hello_greeter", fhg));
+    auto cat_original = std::make_shared<Cat>();
+    bb->set("cat", cat_original);
+
+    std::shared_ptr<Animal> animal{};
+    ASSERT_TRUE(bb->get("cat", animal));
+    ASSERT_STREQ("Cat", animal->name().c_str());
+
+    std::shared_ptr<Cat> cat{};
+    ASSERT_TRUE(bb->get("cat", cat));
+    ASSERT_STREQ("Cat", cat->name().c_str());
+
+    std::shared_ptr<Sphynx> sphynx{};
+    ASSERT_ANY_THROW(auto rc = bb->get("cat", sphynx));
+
+    ASSERT_ANY_THROW(bb->set("cat", animal));
+    ASSERT_NO_THROW(bb->set("cat", cat));
+    ASSERT_ANY_THROW(bb->set("cat", sphynx));
   }
 
   // This test verifies that polymorphic upcasting works correctly during tree creation.
-  // The port "hello_greeter" is produced as HelloGreeter and later consumed as both
-  // HelloGreeter and its base type Greeter. The tree should execute successfully,
-  // confirming safe polymorphic compatibility through the base_chain mechanism.
+  // The port "cat" is produced as Cat and later consumed as both Cat and its base type Animal.
   {
     std::string xml_txt = R"(
     <root BTCPP_format="4" >
       <BehaviorTree ID="Main">
         <Sequence>
-          <CreateHelloGreeter out_derived="{hello_greeter}" />
-          <SetDerivedParameter in_derived="{hello_greeter}" n="2" />
-          <ShowGreetMessage in_base="{hello_greeter}" />
+          <CreateCat out_cat="{cat}" />
+          <PrintCatName in_cat="{cat}" />
+          <PrintAnimalName in_animal="{cat}" />
         </Sequence>
       </BehaviorTree>
     </root>)";
 
     BehaviorTreeFactory factory;
-    factory.registerNodeType<CreateHelloGreeter>("CreateHelloGreeter");
-    factory.registerNodeType<SetDerivedParameter>("SetDerivedParameter");
-    factory.registerNodeType<ShowGreetMessage>("ShowGreetMessage");
+    factory.registerNodeType<CreateCat>("CreateCat");
+    factory.registerNodeType<PrintCatName>("PrintCatName");
+    factory.registerNodeType<PrintAnimalName>("PrintAnimalName");
 
     auto tree = factory.createTreeFromText(xml_txt);
 
@@ -1012,28 +1113,86 @@ TEST(BlackboardTest, Upcasting_Issue943)
     ASSERT_EQ(status, NodeStatus::SUCCESS);
   }
 
+  // This test ensures that an invalid polymorphic upcast is correctly detected
+  // during tree creation. The port "cat" is first created with Cat, then later
+  // expected as Dog, which is invalid.
+  {
+    std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <Sequence>
+          <CreateCat out_cat="{cat}" />
+          <PrintDogName in_dog="{cat}" />
+        </Sequence>
+      </BehaviorTree>
+    </root>)";
+
+    BehaviorTreeFactory factory;
+    factory.registerNodeType<CreateCat>("CreateCat");
+    factory.registerNodeType<PrintDogName>("PrintDogName");
+
+    ASSERT_ANY_THROW(auto tree = factory.createTreeFromText(xml_txt));
+  }
+
   // This test ensures that an invalid polymorphic downcast is correctly detected
-  // during tree creation. The port "hello_greeter" is first created with HelloGreeter,
-  // then later expected as FancyHelloGreeter (a more derived type), which fails.
+  // during tree creation. The port "cat" is first created with Cat, then later
+  // expected as Sphynx (a more derived type), which fails.
+  {
+    std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <Sequence>
+          <CreateCat out_cat="{cat}" />
+          <PrintSphynxName in_sphynx="{cat}" />
+        </Sequence>
+      </BehaviorTree>
+    </root>)";
+
+    BehaviorTreeFactory factory;
+    factory.registerNodeType<CreateCat>("CreateCat");
+    factory.registerNodeType<PrintSphynxName>("PrintSphynxName");
+
+    ASSERT_ANY_THROW(auto tree = factory.createTreeFromText(xml_txt));
+  }
+
+  // This test ensures that no polymorphic upcast can be used when supplied
+  // to an Output port. The port "cat" is first created with Cat, then later
+  // expected as an Animal output port, which fails.
+  {
+    std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <Sequence>
+          <CreateCat out_cat="{cat}" />
+          <CreateAnimal out_animal="{cat}" />
+        </Sequence>
+      </BehaviorTree>
+    </root>)";
+
+    BehaviorTreeFactory factory;
+    factory.registerNodeType<CreateAnimal>("CreateAnimal");
+    factory.registerNodeType<CreateCat>("CreateCat");
+
+    ASSERT_ANY_THROW(auto tree = factory.createTreeFromText(xml_txt));
+  }
+
+  // This test ensures that no polymorphic upcast can be used when supplied
+  // to an Bidirectional port. The port "cat" is first created with Cat, then later
+  // expected as an Animal bidirectional port, which fails.
   {
     std::string xml_txt = R"(
     <root BTCPP_format="4" >
       <BehaviorTree ID="Main">
         <Sequence>
-          <Script code="test := false"/>
-          <CreateHelloGreeter out_derived="{hello_greeter}" />
-          <SetDerivedParameter in_derived="{hello_greeter}" n="2" />
-          <ShowGreetMessage in_base="{hello_greeter}" />
-          <ShowFancyGreetMessage in_invalid_derived="{hello_greeter}" />
+          <CreateCat out_cat="{cat}" />
+          <ModifyAnimalName inout_animal="{cat}" />
         </Sequence>
       </BehaviorTree>
     </root>)";
 
     BehaviorTreeFactory factory;
-    factory.registerNodeType<CreateHelloGreeter>("CreateHelloGreeter");
-    factory.registerNodeType<SetDerivedParameter>("SetDerivedParameter");
-    factory.registerNodeType<ShowGreetMessage>("ShowGreetMessage");
-    factory.registerNodeType<ShowFancyGreetMessage>("ShowFancyGreetMessage");
+    factory.registerNodeType<CreateCat>("CreateCat");
+    factory.registerNodeType<ModifyAnimalName>("ModifyAnimalName");
 
     ASSERT_ANY_THROW(auto tree = factory.createTreeFromText(xml_txt));
   }
diff --git a/tests/gtest_ports.cpp b/tests/gtest_ports.cpp
index c1e79c5c7..686de5c33 100644
--- a/tests/gtest_ports.cpp
+++ b/tests/gtest_ports.cpp
@@ -3,7 +3,7 @@
 #include "behaviortree_cpp/bt_factory.h"
 #include "behaviortree_cpp/xml_parsing.h"
 #include "behaviortree_cpp/json_export.h"
-#include "greeter_test.h"  // upcasting tests
+#include "animal_hierarchy_test.h"
 
 using namespace BT;
 
@@ -732,6 +732,12 @@ TEST(PortTest, DefaultWronglyOverriden)
   ASSERT_NO_THROW(auto tree = factory.createTreeFromText(xml_txt_correct));
 }
 
+class Plant
+{
+public:
+  using Ptr = std::shared_ptr<Plant>;
+};
+
 TEST(PortTest, Upcasting_Issue943)
 {
   using namespace BT;
@@ -740,7 +746,7 @@ TEST(PortTest, Upcasting_Issue943)
   auto animal = PortInfo::Create<Animal::Ptr>();
   auto cat = PortInfo::Create<Cat::Ptr>();
   auto dog = PortInfo::Create<Dog::Ptr>();
-  auto sphynx = PortInfo::Create<SphynxCat::Ptr>();
+  auto sphynx = PortInfo::Create<Sphynx::Ptr>();
 
   ASSERT_EQ(0, plant.baseChain().size());
   ASSERT_EQ(1, animal.baseChain().size());
@@ -754,7 +760,7 @@ TEST(PortTest, Upcasting_Issue943)
   ASSERT_EQ(std::type_index(typeid(Dog)), dog.baseChain()[0]);
   ASSERT_EQ(std::type_index(typeid(Animal)), dog.baseChain()[1]);
 
-  ASSERT_EQ(std::type_index(typeid(SphynxCat)), sphynx.baseChain()[0]);
+  ASSERT_EQ(std::type_index(typeid(Sphynx)), sphynx.baseChain()[0]);
   ASSERT_EQ(std::type_index(typeid(Cat)), sphynx.baseChain()[1]);
   ASSERT_EQ(std::type_index(typeid(Animal)), sphynx.baseChain()[2]);
 
@@ -762,29 +768,29 @@ TEST(PortTest, Upcasting_Issue943)
   ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(Animal))));
   ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(Cat))));
   ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(Dog))));
-  ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+  ASSERT_FALSE(plant.isConvertibleFrom(std::type_index(typeid(Sphynx))));
 
   ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(Plant))));
   ASSERT_TRUE(animal.isConvertibleFrom(std::type_index(typeid(Animal))));
   ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(Cat))));
   ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(Dog))));
-  ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+  ASSERT_FALSE(animal.isConvertibleFrom(std::type_index(typeid(Sphynx))));
 
   ASSERT_FALSE(cat.isConvertibleFrom(std::type_index(typeid(Plant))));
   ASSERT_TRUE(cat.isConvertibleFrom(std::type_index(typeid(Animal))));
   ASSERT_TRUE(cat.isConvertibleFrom(std::type_index(typeid(Cat))));
   ASSERT_FALSE(cat.isConvertibleFrom(std::type_index(typeid(Dog))));
-  ASSERT_FALSE(cat.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+  ASSERT_FALSE(cat.isConvertibleFrom(std::type_index(typeid(Sphynx))));
 
   ASSERT_FALSE(dog.isConvertibleFrom(std::type_index(typeid(Plant))));
   ASSERT_TRUE(dog.isConvertibleFrom(std::type_index(typeid(Animal))));
   ASSERT_FALSE(dog.isConvertibleFrom(std::type_index(typeid(Cat))));
   ASSERT_TRUE(dog.isConvertibleFrom(std::type_index(typeid(Dog))));
-  ASSERT_FALSE(dog.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+  ASSERT_FALSE(dog.isConvertibleFrom(std::type_index(typeid(Sphynx))));
 
   ASSERT_FALSE(sphynx.isConvertibleFrom(std::type_index(typeid(Plant))));
   ASSERT_TRUE(sphynx.isConvertibleFrom(std::type_index(typeid(Animal))));
   ASSERT_TRUE(sphynx.isConvertibleFrom(std::type_index(typeid(Cat))));
   ASSERT_FALSE(sphynx.isConvertibleFrom(std::type_index(typeid(Dog))));
-  ASSERT_TRUE(sphynx.isConvertibleFrom(std::type_index(typeid(SphynxCat))));
+  ASSERT_TRUE(sphynx.isConvertibleFrom(std::type_index(typeid(Sphynx))));
 }
diff --git a/tests/include/animal_hierarchy_test.h b/tests/include/animal_hierarchy_test.h
new file mode 100644
index 000000000..ceac7c3e2
--- /dev/null
+++ b/tests/include/animal_hierarchy_test.h
@@ -0,0 +1,81 @@
+#ifndef ANIMALHIERARCHY_H_
+#define ANIMALHIERARCHY_H_
+
+#include <behaviortree_cpp/utils/safe_any.hpp>
+
+class Animal
+{
+public:
+  using Ptr = std::shared_ptr<Animal>;
+
+  virtual std::string name() const
+  {
+    return name_;
+  }
+
+  void setName(const std::string& name)
+  {
+    name_ = name;
+  }
+
+  virtual ~Animal() = default;
+
+private:
+  std::string name_ = "Unknown";
+};
+
+class Cat : public Animal
+{
+public:
+  using Ptr = std::shared_ptr<Cat>;
+  std::string name() const override
+  {
+    return "Cat";
+  }
+};
+
+class Sphynx : public Cat
+{
+public:
+  using Ptr = std::shared_ptr<Sphynx>;
+  std::string name() const override
+  {
+    return "Sphynx";
+  }
+};
+
+class Dog : public Animal
+{
+public:
+  using Ptr = std::shared_ptr<Dog>;
+  std::string name() const override
+  {
+    return "Dog";
+  }
+};
+
+template <>
+struct BT::any_cast_base<Animal>
+{
+  using type = Animal;
+};
+
+template <>
+struct BT::any_cast_base<Cat>
+{
+  using type = Animal;
+};
+
+template <>
+struct BT::any_cast_base<Sphynx>
+{
+  using type = Cat;
+};
+
+template <>
+struct BT::any_cast_base<Dog>
+{
+  using type = Animal;
+};
+
+#endif  // ANIMALHIERARCHY_H_
diff --git a/tests/include/greeter_test.h b/tests/include/greeter_test.h
deleted file mode 100644
index f452ed4fd..000000000
--- a/tests/include/greeter_test.h
+++ /dev/null
@@ -1,251 +0,0 @@
-#ifndef GREETER_TEST_H_
-#define GREETER_TEST_H_
-
-#include <behaviortree_cpp/utils/safe_any.hpp>
-
-class Animal
-{
-public:
-  using Ptr = std::shared_ptr<Animal>;
-  virtual ~Animal() = default;
-};
-
-class Cat : public Animal
-{
-public:
-  using Ptr = std::shared_ptr<Cat>;
-};
-
-class SphynxCat : public Cat
-{
-public:
-  using Ptr = std::shared_ptr<SphynxCat>;
-};
-
-class Dog : public Animal
-{
-public:
-  using Ptr = std::shared_ptr<Dog>;
-};
-
-// Not registered
-class Plant
-{
-public:
-  using Ptr = std::shared_ptr<Plant>;
-};
-
-template <>
-struct BT::any_cast_base<Animal>
-{
-  using type = Animal;
-};
-
-template <>
-struct BT::any_cast_base<Cat>
-{
-  using type = Animal;
-};
-
-template <>
-struct BT::any_cast_base<SphynxCat>
-{
-  using type = Cat;
-};
-
-template <>
-struct BT::any_cast_base<Dog>
-{
-  using type = Animal;
-};
-
-/**
- *    +-------------------+------------+-------------+-----------------------------+
- *    |       Class       | Base Class | Polymorphic | Type Trait Registered       |
- *    +-------------------+------------+-------------+-----------------------------+
- *    | Greeter           | -          | Yes         | Greeter                     |
- *    | HelloGreeter      | Greeter    | Yes         | Greeter                     |
- *    | FancyHelloGreeter | Greeter    | Yes         | Greeter                     |
- *    | Unwelcomer        | -          | Yes         | Greeter (Purposely invalid) |
- *    +-------------------+------------+-------------+-----------------------------+
- */
-
-class Greeter
-{
-public:
-  using Ptr = std::shared_ptr<Greeter>;
-  virtual ~Greeter() = default;
-  virtual std::string show_msg() const
-  {
-    return "";
-  };
-};
-
-class HelloGreeter : public Greeter
-{
-public:
-  using Ptr = std::shared_ptr<HelloGreeter>;
-  std::string show_msg() const override
-  {
-    return "hello";
-  }
-  void setDerivedParameter(int n){};
-};
-
-class FancyHelloGreeter : public HelloGreeter
-{
-public:
-  using Ptr = std::shared_ptr<FancyHelloGreeter>;
-  std::string show_msg() const override
-  {
-    return "salutations";
-  }
-};
-
-class Unwelcomer
-{
-public:
-  using Ptr = std::shared_ptr<Unwelcomer>;
-  virtual ~Unwelcomer() = default;
-  virtual std::string show_msg() const
-  {
-    return "You’re not welcome here";
-  };
-};
-
-// Register cast base type for self to allow direct cast
-template <>
-struct BT::any_cast_base<Greeter>
-{
-  using type = Greeter;
-};
-
-// Register cast base type for HelloGreeter
-template <>
-struct BT::any_cast_base<HelloGreeter>
-{
-  using type = Greeter;
-};
-
-// Register cast base type for FancyHelloGreeter
-template <>
-struct BT::any_cast_base<FancyHelloGreeter>
-{
-  using type = HelloGreeter;
-};
-
-// Register cast base type for Unwelcomer
-// WARNING: intentionally incorrect
-template <>
-struct BT::any_cast_base<Unwelcomer>
-{
-  using type = Greeter;
-};
-
-/**
-*    +-------------------+--------------+-------------+-----------------------+
-*    |     Class         | Base Class   | Polymorphic | Type Trait Registered |
-*    +-------------------+--------------+-------------+-----------------------+
-*    | GreeterNoReg      | -            | Yes         | -                     |
-*    | HelloGreeterNoReg | GreeterNoReg | Yes         | -                     |
-*    +-------------------+--------------+-------------+-----------------------+
-*/
-
-class GreeterNoReg
-{
-public:
-  using Ptr = std::shared_ptr<GreeterNoReg>;
-  virtual ~GreeterNoReg() = default;
-  virtual std::string show_msg() const
-  {
-    return "";
-  };
-};
-
-class HelloGreeterNoReg : public GreeterNoReg
-{
-public:
-  using Ptr = std::shared_ptr<HelloGreeterNoReg>;
-  std::string show_msg() const override
-  {
-    return "hello";
-  }
-  void setDerivedParameter(int n){};
-};
-
-/**
-*    +--------------------+---------------+-------------+-----------------------+
-*    |     Class          | Base Class    | Polymorphic | Type Trait Registered |
-*    +--------------------+---------------+-------------+-----------------------+
-*    | GreeterNoPoly      | -             | No          | GreeterNoPoly         |
-*    | HelloGreeterNoPoly | GreeterNoPoly | No          | GreeterNoPoly         |
-*    +-----------------------+------------+-------------+-----------------------+
-*/
-
-// Correctly fails to compile:
-//     static_assert(std::is_polymorphic_v<Base>, "Base must be polymorphic");
-
-// class GreeterNoPoly
-// {
-// public:
-//   using Ptr = std::shared_ptr<GreeterNoPoly>;
-//   std::string greet() const
-//   {
-//     return "";
-//   };
-// };
-//
-// class HelloGreeterNoPoly : public GreeterNoPoly
-// {
-// public:
-//   using Ptr = std::shared_ptr<HelloGreeterNoPoly>;
-//   std::string hello_greet()
-//   {
-//     return "hello" + greet();
-//   }
-// };
-//
-// // Register cast base type for self to allow direct cast
-// template <>
-// struct BT::any_cast_base<GreeterNoPoly>
-// {
-//   using type = GreeterNoPoly;
-// };
-//
-// // Register cast base type for HelloGreeter
-// template <>
-// struct BT::any_cast_base<HelloGreeterNoPoly>
-// {
-//   using type = GreeterNoPoly;
-// };
-
-/**
-*    +-----------------------+------------+-------------+-----------------------+
-*    |     Class             | Base Class | Polymorphic | Type Trait Registered |
-*    +-----------------------+------------+-------------+-----------------------+
-*    | GreeterNoPolyReg      | -          | No          | -                     |
-*    | HelloGreeterNoPolyReg | NoGreeter  | No          | -                     |
-*    +-----------------------+------------+-------------+-----------------------+
-*/
-
-class GreeterNoPolyReg
-{
-public:
-  using Ptr = std::shared_ptr<GreeterNoPolyReg>;
-  std::string greet() const
-  {
-    return "";
-  };
-};
-
-class HelloGreeterNoPolyReg : public GreeterNoPolyReg
-{
-public:
-  using Ptr = std::shared_ptr<HelloGreeterNoPolyReg>;
-  std::string hello_greet()
-  {
-    return "hello" + greet();
-  }
-};
-
-#endif  // GREETER_TEST_H_

From 5f94feaa63b46ce238626a6e0143b1bc75246ea6 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Fri, 18 Apr 2025 23:19:17 -0400
Subject: [PATCH 18/20] Restrict polymorphic upcast to INPUT ports only during
 type resolution

---
 src/xml_parsing.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/xml_parsing.cpp b/src/xml_parsing.cpp
index 978bf867c..06366b579 100644
--- a/src/xml_parsing.cpp
+++ b/src/xml_parsing.cpp
@@ -830,9 +830,10 @@ TreeNode::Ptr XMLParser::PImpl::createNodeFromXML(const XMLElement* element,
                prev_info->type() != port_info.type());
 
           // allow mismatch if the previous type appears in the base_chain
-          // of the current port (i.e., valid polymorphic upcast)
-          if(port_type_mismatch && !prev_info->baseChain().empty() &&
-             !port_info.baseChain().empty() &&
+          // of the current port (i.e., valid polymorphic upcast) and the
+          // port direction is an INPUT.
+          if(port_type_mismatch && port_info.direction() == PortDirection::INPUT &&
+             !prev_info->baseChain().empty() && !port_info.baseChain().empty() &&
              prev_info->isConvertibleFrom(port_info.baseChain()[0]))
           {
             port_type_mismatch = false;

From 1ce5185f558124700d94f7d11e9baf5da62ee7c9 Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Sat, 19 Apr 2025 00:10:39 -0400
Subject: [PATCH 19/20] Revert to direct type_index comparison in
 Blackboard::set()

Upcasting is not allowed for OUTPUT/INOUT port directions.
---
 include/behaviortree_cpp/blackboard.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/include/behaviortree_cpp/blackboard.h b/include/behaviortree_cpp/blackboard.h
index 26a80b7de..151b2fc16 100644
--- a/include/behaviortree_cpp/blackboard.h
+++ b/include/behaviortree_cpp/blackboard.h
@@ -256,11 +256,8 @@ inline void Blackboard::set(const std::string& key, const T& value)
 
     std::type_index previous_type = entry.info.type();
 
-    // allow matching if any is of the same base
-    const auto current_type = TypeInfo::Create<T>().type();
-
     // check type mismatch
-    if(previous_type != current_type && previous_type != new_value.type())
+    if(previous_type != std::type_index(typeid(T)) && previous_type != new_value.type())
     {
       bool mismatching = true;
       if(std::is_constructible<StringView, T>::value)

From 67276ddcf7dcda1645b4cc7f262991c0155cb88e Mon Sep 17 00:00:00 2001
From: Captain Yoshi <captain.yoshisaur@gmail.com>
Date: Sat, 19 Apr 2025 00:58:36 -0400
Subject: [PATCH 20/20] Add caching mechanism for derived castPtr() in Any

Improves Any::castPtr() by caching results of std::dynamic_pointer_cast to avoid repeated casts.
Adds _cached_type to track the last casted type and reuse the cached pointer.
Also simplifies the case where the requested type matches the root base.
---
 include/behaviortree_cpp/utils/safe_any.hpp | 34 +++++++++++++--------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/include/behaviortree_cpp/utils/safe_any.hpp b/include/behaviortree_cpp/utils/safe_any.hpp
index d6736b84e..3af974c88 100644
--- a/include/behaviortree_cpp/utils/safe_any.hpp
+++ b/include/behaviortree_cpp/utils/safe_any.hpp
@@ -368,31 +368,38 @@ class Any
 
         try
         {
-          // Attempt to retrieve the stored shared_ptr<Base> from the Any container
-          auto base_ptr = linb::any_cast<std::shared_ptr<RootBase>>(&_any);
-          if(!base_ptr)
-            return nullptr;
-
           // Case 1: If Base and Derived are the same, no casting is needed
           if constexpr(std::is_same_v<RootBase, Derived>)
           {
-            return reinterpret_cast<T*>(base_ptr);
+            return linb::any_cast<std::shared_ptr<RootBase>>(&_any);
           }
 
-          // Case 2: Originally stored as shared_ptr<Derived>
-          if(_original_type == typeid(std::shared_ptr<Derived>))
+          // Case 2: Previously cached
+          if(_cached_type == typeid(T))
           {
-            _cached_derived_ptr = std::static_pointer_cast<Derived>(*base_ptr);
             return reinterpret_cast<T*>(&_cached_derived_ptr);
           }
 
-          // Case 3: Fallback to dynamic cast
-          auto derived_ptr = std::dynamic_pointer_cast<Derived>(*base_ptr);
-          if(derived_ptr)
+          // Attempt to retrieve the stored shared_ptr<Base> from the Any container
+          auto base_ptr = linb::any_cast<std::shared_ptr<RootBase>>(&_any);
+          if(!base_ptr)
+            return nullptr;
+
+          // Case 3: Stored as Derived originally
+          if(_original_type == typeid(std::shared_ptr<Derived>))
           {
+            _cached_derived_ptr = std::static_pointer_cast<Derived>(*base_ptr);
+          }
+          // Case 4: Fallback to dynamic cast
+          else
+          {
+            auto derived_ptr = std::dynamic_pointer_cast<Derived>(*base_ptr);
+            if(!derived_ptr)
+              return nullptr;
             _cached_derived_ptr = derived_ptr;
-            return reinterpret_cast<T*>(&_cached_derived_ptr);
           }
+          _cached_type = typeid(T);
+          return reinterpret_cast<T*>(&_cached_derived_ptr);
         }
         catch(...)
         {
@@ -427,6 +434,7 @@ class Any
   linb::any _any;
   std::type_index _original_type;
   mutable std::shared_ptr<void> _cached_derived_ptr = nullptr;
+  mutable std::type_index _cached_type = typeid(void);
 
   //----------------------------