From 2c31bb55334bf000372afceb2815bf0b120d5a28 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Thu, 19 Feb 2026 20:36:35 +0100
Subject: [PATCH 01/40] T

---
 icey/include/icey/icey_async_await.hpp | 65 +++++++++++++++++++++-----
 1 file changed, 53 insertions(+), 12 deletions(-)

diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 2fb7d1e..dda1f53 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -12,9 +12,12 @@
 #include <functional>
 #include <icey/action/action.hpp>
 #include <icey/impl/promise.hpp>
+#include <mutex>
 #include <optional>
 #include <thread>  /// for ID
 #include <unordered_map>
+#include <unordered_set>
+#include <vector>
 
 #include "rclcpp/rclcpp.hpp"
 #include "rclcpp/version.h"
@@ -113,6 +116,7 @@ struct NodeBase {
   template <class CallbackT>
   void add_task_for(uint64_t id, const Duration &timeout, CallbackT on_timeout,
                     rclcpp::CallbackGroup::SharedPtr group = nullptr) {
+    std::lock_guard<std::mutex> lock{oneoff_tasks_mutex_};
     oneoff_cancelled_timers_.clear();
     oneoff_active_timers_.emplace(id, create_wall_timer(
                                           timeout,
@@ -125,6 +129,7 @@ struct NodeBase {
 
   /// Cancel a previously scheduled task by key (no-op if not present)
   bool cancel_task_for(uint64_t id) {
+    std::lock_guard<std::mutex> lock{oneoff_tasks_mutex_};
     auto it = oneoff_active_timers_.find(id);
     if (it == oneoff_active_timers_.end()) return false;
     auto timer = it->second;
@@ -201,11 +206,18 @@ struct NodeBase {
   std::unordered_set<std::shared_ptr<rclcpp::TimerBase>> oneoff_cancelled_timers_;
   /// Active one-off tasks keyed by a stable uintptr_t key
   std::unordered_map<uint64_t, std::shared_ptr<rclcpp::TimerBase>> oneoff_active_timers_;
+  mutable std::mutex oneoff_tasks_mutex_;
 
 public:
   // Test helpers (introspection)
-  std::size_t oneoff_active_task_count() const { return oneoff_active_timers_.size(); }
-  std::size_t oneoff_cancelled_task_count() const { return oneoff_cancelled_timers_.size(); }
+  std::size_t oneoff_active_task_count() const {
+    std::lock_guard<std::mutex> lock{oneoff_tasks_mutex_};
+    return oneoff_active_timers_.size();
+  }
+  std::size_t oneoff_cancelled_task_count() const {
+    std::lock_guard<std::mutex> lock{oneoff_tasks_mutex_};
+    return oneoff_cancelled_timers_.size();
+  }
 };
 
 /// A subscription + buffer for transforms that allows for asynchronous lookups and to subscribe on
@@ -253,6 +265,8 @@ struct TransformBufferImpl {
     OnTransform on_transform;
     OnError on_error;
     std::optional<Time> maybe_time;
+    std::atomic_bool finished{false};
+    mutable std::mutex state_mutex;
   };
 
   /// A request for a transform lookup: It represents effectively a single call to the async_lookup
@@ -314,11 +328,22 @@ struct TransformBufferImpl {
                                                     on_transform, on_error, time)};
 
     auto weak_request = std::weak_ptr<TransformRequest>(request);
-    requests_.emplace(request);
+    {
+      std::lock_guard<std::recursive_mutex> lock{mutex_};
+      requests_.emplace(request);
+    }
     node_.lock()->add_task_for(
         uint64_t(request.get()), timeout, [this, on_error, request = weak_request]() {
           if (auto req = request.lock()) {
-            requests_.erase(req);  // Destroy the request
+            bool expected = false;
+            if (!req->finished.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
+                                                       std::memory_order_acquire)) {
+              return;
+            }
+            {
+              std::lock_guard<std::recursive_mutex> lock{mutex_};
+              requests_.erase(req);  // Destroy the request
+            }
             on_error(tf2::TimeoutException{"Timed out waiting for transform"});
           }
         });
@@ -423,8 +448,15 @@ struct TransformBufferImpl {
       /// std::vector/tree.
       geometry_msgs::msg::TransformStamped tf_msg =
           buffer_->lookupTransform(info.target_frame(), info.source_frame(), tf2::TimePointZero);
-      if (!info.last_received_transform || tf_msg != *info.last_received_transform) {
-        info.last_received_transform = tf_msg;
+      bool changed = false;
+      {
+        std::lock_guard<std::mutex> lock{info.state_mutex};
+        if (!info.last_received_transform || tf_msg != *info.last_received_transform) {
+          info.last_received_transform = tf_msg;
+          changed = true;
+        }
+      }
+      if (changed) {
         info.on_transform(tf_msg);
         return true;
       }
@@ -440,6 +472,11 @@ struct TransformBufferImpl {
       /// std::vector/tree.
       geometry_msgs::msg::TransformStamped tf_msg = buffer_->lookupTransform(
           request->target_frame(), request->source_frame(), request->maybe_time.value());
+      bool expected = false;
+      if (!request->finished.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
+                                                     std::memory_order_acquire)) {
+        return false;
+      }
       request->on_transform(tf_msg);
       /// If the request is destroyed gracefully (lookup succeeded), cancel the associated task
       /// timer
@@ -455,9 +492,12 @@ struct TransformBufferImpl {
   void notify_if_any_relevant_transform_was_received() {
     /// Iterate all requests, notify and maybe erase them if they are requests for a specific time
     std::vector<RequestHandle> requests_to_delete;
-    mutex_.lock();
-    auto requests = requests_;
-    mutex_.unlock();
+    std::vector<RequestHandle> requests;
+    {
+      std::lock_guard<std::recursive_mutex> lock{mutex_};
+      requests.reserve(requests_.size());
+      for (const auto &req : requests_) requests.push_back(req);
+    }
 
     for (auto req : requests) {
       if (req->maybe_time) {
@@ -469,9 +509,10 @@ struct TransformBufferImpl {
         maybe_notify(*req);
       }
     }
-    mutex_.lock();
-    for (auto k : requests_to_delete) requests_.erase(k);
-    mutex_.unlock();
+    {
+      std::lock_guard<std::recursive_mutex> lock{mutex_};
+      for (const auto &k : requests_to_delete) requests_.erase(k);
+    }
   }
 
   void on_tf_message(const TransformsMsg &msg, bool is_static) {

From 95ff9227b253388ce224b68092c96941b1bdaf37 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Thu, 19 Feb 2026 21:52:09 +0100
Subject: [PATCH 02/40] Added TSAN tests

---
 icey/CMakeLists.txt                    |  22 +++++
 icey/include/icey/icey_async_await.hpp |  60 ++++++++++----
 icey/test/node_tasks_test.cpp          | 107 +++++++++++++++++++++++++
 3 files changed, 172 insertions(+), 17 deletions(-)

diff --git a/icey/CMakeLists.txt b/icey/CMakeLists.txt
index ad3eee6..f6df95b 100644
--- a/icey/CMakeLists.txt
+++ b/icey/CMakeLists.txt
@@ -4,6 +4,9 @@ project(icey)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+option(ICEY_ASYNC_AWAIT_THREAD_SAFE "Enable synchronization in async/await internals" ON)
+option(ICEY_ENABLE_TSAN "Build tests with ThreadSanitizer instrumentation" OFF)
+
 if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   add_compile_options(-Wall -Wextra -pedantic -Werror=return-type -Werror=init-self)
 endif()
@@ -30,6 +33,10 @@ ament_auto_add_library(icey
   src/actions/server_goal_handle.cpp  
   )
 
+if(NOT ICEY_ASYNC_AWAIT_THREAD_SAFE)
+  target_compile_definitions(icey PUBLIC ICEY_ASYNC_AWAIT_THREAD_SAFE=0)
+endif()
+
 if(BUILD_TESTING)
   find_package(ament_cmake_gtest REQUIRED)
 
@@ -50,6 +57,21 @@ if(BUILD_TESTING)
   target_link_libraries(test_main fmt::fmt)
   set_tests_properties(test_main PROPERTIES TIMEOUT 180)
 
+  if(NOT ICEY_ASYNC_AWAIT_THREAD_SAFE)
+    target_compile_definitions(test_main PRIVATE ICEY_ASYNC_AWAIT_THREAD_SAFE=0)
+  endif()
+
+  if(ICEY_ENABLE_TSAN)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+      target_compile_options(icey PUBLIC -fsanitize=thread -fno-omit-frame-pointer)
+      target_link_options(icey PUBLIC -fsanitize=thread)
+      target_compile_options(test_main PRIVATE -fsanitize=thread -fno-omit-frame-pointer)
+      target_link_options(test_main PRIVATE -fsanitize=thread)
+    else()
+      message(WARNING "ICEY_ENABLE_TSAN is ON but compiler does not support TSAN flags")
+    endif()
+  endif()
+
 endif()
 
 if(ament_cmake_auto_VERSION EQUAL 2.7.3)
diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index dda1f53..b5deb0e 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -9,6 +9,7 @@
 /// can include this header only and get faster compile times.
 #pragma once
 
+#include <atomic>
 #include <functional>
 #include <icey/action/action.hpp>
 #include <icey/impl/promise.hpp>
@@ -29,6 +30,10 @@
 
 namespace icey {
 
+#ifndef ICEY_ASYNC_AWAIT_THREAD_SAFE
+#define ICEY_ASYNC_AWAIT_THREAD_SAFE 1
+#endif
+
 using Clock = std::chrono::system_clock;
 using Time = std::chrono::time_point<Clock>;
 using Duration = Clock::duration;
@@ -116,7 +121,9 @@ struct NodeBase {
   template <class CallbackT>
   void add_task_for(uint64_t id, const Duration &timeout, CallbackT on_timeout,
                     rclcpp::CallbackGroup::SharedPtr group = nullptr) {
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
     std::lock_guard<std::mutex> lock{oneoff_tasks_mutex_};
+#endif
     oneoff_cancelled_timers_.clear();
     oneoff_active_timers_.emplace(id, create_wall_timer(
                                           timeout,
@@ -129,7 +136,9 @@ struct NodeBase {
 
   /// Cancel a previously scheduled task by key (no-op if not present)
   bool cancel_task_for(uint64_t id) {
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
     std::lock_guard<std::mutex> lock{oneoff_tasks_mutex_};
+#endif
     auto it = oneoff_active_timers_.find(id);
     if (it == oneoff_active_timers_.end()) return false;
     auto timer = it->second;
@@ -206,16 +215,22 @@ struct NodeBase {
   std::unordered_set<std::shared_ptr<rclcpp::TimerBase>> oneoff_cancelled_timers_;
   /// Active one-off tasks keyed by a stable uintptr_t key
   std::unordered_map<uint64_t, std::shared_ptr<rclcpp::TimerBase>> oneoff_active_timers_;
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
   mutable std::mutex oneoff_tasks_mutex_;
+#endif
 
 public:
   // Test helpers (introspection)
   std::size_t oneoff_active_task_count() const {
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
     std::lock_guard<std::mutex> lock{oneoff_tasks_mutex_};
+#endif
     return oneoff_active_timers_.size();
   }
   std::size_t oneoff_cancelled_task_count() const {
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
     std::lock_guard<std::mutex> lock{oneoff_tasks_mutex_};
+#endif
     return oneoff_cancelled_timers_.size();
   }
 };
@@ -265,8 +280,10 @@ struct TransformBufferImpl {
     OnTransform on_transform;
     OnError on_error;
     std::optional<Time> maybe_time;
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
     std::atomic_bool finished{false};
     mutable std::mutex state_mutex;
+#endif
   };
 
   /// A request for a transform lookup: It represents effectively a single call to the async_lookup
@@ -328,22 +345,22 @@ struct TransformBufferImpl {
                                                     on_transform, on_error, time)};
 
     auto weak_request = std::weak_ptr<TransformRequest>(request);
-    {
-      std::lock_guard<std::recursive_mutex> lock{mutex_};
-      requests_.emplace(request);
-    }
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
+    std::lock_guard<std::recursive_mutex> lock{mutex_};
+#endif
+    requests_.emplace(request);
     node_.lock()->add_task_for(
         uint64_t(request.get()), timeout, [this, on_error, request = weak_request]() {
           if (auto req = request.lock()) {
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
             bool expected = false;
             if (!req->finished.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
                                                        std::memory_order_acquire)) {
               return;
             }
-            {
-              std::lock_guard<std::recursive_mutex> lock{mutex_};
-              requests_.erase(req);  // Destroy the request
-            }
+            std::lock_guard<std::recursive_mutex> lock{mutex_};
+#endif
+            requests_.erase(req);  // Destroy the request
             on_error(tf2::TimeoutException{"Timed out waiting for transform"});
           }
         });
@@ -448,14 +465,17 @@ struct TransformBufferImpl {
       /// std::vector/tree.
       geometry_msgs::msg::TransformStamped tf_msg =
           buffer_->lookupTransform(info.target_frame(), info.source_frame(), tf2::TimePointZero);
-      bool changed = false;
+      bool changed;
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
       {
         std::lock_guard<std::mutex> lock{info.state_mutex};
-        if (!info.last_received_transform || tf_msg != *info.last_received_transform) {
-          info.last_received_transform = tf_msg;
-          changed = true;
-        }
+        changed = !info.last_received_transform || tf_msg != *info.last_received_transform;
+        if (changed) info.last_received_transform = tf_msg;
       }
+#else
+      changed = !info.last_received_transform || tf_msg != *info.last_received_transform;
+      if (changed) info.last_received_transform = tf_msg;
+#endif
       if (changed) {
         info.on_transform(tf_msg);
         return true;
@@ -472,11 +492,13 @@ struct TransformBufferImpl {
       /// std::vector/tree.
       geometry_msgs::msg::TransformStamped tf_msg = buffer_->lookupTransform(
           request->target_frame(), request->source_frame(), request->maybe_time.value());
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
       bool expected = false;
       if (!request->finished.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
                                                      std::memory_order_acquire)) {
         return false;
       }
+#endif
       request->on_transform(tf_msg);
       /// If the request is destroyed gracefully (lookup succeeded), cancel the associated task
       /// timer
@@ -492,12 +514,16 @@ struct TransformBufferImpl {
   void notify_if_any_relevant_transform_was_received() {
     /// Iterate all requests, notify and maybe erase them if they are requests for a specific time
     std::vector<RequestHandle> requests_to_delete;
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
     std::vector<RequestHandle> requests;
     {
       std::lock_guard<std::recursive_mutex> lock{mutex_};
       requests.reserve(requests_.size());
       for (const auto &req : requests_) requests.push_back(req);
     }
+#else
+    auto requests = requests_;
+#endif
 
     for (auto req : requests) {
       if (req->maybe_time) {
@@ -509,10 +535,10 @@ struct TransformBufferImpl {
         maybe_notify(*req);
       }
     }
-    {
-      std::lock_guard<std::recursive_mutex> lock{mutex_};
-      for (const auto &k : requests_to_delete) requests_.erase(k);
-    }
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
+    std::lock_guard<std::recursive_mutex> lock{mutex_};
+#endif
+    for (const auto &k : requests_to_delete) requests_.erase(k);
   }
 
   void on_tf_message(const TransformsMsg &msg, bool is_static) {
diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index e69de29..5e9654a 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -0,0 +1,107 @@
+#include <gtest/gtest.h>
+
+#include <atomic>
+#include <chrono>
+#include <icey/icey_async_await.hpp>
+#include <thread>
+#include <vector>
+
+using namespace std::chrono_literals;
+
+namespace {
+
+void spin_for(rclcpp::executors::MultiThreadedExecutor &exec, std::chrono::milliseconds duration) {
+  auto until = std::chrono::steady_clock::now() + duration;
+  while (std::chrono::steady_clock::now() < until) {
+    exec.spin_some();
+    std::this_thread::sleep_for(1ms);
+  }
+}
+
+void stress_node_oneoff_tasks(icey::NodeBase &node_base, int workers, int iterations) {
+  std::vector<std::thread> threads;
+  threads.reserve(workers);
+  std::atomic_int callbacks{0};
+  for (int t = 0; t < workers; ++t) {
+    threads.emplace_back([&, t] {
+      for (int i = 0; i < iterations; ++i) {
+        const uint64_t id = (uint64_t(t) << 32U) | uint64_t(i);
+        node_base.add_task_for(id, 1ms, [&callbacks]() { callbacks.fetch_add(1); });
+        if ((i % 2) == 0) {
+          node_base.cancel_task_for(id);
+        }
+      }
+    });
+  }
+  for (auto &th : threads) th.join();
+}
+
+void stress_tf_lookup_cancel(icey::TransformBuffer &tf, int workers, int iterations) {
+  std::vector<std::thread> threads;
+  threads.reserve(workers);
+  for (int t = 0; t < workers; ++t) {
+    threads.emplace_back([&, t] {
+      (void)t;
+      for (int i = 0; i < iterations; ++i) {
+        auto handle = tf.lookup("map", "base_link", icey::Clock::now(), 1ms,
+                                [](const auto &) {}, [](const auto &) {});
+        if ((i % 2) == 0) {
+          tf.cancel_request(handle);
+        }
+      }
+    });
+  }
+  for (auto &th : threads) th.join();
+}
+
+}  // namespace
+
+TEST(NodeTasksThreadSafety, OneoffTaskMapsStress) {
+  auto node = std::make_shared<rclcpp::Node>("node_tasks_mt_stress");
+  icey::NodeBase node_base(node.get());
+
+  rclcpp::executors::MultiThreadedExecutor exec(rclcpp::ExecutorOptions(), 4);
+  exec.add_node(node->get_node_base_interface());
+
+  stress_node_oneoff_tasks(node_base, 8, 600);
+  spin_for(exec, 80ms);
+  exec.remove_node(node->get_node_base_interface());
+
+  SUCCEED();
+}
+
+TEST(NodeTasksThreadSafety, TransformBufferLookupCancelStress) {
+  auto node = std::make_shared<rclcpp::Node>("tf_lookup_cancel_mt_stress");
+  auto ctx = std::make_shared<icey::ContextAsyncAwait>(node.get());
+  auto tf = ctx->create_transform_buffer();
+
+  rclcpp::executors::MultiThreadedExecutor exec(rclcpp::ExecutorOptions(), 4);
+  exec.add_node(node->get_node_base_interface());
+
+  stress_tf_lookup_cancel(tf, 8, 400);
+  spin_for(exec, 80ms);
+  exec.remove_node(node->get_node_base_interface());
+
+  SUCCEED();
+}
+
+TEST(NodeTasksThreadSafety, TSanThreadSafetyAssertion) {
+#if defined(__SANITIZE_THREAD__)
+  auto node = std::make_shared<rclcpp::Node>("tsan_mt_safety_assert");
+  auto ctx = std::make_shared<icey::ContextAsyncAwait>(node.get());
+  auto tf = ctx->create_transform_buffer();
+  icey::NodeBase node_base(node.get());
+
+  rclcpp::executors::MultiThreadedExecutor exec(rclcpp::ExecutorOptions(), 4);
+  exec.add_node(node->get_node_base_interface());
+
+  stress_node_oneoff_tasks(node_base, 10, 1000);
+  stress_tf_lookup_cancel(tf, 10, 600);
+  spin_for(exec, 120ms);
+
+  exec.remove_node(node->get_node_base_interface());
+  SUCCEED() << "TSAN would fail this test if races are present.";
+#else
+  GTEST_SKIP() << "Build with TSAN to enable this assertion test.";
+#endif
+}

From 4d30b03b0d85582e32c143ee8676bf1a4c30bfc4 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Thu, 19 Feb 2026 22:31:36 +0100
Subject: [PATCH 03/40] TSAN options

---
 icey/CMakeLists.txt            | 1 +
 icey/doc/source/development.md | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/icey/CMakeLists.txt b/icey/CMakeLists.txt
index f6df95b..5fff614 100644
--- a/icey/CMakeLists.txt
+++ b/icey/CMakeLists.txt
@@ -67,6 +67,7 @@ if(BUILD_TESTING)
       target_link_options(icey PUBLIC -fsanitize=thread)
       target_compile_options(test_main PRIVATE -fsanitize=thread -fno-omit-frame-pointer)
       target_link_options(test_main PRIVATE -fsanitize=thread)
+      set_tests_properties(test_main PROPERTIES ENVIRONMENT "TSAN_OPTIONS=halt_on_error=1")
     else()
       message(WARNING "ICEY_ENABLE_TSAN is ON but compiler does not support TSAN flags")
     endif()
diff --git a/icey/doc/source/development.md b/icey/doc/source/development.md
index 9b4e244..39bde7e 100644
--- a/icey/doc/source/development.md
+++ b/icey/doc/source/development.md
@@ -9,6 +9,12 @@ cd <colcon-ws root>
 ./build/icey/test_main
 ```
 
+For TSAN runs, fail fast on the first detected race:
+
+```sh
+TSAN_OPTIONS=halt_on_error=1 ./build/icey/test_main
+```
+
 ## Debug example node 
 
 Useful: Install mixins: https://github.com/colcon/colcon-mixin-repository

From 185675e95b9a883a05db1a993200431ebbbf1f5d Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Thu, 19 Feb 2026 23:29:03 +0100
Subject: [PATCH 04/40] Added MT tests cases for actions services and TF to
 test for races with TSAN

---
 icey/test/node_tasks_test.cpp | 259 ++++++++++++++++++++++++----------
 1 file changed, 181 insertions(+), 78 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index 5e9654a..f4f7ef7 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -1,107 +1,210 @@
 #include <gtest/gtest.h>
 
+#include <array>
 #include <atomic>
 #include <chrono>
+#include <example_interfaces/action/fibonacci.hpp>
 #include <icey/icey_async_await.hpp>
+#include <std_srvs/srv/set_bool.hpp>
+#include <tf2_msgs/msg/tf_message.hpp>
 #include <thread>
-#include <vector>
 
 using namespace std::chrono_literals;
 
 namespace {
 
-void spin_for(rclcpp::executors::MultiThreadedExecutor &exec, std::chrono::milliseconds duration) {
-  auto until = std::chrono::steady_clock::now() + duration;
-  while (std::chrono::steady_clock::now() < until) {
-    exec.spin_some();
-    std::this_thread::sleep_for(1ms);
+using ExampleService = std_srvs::srv::SetBool;
+using Fibonacci = example_interfaces::action::Fibonacci;
+using GoalHandleFibonacci = icey::rclcpp_action::ServerGoalHandle<Fibonacci>;
+
+struct Harness {
+  std::shared_ptr<rclcpp::Node> sender{std::make_shared<rclcpp::Node>("node_tasks_sender")};
+  std::shared_ptr<rclcpp::Node> receiver{std::make_shared<rclcpp::Node>("node_tasks_receiver")};
+  std::shared_ptr<icey::ContextAsyncAwait> sender_ctx{
+      std::make_shared<icey::ContextAsyncAwait>(sender.get())};
+  std::shared_ptr<icey::ContextAsyncAwait> receiver_ctx{
+      std::make_shared<icey::ContextAsyncAwait>(receiver.get())};
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 2};
+  std::thread spin_thread;
+
+  Harness() {
+    exec.add_node(sender->get_node_base_interface());
+    exec.add_node(receiver->get_node_base_interface());
+    spin_thread = std::thread([this]() { exec.spin(); });
+  }
+
+  ~Harness() {
+    exec.cancel();
+    if (spin_thread.joinable()) spin_thread.join();
+    exec.remove_node(sender->get_node_base_interface());
+    exec.remove_node(receiver->get_node_base_interface());
+  }
+};
+
+void wait_for_dispatches(const std::atomic_uint64_t &dispatches, uint64_t target,
+                         std::chrono::seconds max_time) {
+  const auto deadline = std::chrono::steady_clock::now() + max_time;
+  while (std::chrono::steady_clock::now() < deadline &&
+         dispatches.load(std::memory_order_relaxed) < target) {
+    std::this_thread::sleep_for(10ms);
   }
 }
 
-void stress_node_oneoff_tasks(icey::NodeBase &node_base, int workers, int iterations) {
-  std::vector<std::thread> threads;
-  threads.reserve(workers);
-  std::atomic_int callbacks{0};
-  for (int t = 0; t < workers; ++t) {
-    threads.emplace_back([&, t] {
-      for (int i = 0; i < iterations; ++i) {
-        const uint64_t id = (uint64_t(t) << 32U) | uint64_t(i);
-        node_base.add_task_for(id, 1ms, [&callbacks]() { callbacks.fetch_add(1); });
-        if ((i % 2) == 0) {
-          node_base.cancel_task_for(id);
-        }
+void run_tf_stress() {
+  Harness h;
+  auto tf = std::make_shared<icey::TransformBuffer>(h.receiver_ctx->create_transform_buffer());
+  auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
+  auto stamp_ns = std::make_shared<std::atomic_int64_t>(0);
+  auto dispatches = std::make_shared<std::atomic_uint64_t>(0);
+  auto tf_hits = std::make_shared<std::atomic_uint64_t>(0);
+  auto errors = std::make_shared<std::atomic_uint64_t>(0);
+  auto pub_timer = h.sender->create_wall_timer(6ms, [stamp_ns, tf_pub]() {
+    static std::atomic_uint64_t tick{0};
+    geometry_msgs::msg::TransformStamped t;
+    auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
+    t.header.stamp = icey::rclcpp_from_chrono(icey::Time{std::chrono::nanoseconds(ns)});
+    t.header.frame_id = "map";
+    t.child_frame_id = "base_link";
+    t.transform.rotation.w = 1.0;
+    tf2_msgs::msg::TFMessage msg;
+    msg.transforms.push_back(t);
+    tf_pub->publish(msg);
+    stamp_ns->store(ns, std::memory_order_release);
+  });
+  std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
+  for (size_t i = 0; i < timers.size(); ++i) {
+    timers[i] = h.receiver->create_wall_timer(6ms, [=]() {
+      dispatches->fetch_add(1, std::memory_order_relaxed);
+      auto ns = stamp_ns->load(std::memory_order_acquire);
+      if (ns == 0) return;
+      auto handle = tf->lookup(
+          "map", "base_link", icey::Time{std::chrono::nanoseconds(ns)}, 200ms,
+          [tf_hits](const auto &) { tf_hits->fetch_add(1, std::memory_order_relaxed); },
+          [errors](const auto &) { errors->fetch_add(1, std::memory_order_relaxed); });
+      if ((dispatches->load(std::memory_order_relaxed) % 3U) == 0U) tf->cancel_request(handle);
+    });
+  }
+  wait_for_dispatches(*dispatches, 5000, 10s);
+  for (auto &timer : timers) timer->cancel();
+  pub_timer->cancel();
+  std::this_thread::sleep_for(200ms);
+  EXPECT_GE(dispatches->load(std::memory_order_relaxed), 5000U);
+  EXPECT_GT(tf_hits->load(std::memory_order_relaxed), 0U);
+  EXPECT_EQ(errors->load(std::memory_order_relaxed), 0U);
+}
+
+void run_service_stress() {
+  Harness h;
+  h.sender_ctx->create_service<ExampleService>("stress_set_bool",
+                                               [](std::shared_ptr<ExampleService::Request> req) {
+                                                 auto resp = std::make_shared<ExampleService::Response>();
+                                                 resp->success = req->data;
+                                                 return resp;
+                                               });
+  auto client = std::make_shared<icey::ServiceClient<ExampleService>>(
+      h.receiver_ctx->create_client<ExampleService>("stress_set_bool"));
+  auto dispatches = std::make_shared<std::atomic_uint64_t>(0);
+  auto ok = std::make_shared<std::atomic_uint64_t>(0);
+  auto errors = std::make_shared<std::atomic_uint64_t>(0);
+  auto done = std::make_shared<std::atomic_bool>(false);
+  [=]() -> icey::Promise<void> {
+    for (int i = 0; i < 200; ++i) {
+      try {
+        auto req = std::make_shared<ExampleService::Request>();
+        req->data = true;
+        auto res = co_await client->call(req, 400ms);
+        if (res.has_value() && res.value()->success)
+          ok->fetch_add(1, std::memory_order_relaxed);
+        else
+          errors->fetch_add(1, std::memory_order_relaxed);
+      } catch (...) {
+        errors->fetch_add(1, std::memory_order_relaxed);
       }
+    }
+    done->store(true, std::memory_order_release);
+    co_return;
+  }()
+      .detach();
+  std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
+  for (size_t i = 0; i < timers.size(); ++i) {
+    timers[i] = h.receiver->create_wall_timer(5ms, [=]() {
+      dispatches->fetch_add(1, std::memory_order_relaxed);
     });
   }
-  for (auto &th : threads) th.join();
+  wait_for_dispatches(*dispatches, 5000, 12s);
+  const auto done_deadline = std::chrono::steady_clock::now() + 12s;
+  while (std::chrono::steady_clock::now() < done_deadline &&
+         !done->load(std::memory_order_acquire))
+    std::this_thread::sleep_for(10ms);
+  for (auto &timer : timers) timer->cancel();
+  EXPECT_GE(dispatches->load(std::memory_order_relaxed), 5000U);
+  EXPECT_TRUE(done->load(std::memory_order_acquire));
+  EXPECT_GT(ok->load(std::memory_order_relaxed) + errors->load(std::memory_order_relaxed), 0U);
 }
 
-void stress_tf_lookup_cancel(icey::TransformBuffer &tf, int workers, int iterations) {
-  std::vector<std::thread> threads;
-  threads.reserve(workers);
-  for (int t = 0; t < workers; ++t) {
-    threads.emplace_back([&, t] {
-      (void)t;
-      for (int i = 0; i < iterations; ++i) {
-        auto handle = tf.lookup("map", "base_link", icey::Clock::now(), 1ms,
-                                [](const auto &) {}, [](const auto &) {});
-        if ((i % 2) == 0) {
-          tf.cancel_request(handle);
+void run_action_stress() {
+  Harness h;
+  h.sender_ctx->create_action_server<Fibonacci>(
+      "stress_fib",
+      [](const rclcpp_action::GoalUUID &, std::shared_ptr<const Fibonacci::Goal>) {
+        return rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;
+      },
+      [](std::shared_ptr<GoalHandleFibonacci>) { return rclcpp_action::CancelResponse::ACCEPT; },
+      [](std::shared_ptr<GoalHandleFibonacci> gh) {
+        auto result = std::make_shared<Fibonacci::Result>();
+        result->sequence = {0, 1, 1, 2};
+        gh->succeed(result);
+      });
+  auto client = std::make_shared<icey::ActionClient<Fibonacci>>(
+      h.receiver_ctx->create_action_client<Fibonacci>("stress_fib"));
+  auto dispatches = std::make_shared<std::atomic_uint64_t>(0);
+  auto ok = std::make_shared<std::atomic_uint64_t>(0);
+  auto errors = std::make_shared<std::atomic_uint64_t>(0);
+  auto done = std::make_shared<std::atomic_bool>(false);
+  [=]() -> icey::Promise<void> {
+    for (int i = 0; i < 120; ++i) {
+      try {
+        Fibonacci::Goal goal;
+        goal.order = 4;
+        auto sent = co_await client->send_goal(goal, 400ms, [](auto, auto) {});
+        if (!sent.has_value()) {
+          errors->fetch_add(1, std::memory_order_relaxed);
+        } else {
+          auto res = co_await sent.value().result(400ms);
+          if (res.has_value() && res.value().code == rclcpp_action::ResultCode::SUCCEEDED)
+            ok->fetch_add(1, std::memory_order_relaxed);
+          else
+            errors->fetch_add(1, std::memory_order_relaxed);
         }
+      } catch (...) {
+        errors->fetch_add(1, std::memory_order_relaxed);
       }
+    }
+    done->store(true, std::memory_order_release);
+    co_return;
+  }()
+      .detach();
+  std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
+  for (size_t i = 0; i < timers.size(); ++i) {
+    timers[i] = h.receiver->create_wall_timer(5ms, [=]() {
+      dispatches->fetch_add(1, std::memory_order_relaxed);
     });
   }
-  for (auto &th : threads) th.join();
+  wait_for_dispatches(*dispatches, 5000, 12s);
+  const auto done_deadline = std::chrono::steady_clock::now() + 15s;
+  while (std::chrono::steady_clock::now() < done_deadline &&
+         !done->load(std::memory_order_acquire))
+    std::this_thread::sleep_for(10ms);
+  for (auto &timer : timers) timer->cancel();
+  EXPECT_GE(dispatches->load(std::memory_order_relaxed), 5000U);
+  EXPECT_TRUE(done->load(std::memory_order_acquire));
+  EXPECT_GT(ok->load(std::memory_order_relaxed) + errors->load(std::memory_order_relaxed), 0U);
 }
 
 }  // namespace
 
-TEST(NodeTasksThreadSafety, OneoffTaskMapsStress) {
-  auto node = std::make_shared<rclcpp::Node>("node_tasks_mt_stress");
-  icey::NodeBase node_base(node.get());
-
-  rclcpp::executors::MultiThreadedExecutor exec(rclcpp::ExecutorOptions(), 4);
-  exec.add_node(node->get_node_base_interface());
-
-  stress_node_oneoff_tasks(node_base, 8, 600);
-  spin_for(exec, 80ms);
-  exec.remove_node(node->get_node_base_interface());
+TEST(NodeTasksThreadSafety, TfWithFourTimers) { run_tf_stress(); }
 
-  SUCCEED();
-}
-
-TEST(NodeTasksThreadSafety, TransformBufferLookupCancelStress) {
-  auto node = std::make_shared<rclcpp::Node>("tf_lookup_cancel_mt_stress");
-  auto ctx = std::make_shared<icey::ContextAsyncAwait>(node.get());
-  auto tf = ctx->create_transform_buffer();
-
-  rclcpp::executors::MultiThreadedExecutor exec(rclcpp::ExecutorOptions(), 4);
-  exec.add_node(node->get_node_base_interface());
-
-  stress_tf_lookup_cancel(tf, 8, 400);
-  spin_for(exec, 80ms);
-  exec.remove_node(node->get_node_base_interface());
-
-  SUCCEED();
-}
-
-TEST(NodeTasksThreadSafety, TSanThreadSafetyAssertion) {
-#if defined(__SANITIZE_THREAD__)
-  auto node = std::make_shared<rclcpp::Node>("tsan_mt_safety_assert");
-  auto ctx = std::make_shared<icey::ContextAsyncAwait>(node.get());
-  auto tf = ctx->create_transform_buffer();
-  icey::NodeBase node_base(node.get());
-
-  rclcpp::executors::MultiThreadedExecutor exec(rclcpp::ExecutorOptions(), 4);
-  exec.add_node(node->get_node_base_interface());
+TEST(NodeTasksThreadSafety, ServiceWithFourTimers) { run_service_stress(); }
 
-  stress_node_oneoff_tasks(node_base, 10, 1000);
-  stress_tf_lookup_cancel(tf, 10, 600);
-  spin_for(exec, 120ms);
-
-  exec.remove_node(node->get_node_base_interface());
-  SUCCEED() << "TSAN would fail this test if races are present.";
-#else
-  GTEST_SKIP() << "Build with TSAN to enable this assertion test.";
-#endif
-}
+TEST(NodeTasksThreadSafety, ActionWithFourTimers) { run_action_stress(); }

From 9ebab082f20adcd27a5e5534dedbf6bb5e45a9b0 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Thu, 19 Feb 2026 23:38:00 +0100
Subject: [PATCH 05/40] Now tests pass

---
 icey/test/node_tasks_test.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index f4f7ef7..d2e7432 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -107,7 +107,7 @@ void run_service_stress() {
   auto ok = std::make_shared<std::atomic_uint64_t>(0);
   auto errors = std::make_shared<std::atomic_uint64_t>(0);
   auto done = std::make_shared<std::atomic_bool>(false);
-  [=]() -> icey::Promise<void> {
+  const auto service_loop = [=]() -> icey::Promise<void> {
     for (int i = 0; i < 200; ++i) {
       try {
         auto req = std::make_shared<ExampleService::Request>();
@@ -123,8 +123,8 @@ void run_service_stress() {
     }
     done->store(true, std::memory_order_release);
     co_return;
-  }()
-      .detach();
+  };
+  service_loop().detach();
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
   for (size_t i = 0; i < timers.size(); ++i) {
     timers[i] = h.receiver->create_wall_timer(5ms, [=]() {
@@ -161,7 +161,7 @@ void run_action_stress() {
   auto ok = std::make_shared<std::atomic_uint64_t>(0);
   auto errors = std::make_shared<std::atomic_uint64_t>(0);
   auto done = std::make_shared<std::atomic_bool>(false);
-  [=]() -> icey::Promise<void> {
+  const auto action_loop = [=]() -> icey::Promise<void> {
     for (int i = 0; i < 120; ++i) {
       try {
         Fibonacci::Goal goal;
@@ -182,8 +182,8 @@ void run_action_stress() {
     }
     done->store(true, std::memory_order_release);
     co_return;
-  }()
-      .detach();
+  };
+  action_loop().detach();
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
   for (size_t i = 0; i < timers.size(); ++i) {
     timers[i] = h.receiver->create_wall_timer(5ms, [=]() {

From bea3a67cfd01c520ad96dce358fe0aa08c562f2f Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Fri, 20 Feb 2026 00:11:48 +0100
Subject: [PATCH 06/40] Fixed testsc

---
 icey/test/node_tasks_test.cpp | 201 +++++++++++++++++-----------------
 1 file changed, 102 insertions(+), 99 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index d2e7432..131f440 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -24,41 +24,40 @@ struct Harness {
       std::make_shared<icey::ContextAsyncAwait>(sender.get())};
   std::shared_ptr<icey::ContextAsyncAwait> receiver_ctx{
       std::make_shared<icey::ContextAsyncAwait>(receiver.get())};
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 2};
-  std::thread spin_thread;
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
 
   Harness() {
     exec.add_node(sender->get_node_base_interface());
     exec.add_node(receiver->get_node_base_interface());
-    spin_thread = std::thread([this]() { exec.spin(); });
   }
 
   ~Harness() {
     exec.cancel();
-    if (spin_thread.joinable()) spin_thread.join();
     exec.remove_node(sender->get_node_base_interface());
     exec.remove_node(receiver->get_node_base_interface());
   }
 };
 
-void wait_for_dispatches(const std::atomic_uint64_t &dispatches, uint64_t target,
-                         std::chrono::seconds max_time) {
-  const auto deadline = std::chrono::steady_clock::now() + max_time;
-  while (std::chrono::steady_clock::now() < deadline &&
-         dispatches.load(std::memory_order_relaxed) < target) {
-    std::this_thread::sleep_for(10ms);
+template <class Pred>
+void spin_until(Harness &h, Pred pred, std::chrono::milliseconds timeout) {
+  const auto deadline = std::chrono::steady_clock::now() + timeout;
+  while (std::chrono::steady_clock::now() < deadline && !pred()) {
+    h.exec.spin_some();
   }
 }
 
 void run_tf_stress() {
   Harness h;
-  auto tf = std::make_shared<icey::TransformBuffer>(h.receiver_ctx->create_transform_buffer());
+  auto tf = h.receiver_ctx->create_transform_buffer();
   auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
-  auto stamp_ns = std::make_shared<std::atomic_int64_t>(0);
-  auto dispatches = std::make_shared<std::atomic_uint64_t>(0);
-  auto tf_hits = std::make_shared<std::atomic_uint64_t>(0);
-  auto errors = std::make_shared<std::atomic_uint64_t>(0);
-  auto pub_timer = h.sender->create_wall_timer(6ms, [stamp_ns, tf_pub]() {
+  std::atomic_int64_t stamp_ns{0};
+  std::atomic_uint64_t dispatches{0};
+  std::atomic_uint64_t hits{0};
+  std::atomic_uint64_t timeout_scenarios{0};
+  std::atomic_uint64_t unexpected_errors{0};
+  std::atomic_bool done{false};
+
+  auto pub_timer = h.sender->create_wall_timer(6ms, [&]() {
     static std::atomic_uint64_t tick{0};
     geometry_msgs::msg::TransformStamped t;
     auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
@@ -69,28 +68,44 @@ void run_tf_stress() {
     tf2_msgs::msg::TFMessage msg;
     msg.transforms.push_back(t);
     tf_pub->publish(msg);
-    stamp_ns->store(ns, std::memory_order_release);
+    stamp_ns.store(ns, std::memory_order_release);
   });
+  spin_until(h, [&] { return stamp_ns.load(std::memory_order_acquire) != 0; }, 2s);
+
+  const auto tf_loop = [&]() -> icey::Promise<void> {
+    for (int i = 0; i < 300; ++i) {
+      auto ns = stamp_ns.load(std::memory_order_acquire);
+      const bool should_hit = (i % 2) == 0;
+      auto res = co_await tf.lookup("map", should_hit ? "base_link" : "missing_frame",
+                                    rclcpp::Time(ns), 40ms);
+      if (res.has_value()) {
+        hits.fetch_add(1, std::memory_order_relaxed);
+      } else if (should_hit) {
+        unexpected_errors.fetch_add(1, std::memory_order_relaxed);
+      } else {
+        timeout_scenarios.fetch_add(1, std::memory_order_relaxed);
+      }
+    }
+    done.store(true, std::memory_order_release);
+    co_return;
+  };
+  tf_loop().detach();
+
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (size_t i = 0; i < timers.size(); ++i) {
-    timers[i] = h.receiver->create_wall_timer(6ms, [=]() {
-      dispatches->fetch_add(1, std::memory_order_relaxed);
-      auto ns = stamp_ns->load(std::memory_order_acquire);
-      if (ns == 0) return;
-      auto handle = tf->lookup(
-          "map", "base_link", icey::Time{std::chrono::nanoseconds(ns)}, 200ms,
-          [tf_hits](const auto &) { tf_hits->fetch_add(1, std::memory_order_relaxed); },
-          [errors](const auto &) { errors->fetch_add(1, std::memory_order_relaxed); });
-      if ((dispatches->load(std::memory_order_relaxed) % 3U) == 0U) tf->cancel_request(handle);
-    });
+  for (auto &timer : timers) {
+    timer = h.receiver->create_wall_timer(6ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
-  wait_for_dispatches(*dispatches, 5000, 10s);
+
+  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
+  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 12s);
   for (auto &timer : timers) timer->cancel();
   pub_timer->cancel();
-  std::this_thread::sleep_for(200ms);
-  EXPECT_GE(dispatches->load(std::memory_order_relaxed), 5000U);
-  EXPECT_GT(tf_hits->load(std::memory_order_relaxed), 0U);
-  EXPECT_EQ(errors->load(std::memory_order_relaxed), 0U);
+
+  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
+  EXPECT_TRUE(done.load(std::memory_order_acquire));
+  EXPECT_GT(hits.load(std::memory_order_relaxed), 0U);
+  EXPECT_GT(timeout_scenarios.load(std::memory_order_relaxed), 0U);
+  EXPECT_EQ(unexpected_errors.load(std::memory_order_relaxed), 0U);
 }
 
 void run_service_stress() {
@@ -101,45 +116,39 @@ void run_service_stress() {
                                                  resp->success = req->data;
                                                  return resp;
                                                });
-  auto client = std::make_shared<icey::ServiceClient<ExampleService>>(
-      h.receiver_ctx->create_client<ExampleService>("stress_set_bool"));
-  auto dispatches = std::make_shared<std::atomic_uint64_t>(0);
-  auto ok = std::make_shared<std::atomic_uint64_t>(0);
-  auto errors = std::make_shared<std::atomic_uint64_t>(0);
-  auto done = std::make_shared<std::atomic_bool>(false);
-  const auto service_loop = [=]() -> icey::Promise<void> {
+  auto client = h.receiver_ctx->create_client<ExampleService>("stress_set_bool");
+  std::atomic_uint64_t dispatches{0};
+  std::atomic_uint64_t ok{0};
+  std::atomic_uint64_t errors{0};
+  std::atomic_bool done{false};
+
+  const auto service_loop = [&]() -> icey::Promise<void> {
     for (int i = 0; i < 200; ++i) {
-      try {
-        auto req = std::make_shared<ExampleService::Request>();
-        req->data = true;
-        auto res = co_await client->call(req, 400ms);
-        if (res.has_value() && res.value()->success)
-          ok->fetch_add(1, std::memory_order_relaxed);
-        else
-          errors->fetch_add(1, std::memory_order_relaxed);
-      } catch (...) {
-        errors->fetch_add(1, std::memory_order_relaxed);
-      }
+      auto req = std::make_shared<ExampleService::Request>();
+      req->data = true;
+      auto res = co_await client.call(req, 400ms);
+      if (res.has_value() && res.value()->success)
+        ok.fetch_add(1, std::memory_order_relaxed);
+      else
+        errors.fetch_add(1, std::memory_order_relaxed);
     }
-    done->store(true, std::memory_order_release);
+    done.store(true, std::memory_order_release);
     co_return;
   };
   service_loop().detach();
+
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (size_t i = 0; i < timers.size(); ++i) {
-    timers[i] = h.receiver->create_wall_timer(5ms, [=]() {
-      dispatches->fetch_add(1, std::memory_order_relaxed);
-    });
+  for (auto &timer : timers) {
+    timer = h.receiver->create_wall_timer(5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
-  wait_for_dispatches(*dispatches, 5000, 12s);
-  const auto done_deadline = std::chrono::steady_clock::now() + 12s;
-  while (std::chrono::steady_clock::now() < done_deadline &&
-         !done->load(std::memory_order_acquire))
-    std::this_thread::sleep_for(10ms);
+
+  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
+  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 12s);
   for (auto &timer : timers) timer->cancel();
-  EXPECT_GE(dispatches->load(std::memory_order_relaxed), 5000U);
-  EXPECT_TRUE(done->load(std::memory_order_acquire));
-  EXPECT_GT(ok->load(std::memory_order_relaxed) + errors->load(std::memory_order_relaxed), 0U);
+
+  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
+  EXPECT_TRUE(done.load(std::memory_order_acquire));
+  EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
 }
 
 void run_action_stress() {
@@ -155,50 +164,44 @@ void run_action_stress() {
         result->sequence = {0, 1, 1, 2};
         gh->succeed(result);
       });
-  auto client = std::make_shared<icey::ActionClient<Fibonacci>>(
-      h.receiver_ctx->create_action_client<Fibonacci>("stress_fib"));
-  auto dispatches = std::make_shared<std::atomic_uint64_t>(0);
-  auto ok = std::make_shared<std::atomic_uint64_t>(0);
-  auto errors = std::make_shared<std::atomic_uint64_t>(0);
-  auto done = std::make_shared<std::atomic_bool>(false);
-  const auto action_loop = [=]() -> icey::Promise<void> {
+  auto client = h.receiver_ctx->create_action_client<Fibonacci>("stress_fib");
+  std::atomic_uint64_t dispatches{0};
+  std::atomic_uint64_t ok{0};
+  std::atomic_uint64_t errors{0};
+  std::atomic_bool done{false};
+
+  const auto action_loop = [&]() -> icey::Promise<void> {
     for (int i = 0; i < 120; ++i) {
-      try {
-        Fibonacci::Goal goal;
-        goal.order = 4;
-        auto sent = co_await client->send_goal(goal, 400ms, [](auto, auto) {});
-        if (!sent.has_value()) {
-          errors->fetch_add(1, std::memory_order_relaxed);
-        } else {
-          auto res = co_await sent.value().result(400ms);
-          if (res.has_value() && res.value().code == rclcpp_action::ResultCode::SUCCEEDED)
-            ok->fetch_add(1, std::memory_order_relaxed);
-          else
-            errors->fetch_add(1, std::memory_order_relaxed);
-        }
-      } catch (...) {
-        errors->fetch_add(1, std::memory_order_relaxed);
+      Fibonacci::Goal goal;
+      goal.order = 4;
+      auto sent = co_await client.send_goal(goal, 400ms, [](auto, auto) {});
+      if (!sent.has_value()) {
+        errors.fetch_add(1, std::memory_order_relaxed);
+      } else {
+        auto res = co_await sent.value().result(400ms);
+        if (res.has_value() && res.value().code == rclcpp_action::ResultCode::SUCCEEDED)
+          ok.fetch_add(1, std::memory_order_relaxed);
+        else
+          errors.fetch_add(1, std::memory_order_relaxed);
       }
     }
-    done->store(true, std::memory_order_release);
+    done.store(true, std::memory_order_release);
     co_return;
   };
   action_loop().detach();
+
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (size_t i = 0; i < timers.size(); ++i) {
-    timers[i] = h.receiver->create_wall_timer(5ms, [=]() {
-      dispatches->fetch_add(1, std::memory_order_relaxed);
-    });
+  for (auto &timer : timers) {
+    timer = h.receiver->create_wall_timer(5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
-  wait_for_dispatches(*dispatches, 5000, 12s);
-  const auto done_deadline = std::chrono::steady_clock::now() + 15s;
-  while (std::chrono::steady_clock::now() < done_deadline &&
-         !done->load(std::memory_order_acquire))
-    std::this_thread::sleep_for(10ms);
+
+  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
+  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 15s);
   for (auto &timer : timers) timer->cancel();
-  EXPECT_GE(dispatches->load(std::memory_order_relaxed), 5000U);
-  EXPECT_TRUE(done->load(std::memory_order_acquire));
-  EXPECT_GT(ok->load(std::memory_order_relaxed) + errors->load(std::memory_order_relaxed), 0U);
+
+  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
+  EXPECT_TRUE(done.load(std::memory_order_acquire));
+  EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
 }
 
 }  // namespace

From 7373a5180b8d4b47cd244706c9c90a8bc22ae17a Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Fri, 20 Feb 2026 00:22:54 +0100
Subject: [PATCH 07/40] Added TSAN ignore rules to supress noise from DDS

---
 icey/CMakeLists.txt           |  3 ++-
 icey/test/node_tasks_test.cpp | 21 ++++++++++++---------
 icey/test/tsan_dds.supp       |  6 ++++++
 3 files changed, 20 insertions(+), 10 deletions(-)
 create mode 100644 icey/test/tsan_dds.supp

diff --git a/icey/CMakeLists.txt b/icey/CMakeLists.txt
index 5fff614..062ff4e 100644
--- a/icey/CMakeLists.txt
+++ b/icey/CMakeLists.txt
@@ -67,7 +67,8 @@ if(BUILD_TESTING)
       target_link_options(icey PUBLIC -fsanitize=thread)
       target_compile_options(test_main PRIVATE -fsanitize=thread -fno-omit-frame-pointer)
       target_link_options(test_main PRIVATE -fsanitize=thread)
-      set_tests_properties(test_main PROPERTIES ENVIRONMENT "TSAN_OPTIONS=halt_on_error=1")
+      set_tests_properties(test_main PROPERTIES
+        ENVIRONMENT "TSAN_OPTIONS=halt_on_error=1:suppressions=${CMAKE_CURRENT_SOURCE_DIR}/test/tsan_dds.supp")
     else()
       message(WARNING "ICEY_ENABLE_TSAN is ON but compiler does not support TSAN flags")
     endif()
diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index 131f440..d76173a 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -93,7 +93,8 @@ void run_tf_stress() {
 
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
   for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(6ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
+    timer = h.receiver->create_wall_timer(
+        6ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
 
   spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
@@ -110,12 +111,12 @@ void run_tf_stress() {
 
 void run_service_stress() {
   Harness h;
-  h.sender_ctx->create_service<ExampleService>("stress_set_bool",
-                                               [](std::shared_ptr<ExampleService::Request> req) {
-                                                 auto resp = std::make_shared<ExampleService::Response>();
-                                                 resp->success = req->data;
-                                                 return resp;
-                                               });
+  h.sender_ctx->create_service<ExampleService>(
+      "stress_set_bool", [](std::shared_ptr<ExampleService::Request> req) {
+        auto resp = std::make_shared<ExampleService::Response>();
+        resp->success = req->data;
+        return resp;
+      });
   auto client = h.receiver_ctx->create_client<ExampleService>("stress_set_bool");
   std::atomic_uint64_t dispatches{0};
   std::atomic_uint64_t ok{0};
@@ -139,7 +140,8 @@ void run_service_stress() {
 
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
   for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
+    timer = h.receiver->create_wall_timer(
+        5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
 
   spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
@@ -192,7 +194,8 @@ void run_action_stress() {
 
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
   for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
+    timer = h.receiver->create_wall_timer(
+        5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
 
   spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
diff --git a/icey/test/tsan_dds.supp b/icey/test/tsan_dds.supp
new file mode 100644
index 0000000..72e5df6
--- /dev/null
+++ b/icey/test/tsan_dds.supp
@@ -0,0 +1,6 @@
+# Suppress all known CycloneDDS / DDS runtime races so TSAN reports focus on icey.
+# Intentionally broad per project policy for DDS noise filtering.
+race:libddsc.so
+race:dds_
+race:ddsi_
+race:ddsrt_

From d33720bdc848badc95d86eadf42381e4c976f7b5 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Fri, 20 Feb 2026 01:04:19 +0100
Subject: [PATCH 08/40] examples with tran

---
 icey/test/entities_async_await_test.cpp |  1 -
 icey_examples/CMakeLists.txt            | 37 ++++++++++++++++++++++++-
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/icey/test/entities_async_await_test.cpp b/icey/test/entities_async_await_test.cpp
index 519bdb3..a441530 100644
--- a/icey/test/entities_async_await_test.cpp
+++ b/icey/test/entities_async_await_test.cpp
@@ -103,7 +103,6 @@ TEST_F(AsyncAwaitTwoNodeTest, PubSubTest) {
 TEST_F(AsyncAwaitTwoNodeTest, PubSubTest2) {
   const auto l = [this]() -> icey::Promise<int> {
     std::size_t received_cnt{0};
-
     receiver_->icey()
         .create_subscription<std_msgs::msg::Float32>("/icey_test/sine_signal")
         .then([&](auto msg) {
diff --git a/icey_examples/CMakeLists.txt b/icey_examples/CMakeLists.txt
index e66df8f..ca5296a 100644
--- a/icey_examples/CMakeLists.txt
+++ b/icey_examples/CMakeLists.txt
@@ -3,6 +3,7 @@ project(icey_examples)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_EXTENSIONS OFF)
+option(ICEY_ENABLE_TSAN "Build examples with ThreadSanitizer instrumentation" OFF)
 
 set(USE_ASAN_CHECKS OFF)
 if(USE_ASAN_CHECKS)
@@ -71,6 +72,41 @@ target_link_libraries(action_client_async_await_example fmt::fmt)
 ament_auto_add_executable(action_server_async_await_example src/action_server_async_await.cpp)
 target_link_libraries(action_server_async_await_example fmt::fmt)
 
+if(ICEY_ENABLE_TSAN)
+  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    set(ICEY_EXAMPLE_TARGETS
+      service_server_example
+      signal_generator_example
+      parameters_struct_example
+      tf_subscription_example
+      tf_broadcaster_example
+      using_icey_context_example
+      signal_generator_async_await_example
+      listener_async_await_example
+      talker_async_await_example
+      tf_pub_test_example
+      tf_sychronization_example
+      service_server_async_await_example
+      using_async_await_only_context_example
+      tf_lookup_async_await_example
+      using_image_transport_example
+      listener_example
+      synchronization_example
+      lifecycle_node_example
+      coroutine_example
+      service_client_async_await_example
+      action_client_async_await_example
+      action_server_async_await_example
+    )
+    foreach(target_name IN LISTS ICEY_EXAMPLE_TARGETS)
+      target_compile_options(${target_name} PRIVATE -fsanitize=thread -fno-omit-frame-pointer)
+      target_link_options(${target_name} PRIVATE -fsanitize=thread)
+    endforeach()
+  else()
+    message(WARNING "ICEY_ENABLE_TSAN is ON but compiler does not support TSAN flags")
+  endif()
+endif()
+
 if(ament_cmake_auto_VERSION EQUAL 2.7.3)
   ament_auto_package()
 else()
@@ -78,4 +114,3 @@ else()
     USE_SCOPED_HEADER_INSTALL_DIR  # can be removed after Jazzy EOL
   )
 endif()
-

From cd456d567466934b59924f7b88c5ce0f2d935256 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Fri, 20 Feb 2026 01:15:08 +0100
Subject: [PATCH 09/40] Added TSAN usage doc

---
 icey/doc/source/development.md | 32 ++++++++++++++++++++++++++------
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/icey/doc/source/development.md b/icey/doc/source/development.md
index 39bde7e..67aaa3e 100644
--- a/icey/doc/source/development.md
+++ b/icey/doc/source/development.md
@@ -9,12 +9,6 @@ cd <colcon-ws root>
 ./build/icey/test_main
 ```
 
-For TSAN runs, fail fast on the first detected race:
-
-```sh
-TSAN_OPTIONS=halt_on_error=1 ./build/icey/test_main
-```
-
 ## Debug example node 
 
 Useful: Install mixins: https://github.com/colcon/colcon-mixin-repository
@@ -56,6 +50,32 @@ Then, do not use FastDDS since it uses exceptions as part of it's regular (inste
 RMW_IMPLEMENTATION=rmw_cyclonedds_cpp gdb ./build/icey/test_main
 ```
 
+
+## TSAN (ThreadSanitizer)
+
+TSAN is used to detect data races with multi-threaded executors. 
+Build both `icey` and `icey_examples` with TSAN instrumentation:
+
+```sh
+cd <colcon-ws root>
+source /opt/ros/jazzy/setup.bash
+MAKEFLAGS="-j6" colcon build --packages-select icey icey_examples --cmake-args -DCMAKE_BUILD_TYPE=RelWithDebInfo -DICEY_ENABLE_TSAN=ON -DICEY_ASYNC_AWAIT_THREAD_SAFE=1
+```
+
+Run an example binary under TSAN:
+
+```sh
+TSAN_OPTIONS="halt_on_error=1:detect_deadlocks=1:suppressions=/home/ivo/colcon_ws/src/icey/icey/test/tsan_dds.supp" setarch x86_64 -R /home/ivo/colcon_ws/install/icey_examples/lib/icey_examples/service_client_async_await_example
+```
+
+Why these workarounds are needed:
+
+- `setarch x86_64 -R`: disables ASLR for the process. Without this, TSAN can fail early with `unexpected memory mapping` on Ubuntu 24 (https://bugs.launchpad.net/ubuntu/+source/linux/+bug/2056762, https://github.com/google/sanitizers/issues/1716#issuecomment-2010399341)
+- `suppressions=.../tsan_dds.supp`: filters for known DDS races and deadlocks that only cause noise. 
+- `halt_on_error=1`: fail fast 
+- `detect_deadlocks=0`: There is lock inversion issue in the rclcpp_actions currently
+
+By setting `-DICEY_ASYNC_AWAIT_THREAD_SAFE=0` during build, you can verify that indeed TSAN is able to detect the data races. 
 ## Run clang-tidy: 
 
 

From 87a0c4dd2b0be5a67a6400e815c8bd5189b4c0db Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Fri, 20 Feb 2026 23:32:26 +0100
Subject: [PATCH 10/40] Compiling without MT support, no data races, added MT
 exec to examples

---
 icey/CMakeLists.txt                           |  8 ++-----
 icey/benchmark/src/events_throughput.cpp      |  4 +++-
 .../src/service_server_async_await_plain.cpp  |  4 +++-
 icey/benchmark/src/tf_lookup_async_ref.cpp    |  4 +++-
 icey/doc/source/coroutine_basics.md           |  4 +++-
 icey/doc/source/first_icey_node.md            |  4 +++-
 icey/include/icey/icey_async_await.hpp        | 23 +++++++++++--------
 icey/include/icey/impl/promise.hpp            |  2 --
 icey/test/tsan_dds.supp                       |  1 -
 .../src/action_client_async_await.cpp         |  4 +++-
 .../src/action_server_async_await.cpp         |  4 +++-
 icey_examples/src/coroutine_example.cpp       |  4 +++-
 icey_examples/src/listener.cpp                |  4 +++-
 icey_examples/src/listener_async_await.cpp    |  4 +++-
 icey_examples/src/parameters_struct.cpp       |  4 +++-
 .../src/service_client_async_await.cpp        |  4 +++-
 icey_examples/src/service_server.cpp          |  4 +++-
 .../src/service_server_async_await.cpp        |  4 +++-
 icey_examples/src/signal_generator.cpp        |  4 +++-
 .../src/signal_generator_async_await.cpp      |  4 +++-
 icey_examples/src/synchronization.cpp         |  4 +++-
 icey_examples/src/talker_async_await.cpp      |  4 +++-
 icey_examples/src/tf_broadcaster.cpp          |  4 +++-
 icey_examples/src/tf_lookup_async_await.cpp   |  5 +++-
 icey_examples/src/tf_pub_test.cpp             |  4 +++-
 icey_examples/src/tf_subscription.cpp         |  4 +++-
 icey_examples/src/tf_sychronization.cpp       |  4 +++-
 .../src/using_async_await_only_context.cpp    |  4 +++-
 icey_examples/src/using_icey_context.cpp      |  4 +++-
 icey_examples/src/using_image_transport.cpp   |  4 +++-
 30 files changed, 95 insertions(+), 44 deletions(-)

diff --git a/icey/CMakeLists.txt b/icey/CMakeLists.txt
index 062ff4e..4c76787 100644
--- a/icey/CMakeLists.txt
+++ b/icey/CMakeLists.txt
@@ -33,9 +33,7 @@ ament_auto_add_library(icey
   src/actions/server_goal_handle.cpp  
   )
 
-if(NOT ICEY_ASYNC_AWAIT_THREAD_SAFE)
-  target_compile_definitions(icey PUBLIC ICEY_ASYNC_AWAIT_THREAD_SAFE=0)
-endif()
+
 
 if(BUILD_TESTING)
   find_package(ament_cmake_gtest REQUIRED)
@@ -57,9 +55,7 @@ if(BUILD_TESTING)
   target_link_libraries(test_main fmt::fmt)
   set_tests_properties(test_main PROPERTIES TIMEOUT 180)
 
-  if(NOT ICEY_ASYNC_AWAIT_THREAD_SAFE)
-    target_compile_definitions(test_main PRIVATE ICEY_ASYNC_AWAIT_THREAD_SAFE=0)
-  endif()
+
 
   if(ICEY_ENABLE_TSAN)
     if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
diff --git a/icey/benchmark/src/events_throughput.cpp b/icey/benchmark/src/events_throughput.cpp
index 2398c05..e3b3759 100644
--- a/icey/benchmark/src/events_throughput.cpp
+++ b/icey/benchmark/src/events_throughput.cpp
@@ -56,7 +56,9 @@ int main(int argc, char** argv) {
 //   auto exec = rclcpp::experimental::executors::EventsExecutor()
 //   exec.add(node);
 //   exec.spin();
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
   rclcpp::shutdown();
   return 0;
 }
\ No newline at end of file
diff --git a/icey/benchmark/src/service_server_async_await_plain.cpp b/icey/benchmark/src/service_server_async_await_plain.cpp
index 97bbe05..bb54d5f 100644
--- a/icey/benchmark/src/service_server_async_await_plain.cpp
+++ b/icey/benchmark/src/service_server_async_await_plain.cpp
@@ -55,5 +55,7 @@ int main(int argc, char **argv) {
       });
 
   RCLCPP_INFO_STREAM(node->get_logger(), "Created service server, waiting for requests ... ");
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey/benchmark/src/tf_lookup_async_ref.cpp b/icey/benchmark/src/tf_lookup_async_ref.cpp
index bca2689..cf6c085 100644
--- a/icey/benchmark/src/tf_lookup_async_ref.cpp
+++ b/icey/benchmark/src/tf_lookup_async_ref.cpp
@@ -35,5 +35,7 @@ int main(int argc, char **argv) {
         }
       });
 
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey/doc/source/coroutine_basics.md b/icey/doc/source/coroutine_basics.md
index aa57d68..d61f2b9 100644
--- a/icey/doc/source/coroutine_basics.md
+++ b/icey/doc/source/coroutine_basics.md
@@ -28,7 +28,9 @@ int main(int argc, char **argv) {
     std::cout << "1. Before calling the coroutine" << std::endl;
     a_coroutine(node->icey());
     std::cout << "5. After calling the coroutine" << std::endl;
-    rclcpp::spin(node);
+    rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
     std::cout << "6. After spin" << std::endl;
 }
 ```
diff --git a/icey/doc/source/first_icey_node.md b/icey/doc/source/first_icey_node.md
index 6182bb8..4d8e4bb 100644
--- a/icey/doc/source/first_icey_node.md
+++ b/icey/doc/source/first_icey_node.md
@@ -56,7 +56,9 @@ public:
 int main(int argc, char** argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<MyNode>();
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
 ```
 
diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index b5deb0e..79acbf6 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -31,7 +31,7 @@
 namespace icey {
 
 #ifndef ICEY_ASYNC_AWAIT_THREAD_SAFE
-#define ICEY_ASYNC_AWAIT_THREAD_SAFE 1
+#define ICEY_ASYNC_AWAIT_THREAD_SAFE 0
 #endif
 
 using Clock = std::chrono::system_clock;
@@ -512,19 +512,15 @@ struct TransformBufferImpl {
   }
 
   void notify_if_any_relevant_transform_was_received() {
-    /// Iterate all requests, notify and maybe erase them if they are requests for a specific time
-    std::vector<RequestHandle> requests_to_delete;
+/// Iterate all requests, notify and maybe erase them if they are requests for a specific time
 #if ICEY_ASYNC_AWAIT_THREAD_SAFE
+    std::vector<RequestHandle> requests_to_delete;
     std::vector<RequestHandle> requests;
     {
       std::lock_guard<std::recursive_mutex> lock{mutex_};
       requests.reserve(requests_.size());
       for (const auto &req : requests_) requests.push_back(req);
     }
-#else
-    auto requests = requests_;
-#endif
-
     for (auto req : requests) {
       if (req->maybe_time) {
         if (maybe_notify_specific_time(req)) {
@@ -535,10 +531,19 @@ struct TransformBufferImpl {
         maybe_notify(*req);
       }
     }
-#if ICEY_ASYNC_AWAIT_THREAD_SAFE
     std::lock_guard<std::recursive_mutex> lock{mutex_};
-#endif
     for (const auto &k : requests_to_delete) requests_.erase(k);
+#else
+    std::erase_if(requests_, [this](auto req) {
+      if (req->maybe_time) {
+        return maybe_notify_specific_time(req);
+      } else {
+        // If it is a regular subscription, is is persistend and never erased
+        maybe_notify(*req);
+        return false;
+      }
+    });
+#endif
   }
 
   void on_tf_message(const TransformsMsg &msg, bool is_static) {
diff --git a/icey/include/icey/impl/promise.hpp b/icey/include/icey/impl/promise.hpp
index 474594d..b9f263b 100644
--- a/icey/include/icey/impl/promise.hpp
+++ b/icey/include/icey/impl/promise.hpp
@@ -29,7 +29,6 @@ static std::string get_type(T &t) {
 #endif
 
 /// This header defines a promise type supporting async/await (C++ 20 coroutines) only.
-/// Not thread-safe.
 namespace icey {
 
 inline bool icey_coro_debug_print = false;
@@ -37,7 +36,6 @@ inline bool icey_coro_debug_print = false;
 template <class Value, class Error>
 class Promise;
 
-/// Alias used where "no value"/"no error" is needed while preserving existing API spelling.
 using Nothing = std::monostate;
 
 namespace impl {
diff --git a/icey/test/tsan_dds.supp b/icey/test/tsan_dds.supp
index 72e5df6..4879f42 100644
--- a/icey/test/tsan_dds.supp
+++ b/icey/test/tsan_dds.supp
@@ -1,5 +1,4 @@
 # Suppress all known CycloneDDS / DDS runtime races so TSAN reports focus on icey.
-# Intentionally broad per project policy for DDS noise filtering.
 race:libddsc.so
 race:dds_
 race:ddsi_
diff --git a/icey_examples/src/action_client_async_await.cpp b/icey_examples/src/action_client_async_await.cpp
index 53cb130..9a827cb 100644
--- a/icey_examples/src/action_client_async_await.cpp
+++ b/icey_examples/src/action_client_async_await.cpp
@@ -57,6 +57,8 @@ int main(int argc, char **argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<rclcpp::Node>("icey_action_client_async_await_example");
   (void)call_action(node);
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
   return 0;
 }
diff --git a/icey_examples/src/action_server_async_await.cpp b/icey_examples/src/action_server_async_await.cpp
index b9f1110..3c8db98 100644
--- a/icey_examples/src/action_server_async_await.cpp
+++ b/icey_examples/src/action_server_async_await.cpp
@@ -55,6 +55,8 @@ int main(int argc, char **argv) {
                                        handle_accepted);
 
   RCLCPP_INFO_STREAM(node->get_logger(), "Created action sever");
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
   return 0;
 }
diff --git a/icey_examples/src/coroutine_example.cpp b/icey_examples/src/coroutine_example.cpp
index 573cf2d..2145092 100644
--- a/icey_examples/src/coroutine_example.cpp
+++ b/icey_examples/src/coroutine_example.cpp
@@ -24,6 +24,8 @@ int main(int argc, char **argv) {
   std::cout << "1. Before calling coroutine " << std::endl;
   (void)a_coroutine(node->icey());
   std::cout << "5. After calling coroutine " << std::endl;
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
   std::cout << "6. After sync_wait " << std::endl;
 }
diff --git a/icey_examples/src/listener.cpp b/icey_examples/src/listener.cpp
index 7861f56..adfd3b5 100644
--- a/icey_examples/src/listener.cpp
+++ b/icey_examples/src/listener.cpp
@@ -17,5 +17,7 @@ int main(int argc, char **argv) {
       "my_string", [&](std_msgs::msg::String::SharedPtr msg) {
         RCLCPP_INFO_STREAM(node->get_logger(), "Got value: " << msg->data);
       });
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/listener_async_await.cpp b/icey_examples/src/listener_async_await.cpp
index c06f6fd..f4e8b07 100644
--- a/icey_examples/src/listener_async_await.cpp
+++ b/icey_examples/src/listener_async_await.cpp
@@ -25,5 +25,7 @@ int main(int argc, char **argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<icey::Node>("icey_listener_node");
   (void)receive(node);
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey_examples/src/parameters_struct.cpp b/icey_examples/src/parameters_struct.cpp
index 69ca1e6..2b06217 100644
--- a/icey_examples/src/parameters_struct.cpp
+++ b/icey_examples/src/parameters_struct.cpp
@@ -41,5 +41,7 @@ class MyNode : public icey::Node {
 int main(int argc, char **argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<MyNode>("icey_parameters_struct_example");
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/service_client_async_await.cpp b/icey_examples/src/service_client_async_await.cpp
index b18e782..f325bef 100644
--- a/icey_examples/src/service_client_async_await.cpp
+++ b/icey_examples/src/service_client_async_await.cpp
@@ -41,5 +41,7 @@ int main(int argc, char **argv) {
     }
     co_return;
   });
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey_examples/src/service_server.cpp b/icey_examples/src/service_server.cpp
index 18c4de7..16297f3 100644
--- a/icey_examples/src/service_server.cpp
+++ b/icey_examples/src/service_server.cpp
@@ -35,5 +35,7 @@ int main(int argc, char **argv) {
   node->icey().create_service<ExampleService>("set_bool_service3", service_cb);
 
   RCLCPP_INFO_STREAM(node->get_logger(), "Started services " << service_name.value());
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey_examples/src/service_server_async_await.cpp b/icey_examples/src/service_server_async_await.cpp
index d058d61..48c76c7 100644
--- a/icey_examples/src/service_server_async_await.cpp
+++ b/icey_examples/src/service_server_async_await.cpp
@@ -50,5 +50,7 @@ int main(int argc, char **argv) {
       });
 
   RCLCPP_INFO_STREAM(node->get_logger(), "Created service server, waiting for requests ... ");
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey_examples/src/signal_generator.cpp b/icey_examples/src/signal_generator.cpp
index 99b76c0..d35ef30 100644
--- a/icey_examples/src/signal_generator.cpp
+++ b/icey_examples/src/signal_generator.cpp
@@ -45,5 +45,7 @@ int main(int argc, char **argv) {
       })
       .publish("sine_signal");
 
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/signal_generator_async_await.cpp b/icey_examples/src/signal_generator_async_await.cpp
index 605c1bb..418592e 100644
--- a/icey_examples/src/signal_generator_async_await.cpp
+++ b/icey_examples/src/signal_generator_async_await.cpp
@@ -53,5 +53,7 @@ int main(int argc, char **argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<icey::Node>("icey_signal_generator_async_await_example");
   (void)create_and_spin_node(node);
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey_examples/src/synchronization.cpp b/icey_examples/src/synchronization.cpp
index 62365fd..1837f14 100644
--- a/icey_examples/src/synchronization.cpp
+++ b/icey_examples/src/synchronization.cpp
@@ -40,5 +40,7 @@ int main(int argc, char **argv) {
         << " and point cloud with time " << point_cloud->header.stamp);
         */
       });
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/talker_async_await.cpp b/icey_examples/src/talker_async_await.cpp
index 06e6f24..929534c 100644
--- a/icey_examples/src/talker_async_await.cpp
+++ b/icey_examples/src/talker_async_await.cpp
@@ -30,5 +30,7 @@ int main(int argc, char **argv) {
 
   (void)talk(node);
 
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey_examples/src/tf_broadcaster.cpp b/icey_examples/src/tf_broadcaster.cpp
index 8087e76..038c799 100644
--- a/icey_examples/src/tf_broadcaster.cpp
+++ b/icey_examples/src/tf_broadcaster.cpp
@@ -36,5 +36,7 @@ int main(int argc, char **argv) {
   // gets updated dynamically when the parameter changes.
   create_yaw_rotation(*node, base_frame_param).publish_transform();
 
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/tf_lookup_async_await.cpp b/icey_examples/src/tf_lookup_async_await.cpp
index 98036bf..d1adfe2 100644
--- a/icey_examples/src/tf_lookup_async_await.cpp
+++ b/icey_examples/src/tf_lookup_async_await.cpp
@@ -40,5 +40,8 @@ int main(int argc, char **argv) {
             co_return;
           });
 
-  rclcpp::spin(node);
+
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/tf_pub_test.cpp b/icey_examples/src/tf_pub_test.cpp
index 5c65c45..4eb05ef 100644
--- a/icey_examples/src/tf_pub_test.cpp
+++ b/icey_examples/src/tf_pub_test.cpp
@@ -38,5 +38,7 @@ int main(int argc, char **argv) {
     cnt++;
   });
 
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey_examples/src/tf_subscription.cpp b/icey_examples/src/tf_subscription.cpp
index 0991eb4..a06fe33 100644
--- a/icey_examples/src/tf_subscription.cpp
+++ b/icey_examples/src/tf_subscription.cpp
@@ -23,5 +23,7 @@ int main(int argc, char **argv) {
         RCLCPP_INFO_STREAM(node->get_logger(), "Received a new transform:\n" << tf_mat);
       });
 
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/tf_sychronization.cpp b/icey_examples/src/tf_sychronization.cpp
index 6ad592a..6832e0d 100644
--- a/icey_examples/src/tf_sychronization.cpp
+++ b/icey_examples/src/tf_sychronization.cpp
@@ -49,5 +49,7 @@ int main(int argc, char **argv) {
                 << tf_mat);
       });
 
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/using_async_await_only_context.cpp b/icey_examples/src/using_async_await_only_context.cpp
index bcf2bd3..de0c7ec 100644
--- a/icey_examples/src/using_async_await_only_context.cpp
+++ b/icey_examples/src/using_async_await_only_context.cpp
@@ -41,5 +41,7 @@ int main(int argc, char **argv) {
     }
     co_return;
   });
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
diff --git a/icey_examples/src/using_icey_context.cpp b/icey_examples/src/using_icey_context.cpp
index 9fa256c..ad31dd3 100644
--- a/icey_examples/src/using_icey_context.cpp
+++ b/icey_examples/src/using_icey_context.cpp
@@ -30,5 +30,7 @@ class MyNode : public rclcpp::Node {
 int main(int argc, char** argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<MyNode>();
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file
diff --git a/icey_examples/src/using_image_transport.cpp b/icey_examples/src/using_image_transport.cpp
index 9d7c207..779347d 100644
--- a/icey_examples/src/using_image_transport.cpp
+++ b/icey_examples/src/using_image_transport.cpp
@@ -51,5 +51,7 @@ int main(int argc, char **argv) {
       /// And now publish again using image_transport, creating an image_transport::Publisher:
       .publish<icey::ImageTransportPublisher>("camera_left_painted", rclcpp::SensorDataQoS());
 
-  rclcpp::spin(node);
+  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
+  exec.add_node(node->get_node_base_interface());
+  exec.spin();
 }
\ No newline at end of file

From f5fef03f5217802e3b8391bf15307ddcf79ab352 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Fri, 20 Feb 2026 23:51:12 +0100
Subject: [PATCH 11/40] Successfully created a data race solely using the
 executor threads and separate reentrant callback groups

---
 icey/test/node_tasks_test.cpp | 70 +++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index d76173a..a989c6b 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -7,7 +7,10 @@
 #include <icey/icey_async_await.hpp>
 #include <std_srvs/srv/set_bool.hpp>
 #include <tf2_msgs/msg/tf_message.hpp>
+#include <mutex>
 #include <thread>
+#include <unordered_set>
+#include <vector>
 
 using namespace std::chrono_literals;
 
@@ -207,6 +210,71 @@ void run_action_stress() {
   EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
 }
 
+void run_race_repro_async_internals() {
+  Harness h;
+  icey::NodeBase node_base(h.receiver.get());
+  auto tf = h.receiver_ctx->create_transform_buffer();
+  auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
+  std::atomic_uint64_t ops{0};
+  std::array<std::atomic_uint64_t, 12> seq{};
+  std::mutex worker_ids_mutex;
+  std::unordered_set<std::thread::id> worker_ids;
+  for (auto &x : seq) x.store(0, std::memory_order_relaxed);
+
+  auto pub_timer = h.sender->create_wall_timer(2ms, [&]() {
+    static std::atomic_uint64_t tick{0};
+    geometry_msgs::msg::TransformStamped t;
+    auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
+    t.header.stamp = icey::rclcpp_from_chrono(icey::Time{std::chrono::nanoseconds(ns)});
+    t.header.frame_id = "map";
+    t.child_frame_id = "base_link";
+    t.transform.rotation.w = 1.0;
+    tf2_msgs::msg::TFMessage msg;
+    msg.transforms.push_back(t);
+    tf_pub->publish(msg);
+  });
+
+  std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
+  std::vector<std::shared_ptr<rclcpp::TimerBase>> timers;
+  groups.reserve(seq.size());
+  timers.reserve(seq.size());
+  for (size_t t = 0; t < seq.size(); ++t) {
+    auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
+    groups.push_back(group);
+    timers.push_back(h.receiver->create_wall_timer(
+        1ms,
+        [&, t]() {
+          {
+            std::lock_guard<std::mutex> lock(worker_ids_mutex);
+            worker_ids.insert(std::this_thread::get_id());
+          }
+          const auto i = seq[t].fetch_add(1, std::memory_order_relaxed) + 1;
+          const auto id = (uint64_t(t) << 32U) | i;
+          node_base.add_task_for(id, 1ms, []() {});
+          if ((i % 2U) == 0U) node_base.cancel_task_for(id);
+          auto hnd = tf.lookup("map", "base_link", icey::Clock::now(), 3ms, [](const auto &) {},
+                               [](const auto &) {});
+          if ((i % 3U) == 0U) tf.cancel_request(hnd);
+          ops.fetch_add(1, std::memory_order_relaxed);
+        },
+        group));
+  }
+
+  std::thread spin_thread([&]() { h.exec.spin(); });
+  const auto deadline = std::chrono::steady_clock::now() + 4s;
+  while (std::chrono::steady_clock::now() < deadline &&
+         ops.load(std::memory_order_relaxed) < 30000U) {
+    std::this_thread::sleep_for(2ms);
+  }
+
+  for (auto &timer : timers) timer->cancel();
+  pub_timer->cancel();
+  h.exec.cancel();
+  if (spin_thread.joinable()) spin_thread.join();
+  EXPECT_GE(ops.load(std::memory_order_relaxed), 10000U);
+  EXPECT_GT(worker_ids.size(), 1U);
+}
+
 }  // namespace
 
 TEST(NodeTasksThreadSafety, TfWithFourTimers) { run_tf_stress(); }
@@ -214,3 +282,5 @@ TEST(NodeTasksThreadSafety, TfWithFourTimers) { run_tf_stress(); }
 TEST(NodeTasksThreadSafety, ServiceWithFourTimers) { run_service_stress(); }
 
 TEST(NodeTasksThreadSafety, ActionWithFourTimers) { run_action_stress(); }
+
+TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_race_repro_async_internals(); }

From e8a1389d5d66ac07480c31cf99064e2eeb8ce8f3 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 00:12:04 +0100
Subject: [PATCH 12/40] Changed other tests to use reentrant calback groups to
 cause races

---
 icey/test/node_tasks_test.cpp | 245 +++++++++++-----------------------
 1 file changed, 79 insertions(+), 166 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index a989c6b..aa72ad2 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -1,16 +1,11 @@
 #include <gtest/gtest.h>
 
 #include <array>
-#include <atomic>
 #include <chrono>
 #include <example_interfaces/action/fibonacci.hpp>
 #include <icey/icey_async_await.hpp>
 #include <std_srvs/srv/set_bool.hpp>
 #include <tf2_msgs/msg/tf_message.hpp>
-#include <mutex>
-#include <thread>
-#include <unordered_set>
-#include <vector>
 
 using namespace std::chrono_literals;
 
@@ -27,6 +22,7 @@ struct Harness {
       std::make_shared<icey::ContextAsyncAwait>(sender.get())};
   std::shared_ptr<icey::ContextAsyncAwait> receiver_ctx{
       std::make_shared<icey::ContextAsyncAwait>(receiver.get())};
+  icey::NodeBase receiver_base{receiver.get()};
   rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
 
   Harness() {
@@ -41,78 +37,52 @@ struct Harness {
   }
 };
 
-template <class Pred>
-void spin_until(Harness &h, Pred pred, std::chrono::milliseconds timeout) {
-  const auto deadline = std::chrono::steady_clock::now() + timeout;
-  while (std::chrono::steady_clock::now() < deadline && !pred()) {
-    h.exec.spin_some();
-  }
+void spin_for(Harness &h, std::chrono::milliseconds duration) {
+  const auto deadline = std::chrono::steady_clock::now() + duration;
+  while (std::chrono::steady_clock::now() < deadline) h.exec.spin_some();
 }
 
-void run_tf_stress() {
+TEST(NodeTasksThreadSafety, TfWithFourTimers) {
   Harness h;
   auto tf = h.receiver_ctx->create_transform_buffer();
   auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
-  std::atomic_int64_t stamp_ns{0};
-  std::atomic_uint64_t dispatches{0};
-  std::atomic_uint64_t hits{0};
-  std::atomic_uint64_t timeout_scenarios{0};
-  std::atomic_uint64_t unexpected_errors{0};
-  std::atomic_bool done{false};
+  int64_t stamp_ns = 0;
+  size_t mode = 0;
 
-  auto pub_timer = h.sender->create_wall_timer(6ms, [&]() {
-    static std::atomic_uint64_t tick{0};
+  auto pub_timer = h.sender->create_wall_timer(2ms, [&]() {
     geometry_msgs::msg::TransformStamped t;
-    auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
-    t.header.stamp = icey::rclcpp_from_chrono(icey::Time{std::chrono::nanoseconds(ns)});
+    stamp_ns += 1000000;
+    t.header.stamp = rclcpp::Time(1700000000000000000LL + stamp_ns);
     t.header.frame_id = "map";
     t.child_frame_id = "base_link";
     t.transform.rotation.w = 1.0;
     tf2_msgs::msg::TFMessage msg;
     msg.transforms.push_back(t);
     tf_pub->publish(msg);
-    stamp_ns.store(ns, std::memory_order_release);
   });
-  spin_until(h, [&] { return stamp_ns.load(std::memory_order_acquire) != 0; }, 2s);
-
-  const auto tf_loop = [&]() -> icey::Promise<void> {
-    for (int i = 0; i < 300; ++i) {
-      auto ns = stamp_ns.load(std::memory_order_acquire);
-      const bool should_hit = (i % 2) == 0;
-      auto res = co_await tf.lookup("map", should_hit ? "base_link" : "missing_frame",
-                                    rclcpp::Time(ns), 40ms);
-      if (res.has_value()) {
-        hits.fetch_add(1, std::memory_order_relaxed);
-      } else if (should_hit) {
-        unexpected_errors.fetch_add(1, std::memory_order_relaxed);
-      } else {
-        timeout_scenarios.fetch_add(1, std::memory_order_relaxed);
-      }
-    }
-    done.store(true, std::memory_order_release);
-    co_return;
-  };
-  tf_loop().detach();
 
+  std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(
-        6ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
+  for (size_t i = 0; i < timers.size(); ++i) {
+    auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
+    groups.push_back(group);
+    timers[i] = h.receiver_base.create_wall_timer(
+        2ms,
+        [&]() -> icey::Promise<void> {
+          bool hit = ((mode++) % 2) == 0;
+          (void)co_await tf.lookup("map", hit ? "base_link" : "missing_frame", rclcpp::Time(1700000000000000000LL + stamp_ns), 40ms);
+          co_return;
+        },
+        group);
   }
 
-  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
-  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 12s);
+  spin_for(h, 4s);
   for (auto &timer : timers) timer->cancel();
   pub_timer->cancel();
-
-  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
-  EXPECT_TRUE(done.load(std::memory_order_acquire));
-  EXPECT_GT(hits.load(std::memory_order_relaxed), 0U);
-  EXPECT_GT(timeout_scenarios.load(std::memory_order_relaxed), 0U);
-  EXPECT_EQ(unexpected_errors.load(std::memory_order_relaxed), 0U);
+  SUCCEED();
 }
 
-void run_service_stress() {
+TEST(NodeTasksThreadSafety, ServiceWithFourTimers) {
   Harness h;
   h.sender_ctx->create_service<ExampleService>(
       "stress_set_bool", [](std::shared_ptr<ExampleService::Request> req) {
@@ -121,42 +91,31 @@ void run_service_stress() {
         return resp;
       });
   auto client = h.receiver_ctx->create_client<ExampleService>("stress_set_bool");
-  std::atomic_uint64_t dispatches{0};
-  std::atomic_uint64_t ok{0};
-  std::atomic_uint64_t errors{0};
-  std::atomic_bool done{false};
-
-  const auto service_loop = [&]() -> icey::Promise<void> {
-    for (int i = 0; i < 200; ++i) {
-      auto req = std::make_shared<ExampleService::Request>();
-      req->data = true;
-      auto res = co_await client.call(req, 400ms);
-      if (res.has_value() && res.value()->success)
-        ok.fetch_add(1, std::memory_order_relaxed);
-      else
-        errors.fetch_add(1, std::memory_order_relaxed);
-    }
-    done.store(true, std::memory_order_release);
-    co_return;
-  };
-  service_loop().detach();
+  bool flag = false;
 
+  std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(
-        5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
+  for (size_t i = 0; i < timers.size(); ++i) {
+    auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
+    groups.push_back(group);
+    timers[i] = h.receiver_base.create_wall_timer(
+        2ms,
+        [&]() -> icey::Promise<void> {
+          auto req = std::make_shared<ExampleService::Request>();
+          req->data = flag;
+          flag = !flag;
+          (void)co_await client.call(req, 200ms);
+          co_return;
+        },
+        group);
   }
 
-  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
-  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 12s);
+  spin_for(h, 4s);
   for (auto &timer : timers) timer->cancel();
-
-  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
-  EXPECT_TRUE(done.load(std::memory_order_acquire));
-  EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
+  SUCCEED();
 }
 
-void run_action_stress() {
+TEST(NodeTasksThreadSafety, ActionWithFourTimers) {
   Harness h;
   h.sender_ctx->create_action_server<Fibonacci>(
       "stress_fib",
@@ -170,62 +129,40 @@ void run_action_stress() {
         gh->succeed(result);
       });
   auto client = h.receiver_ctx->create_action_client<Fibonacci>("stress_fib");
-  std::atomic_uint64_t dispatches{0};
-  std::atomic_uint64_t ok{0};
-  std::atomic_uint64_t errors{0};
-  std::atomic_bool done{false};
-
-  const auto action_loop = [&]() -> icey::Promise<void> {
-    for (int i = 0; i < 120; ++i) {
-      Fibonacci::Goal goal;
-      goal.order = 4;
-      auto sent = co_await client.send_goal(goal, 400ms, [](auto, auto) {});
-      if (!sent.has_value()) {
-        errors.fetch_add(1, std::memory_order_relaxed);
-      } else {
-        auto res = co_await sent.value().result(400ms);
-        if (res.has_value() && res.value().code == rclcpp_action::ResultCode::SUCCEEDED)
-          ok.fetch_add(1, std::memory_order_relaxed);
-        else
-          errors.fetch_add(1, std::memory_order_relaxed);
-      }
-    }
-    done.store(true, std::memory_order_release);
-    co_return;
-  };
-  action_loop().detach();
+  int order = 2;
 
+  std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(
-        5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
+  for (size_t i = 0; i < timers.size(); ++i) {
+    auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
+    groups.push_back(group);
+    timers[i] = h.receiver_base.create_wall_timer(
+        2ms,
+        [&]() -> icey::Promise<void> {
+          Fibonacci::Goal goal;
+          goal.order = order;
+          order = (order % 10) + 1;
+          auto sent = co_await client.send_goal(goal, 200ms, [](auto, auto) {});
+          if (sent.has_value()) (void)co_await sent.value().result(200ms);
+          co_return;
+        },
+        group);
   }
 
-  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
-  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 15s);
+  spin_for(h, 4s);
   for (auto &timer : timers) timer->cancel();
-
-  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
-  EXPECT_TRUE(done.load(std::memory_order_acquire));
-  EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
+  SUCCEED();
 }
 
-void run_race_repro_async_internals() {
+TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) {
   Harness h;
-  icey::NodeBase node_base(h.receiver.get());
   auto tf = h.receiver_ctx->create_transform_buffer();
   auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
-  std::atomic_uint64_t ops{0};
-  std::array<std::atomic_uint64_t, 12> seq{};
-  std::mutex worker_ids_mutex;
-  std::unordered_set<std::thread::id> worker_ids;
-  for (auto &x : seq) x.store(0, std::memory_order_relaxed);
+  size_t seq = 0;
 
-  auto pub_timer = h.sender->create_wall_timer(2ms, [&]() {
-    static std::atomic_uint64_t tick{0};
+  auto pub_timer = h.sender->create_wall_timer(1ms, [&]() {
     geometry_msgs::msg::TransformStamped t;
-    auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
-    t.header.stamp = icey::rclcpp_from_chrono(icey::Time{std::chrono::nanoseconds(ns)});
+    t.header.stamp = rclcpp::Time(1700000000000000000LL + static_cast<int64_t>(++seq) * 1000000LL);
     t.header.frame_id = "map";
     t.child_frame_id = "base_link";
     t.transform.rotation.w = 1.0;
@@ -235,52 +172,28 @@ void run_race_repro_async_internals() {
   });
 
   std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
-  std::vector<std::shared_ptr<rclcpp::TimerBase>> timers;
-  groups.reserve(seq.size());
-  timers.reserve(seq.size());
-  for (size_t t = 0; t < seq.size(); ++t) {
+  std::array<std::shared_ptr<rclcpp::TimerBase>, 12> timers;
+  for (size_t i = 0; i < timers.size(); ++i) {
     auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
     groups.push_back(group);
-    timers.push_back(h.receiver->create_wall_timer(
+    timers[i] = h.receiver_base.create_wall_timer(
         1ms,
-        [&, t]() {
-          {
-            std::lock_guard<std::mutex> lock(worker_ids_mutex);
-            worker_ids.insert(std::this_thread::get_id());
-          }
-          const auto i = seq[t].fetch_add(1, std::memory_order_relaxed) + 1;
-          const auto id = (uint64_t(t) << 32U) | i;
-          node_base.add_task_for(id, 1ms, []() {});
-          if ((i % 2U) == 0U) node_base.cancel_task_for(id);
-          auto hnd = tf.lookup("map", "base_link", icey::Clock::now(), 3ms, [](const auto &) {},
-                               [](const auto &) {});
-          if ((i % 3U) == 0U) tf.cancel_request(hnd);
-          ops.fetch_add(1, std::memory_order_relaxed);
+        [&]() -> icey::Promise<void> {
+          auto id = ++seq;
+          h.receiver_base.add_task_for(id, 1ms, []() {});
+          if ((id % 2U) == 0U) h.receiver_base.cancel_task_for(id);
+          auto handle = tf.lookup("map", "base_link", icey::Clock::now(), 3ms, [](const auto &) {},
+                                  [](const auto &) {});
+          if ((id % 3U) == 0U) tf.cancel_request(handle);
+          co_return;
         },
-        group));
-  }
-
-  std::thread spin_thread([&]() { h.exec.spin(); });
-  const auto deadline = std::chrono::steady_clock::now() + 4s;
-  while (std::chrono::steady_clock::now() < deadline &&
-         ops.load(std::memory_order_relaxed) < 30000U) {
-    std::this_thread::sleep_for(2ms);
+        group);
   }
 
+  spin_for(h, 4s);
   for (auto &timer : timers) timer->cancel();
   pub_timer->cancel();
-  h.exec.cancel();
-  if (spin_thread.joinable()) spin_thread.join();
-  EXPECT_GE(ops.load(std::memory_order_relaxed), 10000U);
-  EXPECT_GT(worker_ids.size(), 1U);
+  SUCCEED();
 }
 
 }  // namespace
-
-TEST(NodeTasksThreadSafety, TfWithFourTimers) { run_tf_stress(); }
-
-TEST(NodeTasksThreadSafety, ServiceWithFourTimers) { run_service_stress(); }
-
-TEST(NodeTasksThreadSafety, ActionWithFourTimers) { run_action_stress(); }
-
-TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_race_repro_async_internals(); }

From 2155d672fadc7b0d2ff0123724d367ed51a995a1 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 00:30:46 +0100
Subject: [PATCH 13/40] Revert "Changed other tests to use reentrant calback
 groups to cause races"

This reverts commit e8a1389d5d66ac07480c31cf99064e2eeb8ce8f3.
---
 icey/test/node_tasks_test.cpp | 245 +++++++++++++++++++++++-----------
 1 file changed, 166 insertions(+), 79 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index aa72ad2..a989c6b 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -1,11 +1,16 @@
 #include <gtest/gtest.h>
 
 #include <array>
+#include <atomic>
 #include <chrono>
 #include <example_interfaces/action/fibonacci.hpp>
 #include <icey/icey_async_await.hpp>
 #include <std_srvs/srv/set_bool.hpp>
 #include <tf2_msgs/msg/tf_message.hpp>
+#include <mutex>
+#include <thread>
+#include <unordered_set>
+#include <vector>
 
 using namespace std::chrono_literals;
 
@@ -22,7 +27,6 @@ struct Harness {
       std::make_shared<icey::ContextAsyncAwait>(sender.get())};
   std::shared_ptr<icey::ContextAsyncAwait> receiver_ctx{
       std::make_shared<icey::ContextAsyncAwait>(receiver.get())};
-  icey::NodeBase receiver_base{receiver.get()};
   rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
 
   Harness() {
@@ -37,52 +41,78 @@ struct Harness {
   }
 };
 
-void spin_for(Harness &h, std::chrono::milliseconds duration) {
-  const auto deadline = std::chrono::steady_clock::now() + duration;
-  while (std::chrono::steady_clock::now() < deadline) h.exec.spin_some();
+template <class Pred>
+void spin_until(Harness &h, Pred pred, std::chrono::milliseconds timeout) {
+  const auto deadline = std::chrono::steady_clock::now() + timeout;
+  while (std::chrono::steady_clock::now() < deadline && !pred()) {
+    h.exec.spin_some();
+  }
 }
 
-TEST(NodeTasksThreadSafety, TfWithFourTimers) {
+void run_tf_stress() {
   Harness h;
   auto tf = h.receiver_ctx->create_transform_buffer();
   auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
-  int64_t stamp_ns = 0;
-  size_t mode = 0;
+  std::atomic_int64_t stamp_ns{0};
+  std::atomic_uint64_t dispatches{0};
+  std::atomic_uint64_t hits{0};
+  std::atomic_uint64_t timeout_scenarios{0};
+  std::atomic_uint64_t unexpected_errors{0};
+  std::atomic_bool done{false};
 
-  auto pub_timer = h.sender->create_wall_timer(2ms, [&]() {
+  auto pub_timer = h.sender->create_wall_timer(6ms, [&]() {
+    static std::atomic_uint64_t tick{0};
     geometry_msgs::msg::TransformStamped t;
-    stamp_ns += 1000000;
-    t.header.stamp = rclcpp::Time(1700000000000000000LL + stamp_ns);
+    auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
+    t.header.stamp = icey::rclcpp_from_chrono(icey::Time{std::chrono::nanoseconds(ns)});
     t.header.frame_id = "map";
     t.child_frame_id = "base_link";
     t.transform.rotation.w = 1.0;
     tf2_msgs::msg::TFMessage msg;
     msg.transforms.push_back(t);
     tf_pub->publish(msg);
+    stamp_ns.store(ns, std::memory_order_release);
   });
+  spin_until(h, [&] { return stamp_ns.load(std::memory_order_acquire) != 0; }, 2s);
+
+  const auto tf_loop = [&]() -> icey::Promise<void> {
+    for (int i = 0; i < 300; ++i) {
+      auto ns = stamp_ns.load(std::memory_order_acquire);
+      const bool should_hit = (i % 2) == 0;
+      auto res = co_await tf.lookup("map", should_hit ? "base_link" : "missing_frame",
+                                    rclcpp::Time(ns), 40ms);
+      if (res.has_value()) {
+        hits.fetch_add(1, std::memory_order_relaxed);
+      } else if (should_hit) {
+        unexpected_errors.fetch_add(1, std::memory_order_relaxed);
+      } else {
+        timeout_scenarios.fetch_add(1, std::memory_order_relaxed);
+      }
+    }
+    done.store(true, std::memory_order_release);
+    co_return;
+  };
+  tf_loop().detach();
 
-  std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (size_t i = 0; i < timers.size(); ++i) {
-    auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
-    groups.push_back(group);
-    timers[i] = h.receiver_base.create_wall_timer(
-        2ms,
-        [&]() -> icey::Promise<void> {
-          bool hit = ((mode++) % 2) == 0;
-          (void)co_await tf.lookup("map", hit ? "base_link" : "missing_frame", rclcpp::Time(1700000000000000000LL + stamp_ns), 40ms);
-          co_return;
-        },
-        group);
+  for (auto &timer : timers) {
+    timer = h.receiver->create_wall_timer(
+        6ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
 
-  spin_for(h, 4s);
+  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
+  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 12s);
   for (auto &timer : timers) timer->cancel();
   pub_timer->cancel();
-  SUCCEED();
+
+  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
+  EXPECT_TRUE(done.load(std::memory_order_acquire));
+  EXPECT_GT(hits.load(std::memory_order_relaxed), 0U);
+  EXPECT_GT(timeout_scenarios.load(std::memory_order_relaxed), 0U);
+  EXPECT_EQ(unexpected_errors.load(std::memory_order_relaxed), 0U);
 }
 
-TEST(NodeTasksThreadSafety, ServiceWithFourTimers) {
+void run_service_stress() {
   Harness h;
   h.sender_ctx->create_service<ExampleService>(
       "stress_set_bool", [](std::shared_ptr<ExampleService::Request> req) {
@@ -91,31 +121,42 @@ TEST(NodeTasksThreadSafety, ServiceWithFourTimers) {
         return resp;
       });
   auto client = h.receiver_ctx->create_client<ExampleService>("stress_set_bool");
-  bool flag = false;
+  std::atomic_uint64_t dispatches{0};
+  std::atomic_uint64_t ok{0};
+  std::atomic_uint64_t errors{0};
+  std::atomic_bool done{false};
+
+  const auto service_loop = [&]() -> icey::Promise<void> {
+    for (int i = 0; i < 200; ++i) {
+      auto req = std::make_shared<ExampleService::Request>();
+      req->data = true;
+      auto res = co_await client.call(req, 400ms);
+      if (res.has_value() && res.value()->success)
+        ok.fetch_add(1, std::memory_order_relaxed);
+      else
+        errors.fetch_add(1, std::memory_order_relaxed);
+    }
+    done.store(true, std::memory_order_release);
+    co_return;
+  };
+  service_loop().detach();
 
-  std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (size_t i = 0; i < timers.size(); ++i) {
-    auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
-    groups.push_back(group);
-    timers[i] = h.receiver_base.create_wall_timer(
-        2ms,
-        [&]() -> icey::Promise<void> {
-          auto req = std::make_shared<ExampleService::Request>();
-          req->data = flag;
-          flag = !flag;
-          (void)co_await client.call(req, 200ms);
-          co_return;
-        },
-        group);
+  for (auto &timer : timers) {
+    timer = h.receiver->create_wall_timer(
+        5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
 
-  spin_for(h, 4s);
+  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
+  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 12s);
   for (auto &timer : timers) timer->cancel();
-  SUCCEED();
+
+  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
+  EXPECT_TRUE(done.load(std::memory_order_acquire));
+  EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
 }
 
-TEST(NodeTasksThreadSafety, ActionWithFourTimers) {
+void run_action_stress() {
   Harness h;
   h.sender_ctx->create_action_server<Fibonacci>(
       "stress_fib",
@@ -129,40 +170,62 @@ TEST(NodeTasksThreadSafety, ActionWithFourTimers) {
         gh->succeed(result);
       });
   auto client = h.receiver_ctx->create_action_client<Fibonacci>("stress_fib");
-  int order = 2;
+  std::atomic_uint64_t dispatches{0};
+  std::atomic_uint64_t ok{0};
+  std::atomic_uint64_t errors{0};
+  std::atomic_bool done{false};
+
+  const auto action_loop = [&]() -> icey::Promise<void> {
+    for (int i = 0; i < 120; ++i) {
+      Fibonacci::Goal goal;
+      goal.order = 4;
+      auto sent = co_await client.send_goal(goal, 400ms, [](auto, auto) {});
+      if (!sent.has_value()) {
+        errors.fetch_add(1, std::memory_order_relaxed);
+      } else {
+        auto res = co_await sent.value().result(400ms);
+        if (res.has_value() && res.value().code == rclcpp_action::ResultCode::SUCCEEDED)
+          ok.fetch_add(1, std::memory_order_relaxed);
+        else
+          errors.fetch_add(1, std::memory_order_relaxed);
+      }
+    }
+    done.store(true, std::memory_order_release);
+    co_return;
+  };
+  action_loop().detach();
 
-  std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
   std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (size_t i = 0; i < timers.size(); ++i) {
-    auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
-    groups.push_back(group);
-    timers[i] = h.receiver_base.create_wall_timer(
-        2ms,
-        [&]() -> icey::Promise<void> {
-          Fibonacci::Goal goal;
-          goal.order = order;
-          order = (order % 10) + 1;
-          auto sent = co_await client.send_goal(goal, 200ms, [](auto, auto) {});
-          if (sent.has_value()) (void)co_await sent.value().result(200ms);
-          co_return;
-        },
-        group);
+  for (auto &timer : timers) {
+    timer = h.receiver->create_wall_timer(
+        5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
   }
 
-  spin_for(h, 4s);
+  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
+  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 15s);
   for (auto &timer : timers) timer->cancel();
-  SUCCEED();
+
+  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
+  EXPECT_TRUE(done.load(std::memory_order_acquire));
+  EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
 }
 
-TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) {
+void run_race_repro_async_internals() {
   Harness h;
+  icey::NodeBase node_base(h.receiver.get());
   auto tf = h.receiver_ctx->create_transform_buffer();
   auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
-  size_t seq = 0;
+  std::atomic_uint64_t ops{0};
+  std::array<std::atomic_uint64_t, 12> seq{};
+  std::mutex worker_ids_mutex;
+  std::unordered_set<std::thread::id> worker_ids;
+  for (auto &x : seq) x.store(0, std::memory_order_relaxed);
 
-  auto pub_timer = h.sender->create_wall_timer(1ms, [&]() {
+  auto pub_timer = h.sender->create_wall_timer(2ms, [&]() {
+    static std::atomic_uint64_t tick{0};
     geometry_msgs::msg::TransformStamped t;
-    t.header.stamp = rclcpp::Time(1700000000000000000LL + static_cast<int64_t>(++seq) * 1000000LL);
+    auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
+    t.header.stamp = icey::rclcpp_from_chrono(icey::Time{std::chrono::nanoseconds(ns)});
     t.header.frame_id = "map";
     t.child_frame_id = "base_link";
     t.transform.rotation.w = 1.0;
@@ -172,28 +235,52 @@ TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) {
   });
 
   std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
-  std::array<std::shared_ptr<rclcpp::TimerBase>, 12> timers;
-  for (size_t i = 0; i < timers.size(); ++i) {
+  std::vector<std::shared_ptr<rclcpp::TimerBase>> timers;
+  groups.reserve(seq.size());
+  timers.reserve(seq.size());
+  for (size_t t = 0; t < seq.size(); ++t) {
     auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
     groups.push_back(group);
-    timers[i] = h.receiver_base.create_wall_timer(
+    timers.push_back(h.receiver->create_wall_timer(
         1ms,
-        [&]() -> icey::Promise<void> {
-          auto id = ++seq;
-          h.receiver_base.add_task_for(id, 1ms, []() {});
-          if ((id % 2U) == 0U) h.receiver_base.cancel_task_for(id);
-          auto handle = tf.lookup("map", "base_link", icey::Clock::now(), 3ms, [](const auto &) {},
-                                  [](const auto &) {});
-          if ((id % 3U) == 0U) tf.cancel_request(handle);
-          co_return;
+        [&, t]() {
+          {
+            std::lock_guard<std::mutex> lock(worker_ids_mutex);
+            worker_ids.insert(std::this_thread::get_id());
+          }
+          const auto i = seq[t].fetch_add(1, std::memory_order_relaxed) + 1;
+          const auto id = (uint64_t(t) << 32U) | i;
+          node_base.add_task_for(id, 1ms, []() {});
+          if ((i % 2U) == 0U) node_base.cancel_task_for(id);
+          auto hnd = tf.lookup("map", "base_link", icey::Clock::now(), 3ms, [](const auto &) {},
+                               [](const auto &) {});
+          if ((i % 3U) == 0U) tf.cancel_request(hnd);
+          ops.fetch_add(1, std::memory_order_relaxed);
         },
-        group);
+        group));
+  }
+
+  std::thread spin_thread([&]() { h.exec.spin(); });
+  const auto deadline = std::chrono::steady_clock::now() + 4s;
+  while (std::chrono::steady_clock::now() < deadline &&
+         ops.load(std::memory_order_relaxed) < 30000U) {
+    std::this_thread::sleep_for(2ms);
   }
 
-  spin_for(h, 4s);
   for (auto &timer : timers) timer->cancel();
   pub_timer->cancel();
-  SUCCEED();
+  h.exec.cancel();
+  if (spin_thread.joinable()) spin_thread.join();
+  EXPECT_GE(ops.load(std::memory_order_relaxed), 10000U);
+  EXPECT_GT(worker_ids.size(), 1U);
 }
 
 }  // namespace
+
+TEST(NodeTasksThreadSafety, TfWithFourTimers) { run_tf_stress(); }
+
+TEST(NodeTasksThreadSafety, ServiceWithFourTimers) { run_service_stress(); }
+
+TEST(NodeTasksThreadSafety, ActionWithFourTimers) { run_action_stress(); }
+
+TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_race_repro_async_internals(); }

From cf937713479581b4688c7cf68b06b2f1885a41c1 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 14:15:09 +0100
Subject: [PATCH 14/40] Rewriting the test case myself, so right now we do not
 have contention anymore and can executore multiple timers from multiple
 nodes, but the MT executor only uses the main thread ?!

---
 icey/include/icey/icey_async_await.hpp |  6 ++-
 icey/test/node_tasks_test.cpp          | 75 ++++++++------------------
 2 files changed, 26 insertions(+), 55 deletions(-)

diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 79acbf6..7d16814 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -901,8 +901,10 @@ class ContextAsyncAwait {
   /// \note A callback signature that accepts a TimerInfo argument is not implemented yet
   /// Works otherwise the same as [rclcpp::Node::create_timer].
   template <class Callback>
-  std::shared_ptr<rclcpp::TimerBase> create_timer_async(const Duration &period, Callback callback) {
-    auto timer = node_base()->create_wall_timer(period, [callback]() { callback(std::size_t{}); });
+  std::shared_ptr<rclcpp::TimerBase> create_timer_async(
+      const Duration &period, Callback callback, rclcpp::CallbackGroup::SharedPtr group = nullptr) {
+    auto timer =
+        node_base()->create_wall_timer(period, [callback]() { callback(std::size_t{}); }, group);
     std::lock_guard<std::recursive_mutex> lock{bookkeeping_mutex_};
     timers_.push_back(std::dynamic_pointer_cast<rclcpp::TimerBase>(timer));
     return timer;
diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index a989c6b..cbdfb62 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -5,9 +5,9 @@
 #include <chrono>
 #include <example_interfaces/action/fibonacci.hpp>
 #include <icey/icey_async_await.hpp>
+#include <mutex>
 #include <std_srvs/srv/set_bool.hpp>
 #include <tf2_msgs/msg/tf_message.hpp>
-#include <mutex>
 #include <thread>
 #include <unordered_set>
 #include <vector>
@@ -43,9 +43,9 @@ struct Harness {
 
 template <class Pred>
 void spin_until(Harness &h, Pred pred, std::chrono::milliseconds timeout) {
-  const auto deadline = std::chrono::steady_clock::now() + timeout;
-  while (std::chrono::steady_clock::now() < deadline && !pred()) {
-    h.exec.spin_some();
+  auto start = icey::Clock::now();
+  while ((icey::Clock::now() - start) < timeout) {
+    h.exec.spin_once(10ms);
   }
 }
 
@@ -212,75 +212,44 @@ void run_action_stress() {
 
 void run_race_repro_async_internals() {
   Harness h;
-  icey::NodeBase node_base(h.receiver.get());
-  auto tf = h.receiver_ctx->create_transform_buffer();
   auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
-  std::atomic_uint64_t ops{0};
-  std::array<std::atomic_uint64_t, 12> seq{};
-  std::mutex worker_ids_mutex;
-  std::unordered_set<std::thread::id> worker_ids;
-  for (auto &x : seq) x.store(0, std::memory_order_relaxed);
 
-  auto pub_timer = h.sender->create_wall_timer(2ms, [&]() {
-    static std::atomic_uint64_t tick{0};
+  auto pub_timer = h.sender->create_wall_timer(10ms, [&]() {
     geometry_msgs::msg::TransformStamped t;
-    auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
-    t.header.stamp = icey::rclcpp_from_chrono(icey::Time{std::chrono::nanoseconds(ns)});
+    t.header.stamp = icey::rclcpp_from_chrono(icey::Clock::now());
     t.header.frame_id = "map";
     t.child_frame_id = "base_link";
     t.transform.rotation.w = 1.0;
     tf2_msgs::msg::TFMessage msg;
     msg.transforms.push_back(t);
+    std::cout << "Pub Thread ID: " << std::this_thread::get_id() << std::endl;
     tf_pub->publish(msg);
   });
 
-  std::vector<rclcpp::CallbackGroup::SharedPtr> groups;
-  std::vector<std::shared_ptr<rclcpp::TimerBase>> timers;
-  groups.reserve(seq.size());
-  timers.reserve(seq.size());
-  for (size_t t = 0; t < seq.size(); ++t) {
-    auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
-    groups.push_back(group);
-    timers.push_back(h.receiver->create_wall_timer(
-        1ms,
-        [&, t]() {
-          {
-            std::lock_guard<std::mutex> lock(worker_ids_mutex);
-            worker_ids.insert(std::this_thread::get_id());
-          }
-          const auto i = seq[t].fetch_add(1, std::memory_order_relaxed) + 1;
-          const auto id = (uint64_t(t) << 32U) | i;
-          node_base.add_task_for(id, 1ms, []() {});
-          if ((i % 2U) == 0U) node_base.cancel_task_for(id);
-          auto hnd = tf.lookup("map", "base_link", icey::Clock::now(), 3ms, [](const auto &) {},
-                               [](const auto &) {});
-          if ((i % 3U) == 0U) tf.cancel_request(hnd);
-          ops.fetch_add(1, std::memory_order_relaxed);
+  auto tf = h.receiver_ctx->create_transform_buffer();
+  auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
+  for (size_t t = 0; t < 100; t++) {
+    h.receiver_ctx->create_timer_async(
+        50ms,
+        [&, t](std::size_t) -> icey::Promise<void> {
+          std::cout << "Timer #" << t << " Thread ID: " << std::this_thread::get_id() << std::endl;
+          auto transform = co_await tf.lookup("map", "base_link", icey::Clock::now(), 3ms);
         },
-        group));
+        group);
   }
 
-  std::thread spin_thread([&]() { h.exec.spin(); });
-  const auto deadline = std::chrono::steady_clock::now() + 4s;
-  while (std::chrono::steady_clock::now() < deadline &&
-         ops.load(std::memory_order_relaxed) < 30000U) {
-    std::this_thread::sleep_for(2ms);
-  }
-
-  for (auto &timer : timers) timer->cancel();
-  pub_timer->cancel();
-  h.exec.cancel();
-  if (spin_thread.joinable()) spin_thread.join();
-  EXPECT_GE(ops.load(std::memory_order_relaxed), 10000U);
-  EXPECT_GT(worker_ids.size(), 1U);
+  spin_until(h, []() { return false; }, 2s);
+  std::cout << "Main Thread ID: " << std::this_thread::get_id() << std::endl;
 }
 
 }  // namespace
 
+TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_race_repro_async_internals(); }
+
+/*
 TEST(NodeTasksThreadSafety, TfWithFourTimers) { run_tf_stress(); }
 
 TEST(NodeTasksThreadSafety, ServiceWithFourTimers) { run_service_stress(); }
 
 TEST(NodeTasksThreadSafety, ActionWithFourTimers) { run_action_stress(); }
-
-TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_race_repro_async_internals(); }
+*/

From b72247652513e462785bf3f7291c7b5c5987ac55 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 14:53:06 +0100
Subject: [PATCH 15/40] Separate

---
 icey/test/node_tasks_test.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index cbdfb62..fc55148 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -227,18 +227,20 @@ void run_race_repro_async_internals() {
   });
 
   auto tf = h.receiver_ctx->create_transform_buffer();
-  auto group = h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
+  std::vector<rclcpp::CallbackGroup::SharedPtr> cb_groups;
+
   for (size_t t = 0; t < 100; t++) {
+    cb_groups.push_back(h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant));
     h.receiver_ctx->create_timer_async(
         50ms,
         [&, t](std::size_t) -> icey::Promise<void> {
           std::cout << "Timer #" << t << " Thread ID: " << std::this_thread::get_id() << std::endl;
           auto transform = co_await tf.lookup("map", "base_link", icey::Clock::now(), 3ms);
         },
-        group);
+        cb_groups.back());
   }
 
-  spin_until(h, []() { return false; }, 2s);
+  spin_until(h, []() { return false; }, 10s);
   std::cout << "Main Thread ID: " << std::this_thread::get_id() << std::endl;
 }
 

From 92d5acf0689c9df08741c0520f946db69ea8beec Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 14:57:19 +0100
Subject: [PATCH 16/40] Found the issue: spin_once does not properly use the
 multiple threads

---
 icey/test/node_tasks_test.cpp | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index fc55148..27c85c4 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -42,14 +42,16 @@ struct Harness {
 };
 
 template <class Pred>
+[[maybe_unused]]
 void spin_until(Harness &h, Pred pred, std::chrono::milliseconds timeout) {
-  auto start = icey::Clock::now();
-  while ((icey::Clock::now() - start) < timeout) {
-    h.exec.spin_once(10ms);
+  const auto deadline = std::chrono::steady_clock::now() + timeout;
+  while (std::chrono::steady_clock::now() < deadline && !pred()) {
+    h.exec.spin_some();
+    std::this_thread::sleep_for(1ms);
   }
 }
 
-void run_tf_stress() {
+[[maybe_unused]] void run_tf_stress() {
   Harness h;
   auto tf = h.receiver_ctx->create_transform_buffer();
   auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
@@ -112,7 +114,7 @@ void run_tf_stress() {
   EXPECT_EQ(unexpected_errors.load(std::memory_order_relaxed), 0U);
 }
 
-void run_service_stress() {
+[[maybe_unused]] void run_service_stress() {
   Harness h;
   h.sender_ctx->create_service<ExampleService>(
       "stress_set_bool", [](std::shared_ptr<ExampleService::Request> req) {
@@ -156,7 +158,7 @@ void run_service_stress() {
   EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
 }
 
-void run_action_stress() {
+[[maybe_unused]] void run_action_stress() {
   Harness h;
   h.sender_ctx->create_action_server<Fibonacci>(
       "stress_fib",
@@ -235,12 +237,16 @@ void run_race_repro_async_internals() {
         50ms,
         [&, t](std::size_t) -> icey::Promise<void> {
           std::cout << "Timer #" << t << " Thread ID: " << std::this_thread::get_id() << std::endl;
-          auto transform = co_await tf.lookup("map", "base_link", icey::Clock::now(), 3ms);
+          (void)co_await tf.lookup("map", "base_link", icey::Clock::now(), 3ms);
         },
         cb_groups.back());
   }
 
-  spin_until(h, []() { return false; }, 10s);
+  std::thread spin_thread([&]() { h.exec.spin(); });
+  std::this_thread::sleep_for(10s);
+  h.exec.cancel();
+  if (spin_thread.joinable()) spin_thread.join();
+  pub_timer->cancel();
   std::cout << "Main Thread ID: " << std::this_thread::get_id() << std::endl;
 }
 

From 02282ec8f1e89d06fe1f4d647b8fa5245f40914f Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 15:29:35 +0100
Subject: [PATCH 17/40] Updated examples, notices unclear action examples and
 another unnecessary occurence of an icey-type that is the same as in
 rclcpp_action.

---
 .../icey/action/client_goal_handle.hpp        |  22 +-
 icey/include/icey/icey_async_await.hpp        |  13 +-
 icey/test/node_tasks_test.cpp                 | 218 ++++--------------
 .../src/action_client_async_await.cpp         |  32 ++-
 4 files changed, 83 insertions(+), 202 deletions(-)

diff --git a/icey/include/icey/action/client_goal_handle.hpp b/icey/include/icey/action/client_goal_handle.hpp
index c50b2ca..1c89e0b 100644
--- a/icey/include/icey/action/client_goal_handle.hpp
+++ b/icey/include/icey/action/client_goal_handle.hpp
@@ -23,22 +23,11 @@
 #include "rcl_action/action_client.h"
 #include "rclcpp/macros.hpp"
 #include "rclcpp/time.hpp"
+#include "rclcpp_action/client_goal_handle.hpp"
 #include "rclcpp_action/exceptions.hpp"
 #include "rclcpp_action/types.hpp"
 #include "rclcpp_action/visibility_control.hpp"
 
-// I'm defining this in namespace rclcpp_action so that people don't have to change their code unnecessarily. 
-// I could also just include the rclcpp_action header, but just defining the enum here is faster to compile.
-namespace rclcpp_action {
-/// The possible statuses that an action goal can finish with.
-enum class ResultCode : int8_t {
-  UNKNOWN = action_msgs::msg::GoalStatus::STATUS_UNKNOWN,
-  SUCCEEDED = action_msgs::msg::GoalStatus::STATUS_SUCCEEDED,
-  CANCELED = action_msgs::msg::GoalStatus::STATUS_CANCELED,
-  ABORTED = action_msgs::msg::GoalStatus::STATUS_ABORTED
-};
-}  // namespace rclcpp_action
-
 namespace icey::rclcpp_action {
 
 using GoalUUID = std::array<uint8_t, UUID_SIZE>;
@@ -66,14 +55,7 @@ class ClientGoalHandle {
   RCLCPP_SMART_PTR_DEFINITIONS_NOT_COPYABLE(ClientGoalHandle)
 
   // A wrapper that defines the result of an action
-  struct WrappedResult {
-    /// The unique identifier of the goal
-    GoalUUID goal_id;
-    /// A status to indicate if the goal was canceled, aborted, or succeeded
-    ResultCode code;
-    /// User defined fields sent back with an action
-    typename ActionT::Result::SharedPtr result;
-  };
+  using WrappedResult = typename ::rclcpp_action::ClientGoalHandle<ActionT>::WrappedResult;
 
   using Feedback = typename ActionT::Feedback;
   using Result = typename ActionT::Result;
diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 7d16814..543a009 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -903,8 +903,17 @@ class ContextAsyncAwait {
   template <class Callback>
   std::shared_ptr<rclcpp::TimerBase> create_timer_async(
       const Duration &period, Callback callback, rclcpp::CallbackGroup::SharedPtr group = nullptr) {
-    auto timer =
-        node_base()->create_wall_timer(period, [callback]() { callback(std::size_t{}); }, group);
+    auto timer = node_base()->create_wall_timer(
+        period,
+        [callback]() {
+          using ReturnType = decltype(callback(std::size_t{}));
+          if constexpr (!impl::HasPromiseType<ReturnType>) {
+            callback(std::size_t{});
+          } else {
+            callback(std::size_t{}).detach();
+          }
+        },
+        group);
     std::lock_guard<std::recursive_mutex> lock{bookkeeping_mutex_};
     timers_.push_back(std::dynamic_pointer_cast<rclcpp::TimerBase>(timer));
     return timer;
diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index 27c85c4..add0434 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -1,15 +1,11 @@
 #include <gtest/gtest.h>
 
-#include <array>
-#include <atomic>
 #include <chrono>
 #include <example_interfaces/action/fibonacci.hpp>
 #include <icey/icey_async_await.hpp>
-#include <mutex>
 #include <std_srvs/srv/set_bool.hpp>
 #include <tf2_msgs/msg/tf_message.hpp>
 #include <thread>
-#include <unordered_set>
 #include <vector>
 
 using namespace std::chrono_literals;
@@ -51,117 +47,71 @@ void spin_until(Harness &h, Pred pred, std::chrono::milliseconds timeout) {
   }
 }
 
-[[maybe_unused]] void run_tf_stress() {
+void spin_executor_for(Harness &h, std::chrono::seconds duration) {
+  std::thread spin_thread([&]() { h.exec.spin(); });
+  std::this_thread::sleep_for(duration);
+  h.exec.cancel();
+  if (spin_thread.joinable()) spin_thread.join();
+}
+
+void run_tf_race_repro() {
   Harness h;
-  auto tf = h.receiver_ctx->create_transform_buffer();
   auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
-  std::atomic_int64_t stamp_ns{0};
-  std::atomic_uint64_t dispatches{0};
-  std::atomic_uint64_t hits{0};
-  std::atomic_uint64_t timeout_scenarios{0};
-  std::atomic_uint64_t unexpected_errors{0};
-  std::atomic_bool done{false};
 
-  auto pub_timer = h.sender->create_wall_timer(6ms, [&]() {
-    static std::atomic_uint64_t tick{0};
+  auto pub_timer = h.sender->create_wall_timer(10ms, [&]() {
     geometry_msgs::msg::TransformStamped t;
-    auto ns = 1700000000000000000LL + int64_t((tick.fetch_add(1) + 1) * 1000000ULL);
-    t.header.stamp = icey::rclcpp_from_chrono(icey::Time{std::chrono::nanoseconds(ns)});
+    t.header.stamp = icey::rclcpp_from_chrono(icey::Clock::now());
     t.header.frame_id = "map";
     t.child_frame_id = "base_link";
     t.transform.rotation.w = 1.0;
     tf2_msgs::msg::TFMessage msg;
     msg.transforms.push_back(t);
     tf_pub->publish(msg);
-    stamp_ns.store(ns, std::memory_order_release);
   });
-  spin_until(h, [&] { return stamp_ns.load(std::memory_order_acquire) != 0; }, 2s);
 
-  const auto tf_loop = [&]() -> icey::Promise<void> {
-    for (int i = 0; i < 300; ++i) {
-      auto ns = stamp_ns.load(std::memory_order_acquire);
-      const bool should_hit = (i % 2) == 0;
-      auto res = co_await tf.lookup("map", should_hit ? "base_link" : "missing_frame",
-                                    rclcpp::Time(ns), 40ms);
-      if (res.has_value()) {
-        hits.fetch_add(1, std::memory_order_relaxed);
-      } else if (should_hit) {
-        unexpected_errors.fetch_add(1, std::memory_order_relaxed);
-      } else {
-        timeout_scenarios.fetch_add(1, std::memory_order_relaxed);
-      }
-    }
-    done.store(true, std::memory_order_release);
-    co_return;
-  };
-  tf_loop().detach();
-
-  std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(
-        6ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
+  auto tf = h.receiver_ctx->create_transform_buffer();
+  std::vector<rclcpp::CallbackGroup::SharedPtr> cb_groups;
+  for (size_t t = 0; t < 100; ++t) {
+    cb_groups.push_back(h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant));
+    h.receiver_ctx->create_timer_async(
+        50ms,
+        [&](std::size_t) -> icey::Promise<void> {
+          (void)co_await tf.lookup("map", "base_link", icey::Clock::now(), 3ms);
+        },
+        cb_groups.back());
   }
-
-  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
-  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 12s);
-  for (auto &timer : timers) timer->cancel();
-  pub_timer->cancel();
-
-  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
-  EXPECT_TRUE(done.load(std::memory_order_acquire));
-  EXPECT_GT(hits.load(std::memory_order_relaxed), 0U);
-  EXPECT_GT(timeout_scenarios.load(std::memory_order_relaxed), 0U);
-  EXPECT_EQ(unexpected_errors.load(std::memory_order_relaxed), 0U);
+  (void)pub_timer;
+  spin_executor_for(h, 10s);
 }
 
-[[maybe_unused]] void run_service_stress() {
+void run_service_race_repro() {
   Harness h;
   h.sender_ctx->create_service<ExampleService>(
-      "stress_set_bool", [](std::shared_ptr<ExampleService::Request> req) {
+      "race_set_bool", [](std::shared_ptr<ExampleService::Request> req) {
         auto resp = std::make_shared<ExampleService::Response>();
         resp->success = req->data;
         return resp;
       });
-  auto client = h.receiver_ctx->create_client<ExampleService>("stress_set_bool");
-  std::atomic_uint64_t dispatches{0};
-  std::atomic_uint64_t ok{0};
-  std::atomic_uint64_t errors{0};
-  std::atomic_bool done{false};
-
-  const auto service_loop = [&]() -> icey::Promise<void> {
-    for (int i = 0; i < 200; ++i) {
-      auto req = std::make_shared<ExampleService::Request>();
-      req->data = true;
-      auto res = co_await client.call(req, 400ms);
-      if (res.has_value() && res.value()->success)
-        ok.fetch_add(1, std::memory_order_relaxed);
-      else
-        errors.fetch_add(1, std::memory_order_relaxed);
-    }
-    done.store(true, std::memory_order_release);
-    co_return;
-  };
-  service_loop().detach();
-
-  std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(
-        5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
+  auto client = h.receiver_ctx->create_client<ExampleService>("race_set_bool");
+  std::vector<rclcpp::CallbackGroup::SharedPtr> cb_groups;
+  for (size_t t = 0; t < 100; ++t) {
+    cb_groups.push_back(h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant));
+    h.receiver_ctx->create_timer_async(
+        50ms,
+        [&](std::size_t) -> icey::Promise<void> {
+          auto req = std::make_shared<ExampleService::Request>();
+          req->data = true;
+          (void)co_await client.call(req, 3ms);
+        },
+        cb_groups.back());
   }
-
-  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
-  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 12s);
-  for (auto &timer : timers) timer->cancel();
-
-  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
-  EXPECT_TRUE(done.load(std::memory_order_acquire));
-  EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
+  spin_executor_for(h, 10s);
 }
 
-[[maybe_unused]] void run_action_stress() {
+void run_action_race_repro() {
   Harness h;
   h.sender_ctx->create_action_server<Fibonacci>(
-      "stress_fib",
+      "race_fib",
       [](const rclcpp_action::GoalUUID &, std::shared_ptr<const Fibonacci::Goal>) {
         return rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;
       },
@@ -171,93 +121,25 @@ void spin_until(Harness &h, Pred pred, std::chrono::milliseconds timeout) {
         result->sequence = {0, 1, 1, 2};
         gh->succeed(result);
       });
-  auto client = h.receiver_ctx->create_action_client<Fibonacci>("stress_fib");
-  std::atomic_uint64_t dispatches{0};
-  std::atomic_uint64_t ok{0};
-  std::atomic_uint64_t errors{0};
-  std::atomic_bool done{false};
-
-  const auto action_loop = [&]() -> icey::Promise<void> {
-    for (int i = 0; i < 120; ++i) {
-      Fibonacci::Goal goal;
-      goal.order = 4;
-      auto sent = co_await client.send_goal(goal, 400ms, [](auto, auto) {});
-      if (!sent.has_value()) {
-        errors.fetch_add(1, std::memory_order_relaxed);
-      } else {
-        auto res = co_await sent.value().result(400ms);
-        if (res.has_value() && res.value().code == rclcpp_action::ResultCode::SUCCEEDED)
-          ok.fetch_add(1, std::memory_order_relaxed);
-        else
-          errors.fetch_add(1, std::memory_order_relaxed);
-      }
-    }
-    done.store(true, std::memory_order_release);
-    co_return;
-  };
-  action_loop().detach();
-
-  std::array<std::shared_ptr<rclcpp::TimerBase>, 4> timers;
-  for (auto &timer : timers) {
-    timer = h.receiver->create_wall_timer(
-        5ms, [&]() { dispatches.fetch_add(1, std::memory_order_relaxed); });
-  }
-
-  spin_until(h, [&] { return dispatches.load(std::memory_order_relaxed) >= 5000; }, 12s);
-  spin_until(h, [&] { return done.load(std::memory_order_acquire); }, 15s);
-  for (auto &timer : timers) timer->cancel();
-
-  EXPECT_GE(dispatches.load(std::memory_order_relaxed), 5000U);
-  EXPECT_TRUE(done.load(std::memory_order_acquire));
-  EXPECT_GT(ok.load(std::memory_order_relaxed) + errors.load(std::memory_order_relaxed), 0U);
-}
-
-void run_race_repro_async_internals() {
-  Harness h;
-  auto tf_pub = h.sender->create_publisher<tf2_msgs::msg::TFMessage>("/tf", 10);
-
-  auto pub_timer = h.sender->create_wall_timer(10ms, [&]() {
-    geometry_msgs::msg::TransformStamped t;
-    t.header.stamp = icey::rclcpp_from_chrono(icey::Clock::now());
-    t.header.frame_id = "map";
-    t.child_frame_id = "base_link";
-    t.transform.rotation.w = 1.0;
-    tf2_msgs::msg::TFMessage msg;
-    msg.transforms.push_back(t);
-    std::cout << "Pub Thread ID: " << std::this_thread::get_id() << std::endl;
-    tf_pub->publish(msg);
-  });
-
-  auto tf = h.receiver_ctx->create_transform_buffer();
+  auto client = h.receiver_ctx->create_action_client<Fibonacci>("race_fib");
   std::vector<rclcpp::CallbackGroup::SharedPtr> cb_groups;
-
-  for (size_t t = 0; t < 100; t++) {
+  for (size_t t = 0; t < 100; ++t) {
     cb_groups.push_back(h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant));
     h.receiver_ctx->create_timer_async(
         50ms,
-        [&, t](std::size_t) -> icey::Promise<void> {
-          std::cout << "Timer #" << t << " Thread ID: " << std::this_thread::get_id() << std::endl;
-          (void)co_await tf.lookup("map", "base_link", icey::Clock::now(), 3ms);
+        [&](std::size_t) -> icey::Promise<void> {
+          Fibonacci::Goal goal;
+          goal.order = 4;
+          auto sent = co_await client.send_goal(goal, 3ms, [](auto, auto) {});
+          if (sent.has_value()) (void)co_await sent.value().result(3ms);
         },
         cb_groups.back());
   }
-
-  std::thread spin_thread([&]() { h.exec.spin(); });
-  std::this_thread::sleep_for(10s);
-  h.exec.cancel();
-  if (spin_thread.joinable()) spin_thread.join();
-  pub_timer->cancel();
-  std::cout << "Main Thread ID: " << std::this_thread::get_id() << std::endl;
+  spin_executor_for(h, 10s);
 }
 
 }  // namespace
 
-TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_race_repro_async_internals(); }
-
-/*
-TEST(NodeTasksThreadSafety, TfWithFourTimers) { run_tf_stress(); }
-
-TEST(NodeTasksThreadSafety, ServiceWithFourTimers) { run_service_stress(); }
-
-TEST(NodeTasksThreadSafety, ActionWithFourTimers) { run_action_stress(); }
-*/
+TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_tf_race_repro(); }
+TEST(NodeTasksThreadSafety, TSanRaceReproServiceAsyncInternals) { run_service_race_repro(); }
+TEST(NodeTasksThreadSafety, TSanRaceReproActionAsyncInternals) { run_action_race_repro(); }
diff --git a/icey_examples/src/action_client_async_await.cpp b/icey_examples/src/action_client_async_await.cpp
index 9a827cb..8b3c09f 100644
--- a/icey_examples/src/action_client_async_await.cpp
+++ b/icey_examples/src/action_client_async_await.cpp
@@ -3,18 +3,22 @@
 /// Author: Ivo Ivanov
 /// This software is licensed under the Apache License, Version 2.0.
 
-/// Action client example using ICEY async/await.
-///
-/// Key differences vs regular rclcpp_action API:
-/// - No manual SendGoalOptions wiring for result/feedback callbacks when using co_await.
-/// - Per-goal timeout is explicit and automatic cleanup on timeout.
-/// - Looks synchronous (co_await), but uses rclcpp under the hood without threads.
+/// Action client example using ICEY async/await. Demonstrates an async/await API for sending the
+/// goal and obtaining the result. The feedback messages are still received through a callback
+/// because ROS does not guarantee that no feedback can be received before the result request or
+/// even after the result has arrived
+/// (https://github.com/ros2/rclcpp/issues/2782#issuecomment-2761123049). Therefore, to prevent
+/// losing any feedback messages, ICEY does not provide an async/await API for obtaining feedback
+/// and instead uses a callback. See also https://github.com/iv461/icey/pull/17 for an alternative
+/// API proposal once this issue is fixed in rclcpp.
 
 #include <example_interfaces/action/fibonacci.hpp>
 #include <icey/icey_async_await.hpp>
 
 using namespace std::chrono_literals;
 using Fibonacci = example_interfaces::action::Fibonacci;
+using GoalHandle = rclcpp_action::ClientGoalHandle<Fibonacci>;
+using ActionResult = typename GoalHandle::WrappedResult;
 
 icey::Promise<void> call_action(std::shared_ptr<rclcpp::Node> node) {
   auto ctx = std::make_shared<icey::ContextAsyncAwait>(node.get());
@@ -23,10 +27,14 @@ icey::Promise<void> call_action(std::shared_ptr<rclcpp::Node> node) {
   Fibonacci::Goal goal;
   goal.order = 7;
 
+  const auto on_feedback = [node](auto, auto) {
+    RCLCPP_WARN(node->get_logger(), "Got some feedback");
+  };
+  
   RCLCPP_INFO_STREAM(node->get_logger(), "Sending goal.. ");
-  // Request a goal with 2 seconds timeout
-  auto maybe_goal_handle = co_await client.send_goal(
-      goal, 5s, [node](auto, auto) { RCLCPP_WARN(node->get_logger(), "Got some feedback"); });
+  // Request a goal with 2 seconds timeout, pass a callback for obtaining feedback messages
+  icey::Result<icey::AsyncGoalHandle<Fibonacci>, std::string> maybe_goal_handle =
+      co_await client.send_goal(goal, 5s, on_feedback);
 
   if (maybe_goal_handle.has_error()) {
     RCLCPP_WARN_STREAM(node->get_logger(),
@@ -35,14 +43,14 @@ icey::Promise<void> call_action(std::shared_ptr<rclcpp::Node> node) {
   }
   RCLCPP_INFO_STREAM(node->get_logger(),
                      "Goal request was accepted, starting to wait for the result..");
-  auto goal_handle = maybe_goal_handle.value();
+  icey::AsyncGoalHandle<Fibonacci> goal_handle = maybe_goal_handle.value();
   /// Now wait for the result of the action for 20 seconds.
-  auto maybe_result = co_await goal_handle.result(20s);
+  icey::Result<ActionResult, std::string> maybe_result = co_await goal_handle.result(20s);
   if (maybe_result.has_error()) {
     RCLCPP_WARN_STREAM(node->get_logger(), "Action failed: " << maybe_result.error());
 
   } else {
-    auto const &result = maybe_result.value();
+    const ActionResult &result = maybe_result.value();
     if (result.code == rclcpp_action::ResultCode::SUCCEEDED) {
       RCLCPP_INFO(node->get_logger(), "Fibonacci done. Size: %zu", result.result->sequence.size());
     } else {

From 912e0ed29002dac2b54a315155133746800e8549 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 15:29:54 +0100
Subject: [PATCH 18/40] removed unnecessary typedef in server example

---
 icey_examples/src/action_server_async_await.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/icey_examples/src/action_server_async_await.cpp b/icey_examples/src/action_server_async_await.cpp
index 3c8db98..318da3d 100644
--- a/icey_examples/src/action_server_async_await.cpp
+++ b/icey_examples/src/action_server_async_await.cpp
@@ -15,7 +15,6 @@
 
 using namespace std::chrono_literals;
 using Fibonacci = example_interfaces::action::Fibonacci;
-using GoalHandleFibonacci = icey::rclcpp_action::ClientGoalHandle<Fibonacci>;
 using ServerGoalHandleFibonacci = icey::rclcpp_action::ServerGoalHandle<Fibonacci>;
 
 int main(int argc, char **argv) {

From d152bba78c88fc916325e3d3780233ff5df6d10d Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 15:32:46 +0100
Subject: [PATCH 19/40] Polish language

---
 icey_examples/src/action_client_async_await.cpp | 17 ++++++++---------
 icey_examples/src/action_server_async_await.cpp |  8 ++++----
 2 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/icey_examples/src/action_client_async_await.cpp b/icey_examples/src/action_client_async_await.cpp
index 8b3c09f..5c2cd0c 100644
--- a/icey_examples/src/action_client_async_await.cpp
+++ b/icey_examples/src/action_client_async_await.cpp
@@ -3,14 +3,13 @@
 /// Author: Ivo Ivanov
 /// This software is licensed under the Apache License, Version 2.0.
 
-/// Action client example using ICEY async/await. Demonstrates an async/await API for sending the
-/// goal and obtaining the result. The feedback messages are still received through a callback
-/// because ROS does not guarantee that no feedback can be received before the result request or
-/// even after the result has arrived
-/// (https://github.com/ros2/rclcpp/issues/2782#issuecomment-2761123049). Therefore, to prevent
-/// losing any feedback messages, ICEY does not provide an async/await API for obtaining feedback
-/// and instead uses a callback. See also https://github.com/iv461/icey/pull/17 for an alternative
-/// API proposal once this issue is fixed in rclcpp.
+/// Action client example using ICEY async/await. It demonstrates an async/await API for sending the
+/// goal and obtaining the result. Feedback messages are received via a callback because ROS does
+/// not guarantee that feedback cannot be received before or after the result request
+/// (https://github.com/ros2/rclcpp/issues/2782#issuecomment-2761123049). To prevent losing any
+/// feedback messages, ICEY does not provide an async/await API for obtaining feedback and instead
+/// uses a callback. See https://github.com/iv461/icey/pull/17 for an alternative API proposal once
+/// this issue is fixed in rclcpp.
 
 #include <example_interfaces/action/fibonacci.hpp>
 #include <icey/icey_async_await.hpp>
@@ -30,7 +29,7 @@ icey::Promise<void> call_action(std::shared_ptr<rclcpp::Node> node) {
   const auto on_feedback = [node](auto, auto) {
     RCLCPP_WARN(node->get_logger(), "Got some feedback");
   };
-  
+
   RCLCPP_INFO_STREAM(node->get_logger(), "Sending goal.. ");
   // Request a goal with 2 seconds timeout, pass a callback for obtaining feedback messages
   icey::Result<icey::AsyncGoalHandle<Fibonacci>, std::string> maybe_goal_handle =
diff --git a/icey_examples/src/action_server_async_await.cpp b/icey_examples/src/action_server_async_await.cpp
index 318da3d..e81bf26 100644
--- a/icey_examples/src/action_server_async_await.cpp
+++ b/icey_examples/src/action_server_async_await.cpp
@@ -3,10 +3,10 @@
 /// Author: Ivo Ivanov
 /// This software is licensed under the Apache License, Version 2.0.
 
-/// Action server example that demonstrates how callbacks of the action server can be coroutines. In
-/// this case, the handle_goal-callback is a coroutine and calls a service. Once the service
-/// response, the goal is accepted. The handle_cancel and handle_accepted could be coroutines as
-/// well.
+/// This is an action server example that demonstrates how callbacks of the action server can be
+/// coroutines. In this case, the handle_goal callback is a coroutine that calls a service. Once the
+/// service responds, the goal is accepted. handle_cancel and handle_accepted could also be
+/// coroutines.
 
 #include <example_interfaces/action/fibonacci.hpp>
 #include <icey/icey_async_await.hpp>

From 88dc8659ad697676c0065e91695aec2940142aa9 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 15:37:57 +0100
Subject: [PATCH 20/40] Race test case: Multiple cb groups are of course not
 necessary, one reentrant suffices

---
 icey/test/node_tasks_test.cpp | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index add0434..d10151c 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -70,15 +70,14 @@ void run_tf_race_repro() {
   });
 
   auto tf = h.receiver_ctx->create_transform_buffer();
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cb_groups;
+  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant)};
   for (size_t t = 0; t < 100; ++t) {
-    cb_groups.push_back(h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant));
     h.receiver_ctx->create_timer_async(
         50ms,
         [&](std::size_t) -> icey::Promise<void> {
           (void)co_await tf.lookup("map", "base_link", icey::Clock::now(), 3ms);
         },
-        cb_groups.back());
+        cb_group);
   }
   (void)pub_timer;
   spin_executor_for(h, 10s);
@@ -93,9 +92,8 @@ void run_service_race_repro() {
         return resp;
       });
   auto client = h.receiver_ctx->create_client<ExampleService>("race_set_bool");
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cb_groups;
+  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant)};
   for (size_t t = 0; t < 100; ++t) {
-    cb_groups.push_back(h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant));
     h.receiver_ctx->create_timer_async(
         50ms,
         [&](std::size_t) -> icey::Promise<void> {
@@ -103,7 +101,7 @@ void run_service_race_repro() {
           req->data = true;
           (void)co_await client.call(req, 3ms);
         },
-        cb_groups.back());
+        cb_group);
   }
   spin_executor_for(h, 10s);
 }
@@ -122,9 +120,8 @@ void run_action_race_repro() {
         gh->succeed(result);
       });
   auto client = h.receiver_ctx->create_action_client<Fibonacci>("race_fib");
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cb_groups;
+  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant)};
   for (size_t t = 0; t < 100; ++t) {
-    cb_groups.push_back(h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant));
     h.receiver_ctx->create_timer_async(
         50ms,
         [&](std::size_t) -> icey::Promise<void> {
@@ -133,13 +130,13 @@ void run_action_race_repro() {
           auto sent = co_await client.send_goal(goal, 3ms, [](auto, auto) {});
           if (sent.has_value()) (void)co_await sent.value().result(3ms);
         },
-        cb_groups.back());
+        cb_group);
   }
   spin_executor_for(h, 10s);
 }
 
 }  // namespace
 
-TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_tf_race_repro(); }
+// TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_tf_race_repro(); }
 TEST(NodeTasksThreadSafety, TSanRaceReproServiceAsyncInternals) { run_service_race_repro(); }
-TEST(NodeTasksThreadSafety, TSanRaceReproActionAsyncInternals) { run_action_race_repro(); }
+// TEST(NodeTasksThreadSafety, TSanRaceReproActionAsyncInternals) { run_action_race_repro(); }

From 4f619e812f335531ef8da9d9355df12e191892d2 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 15:50:57 +0100
Subject: [PATCH 21/40] Added TSAN CI job

---
 .github/workflows/tsan.yml             | 52 ++++++++++++++++++++++++++
 icey/include/icey/icey_async_await.hpp |  2 +-
 icey/test/node_tasks_test.cpp          |  4 +-
 3 files changed, 55 insertions(+), 3 deletions(-)
 create mode 100644 .github/workflows/tsan.yml

diff --git a/.github/workflows/tsan.yml b/.github/workflows/tsan.yml
new file mode 100644
index 0000000..a9fa935
--- /dev/null
+++ b/.github/workflows/tsan.yml
@@ -0,0 +1,52 @@
+name: TSAN Race Check
+
+on:
+  workflow_dispatch:
+
+jobs:
+  tsan:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - ros_distro: humble
+            container_image: rostooling/setup-ros-docker:ubuntu-jammy-latest
+          - ros_distro: jazzy
+            container_image: rostooling/setup-ros-docker:ubuntu-noble-latest
+          - ros_distro: kilted
+            container_image: rostooling/setup-ros-docker:ubuntu-noble-latest
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ matrix.container_image }}
+    env:
+      RMW_IMPLEMENTATION: rmw_cyclonedds_cpp
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install tooling
+        shell: bash
+        run: |
+          apt-get update
+          apt-get install -y --no-install-recommends util-linux
+
+      - name: Build with TSAN
+        shell: bash
+        run: |
+          source /opt/ros/${{ matrix.ros_distro }}/setup.bash
+          MAKEFLAGS="-j6" colcon build \
+            --packages-select icey icey_examples \
+            --cmake-args \
+              -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+              -DICEY_ENABLE_TSAN=ON \
+              -DICEY_ASYNC_AWAIT_THREAD_SAFE=1
+
+      - name: Run TSAN race repro tests
+        shell: bash
+        run: |
+          source /opt/ros/${{ matrix.ros_distro }}/setup.bash
+          source install/setup.bash
+          TSAN_OPTIONS="halt_on_error=1:detect_deadlocks=1:suppressions=${GITHUB_WORKSPACE}/icey/test/tsan_dds.supp" \
+            setarch x86_64 -R \
+            ${GITHUB_WORKSPACE}/build/icey/test_main \
+            --gtest_filter=NodeTasksThreadSafety.TSanRaceRepro*
diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 543a009..4d3b9cc 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -31,7 +31,7 @@
 namespace icey {
 
 #ifndef ICEY_ASYNC_AWAIT_THREAD_SAFE
-#define ICEY_ASYNC_AWAIT_THREAD_SAFE 0
+#define ICEY_ASYNC_AWAIT_THREAD_SAFE 1
 #endif
 
 using Clock = std::chrono::system_clock;
diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index d10151c..c8b7b9a 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -137,6 +137,6 @@ void run_action_race_repro() {
 
 }  // namespace
 
-// TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_tf_race_repro(); }
-TEST(NodeTasksThreadSafety, TSanRaceReproServiceAsyncInternals) { run_service_race_repro(); }
+TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_tf_race_repro(); }
+// TEST(NodeTasksThreadSafety, TSanRaceReproServiceAsyncInternals) { run_service_race_repro(); }
 // TEST(NodeTasksThreadSafety, TSanRaceReproActionAsyncInternals) { run_action_race_repro(); }

From d51e6f7ca08b01e3ed1d4501c8b98198af725f5a Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 16:22:26 +0100
Subject: [PATCH 22/40] Fixed a race on the coroutine state index where the
 thread that dispatched the async operation and detached the coroutine checks
 again if this coroutine is finished in it's destructor, while another thread
 continues the same coroutine. The fix is easy, since we do not have to do
 anything with this coroutine state in case we detached, we simply set the
 pointer to the coroutine state (aka. coroutine_handle) to zero

---
 icey/include/icey/impl/promise.hpp | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/icey/include/icey/impl/promise.hpp b/icey/include/icey/impl/promise.hpp
index b9f263b..cef035f 100644
--- a/icey/include/icey/impl/promise.hpp
+++ b/icey/include/icey/impl/promise.hpp
@@ -377,18 +377,25 @@ class [[nodiscard("Promise must be used")]] Promise {
                              std::size_t(coroutine_.address()))
               << std::endl;
 #endif
-    if (coroutine_ && coroutine_.done()) {
-      coroutine_.destroy();
-    } else if (coroutine_) {
-      /// TODO to enforce users explicitly detaching, this should probably throw
-      coroutine_.promise().detach();
+    if (coroutine_) {
+      if (coroutine_.done()) {
+        coroutine_.destroy();
+      } else {
+        /// TODO to enforce users explicitly detaching, this should probably throw
+        detach();
+      }
     }
   }
 
   /// You need to detach a Promise if you are not awaiting it but it should still continue to run.
   /// Detaching this outer promise means the coroutine state won't be destroyed on destruction of
   /// outer promise. This also avoid the discarting warning
-  void detach() { coroutine_.promise().detach(); }
+  void detach() {
+    coroutine_.promise().detach(); // Tell the promise it must continue after final suspend so that it reaches the final state where the coroutine state is destroyed. 
+    coroutine_ = nullptr;  /// set to nullptr so that we do not access coroutine and cause a race on
+                           /// destruction where potentially another thread continues the coroutine
+                           /// that this thread has just detached
+  }
 
   bool await_ready() const noexcept { return coroutine_ && coroutine_.done(); }
 

From cdb6094c89288a77cc61166ab376c2780c2fb855 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 17:10:47 +0100
Subject: [PATCH 23/40] Fix another race

---
 icey/include/icey/impl/promise.hpp | 7 +++++--
 icey/test/node_tasks_test.cpp      | 4 ++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/icey/include/icey/impl/promise.hpp b/icey/include/icey/impl/promise.hpp
index cef035f..b655ce1 100644
--- a/icey/include/icey/impl/promise.hpp
+++ b/icey/include/icey/impl/promise.hpp
@@ -182,7 +182,8 @@ class PromiseBase : public PromiseTag {
   auto await_suspend(std::coroutine_handle<> awaiting_coroutine) noexcept {
     this->continuation_ = awaiting_coroutine;
     if (this->launch_async_) {
-      this->launch_async_(*this);
+      auto launch = std::move(launch_async_); // copy the lambda to avoid a race between two threads, one resuming the coroutine that holds this promise object stored and therefore eventually destroying this promise, while this thread still has not finished calling launch_async
+      launch(*this);
     }
 #ifdef ICEY_CORO_DEBUG_PRINT
     std::cout << fmt::format(
@@ -391,7 +392,9 @@ class [[nodiscard("Promise must be used")]] Promise {
   /// Detaching this outer promise means the coroutine state won't be destroyed on destruction of
   /// outer promise. This also avoid the discarting warning
   void detach() {
-    coroutine_.promise().detach(); // Tell the promise it must continue after final suspend so that it reaches the final state where the coroutine state is destroyed. 
+    coroutine_.promise()
+        .detach();  // Tell the promise it must continue after final suspend so that it reaches the
+                    // final state where the coroutine state is destroyed.
     coroutine_ = nullptr;  /// set to nullptr so that we do not access coroutine and cause a race on
                            /// destruction where potentially another thread continues the coroutine
                            /// that this thread has just detached
diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index c8b7b9a..d6c1167 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -138,5 +138,5 @@ void run_action_race_repro() {
 }  // namespace
 
 TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_tf_race_repro(); }
-// TEST(NodeTasksThreadSafety, TSanRaceReproServiceAsyncInternals) { run_service_race_repro(); }
-// TEST(NodeTasksThreadSafety, TSanRaceReproActionAsyncInternals) { run_action_race_repro(); }
+TEST(NodeTasksThreadSafety, TSanRaceReproServiceAsyncInternals) { run_service_race_repro(); }
+TEST(NodeTasksThreadSafety, TSanRaceReproActionAsyncInternals) { run_action_race_repro(); }

From 0df63342b6a1c595404b0d055a9da1d83420bfd6 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 17:16:52 +0100
Subject: [PATCH 24/40] Added missing locking in action client

---
 icey/src/actions/client.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/icey/src/actions/client.cpp b/icey/src/actions/client.cpp
index 22c9391..f2c75f3 100644
--- a/icey/src/actions/client.cpp
+++ b/icey/src/actions/client.cpp
@@ -158,6 +158,7 @@ class ClientBaseImpl {
   std::map<int64_t, ResponseCallback> pending_cancel_responses;
   std::mutex cancel_requests_mutex;
 
+  std::mutex goal_id_rng_mutex;
   std::independent_bits_engine<std::mt19937, 8, unsigned int> random_bytes_generator;
 };
 
@@ -428,6 +429,7 @@ int64_t ClientBase::send_cancel_request(std::shared_ptr<void> request, ResponseC
 
 GoalUUID ClientBase::generate_goal_id() {
   GoalUUID goal_id;
+  std::lock_guard<std::mutex> lock(pimpl_->goal_id_rng_mutex);
   // TODO(hidmic): Do something better than this for UUID generation.
   // std::generate(
   //   goal_id.uuid.begin(), goal_id.uuid.end(),
@@ -697,14 +699,17 @@ void ClientBase::execute(std::shared_ptr<void> &data_in) {
 }
 
 bool ClientBase::cancel_cancellation_request(int64_t request_id) {
+  std::lock_guard<std::mutex> lock(pimpl_->cancel_requests_mutex);
   return pimpl_->pending_cancel_responses.erase(request_id);
 }
 
 bool ClientBase::cancel_goal_request(int64_t request_id) {
+  std::lock_guard<std::mutex> lock(pimpl_->goal_requests_mutex);
   return pimpl_->pending_goal_responses.erase(request_id);
 }
 
 bool ClientBase::cancel_result_request(int64_t request_id) {
+  std::lock_guard<std::mutex> lock(pimpl_->result_requests_mutex);
   return pimpl_->pending_result_responses.erase(request_id);
 }
 

From 61e8cfe6aecea479de7beea7ba470316cf1c019a Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 17:23:53 +0100
Subject: [PATCH 25/40] Using lock guards instead of manual locking is actually
 better because it is exception safe

---
 icey/src/actions/client.cpp | 72 +++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 35 deletions(-)

diff --git a/icey/src/actions/client.cpp b/icey/src/actions/client.cpp
index f2c75f3..e146d21 100644
--- a/icey/src/actions/client.cpp
+++ b/icey/src/actions/client.cpp
@@ -341,22 +341,23 @@ bool ClientBase::is_ready(rcl_wait_set_t *wait_set) {
 
 void ClientBase::handle_goal_response(const rmw_request_id_t &response_header,
                                       std::shared_ptr<void> response) {
-  pimpl_->goal_requests_mutex.lock();
-  auto it = pimpl_->pending_goal_responses.find(response_header.sequence_number);
-  if (it == pimpl_->pending_goal_responses.end()) {
-    pimpl_->goal_requests_mutex.unlock();
-    return;
-  }
-  auto callback = it->second;
-  pimpl_->goal_requests_mutex.unlock();
+  const int64_t sequence_number = response_header.sequence_number;
+  ResponseCallback callback;
+  {
+    std::lock_guard<std::mutex> lock(pimpl_->goal_requests_mutex);
+    auto it = pimpl_->pending_goal_responses.find(sequence_number);
+    if (it == pimpl_->pending_goal_responses.end()) return;
+    callback = it->second;
+  }
   callback(response);
-  pimpl_->goal_requests_mutex.lock();
-  pimpl_->pending_goal_responses.erase(it);
-  pimpl_->goal_requests_mutex.unlock();
+  {
+    std::lock_guard<std::mutex> lock(pimpl_->goal_requests_mutex);
+    pimpl_->pending_goal_responses.erase(sequence_number);
+  }
 }
 
 int64_t ClientBase::send_goal_request(std::shared_ptr<void> request, ResponseCallback callback) {
-  std::unique_lock<std::mutex> guard(pimpl_->goal_requests_mutex);
+  std::lock_guard<std::mutex> guard(pimpl_->goal_requests_mutex);
   int64_t sequence_number;
   rcl_ret_t ret =
       rcl_action_send_goal_request(pimpl_->client_handle.get(), request.get(), &sequence_number);
@@ -370,18 +371,19 @@ int64_t ClientBase::send_goal_request(std::shared_ptr<void> request, ResponseCal
 
 void ClientBase::handle_result_response(const rmw_request_id_t &response_header,
                                         std::shared_ptr<void> response) {
-  pimpl_->result_requests_mutex.lock();
-  auto it = pimpl_->pending_result_responses.find(response_header.sequence_number);
-  if (it == pimpl_->pending_result_responses.end()) {
-    pimpl_->result_requests_mutex.unlock();
-    return;
-  }
-  auto callback = it->second;
-  pimpl_->result_requests_mutex.unlock();
+  const int64_t sequence_number = response_header.sequence_number;
+  ResponseCallback callback;
+  {
+    std::lock_guard<std::mutex> lock(pimpl_->result_requests_mutex);
+    auto it = pimpl_->pending_result_responses.find(sequence_number);
+    if (it == pimpl_->pending_result_responses.end()) return;
+    callback = it->second;
+  }
   callback(response);
-  pimpl_->result_requests_mutex.lock();
-  pimpl_->pending_result_responses.erase(it);
-  pimpl_->result_requests_mutex.unlock();
+  {
+    std::lock_guard<std::mutex> lock(pimpl_->result_requests_mutex);
+    pimpl_->pending_result_responses.erase(sequence_number);
+  }
 }
 
 int64_t ClientBase::send_result_request(std::shared_ptr<void> request, ResponseCallback callback) {
@@ -399,19 +401,19 @@ int64_t ClientBase::send_result_request(std::shared_ptr<void> request, ResponseC
 
 void ClientBase::handle_cancel_response(const rmw_request_id_t &response_header,
                                         std::shared_ptr<void> response) {
-  pimpl_->cancel_requests_mutex.lock();
-  const int64_t &sequence_number = response_header.sequence_number;
-  auto it = pimpl_->pending_cancel_responses.find(sequence_number);
-  if (it == pimpl_->pending_cancel_responses.end()) {
-    return;
-  }
-  auto callback = it->second;
-  pimpl_->goal_requests_mutex.unlock();
+  const int64_t sequence_number = response_header.sequence_number;
+  ResponseCallback callback;
+  {
+    std::lock_guard<std::mutex> lock(pimpl_->cancel_requests_mutex);
+    auto it = pimpl_->pending_cancel_responses.find(sequence_number);
+    if (it == pimpl_->pending_cancel_responses.end()) return;
+    callback = it->second;
+  }
   callback(response);
-  pimpl_->cancel_requests_mutex.lock();
-  pimpl_->pending_cancel_responses.erase(
-      it);  /// imagine thread-safe datastructures like tbb::concurrent_hash_map would have been discovered already
-  pimpl_->cancel_requests_mutex.unlock();
+  {
+    std::lock_guard<std::mutex> lock(pimpl_->cancel_requests_mutex);
+    pimpl_->pending_cancel_responses.erase(sequence_number);
+  }
 }
 
 int64_t ClientBase::send_cancel_request(std::shared_ptr<void> request, ResponseCallback callback) {

From 5a56bc90dbd4c57309b3be91659d01c5fa4f9c0e Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 18:14:45 +0100
Subject: [PATCH 26/40] Fixed UAF

---
 icey/test/entities_async_await_test.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/icey/test/entities_async_await_test.cpp b/icey/test/entities_async_await_test.cpp
index a441530..9e8ddec 100644
--- a/icey/test/entities_async_await_test.cpp
+++ b/icey/test/entities_async_await_test.cpp
@@ -102,12 +102,12 @@ TEST_F(AsyncAwaitTwoNodeTest, PubSubTest) {
 
 TEST_F(AsyncAwaitTwoNodeTest, PubSubTest2) {
   const auto l = [this]() -> icey::Promise<int> {
-    std::size_t received_cnt{0};
+    auto received_cnt = std::make_shared<std::size_t>(0);
     receiver_->icey()
         .create_subscription<std_msgs::msg::Float32>("/icey_test/sine_signal")
-        .then([&](auto msg) {
-          EXPECT_EQ(received_cnt, std::size_t(msg->data));
-          received_cnt++;
+        .then([received_cnt](auto msg) {
+          EXPECT_EQ(*received_cnt, std::size_t(msg->data));
+          (*received_cnt)++;
         });
 
     auto timer = sender_->icey().create_timer(100ms);
@@ -125,7 +125,7 @@ TEST_F(AsyncAwaitTwoNodeTest, PubSubTest2) {
     /// We do not await till the published message was received.
     /// Since the ACK from DDS is exposed in rclcpp via PublisherBase::wait_for_all_acked, we could
     /// implement a co_await publish(msg, timeout).
-    EXPECT_EQ(received_cnt, 9);
+    EXPECT_EQ(*received_cnt, 9);
     async_completed = true;
     co_return 0;
   };

From 42b6b643c2d16d9587e76a68ed785ef4d151c2db Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 18:17:11 +0100
Subject: [PATCH 27/40] Fixed another UAF

---
 icey/test/entities_async_await_test.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/icey/test/entities_async_await_test.cpp b/icey/test/entities_async_await_test.cpp
index 9e8ddec..23dfca7 100644
--- a/icey/test/entities_async_await_test.cpp
+++ b/icey/test/entities_async_await_test.cpp
@@ -243,7 +243,7 @@ TEST_F(AsyncAwaitTwoNodeTest, TFAsyncLookupTest) {
 
     sender_->icey()
         .create_timer(100ms)
-        .then([&](size_t ticks) -> std::optional<geometry_msgs::msg::TransformStamped> {
+        .then([base_time](size_t ticks) -> std::optional<geometry_msgs::msg::TransformStamped> {
           geometry_msgs::msg::TransformStamped tf1;
           tf1.header.stamp = icey::rclcpp_from_chrono(base_time + ticks * 100ms);
           tf1.header.frame_id = "icey_test_frame1";
@@ -256,7 +256,7 @@ TEST_F(AsyncAwaitTwoNodeTest, TFAsyncLookupTest) {
 
     sender_->icey()
         .create_timer(100ms)
-        .then([&](size_t ticks) -> std::optional<geometry_msgs::msg::TransformStamped> {
+        .then([base_time](size_t ticks) -> std::optional<geometry_msgs::msg::TransformStamped> {
           geometry_msgs::msg::TransformStamped tf1;
           tf1.header.stamp = icey::rclcpp_from_chrono(base_time + ticks * 100ms);
           tf1.header.frame_id = "icey_test_frame2";

From 1f2998f5e7c311b0062bb1a07d79915679e7a552 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 18:25:25 +0100
Subject: [PATCH 28/40] Renamed tests

---
 icey/test/node_tasks_test.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index d6c1167..2e797c8 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -137,6 +137,6 @@ void run_action_race_repro() {
 
 }  // namespace
 
-TEST(NodeTasksThreadSafety, TSanRaceReproAsyncInternals) { run_tf_race_repro(); }
-TEST(NodeTasksThreadSafety, TSanRaceReproServiceAsyncInternals) { run_service_race_repro(); }
-TEST(NodeTasksThreadSafety, TSanRaceReproActionAsyncInternals) { run_action_race_repro(); }
+TEST(ThreadSafety, TFRaces) { run_tf_race_repro(); }
+TEST(ThreadSafety, Services) { run_service_race_repro(); }
+TEST(ThreadSafety, Actions) { run_action_race_repro(); }

From 49ba8460f1662674a94d603e43c80bffbdf505f5 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sat, 21 Feb 2026 18:28:58 +0100
Subject: [PATCH 29/40] Fix for humble ttest exception: what():  Callback group
 needs to be associated with executor.

---
 icey/test/node_tasks_test.cpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index 2e797c8..7b9007e 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -70,7 +70,9 @@ void run_tf_race_repro() {
   });
 
   auto tf = h.receiver_ctx->create_transform_buffer();
-  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant)};
+  auto cb_group{
+      h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
+  h.exec.add_callback_group(cb_group, h.receiver->get_node_base_interface());
   for (size_t t = 0; t < 100; ++t) {
     h.receiver_ctx->create_timer_async(
         50ms,
@@ -92,7 +94,9 @@ void run_service_race_repro() {
         return resp;
       });
   auto client = h.receiver_ctx->create_client<ExampleService>("race_set_bool");
-  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant)};
+  auto cb_group{
+      h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
+  h.exec.add_callback_group(cb_group, h.receiver->get_node_base_interface());
   for (size_t t = 0; t < 100; ++t) {
     h.receiver_ctx->create_timer_async(
         50ms,
@@ -120,7 +124,9 @@ void run_action_race_repro() {
         gh->succeed(result);
       });
   auto client = h.receiver_ctx->create_action_client<Fibonacci>("race_fib");
-  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant)};
+  auto cb_group{
+      h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
+  h.exec.add_callback_group(cb_group, h.receiver->get_node_base_interface());
   for (size_t t = 0; t < 100; ++t) {
     h.receiver_ctx->create_timer_async(
         50ms,

From 123becc87156b9f6f241f6fa1bea543ae9ac7cef Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sun, 22 Feb 2026 13:56:34 +0100
Subject: [PATCH 30/40] Clarified race in await_suspend, fixed that outer
 promise return await_ready false if there is coroutine pointer: In this case,
 we are done (short-circuiting still prevents accessing .done() on a nullptr)

---
 icey/include/icey/impl/promise.hpp | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/icey/include/icey/impl/promise.hpp b/icey/include/icey/impl/promise.hpp
index b655ce1..8f22214 100644
--- a/icey/include/icey/impl/promise.hpp
+++ b/icey/include/icey/impl/promise.hpp
@@ -180,11 +180,6 @@ class PromiseBase : public PromiseTag {
   /// as continuation. Suspends the current coroutine, i.e. returns true. Used only when wrapping a
   /// callback-based API.
   auto await_suspend(std::coroutine_handle<> awaiting_coroutine) noexcept {
-    this->continuation_ = awaiting_coroutine;
-    if (this->launch_async_) {
-      auto launch = std::move(launch_async_); // copy the lambda to avoid a race between two threads, one resuming the coroutine that holds this promise object stored and therefore eventually destroying this promise, while this thread still has not finished calling launch_async
-      launch(*this);
-    }
 #ifdef ICEY_CORO_DEBUG_PRINT
     std::cout << fmt::format(
                      "PromiseBase await_suspend(), awaiting coroutine is 0x{:x}, "
@@ -192,6 +187,20 @@ class PromiseBase : public PromiseTag {
                      std::size_t(awaiting_coroutine.address()), get_type(*this))
               << std::endl;
 #endif
+    this->continuation_ = awaiting_coroutine;
+    if (this->launch_async_) {
+      // copy the lambda to avoid a race between two threads, one resuming the coroutine that holds
+      // this promise object  and therefore eventually destroying this promise, while this
+      // thread still has not finished calling launch_async (such a race is detected by TSAN
+      // otherwise)
+      /// Note that it is perfectly legal that when calling launch, another thread might imediately
+      /// resume this coroutine. Citing cppreference
+      /// (https://en.cppreference.com/w/cpp/language/coroutines.html): "Note that the coroutine is
+      /// fully suspended before entering awaiter.await_suspend(). Its handle can be shared with
+      /// another thread and resumed before the await_suspend() function returns."
+      auto launch = launch_async_;
+      launch(*this);
+    }
     return true;
   }
 
@@ -254,6 +263,9 @@ class PromiseBase : public PromiseTag {
   /// State of the promise: May be nothing, value or error.
   State state_;
 
+  /// An exception that may be present additionally
+  std::exception_ptr exception_ptr_{nullptr};
+
   /// A function called on await_suspend that starts the asynchronous operation
   LaunchAsync launch_async_;
 
@@ -264,8 +276,6 @@ class PromiseBase : public PromiseTag {
 
   /// The continuation that is registered when co_awaiting this promise
   std::coroutine_handle<> continuation_{nullptr};
-  /// An exception that may be present additionally
-  std::exception_ptr exception_ptr_{nullptr};
 };
 
 /// A Promise is used in ICEY for async/await. It is returned from asynchronous operations such as a
@@ -400,7 +410,7 @@ class [[nodiscard("Promise must be used")]] Promise {
                            /// that this thread has just detached
   }
 
-  bool await_ready() const noexcept { return coroutine_ && coroutine_.done(); }
+  bool await_ready() const noexcept { return !coroutine_ || coroutine_.done(); }
 
   auto await_suspend(std::coroutine_handle<> awaiting_coroutine) noexcept {
     if (coroutine_.done()) {

From 0ac97ac6f02d934ad6042be7f8fd9daa5c52b843 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sun, 22 Feb 2026 15:38:21 +0100
Subject: [PATCH 31/40] Improved parity of action API with regular ROS

---
 icey/include/icey/icey_async_await.hpp | 28 +++++++++++++++++++++-----
 1 file changed, 23 insertions(+), 5 deletions(-)

diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 4d3b9cc..3dd89d0 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -824,11 +824,22 @@ struct ActionClient {
   using RequestID = int64_t;
   using AsyncGoalHandleT = AsyncGoalHandle<ActionT>;
 
-  ActionClient(std::weak_ptr<NodeBase> node, const std::string &action_name) : node_(node) {
+  /// Construct an async action client wrapper.
+  /// @param node Node base used to create the underlying rclcpp_action client.
+  /// @param action_name Name of the action topic (e.g. "/fibonacci").
+  /// @param group Optional callback group for the action client waitable. If nullptr, the node's
+  /// default callback group is used.
+  /// @param options rcl_action client options. Defaults to
+  /// rcl_action_client_get_default_options().
+  ActionClient(
+      std::weak_ptr<NodeBase> node, const std::string &action_name,
+      rclcpp::CallbackGroup::SharedPtr group = nullptr,
+      const rcl_action_client_options_t &options = rcl_action_client_get_default_options())
+      : node_(node) {
     client_ = icey::rclcpp_action::create_client<ActionT>(
         node.lock()->get_node_base_interface(), node.lock()->get_node_graph_interface(),
         node.lock()->get_node_logging_interface(), node.lock()->get_node_waitables_interface(),
-        action_name);
+        action_name, group, options);
   }
 
   /// Send asynchronously an action goal: if it is accepted, then you get a goal handle.
@@ -1038,10 +1049,17 @@ class ContextAsyncAwait {
     return server;
   }
 
-  /// Create an action client that supports async/await send_goal
+  /// Create an action client that supports async/await send_goal.
+  /// @param action_name Name of the action topic (e.g. "/fibonacci").
+  /// @param group Optional callback group for the action client waitable. If nullptr, the node's
+  /// default callback group is used.
+  /// @param options rcl_action client options. Defaults to
+  /// rcl_action_client_get_default_options().
   template <class ActionT>
-  ActionClient<ActionT> create_action_client(const std::string &action_name) {
-    return ActionClient<ActionT>(node_base(), action_name);
+  ActionClient<ActionT> create_action_client(
+      const std::string &action_name, rclcpp::CallbackGroup::SharedPtr group = nullptr,
+      const rcl_action_client_options_t &options = rcl_action_client_get_default_options()) {
+    return ActionClient<ActionT>(node_base(), action_name, group, options);
   }
 
   /// Creates a transform buffer that works like the usual combination of a tf2_ros::Buffer and a

From 14075e88fe0c0feee340bb3aa559e8550e3a3720 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sun, 22 Feb 2026 15:39:58 +0100
Subject: [PATCH 32/40] Changed back to using single threaded executor in
 examples

---
 icey_examples/src/action_client_async_await.cpp      | 4 +---
 icey_examples/src/action_server_async_await.cpp      | 4 +---
 icey_examples/src/coroutine_example.cpp              | 4 +---
 icey_examples/src/listener.cpp                       | 4 +---
 icey_examples/src/listener_async_await.cpp           | 4 +---
 icey_examples/src/parameters_struct.cpp              | 4 +---
 icey_examples/src/service_client_async_await.cpp     | 4 +---
 icey_examples/src/service_server.cpp                 | 4 +---
 icey_examples/src/service_server_async_await.cpp     | 4 +---
 icey_examples/src/signal_generator.cpp               | 4 +---
 icey_examples/src/signal_generator_async_await.cpp   | 4 +---
 icey_examples/src/synchronization.cpp                | 4 +---
 icey_examples/src/talker_async_await.cpp             | 4 +---
 icey_examples/src/tf_broadcaster.cpp                 | 4 +---
 icey_examples/src/tf_lookup_async_await.cpp          | 4 +---
 icey_examples/src/tf_pub_test.cpp                    | 4 +---
 icey_examples/src/tf_subscription.cpp                | 4 +---
 icey_examples/src/tf_sychronization.cpp              | 4 +---
 icey_examples/src/using_async_await_only_context.cpp | 4 +---
 icey_examples/src/using_icey_context.cpp             | 4 +---
 icey_examples/src/using_image_transport.cpp          | 4 +---
 21 files changed, 21 insertions(+), 63 deletions(-)

diff --git a/icey_examples/src/action_client_async_await.cpp b/icey_examples/src/action_client_async_await.cpp
index 5c2cd0c..cc08a46 100644
--- a/icey_examples/src/action_client_async_await.cpp
+++ b/icey_examples/src/action_client_async_await.cpp
@@ -64,8 +64,6 @@ int main(int argc, char **argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<rclcpp::Node>("icey_action_client_async_await_example");
   (void)call_action(node);
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
   return 0;
 }
diff --git a/icey_examples/src/action_server_async_await.cpp b/icey_examples/src/action_server_async_await.cpp
index e81bf26..0e99547 100644
--- a/icey_examples/src/action_server_async_await.cpp
+++ b/icey_examples/src/action_server_async_await.cpp
@@ -54,8 +54,6 @@ int main(int argc, char **argv) {
                                        handle_accepted);
 
   RCLCPP_INFO_STREAM(node->get_logger(), "Created action sever");
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
   return 0;
 }
diff --git a/icey_examples/src/coroutine_example.cpp b/icey_examples/src/coroutine_example.cpp
index 2145092..573cf2d 100644
--- a/icey_examples/src/coroutine_example.cpp
+++ b/icey_examples/src/coroutine_example.cpp
@@ -24,8 +24,6 @@ int main(int argc, char **argv) {
   std::cout << "1. Before calling coroutine " << std::endl;
   (void)a_coroutine(node->icey());
   std::cout << "5. After calling coroutine " << std::endl;
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
   std::cout << "6. After sync_wait " << std::endl;
 }
diff --git a/icey_examples/src/listener.cpp b/icey_examples/src/listener.cpp
index adfd3b5..7861f56 100644
--- a/icey_examples/src/listener.cpp
+++ b/icey_examples/src/listener.cpp
@@ -17,7 +17,5 @@ int main(int argc, char **argv) {
       "my_string", [&](std_msgs::msg::String::SharedPtr msg) {
         RCLCPP_INFO_STREAM(node->get_logger(), "Got value: " << msg->data);
       });
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/listener_async_await.cpp b/icey_examples/src/listener_async_await.cpp
index f4e8b07..c06f6fd 100644
--- a/icey_examples/src/listener_async_await.cpp
+++ b/icey_examples/src/listener_async_await.cpp
@@ -25,7 +25,5 @@ int main(int argc, char **argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<icey::Node>("icey_listener_node");
   (void)receive(node);
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey_examples/src/parameters_struct.cpp b/icey_examples/src/parameters_struct.cpp
index 2b06217..69ca1e6 100644
--- a/icey_examples/src/parameters_struct.cpp
+++ b/icey_examples/src/parameters_struct.cpp
@@ -41,7 +41,5 @@ class MyNode : public icey::Node {
 int main(int argc, char **argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<MyNode>("icey_parameters_struct_example");
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/service_client_async_await.cpp b/icey_examples/src/service_client_async_await.cpp
index f325bef..b18e782 100644
--- a/icey_examples/src/service_client_async_await.cpp
+++ b/icey_examples/src/service_client_async_await.cpp
@@ -41,7 +41,5 @@ int main(int argc, char **argv) {
     }
     co_return;
   });
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey_examples/src/service_server.cpp b/icey_examples/src/service_server.cpp
index 16297f3..18c4de7 100644
--- a/icey_examples/src/service_server.cpp
+++ b/icey_examples/src/service_server.cpp
@@ -35,7 +35,5 @@ int main(int argc, char **argv) {
   node->icey().create_service<ExampleService>("set_bool_service3", service_cb);
 
   RCLCPP_INFO_STREAM(node->get_logger(), "Started services " << service_name.value());
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey_examples/src/service_server_async_await.cpp b/icey_examples/src/service_server_async_await.cpp
index 48c76c7..d058d61 100644
--- a/icey_examples/src/service_server_async_await.cpp
+++ b/icey_examples/src/service_server_async_await.cpp
@@ -50,7 +50,5 @@ int main(int argc, char **argv) {
       });
 
   RCLCPP_INFO_STREAM(node->get_logger(), "Created service server, waiting for requests ... ");
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey_examples/src/signal_generator.cpp b/icey_examples/src/signal_generator.cpp
index d35ef30..99b76c0 100644
--- a/icey_examples/src/signal_generator.cpp
+++ b/icey_examples/src/signal_generator.cpp
@@ -45,7 +45,5 @@ int main(int argc, char **argv) {
       })
       .publish("sine_signal");
 
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/signal_generator_async_await.cpp b/icey_examples/src/signal_generator_async_await.cpp
index 418592e..605c1bb 100644
--- a/icey_examples/src/signal_generator_async_await.cpp
+++ b/icey_examples/src/signal_generator_async_await.cpp
@@ -53,7 +53,5 @@ int main(int argc, char **argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<icey::Node>("icey_signal_generator_async_await_example");
   (void)create_and_spin_node(node);
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey_examples/src/synchronization.cpp b/icey_examples/src/synchronization.cpp
index 1837f14..62365fd 100644
--- a/icey_examples/src/synchronization.cpp
+++ b/icey_examples/src/synchronization.cpp
@@ -40,7 +40,5 @@ int main(int argc, char **argv) {
         << " and point cloud with time " << point_cloud->header.stamp);
         */
       });
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/talker_async_await.cpp b/icey_examples/src/talker_async_await.cpp
index 929534c..06e6f24 100644
--- a/icey_examples/src/talker_async_await.cpp
+++ b/icey_examples/src/talker_async_await.cpp
@@ -30,7 +30,5 @@ int main(int argc, char **argv) {
 
   (void)talk(node);
 
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey_examples/src/tf_broadcaster.cpp b/icey_examples/src/tf_broadcaster.cpp
index 038c799..8087e76 100644
--- a/icey_examples/src/tf_broadcaster.cpp
+++ b/icey_examples/src/tf_broadcaster.cpp
@@ -36,7 +36,5 @@ int main(int argc, char **argv) {
   // gets updated dynamically when the parameter changes.
   create_yaw_rotation(*node, base_frame_param).publish_transform();
 
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/tf_lookup_async_await.cpp b/icey_examples/src/tf_lookup_async_await.cpp
index d1adfe2..3c79535 100644
--- a/icey_examples/src/tf_lookup_async_await.cpp
+++ b/icey_examples/src/tf_lookup_async_await.cpp
@@ -41,7 +41,5 @@ int main(int argc, char **argv) {
           });
 
 
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/tf_pub_test.cpp b/icey_examples/src/tf_pub_test.cpp
index 4eb05ef..5c65c45 100644
--- a/icey_examples/src/tf_pub_test.cpp
+++ b/icey_examples/src/tf_pub_test.cpp
@@ -38,7 +38,5 @@ int main(int argc, char **argv) {
     cnt++;
   });
 
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey_examples/src/tf_subscription.cpp b/icey_examples/src/tf_subscription.cpp
index a06fe33..0991eb4 100644
--- a/icey_examples/src/tf_subscription.cpp
+++ b/icey_examples/src/tf_subscription.cpp
@@ -23,7 +23,5 @@ int main(int argc, char **argv) {
         RCLCPP_INFO_STREAM(node->get_logger(), "Received a new transform:\n" << tf_mat);
       });
 
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/tf_sychronization.cpp b/icey_examples/src/tf_sychronization.cpp
index 6832e0d..6ad592a 100644
--- a/icey_examples/src/tf_sychronization.cpp
+++ b/icey_examples/src/tf_sychronization.cpp
@@ -49,7 +49,5 @@ int main(int argc, char **argv) {
                 << tf_mat);
       });
 
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/using_async_await_only_context.cpp b/icey_examples/src/using_async_await_only_context.cpp
index de0c7ec..bcf2bd3 100644
--- a/icey_examples/src/using_async_await_only_context.cpp
+++ b/icey_examples/src/using_async_await_only_context.cpp
@@ -41,7 +41,5 @@ int main(int argc, char **argv) {
     }
     co_return;
   });
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey_examples/src/using_icey_context.cpp b/icey_examples/src/using_icey_context.cpp
index ad31dd3..9fa256c 100644
--- a/icey_examples/src/using_icey_context.cpp
+++ b/icey_examples/src/using_icey_context.cpp
@@ -30,7 +30,5 @@ class MyNode : public rclcpp::Node {
 int main(int argc, char** argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<MyNode>();
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file
diff --git a/icey_examples/src/using_image_transport.cpp b/icey_examples/src/using_image_transport.cpp
index 779347d..9d7c207 100644
--- a/icey_examples/src/using_image_transport.cpp
+++ b/icey_examples/src/using_image_transport.cpp
@@ -51,7 +51,5 @@ int main(int argc, char **argv) {
       /// And now publish again using image_transport, creating an image_transport::Publisher:
       .publish<icey::ImageTransportPublisher>("camera_left_painted", rclcpp::SensorDataQoS());
 
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
\ No newline at end of file

From f14d58b10585e715cc3b6c1b5fe39ace9905a92a Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sun, 22 Feb 2026 15:57:30 +0100
Subject: [PATCH 33/40] Fixed API parity: added callbackgroup arguments and
 removed size_t from the timer callback

---
 icey/include/icey/icey_async_await.hpp        | 57 ++++++++++++-------
 icey/src/actions/client.cpp                   |  4 +-
 icey/test/node_tasks_test.cpp                 | 15 ++---
 icey_examples/src/filters.cpp                 |  2 +-
 .../src/service_client_async_await.cpp        |  2 +-
 .../src/using_async_await_only_context.cpp    |  2 +-
 6 files changed, 47 insertions(+), 35 deletions(-)

diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 3dd89d0..42284c4 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -642,8 +642,9 @@ struct ServiceClientImpl {
   ServiceClientImpl &operator=(ServiceClientImpl &&) = delete;
 
   ServiceClientImpl(std::weak_ptr<NodeBase> node, const std::string &service_name,
-                    const rclcpp::QoS &qos = rclcpp::ServicesQoS())
-      : node_(node), client(node.lock()->create_client<ServiceT>(service_name, qos)) {}
+                    const rclcpp::QoS &qos = rclcpp::ServicesQoS(),
+                    rclcpp::CallbackGroup::SharedPtr group = nullptr)
+      : node_(node), client(node.lock()->create_client<ServiceT>(service_name, qos, group)) {}
 
   impl::Promise<Response, std::string> call(Request request, const Duration &timeout) {
     return impl::Promise<Response, std::string>([this, request, timeout](auto &promise) {
@@ -692,8 +693,9 @@ struct ServiceClient {
   /// Constructs the service client. A node has to be provided because it is needed to create
   /// timeout timers for every service call.
   ServiceClient(std::weak_ptr<NodeBase> node, const std::string &service_name,
-                const rclcpp::QoS &qos = rclcpp::ServicesQoS())
-      : impl_(std::make_shared<ServiceClientImpl<ServiceT>>(node, service_name, qos)) {}
+                const rclcpp::QoS &qos = rclcpp::ServicesQoS(),
+                rclcpp::CallbackGroup::SharedPtr group = nullptr)
+      : impl_(std::make_shared<ServiceClientImpl<ServiceT>>(node, service_name, qos, group)) {}
 
   // clang-format off
   /*! Make an asynchronous call to the service. Returns a impl::Promise that can be awaited using `co_await`.
@@ -831,10 +833,9 @@ struct ActionClient {
   /// default callback group is used.
   /// @param options rcl_action client options. Defaults to
   /// rcl_action_client_get_default_options().
-  ActionClient(
-      std::weak_ptr<NodeBase> node, const std::string &action_name,
-      rclcpp::CallbackGroup::SharedPtr group = nullptr,
-      const rcl_action_client_options_t &options = rcl_action_client_get_default_options())
+  ActionClient(std::weak_ptr<NodeBase> node, const std::string &action_name,
+               rclcpp::CallbackGroup::SharedPtr group = nullptr,
+               const rcl_action_client_options_t &options = rcl_action_client_get_default_options())
       : node_(node) {
     client_ = icey::rclcpp_action::create_client<ActionT>(
         node.lock()->get_node_base_interface(), node.lock()->get_node_graph_interface(),
@@ -897,8 +898,16 @@ class ContextAsyncAwait {
       const std::string &topic_name, Callback &&callback,
       const rclcpp::QoS &qos = rclcpp::SystemDefaultsQoS(),
       const rclcpp::SubscriptionOptions &options = rclcpp::SubscriptionOptions()) {
+    auto callback_wrapper = [callback = std::forward<Callback>(callback)](auto... args) {
+      using ReturnType = decltype(callback(args...));
+      if constexpr (!impl::HasPromiseType<ReturnType>) {
+        callback(args...);
+      } else {
+        callback(args...).detach();
+      }
+    };
     auto subscription = node_base()->create_subscription<MessageT>(
-        topic_name, [callback](typename MessageT::SharedPtr msg) { callback(msg); }, qos, options);
+        topic_name, std::move(callback_wrapper), qos, options);
     std::lock_guard<std::recursive_mutex> lock{bookkeeping_mutex_};
     subscriptions_.push_back(std::dynamic_pointer_cast<rclcpp::SubscriptionBase>(subscription));
     return subscription;
@@ -913,15 +922,18 @@ class ContextAsyncAwait {
   /// Works otherwise the same as [rclcpp::Node::create_timer].
   template <class Callback>
   std::shared_ptr<rclcpp::TimerBase> create_timer_async(
-      const Duration &period, Callback callback, rclcpp::CallbackGroup::SharedPtr group = nullptr) {
+      const Duration &period, Callback &&callback,
+      rclcpp::CallbackGroup::SharedPtr group = nullptr) {
     auto timer = node_base()->create_wall_timer(
         period,
-        [callback]() {
-          using ReturnType = decltype(callback(std::size_t{}));
+        [callback = std::forward<Callback>(callback)]() {
+          static_assert(std::is_invocable_v<const std::decay_t<Callback> &>,
+                        "create_timer_async callback must be invocable as ()");
+          using ReturnType = decltype(callback());
           if constexpr (!impl::HasPromiseType<ReturnType>) {
-            callback(std::size_t{});
+            callback();
           } else {
-            callback(std::size_t{}).detach();
+            callback().detach();
           }
         },
         group);
@@ -943,8 +955,9 @@ class ContextAsyncAwait {
   /// icey::Promise<std::shared_ptr<ServiceT::Response>>
   template <class ServiceT, class Callback>
   std::shared_ptr<rclcpp::Service<ServiceT>> create_service(
-      const std::string &service_name, Callback callback,
-      const rclcpp::QoS &qos = rclcpp::ServicesQoS()) {
+      const std::string &service_name, Callback &&callback,
+      const rclcpp::QoS &qos = rclcpp::ServicesQoS(),
+      rclcpp::CallbackGroup::SharedPtr group = nullptr) {
     using Request = std::shared_ptr<typename ServiceT::Request>;
     using RequestID = std::shared_ptr<rmw_request_id_t>;
     /// The type of the user callback that can response synchronously (i.e. immediately): It
@@ -956,8 +969,9 @@ class ContextAsyncAwait {
     /// [rcl_send_response](http://docs.ros.org/en/jazzy/p/rcl/generated/function_service_8h_1a8631f47c48757228b813d0849d399d81.html#_CPPv417rcl_send_responsePK13rcl_service_tP16rmw_request_id_tPv)
     auto service = node_base()->create_service<ServiceT>(
         service_name,
-        [callback](std::shared_ptr<rclcpp::Service<ServiceT>> server, RequestID request_id,
-                   Request request) {
+        [callback = std::forward<Callback>(callback)](
+            std::shared_ptr<rclcpp::Service<ServiceT>> server, RequestID request_id,
+            Request request) {
           using ReturnType = decltype(callback(request));
           if constexpr (!impl::HasPromiseType<ReturnType>) {
             auto response = callback(request);
@@ -974,7 +988,7 @@ class ContextAsyncAwait {
             continuation(server, callback, request_id, request).detach();
           }
         },
-        qos);
+        qos, group);
     std::lock_guard<std::recursive_mutex> lock{bookkeeping_mutex_};
     services_.push_back(std::dynamic_pointer_cast<rclcpp::ServiceBase>(service));
     return service;
@@ -984,8 +998,9 @@ class ContextAsyncAwait {
   /// Works otherwise the same as [rclcpp::Node::create_client].
   template <class ServiceT>
   ServiceClient<ServiceT> create_client(const std::string &service_name,
-                                        const rclcpp::QoS &qos = rclcpp::ServicesQoS()) {
-    return ServiceClient<ServiceT>(node_base(), service_name, qos);
+                                        const rclcpp::QoS &qos = rclcpp::ServicesQoS(),
+                                        rclcpp::CallbackGroup::SharedPtr group = nullptr) {
+    return ServiceClient<ServiceT>(node_base(), service_name, qos, group);
   }
 
   /// Create an action server with a synchronous or asynchronous callbacks.
diff --git a/icey/src/actions/client.cpp b/icey/src/actions/client.cpp
index e146d21..c81aaa9 100644
--- a/icey/src/actions/client.cpp
+++ b/icey/src/actions/client.cpp
@@ -261,7 +261,7 @@ size_t ClientBase::get_number_of_ready_services() { return pimpl_->num_services;
 void ClientBase::add_to_wait_set(rcl_wait_set_t &wait_set) {
   std::lock_guard<std::recursive_mutex> lock(pimpl_->action_client_mutex_);
   rcl_ret_t ret = rcl_action_wait_set_add_action_client(&wait_set, pimpl_->client_handle.get(),
-                                                         nullptr, nullptr);
+                                                        nullptr, nullptr);
   if (RCL_RET_OK != ret) {
     rclcpp::exceptions::throw_from_rcl_error(ret, "ClientBase::add_to_wait_set() failed");
   }
@@ -275,7 +275,7 @@ void ClientBase::add_to_wait_set(rcl_wait_set_t *wait_set) {
   }
   std::lock_guard<std::recursive_mutex> lock(pimpl_->action_client_mutex_);
   rcl_ret_t ret = rcl_action_wait_set_add_action_client(wait_set, pimpl_->client_handle.get(),
-                                                         nullptr, nullptr);
+                                                        nullptr, nullptr);
   if (RCL_RET_OK != ret) {
     rclcpp::exceptions::throw_from_rcl_error(ret, "ClientBase::add_to_wait_set() failed");
   }
diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index 7b9007e..a7a1ae8 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -70,13 +70,12 @@ void run_tf_race_repro() {
   });
 
   auto tf = h.receiver_ctx->create_transform_buffer();
-  auto cb_group{
-      h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
+  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
   h.exec.add_callback_group(cb_group, h.receiver->get_node_base_interface());
   for (size_t t = 0; t < 100; ++t) {
     h.receiver_ctx->create_timer_async(
         50ms,
-        [&](std::size_t) -> icey::Promise<void> {
+        [&]() -> icey::Promise<void> {
           (void)co_await tf.lookup("map", "base_link", icey::Clock::now(), 3ms);
         },
         cb_group);
@@ -94,13 +93,12 @@ void run_service_race_repro() {
         return resp;
       });
   auto client = h.receiver_ctx->create_client<ExampleService>("race_set_bool");
-  auto cb_group{
-      h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
+  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
   h.exec.add_callback_group(cb_group, h.receiver->get_node_base_interface());
   for (size_t t = 0; t < 100; ++t) {
     h.receiver_ctx->create_timer_async(
         50ms,
-        [&](std::size_t) -> icey::Promise<void> {
+        [&]() -> icey::Promise<void> {
           auto req = std::make_shared<ExampleService::Request>();
           req->data = true;
           (void)co_await client.call(req, 3ms);
@@ -124,13 +122,12 @@ void run_action_race_repro() {
         gh->succeed(result);
       });
   auto client = h.receiver_ctx->create_action_client<Fibonacci>("race_fib");
-  auto cb_group{
-      h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
+  auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
   h.exec.add_callback_group(cb_group, h.receiver->get_node_base_interface());
   for (size_t t = 0; t < 100; ++t) {
     h.receiver_ctx->create_timer_async(
         50ms,
-        [&](std::size_t) -> icey::Promise<void> {
+        [&]() -> icey::Promise<void> {
           Fibonacci::Goal goal;
           goal.order = 4;
           auto sent = co_await client.send_goal(goal, 3ms, [](auto, auto) {});
diff --git a/icey_examples/src/filters.cpp b/icey_examples/src/filters.cpp
index 572353a..31fd196 100644
--- a/icey_examples/src/filters.cpp
+++ b/icey_examples/src/filters.cpp
@@ -1 +1 @@
-/// TODO 
\ No newline at end of file
+/// TODO
\ No newline at end of file
diff --git a/icey_examples/src/service_client_async_await.cpp b/icey_examples/src/service_client_async_await.cpp
index b18e782..a34d7e4 100644
--- a/icey_examples/src/service_client_async_await.cpp
+++ b/icey_examples/src/service_client_async_await.cpp
@@ -24,7 +24,7 @@ int main(int argc, char **argv) {
 
   /// Create the service client beforehand
   auto client = ctx->create_client<ExampleService>("set_bool_service");
-  auto timer = ctx->create_timer_async(500ms, [&](std::size_t) -> icey::Promise<void> {
+  auto timer = ctx->create_timer_async(500ms, [&]() -> icey::Promise<void> {
     RCLCPP_INFO_STREAM(node->get_logger(), "Timer ticked");
 
     auto request = std::make_shared<ExampleService::Request>();
diff --git a/icey_examples/src/using_async_await_only_context.cpp b/icey_examples/src/using_async_await_only_context.cpp
index bcf2bd3..6727476 100644
--- a/icey_examples/src/using_async_await_only_context.cpp
+++ b/icey_examples/src/using_async_await_only_context.cpp
@@ -24,7 +24,7 @@ int main(int argc, char **argv) {
   /// Create the service client beforehand
   auto service = ctx->create_client<ExampleService>("set_bool_service");
 
-  auto timer = ctx->create_timer_async(1s, [&](std::size_t) -> icey::Promise<void> {
+  auto timer = ctx->create_timer_async(1s, [&]() -> icey::Promise<void> {
     auto request = std::make_shared<ExampleService::Request>();
     request->data = 1;
     RCLCPP_INFO_STREAM(node->get_logger(), "Timer ticked, sending request: " << request->data);

From 984d9fea92a8c03a03e87f6e1e59c5433772569e Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sun, 22 Feb 2026 16:02:43 +0100
Subject: [PATCH 34/40] Readme update

---
 CHANGELOG.md | 7 ++++++-
 README.md    | 7 ++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 35a55b3..f45f54f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## 0.4.0
 
+### Changed 
+
+- Timer callback signature not longer taking size_t as an argument
+- Added CallbackGroup arguments to API
+
 ### Added
  
 - Support for actions
@@ -22,7 +27,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - allowing coroutines without suspension points (i.e. co_await) but only a single co_return
 - Correct result type implementation
 - Missing request cleanup in ServiceClientImpl::our_to_real_req_id_
-- Added missing cancellation of timeout timer in Promise destruction
+- Missing cancellation of timeout timer in Promise destruction
 
 ## 0.3.0 
 
diff --git a/README.md b/README.md
index 0c54175..b4f266b 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,11 @@
   <img src="https://img.shields.io/github/actions/workflow/status/iv461/icey/build.yml?branch=main&job=build_and_test_ros2_humble%20(humble)&label=ROS%202%20Humble&style=for-the-badge" alt="ROS 2 Humble Build Status" />
 </p>
 
+### Updates:
+- v0.4.0: 
+  - Adds support multi-threaded executor, the async/await API is now thread-safe. 
+  - Also adds support for actions.
+
 ICEY is a new client API for modern asynchronous programming in the Robot Operating System (ROS) 2. It uses C++20 coroutines with async/await syntax for service calls and TF lookups. ICEY allows you to model data flows based on streams and promises. These features simplify application code and make asynchronous data flows clearly visible.
 
 ### Problems ICEY solves:
@@ -22,7 +27,7 @@ ICEY is a new client API for modern asynchronous programming in the Robot Operat
 ICEY is fully compatible with the ROS 2 API since it is built on top of rclcpp. This allows for gradual adoption. It supports all major ROS features: parameters, subscriptions, publishers, timers, services, clients, actions and TF. Additionally, ICEY supports lifecycle nodes using a single API.
 ICEY operates smoothly with the message_filters package, using it for synchronization. ICEY is also extensible, as demonstrated by its support for image transport camera subscription/publishers.
 
-ICEY supports ROS 2 Humble and ROS 2 Jazzy.
+ICEY supports ROS 2 Humble/Jazzy/Kilted.
 
 The [icey_examples](icey_examples) package contains many different example nodes, demonstrating the capabilities of ICEY.
 

From 594b39aa2dcbcd9a736c2aab5b6861b0a8a59fcd Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Sun, 22 Feb 2026 16:05:44 +0100
Subject: [PATCH 35/40] Reverted unnecessary changes to the MT executor (caused
 by mass-replace) and removed the warning about MT executor

---
 icey/benchmark/src/service_server_async_await_plain.cpp | 4 +---
 icey/doc/source/coroutine_basics.md                     | 4 +---
 icey/doc/source/first_icey_node.md                      | 9 +--------
 3 files changed, 3 insertions(+), 14 deletions(-)

diff --git a/icey/benchmark/src/service_server_async_await_plain.cpp b/icey/benchmark/src/service_server_async_await_plain.cpp
index bb54d5f..97bbe05 100644
--- a/icey/benchmark/src/service_server_async_await_plain.cpp
+++ b/icey/benchmark/src/service_server_async_await_plain.cpp
@@ -55,7 +55,5 @@ int main(int argc, char **argv) {
       });
 
   RCLCPP_INFO_STREAM(node->get_logger(), "Created service server, waiting for requests ... ");
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
diff --git a/icey/doc/source/coroutine_basics.md b/icey/doc/source/coroutine_basics.md
index d61f2b9..aa57d68 100644
--- a/icey/doc/source/coroutine_basics.md
+++ b/icey/doc/source/coroutine_basics.md
@@ -28,9 +28,7 @@ int main(int argc, char **argv) {
     std::cout << "1. Before calling the coroutine" << std::endl;
     a_coroutine(node->icey());
     std::cout << "5. After calling the coroutine" << std::endl;
-    rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+    rclcpp::spin(node);
     std::cout << "6. After spin" << std::endl;
 }
 ```
diff --git a/icey/doc/source/first_icey_node.md b/icey/doc/source/first_icey_node.md
index 4d8e4bb..ed1ad09 100644
--- a/icey/doc/source/first_icey_node.md
+++ b/icey/doc/source/first_icey_node.md
@@ -56,9 +56,7 @@ public:
 int main(int argc, char** argv) {
   rclcpp::init(argc, argv);
   auto node = std::make_shared<MyNode>();
-  rclcpp::executors::MultiThreadedExecutor exec{rclcpp::ExecutorOptions(), 8};
-  exec.add_node(node->get_node_base_interface());
-  exec.spin();
+  rclcpp::spin(node);
 }
 ```
 
@@ -69,9 +67,4 @@ ICEY represents ROS primitives such as timers as a `Stream`, an abstraction over
 
 We also do not need to store the timer object anywhere, because the lifetime of entities in ICEY is bound to the lifetime of the node. In ICEY, you do not need to store subscriptions/timers/services as members of the class, ICEY does this bookkeeping for you.
 
-
-```{warning}
-ICEY-nodes can currently only be used with a single-threaded executor.
-```
-
 In the following, we will look more closely into how Subscriptions and Timers follow the `Stream` concept and how this changes the way of asynchronous programming. 

From ad75af77fbf39b83b486ee7abe78ca811da31767 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Mon, 23 Feb 2026 02:28:11 +0100
Subject: [PATCH 36/40] Synchronized the race between the timeout timer and the
 other timer properly: If the response cb resumes the coro and eventually
 destroys the promise, we cannot use the atomic inside the promise for
 arbitration because this leads to UAF. No races reported by TSAN anymore

---
 icey/include/icey/icey_async_await.hpp | 26 +++++++++++++++-----------
 icey/test/node_tasks_test.cpp          |  9 +++++----
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 42284c4..e921a41 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -128,8 +128,9 @@ struct NodeBase {
     oneoff_active_timers_.emplace(id, create_wall_timer(
                                           timeout,
                                           [this, id, on_timeout]() {
-                                            cancel_task_for(id);
-                                            on_timeout();
+                                            if (cancel_task_for(id)) {
+                                              on_timeout();
+                                            }
                                           },
                                           group));
   }
@@ -651,11 +652,12 @@ struct ServiceClientImpl {
       auto future_and_req_id = client->async_send_request(
           request, [this, &promise](typename Client::SharedFuture result) {
             /// Cancel the timeout task since we got a response
-            node_.lock()->cancel_task_for(uint64_t(&promise));
-            if (!result.valid()) {
-              promise.reject(rclcpp::ok() ? "TIMEOUT" : "INTERRUPTED");
-            } else {
-              promise.resolve(result.get());
+            if (node_.lock()->cancel_task_for(uint64_t(&promise))) {
+              if (!result.valid()) {
+                promise.reject(rclcpp::ok() ? "TIMEOUT" : "INTERRUPTED");
+              } else {
+                promise.resolve(result.get());
+              }
             }
           });
       auto request_id = future_and_req_id.request_id;
@@ -760,8 +762,9 @@ struct AsyncGoalHandle {
       try {
         auto request_id =
             client_.lock()->async_get_result(goal_handle_, [this, &promise](const Result &result) {
-              node_.lock()->cancel_task_for(uint64_t(&promise));
-              promise.resolve(result);
+              if (node_.lock()->cancel_task_for(uint64_t(&promise))) {
+                promise.resolve(result);
+              }
             });
         if (!request_id) {
           promise.reject("FAILED");
@@ -787,8 +790,9 @@ struct AsyncGoalHandle {
       try {
         auto request_id = client_.lock()->async_cancel_goal(
             goal_handle_, [this, &promise](CancelResponse cancel_response) {
-              node_.lock()->cancel_task_for(uint64_t(&promise));
-              promise.resolve(cancel_response);
+              if (node_.lock()->cancel_task_for(uint64_t(&promise))) {
+                promise.resolve(cancel_response);
+              }
             });
         /// Add timeout task
         node_.lock()->add_task_for(uint64_t(&promise), timeout, [this, &promise, request_id] {
diff --git a/icey/test/node_tasks_test.cpp b/icey/test/node_tasks_test.cpp
index a7a1ae8..7e534d6 100644
--- a/icey/test/node_tasks_test.cpp
+++ b/icey/test/node_tasks_test.cpp
@@ -92,12 +92,13 @@ void run_service_race_repro() {
         resp->success = req->data;
         return resp;
       });
-  auto client = h.receiver_ctx->create_client<ExampleService>("race_set_bool");
   auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
   h.exec.add_callback_group(cb_group, h.receiver->get_node_base_interface());
+  auto client = h.receiver_ctx->create_client<ExampleService>("race_set_bool",
+                                                              rclcpp::ServicesQoS(), cb_group);
   for (size_t t = 0; t < 100; ++t) {
     h.receiver_ctx->create_timer_async(
-        50ms,
+        1ms,
         [&]() -> icey::Promise<void> {
           auto req = std::make_shared<ExampleService::Request>();
           req->data = true;
@@ -121,12 +122,12 @@ void run_action_race_repro() {
         result->sequence = {0, 1, 1, 2};
         gh->succeed(result);
       });
-  auto client = h.receiver_ctx->create_action_client<Fibonacci>("race_fib");
   auto cb_group{h.receiver->create_callback_group(rclcpp::CallbackGroupType::Reentrant, false)};
   h.exec.add_callback_group(cb_group, h.receiver->get_node_base_interface());
+  auto client = h.receiver_ctx->create_action_client<Fibonacci>("race_fib", cb_group);
   for (size_t t = 0; t < 100; ++t) {
     h.receiver_ctx->create_timer_async(
-        50ms,
+        5ms,
         [&]() -> icey::Promise<void> {
           Fibonacci::Goal goal;
           goal.order = 4;

From e1f31fb8de240718f171c71b92a18bac35f98075 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Mon, 23 Feb 2026 12:23:22 +0100
Subject: [PATCH 37/40] Added timeout/response arbitration for action client
 request goal

---
 icey/include/icey/icey_async_await.hpp | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index e921a41..3ec4712 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -355,8 +355,7 @@ struct TransformBufferImpl {
           if (auto req = request.lock()) {
 #if ICEY_ASYNC_AWAIT_THREAD_SAFE
             bool expected = false;
-            if (!req->finished.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
-                                                       std::memory_order_acquire)) {
+            if (!req->finished.compare_exchange_strong(expected, true)) {
               return;
             }
             std::lock_guard<std::recursive_mutex> lock{mutex_};
@@ -766,7 +765,7 @@ struct AsyncGoalHandle {
                 promise.resolve(result);
               }
             });
-        if (!request_id) {
+        if (!request_id) { /// This can only happen in case the rcl/rmw function fails
           promise.reject("FAILED");
         } else {
           node_.lock()->add_task_for(uint64_t(&promise), timeout,
@@ -783,8 +782,6 @@ struct AsyncGoalHandle {
 
   /// Cancel this goal. Warning: Not co_awaiting this promise leads to use-after free !
   // The promise is rejected in case the goal was already reached.
-  /// TODO check in gdb whether it is a problem that this promise might resolve synchronously, i.e.
-  /// do we get a stack overflow ?
   impl::Promise<CancelResponse, std::string> cancel(const Duration &timeout) const {
     return impl::Promise<CancelResponse, std::string>([this, timeout](auto &promise) {
       try {
@@ -855,11 +852,12 @@ struct ActionClient {
         [this, goal, timeout, feedback_callback](auto &promise) {
           typename Client::SendGoalOptions options;
           options.goal_response_callback = [this, &promise](auto goal_handle) {
-            node_.lock()->cancel_task_for(uint64_t(&promise));
-            if (goal_handle == nullptr) {
-              promise.reject("GOAL REJECTED");  /// TODO error type
-            } else {
-              promise.resolve(AsyncGoalHandle<ActionT>(node_, client_, goal_handle));
+            if (node_.lock()->cancel_task_for(uint64_t(&promise))) {
+              if (goal_handle == nullptr) {
+                promise.reject("GOAL REJECTED");  /// TODO error type
+              } else {
+                promise.resolve(AsyncGoalHandle<ActionT>(node_, client_, goal_handle));
+              }
             }
           };
           /// HINT:  Wrap inside a lambda to support feedback_callback being a coroutine

From 847d49bc2343c9db766e24c47b5e729785320819 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Mon, 23 Feb 2026 14:39:20 +0100
Subject: [PATCH 38/40] Refactored TF buffer impl to cpp

---
 icey/CMakeLists.txt                    |   1 +
 icey/doc/source/api_ros.md             |   3 -
 icey/include/icey/icey_async_await.hpp | 368 ++-----------------------
 icey/src/icey_async_await.cpp          | 337 ++++++++++++++++++++++
 4 files changed, 355 insertions(+), 354 deletions(-)
 create mode 100644 icey/src/icey_async_await.cpp

diff --git a/icey/CMakeLists.txt b/icey/CMakeLists.txt
index 4c76787..5c01a64 100644
--- a/icey/CMakeLists.txt
+++ b/icey/CMakeLists.txt
@@ -28,6 +28,7 @@ include_directories(
 )
 
 ament_auto_add_library(icey 
+  src/icey_async_await.cpp
   src/actions/client.cpp 
   src/actions/server.cpp 
   src/actions/server_goal_handle.cpp  
diff --git a/icey/doc/source/api_ros.md b/icey/doc/source/api_ros.md
index 8dc8edb..abff19a 100644
--- a/icey/doc/source/api_ros.md
+++ b/icey/doc/source/api_ros.md
@@ -21,9 +21,6 @@ Convenience node wrappers containing the Icey context
 ```{doxygenclass} icey::NodeWithIceyContext
 ```
 
-```{doxygenstruct} icey::TransformBufferImpl
-```
-
 ```{doxygenstruct} icey::NodeBase
 ```
 
diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 3ec4712..8814633 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -236,341 +236,19 @@ struct NodeBase {
   }
 };
 
-/// A subscription + buffer for transforms that allows for asynchronous lookups and to subscribe on
-/// a single transform between two coordinate systems. It is otherwise implemented similarly to the
-/// tf2_ros::TransformListener but offering a well-developed asynchronous API.
-/// It subscribes on the topic /tf and listens for relevant transforms (i.e. ones we subscribed to
-/// or the ones we requested a lookup). If any relevant transform was received, it notifies via a
-/// callback.
-///
-/// Why not using `tf2_ros::AsyncBuffer` ? Due to multiple issues with it: (1) It uses
-/// the `std::future/std::promise` primitives that are effectively useless. (2)
-/// tf2_ros::AsyncBuffer::waitForTransform has a bug: We cannot make another lookup in the callback
-/// of a lookup (it holds a (non-reentrant) mutex locked while calling the user callback), making it
-/// impossible to chain asynchronous operations.
-///
-/// @sa This class is used to implement the `TransformSubscriptionStream` and the `TransformBuffer`.
-struct TransformBufferImpl {
-  using TransformMsg = geometry_msgs::msg::TransformStamped;
-  using TransformsMsg = tf2_msgs::msg::TFMessage::ConstSharedPtr;
-  using OnTransform = std::function<void(const TransformMsg &)>;
-  using OnError = std::function<void(const tf2::TransformException &)>;
-  using GetFrame = std::function<std::string()>;
-
-  /// We make this class non-copyable since it captures the this-pointer in clojures.
-  TransformBufferImpl(const TransformBufferImpl &) = delete;
-  TransformBufferImpl(TransformBufferImpl &&) = delete;
-  TransformBufferImpl &operator=(const TransformBufferImpl &) = delete;
-  TransformBufferImpl &operator=(TransformBufferImpl &&) = delete;
-
-  /// A transform request stores a request for looking up a transform between two coordinate
-  /// systems. Either (1) at a particular time with a timeout, or (2) as a subscription. When
-  /// "subscribing" to a transform, we yield a transform each time it changes.
-  struct TransformRequest {
-    TransformRequest(const GetFrame &target_frame, const GetFrame &source_frame,
-                     OnTransform on_transform, OnError on_error,
-                     std::optional<Time> _maybe_time = {})
-        : target_frame(target_frame),
-          source_frame(source_frame),
-          on_transform(on_transform),
-          on_error(on_error),
-          maybe_time(_maybe_time) {}
-    GetFrame target_frame;
-    GetFrame source_frame;
-    std::optional<TransformMsg> last_received_transform;
-    OnTransform on_transform;
-    OnError on_error;
-    std::optional<Time> maybe_time;
-#if ICEY_ASYNC_AWAIT_THREAD_SAFE
-    std::atomic_bool finished{false};
-    mutable std::mutex state_mutex;
-#endif
-  };
-
-  /// A request for a transform lookup: It represents effectively a single call to the async_lookup
-  /// function. Even if you call async_lookup with the exact same arguments (same frames and time),
-  /// this will count as two separate requests.
-  using RequestHandle = std::shared_ptr<TransformRequest>;
-
-  explicit TransformBufferImpl(std::weak_ptr<NodeBase> node) : node_(node) { init(); }
-
-  /// @brief Subscribe to a single transform between two coordinate systems. Every time this
-  /// transform changes, the `on_transform` callback function is called. More precisely, every time
-  /// a message arrives on the `/tf` or `/tf_static` topic, a lookup is attempted. If the lookup
-  /// fails, `on_error` is called. If the lookup succeeds and if the looked up transform is
-  // different to the previously emitted one, the `on_transform` callback is called.
-  void add_subscription(const GetFrame &target_frame, const GetFrame &source_frame,
-                        const OnTransform &on_transform, const OnError &on_error) {
-    std::lock_guard<std::recursive_mutex> lock{mutex_};
-    requests_.emplace(
-        std::make_shared<TransformRequest>(target_frame, source_frame, on_transform, on_error));
-  }
-
-  /// @brief Queries the TF buffer for a transform at the given time between the given frames. It
-  /// does not wait but instead only returns something if the transform is already in the buffer.
-  ///
-  /// @param target_frame
-  /// @param source_frame
-  /// @param time
-  /// @return The transform or the TF error if the transform is not in the buffer.
-  Result<geometry_msgs::msg::TransformStamped, std::string> get_from_buffer(
-      std::string target_frame, std::string source_frame, const Time &time) const {
-    try {
-      const tf2::TimePoint legacy_timepoint = tf2_ros::fromRclcpp(rclcpp_from_chrono(time));
-      // Note that this call does not wait, the transform must already have arrived.
-      auto tf = buffer_->lookupTransform(target_frame, source_frame, legacy_timepoint);
-      return Ok(tf);
-    } catch (const tf2::TransformException &e) {
-      return Err(std::string(e.what()));
-    }
-  }
-
-  /// @brief Makes an asynchronous lookup for a for a transform at the given time between the given
-  /// frames. Callback-based API.
-  ///
-  /// @param target_frame
-  /// @param source_frame
-  /// @param time
-  /// @param timeout
-  /// @param on_transform The callback that is called with the requested transform after it becomes
-  /// available
-  /// @param on_error The callback that is called if a timeout occurs.
-  /// @return The "handle", identifying this request. You can use this handle to call
-  /// `cancel_request` if you want to cancel the request.
-  /// @warning Currently the timeout is measured with wall-time, i.e. does not consider sim-time due
-  /// to the limitation of ROS 2 Humble only offering wall-timers
-  RequestHandle lookup(const std::string &target_frame, const std::string &source_frame, Time time,
-                       const Duration &timeout, OnTransform on_transform, OnError on_error) {
-    auto request{std::make_shared<TransformRequest>([target_frame]() { return target_frame; },
-                                                    [source_frame]() { return source_frame; },
-                                                    on_transform, on_error, time)};
-
-    auto weak_request = std::weak_ptr<TransformRequest>(request);
-#if ICEY_ASYNC_AWAIT_THREAD_SAFE
-    std::lock_guard<std::recursive_mutex> lock{mutex_};
-#endif
-    requests_.emplace(request);
-    node_.lock()->add_task_for(
-        uint64_t(request.get()), timeout, [this, on_error, request = weak_request]() {
-          if (auto req = request.lock()) {
-#if ICEY_ASYNC_AWAIT_THREAD_SAFE
-            bool expected = false;
-            if (!req->finished.compare_exchange_strong(expected, true)) {
-              return;
-            }
-            std::lock_guard<std::recursive_mutex> lock{mutex_};
-#endif
-            requests_.erase(req);  // Destroy the request
-            on_error(tf2::TimeoutException{"Timed out waiting for transform"});
-          }
-        });
-    return request;
-  }
-
-  /// @brief Does an asynchronous lookup for a single transform that can be awaited using `co_await`
-  ///
-  /// @param target_frame
-  /// @param source_frame
-  /// @param time At which time to get the transform
-  /// @param timeout How long to wait for the transform
-  /// @return A future that resolves with the transform or with an error if a timeout occurs
-  impl::Promise<geometry_msgs::msg::TransformStamped, std::string> lookup(
-      const std::string &target_frame, const std::string &source_frame, const Time &time,
-      const Duration &timeout) {
-    return impl::Promise<geometry_msgs::msg::TransformStamped, std::string>(
-        [this, target_frame, source_frame, time, timeout](auto &promise) {
-          auto request_handle = this->lookup(
-              target_frame, source_frame, time, timeout,
-              [&promise](const geometry_msgs::msg::TransformStamped &tf) { promise.resolve(tf); },
-              [&promise](const tf2::TransformException &ex) { promise.reject(ex.what()); });
-        });
-  }
-
-  /// @brief Same as `lookup`, but accepts a ROS time point
-  ///
-  /// @param target_frame
-  /// @param source_frame
-  /// @param time At which time to get the transform
-  /// @param timeout How long to wait for the transform
-  /// @return A future that resolves with the transform or with an error if a timeout occurs
-  impl::Promise<geometry_msgs::msg::TransformStamped, std::string> lookup(
-      const std::string &target_frame, const std::string &source_frame, const rclcpp::Time &time,
-      const Duration &timeout) {
-    return lookup(target_frame, source_frame, icey::rclcpp_to_chrono(time), timeout);
-  }
-
-  /// Cancel a transform request: This means that the registered callbacks will no longer be called.
-  /// If the given request does not exist, this function does nothing.
-  bool cancel_request(RequestHandle request) {
-    std::lock_guard<std::recursive_mutex> lock{mutex_};
-    requests_.erase(request);
-    return node_.lock()->cancel_task_for(uint64_t(request.get()));
-  }
-
-  /// We take a tf2_ros::Buffer instead of a tf2::BufferImpl only to be able to use ROS-time API
-  /// (internally TF2 has it's own timestamps...), not because we need to wait on anything (that's
-  /// what tf2_ros::Buffer does in addition to tf2::BufferImpl).
-  std::shared_ptr<tf2_ros::Buffer> buffer_;
-
-protected:
-  void init() {
-    init_tf_buffer();
-    message_subscription_tf_ = node_.lock()->create_subscription<tf2_msgs::msg::TFMessage>(
-        "/tf", [this](TransformsMsg msg) { on_tf_message(msg, false); },
-        tf2_ros::DynamicListenerQoS());
-    message_subscription_tf_static_ = node_.lock()->create_subscription<tf2_msgs::msg::TFMessage>(
-        "/tf_static", [this](TransformsMsg msg) { on_tf_message(msg, true); },
-        tf2_ros::StaticListenerQoS());
-  }
-
-  void init_tf_buffer() {
-    /// Mind that the official example regarding the piece of code below is incomplete:
-    /// ([official](https://docs.ros.org/en/jazzy/Tutorials/Intermediate/Tf2/Writing-A-Tf2-Listener-Cpp.html))
-    /// . I'm following this example instead:
-    /// https://github.com/ros-perception/imu_pipeline/blob/ros2/imu_transformer/src/imu_transformer.cpp#L16
-    /// See also the following discussions on why this code needs to be this way:
-    /// https://answers.ros.org/question/372608/?sort=votes
-    /// https://github.com/ros-navigation/navigation2/issues/1182
-    /// https://github.com/ros2/geometry2/issues/446
-    buffer_ =
-        std::make_shared<tf2_ros::Buffer>(node_.lock()->get_node_clock_interface()->get_clock());
-    auto timer_interface = std::make_shared<tf2_ros::CreateTimerROS>(
-        node_.lock()->get_node_base_interface(), node_.lock()->get_node_timers_interface());
-    buffer_->setCreateTimerInterface(timer_interface);
-  }
-
-  /// Store the received transforms in the buffer.
-  void store_in_buffer(const tf2_msgs::msg::TFMessage &msg_in, bool is_static) {
-    std::string authority = "Authority undetectable";
-    for (const auto &transform : msg_in.transforms) {
-      try {
-        buffer_->setTransform(transform, authority, is_static);
-      } catch (const tf2::TransformException &ex) {
-        std::string temp = ex.what();
-        RCLCPP_ERROR(node_.lock()->get_node_logging_interface()->get_logger(),
-                     "Failure to set received transform from %s to %s with error: %s\n",
-                     transform.child_frame_id.c_str(), transform.header.frame_id.c_str(),
-                     temp.c_str());
-      }
-    }
-  }
-
-  /// This simply looks up the transform in the buffer at the latest stamp and checks if it
-  /// changed with respect to the previously received one. If the transform has changed, we know
-  /// we have to notify. Returns true when it notified about a changed transform (called
-  /// on_transform) and false otherwise.
-  bool maybe_notify(TransformRequest &info) {
-    try {
-      /// Note that this does not wait/thread-sleep etc. This is simply a lookup in a
-      /// std::vector/tree.
-      geometry_msgs::msg::TransformStamped tf_msg =
-          buffer_->lookupTransform(info.target_frame(), info.source_frame(), tf2::TimePointZero);
-      bool changed;
-#if ICEY_ASYNC_AWAIT_THREAD_SAFE
-      {
-        std::lock_guard<std::mutex> lock{info.state_mutex};
-        changed = !info.last_received_transform || tf_msg != *info.last_received_transform;
-        if (changed) info.last_received_transform = tf_msg;
-      }
-#else
-      changed = !info.last_received_transform || tf_msg != *info.last_received_transform;
-      if (changed) info.last_received_transform = tf_msg;
-#endif
-      if (changed) {
-        info.on_transform(tf_msg);
-        return true;
-      }
-    } catch (const tf2::TransformException &e) {
-      info.on_error(e);
-    }
-    return false;
-  }
-
-  bool maybe_notify_specific_time(RequestHandle request) {
-    try {
-      /// Note that this does not wait/thread-sleep etc. This is simply a lookup in a
-      /// std::vector/tree.
-      geometry_msgs::msg::TransformStamped tf_msg = buffer_->lookupTransform(
-          request->target_frame(), request->source_frame(), request->maybe_time.value());
-#if ICEY_ASYNC_AWAIT_THREAD_SAFE
-      bool expected = false;
-      if (!request->finished.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
-                                                     std::memory_order_acquire)) {
-        return false;
-      }
-#endif
-      request->on_transform(tf_msg);
-      /// If the request is destroyed gracefully (lookup succeeded), cancel the associated task
-      /// timer
-      node_.lock()->cancel_task_for(uint64_t(request.get()));
-      return true;
-    } catch (
-        const tf2::TransformException &e) {  /// TODO we could catch for extrapolation here as well
-      /// For any other error, we continue waiting
-    }
-    return false;
-  }
-
-  void notify_if_any_relevant_transform_was_received() {
-/// Iterate all requests, notify and maybe erase them if they are requests for a specific time
-#if ICEY_ASYNC_AWAIT_THREAD_SAFE
-    std::vector<RequestHandle> requests_to_delete;
-    std::vector<RequestHandle> requests;
-    {
-      std::lock_guard<std::recursive_mutex> lock{mutex_};
-      requests.reserve(requests_.size());
-      for (const auto &req : requests_) requests.push_back(req);
-    }
-    for (auto req : requests) {
-      if (req->maybe_time) {
-        if (maybe_notify_specific_time(req)) {
-          requests_to_delete.push_back(req);
-        }
-      } else {
-        // If it is a regular subscription, is is persistend and never erased
-        maybe_notify(*req);
-      }
-    }
-    std::lock_guard<std::recursive_mutex> lock{mutex_};
-    for (const auto &k : requests_to_delete) requests_.erase(k);
-#else
-    std::erase_if(requests_, [this](auto req) {
-      if (req->maybe_time) {
-        return maybe_notify_specific_time(req);
-      } else {
-        // If it is a regular subscription, is is persistend and never erased
-        maybe_notify(*req);
-        return false;
-      }
-    });
-#endif
-  }
-
-  void on_tf_message(const TransformsMsg &msg, bool is_static) {
-    store_in_buffer(*msg, is_static);
-    notify_if_any_relevant_transform_was_received();
-  }
-
-  std::weak_ptr<NodeBase> node_;  /// Hold weak reference to the NodeBase because the Context owns
-                                  /// the NodeBase as well, so we avoid circular reference
-
-  rclcpp::Subscription<tf2_msgs::msg::TFMessage>::SharedPtr message_subscription_tf_;
-  rclcpp::Subscription<tf2_msgs::msg::TFMessage>::SharedPtr message_subscription_tf_static_;
-
-  std::recursive_mutex mutex_;
-  std::unordered_set<RequestHandle> requests_;
-};
+struct TransformBufferImpl;
 
 /// A TransformBuffer offers a modern, asynchronous interface for looking up transforms at a given
 /// point in time. This class is lightweight pointer to underlying implementation and can therefore
 /// be copied and passed around by value (PIMPL idiom)
 struct TransformBuffer {
-  using RequestHandle = TransformBufferImpl::RequestHandle;
+  using RequestHandle = uint64_t;
   using OnTransform = std::function<void(const geometry_msgs::msg::TransformStamped &)>;
   using OnError = std::function<void(const tf2::TransformException &)>;
 
-  TransformBuffer() = default;
-  TransformBuffer(std::shared_ptr<TransformBufferImpl> impl) : impl_(impl) {}
+  /// Initializes the transform buffer by starting the subscriptions on TF. Returns *this;
+  /// Does nothing if already initialized.
+  TransformBuffer &init(std:weak_ptr<NodeBase> node_base);
 
   /// @brief Makes an asynchronous lookup for a for a transform at the given time between the given
   /// frames. Callback-based API.
@@ -582,20 +260,20 @@ struct TransformBuffer {
   /// @param on_transform The callback that is called with the requested transform after it becomes
   /// available
   /// @param on_error The callback that is called if a timeout occurs.
-  /// @return The "handle", identifying this request. You can use this handle to call
+  /// @return The request id, identifying this request. You can use this handle to call
   /// `cancel_request` if you want to cancel the request.
   /// @warning Currently the timeout is measured with wall-time, i.e. does not consider sim-time due
   /// to the limitation of ROS 2 Humble only offering wall-timers
-  RequestHandle lookup(const std::string &target_frame, const std::string &source_frame, Time time,
+  uint64_t lookup(const std::string &target_frame, const std::string &source_frame, Time time,
                        const Duration &timeout, OnTransform on_transform, OnError on_error) {
-    return impl_.lock()->lookup(target_frame, source_frame, time, timeout, on_transform, on_error);
+    return impl_->lookup(target_frame, source_frame, time, timeout, on_transform, on_error);
   }
 
   /// Cancel a transform request: This means that the registered callbacks will no longer be called.
   /// If the given request does not exist, this function does nothing, in this case it returns
   /// false. If a request was cleaned up, this function returns true.
-  bool cancel_request(RequestHandle request_handle) {
-    return impl_.lock()->cancel_request(request_handle);
+  bool cancel_request(uint64_t request_id) {
+    return impl_->cancel_request(request_id);
   }
 
   /// @brief Does an asynchronous lookup for a single transform that can be awaited using `co_await`
@@ -608,7 +286,7 @@ struct TransformBuffer {
   impl::Promise<geometry_msgs::msg::TransformStamped, std::string> lookup(
       const std::string &target_frame, const std::string &source_frame, const Time &time,
       const Duration &timeout) {
-    return impl_.lock()->lookup(target_frame, source_frame, time, timeout);
+    return impl_->lookup(target_frame, source_frame, time, timeout);
   }
 
   /// @brief Same as `lookup`, but accepts a ROS time point
@@ -621,11 +299,11 @@ struct TransformBuffer {
   impl::Promise<geometry_msgs::msg::TransformStamped, std::string> lookup(
       const std::string &target_frame, const std::string &source_frame, const rclcpp::Time &time,
       const Duration &timeout) {
-    return impl_.lock()->lookup(target_frame, source_frame, time, timeout);
+    return impl_->lookup(target_frame, source_frame, time, timeout);
   }
 
 private:
-  std::weak_ptr<TransformBufferImpl> impl_;
+  std::shared_ptr<TransformBufferImpl> impl_;
 };
 
 template <class ServiceT>
@@ -765,7 +443,7 @@ struct AsyncGoalHandle {
                 promise.resolve(result);
               }
             });
-        if (!request_id) { /// This can only happen in case the rcl/rmw function fails
+        if (!request_id) {  /// This can only happen in case the rcl/rmw function fails
           promise.reject("FAILED");
         } else {
           node_.lock()->add_task_for(uint64_t(&promise), timeout,
@@ -1082,27 +760,15 @@ class ContextAsyncAwait {
   /// Creates a transform buffer that works like the usual combination of a tf2_ros::Buffer and a
   /// tf2_ros::TransformListener. It is used to `lookup()` transforms asynchronously at a specific
   /// point in time.
-  TransformBuffer create_transform_buffer() { return TransformBuffer{add_tf_listener_if_needed()}; }
+  TransformBuffer create_transform_buffer() { return tf_buffer_.init(this->node_base()); }
 
   /// Get the NodeBase, i.e. the ROS node using which this Context was created.
   std::shared_ptr<NodeBase> node_base() { return node_base_; }
 
-  std::shared_ptr<TransformBufferImpl> add_tf_listener_if_needed() {
-    std::call_once(tf_buffer_init_flag_, [this]() {
-      /// We need only one subscription on /tf, but we can have multiple transforms on which we
-      /// listen to
-      tf_buffer_impl_ = std::make_shared<TransformBufferImpl>(this->node_base());
-    });
-    return tf_buffer_impl_;
-  }
-
-  /// The TF async interface impl
-  std::shared_ptr<TransformBufferImpl> tf_buffer_impl_;
-  /// We need bookkeeping for the service servers.
 protected:
+  /// The TF async interface impl
+  TransformBuffer tf_buffer_;
   std::shared_ptr<NodeBase> node_base_;
-  std::once_flag
-      tf_buffer_init_flag_;  /// Needed for atomic, i.e. thread-safe initialization of tf buffer.
   std::recursive_mutex bookkeeping_mutex_;
   std::vector<std::shared_ptr<rclcpp::TimerBase>> timers_;
   std::vector<std::shared_ptr<rclcpp::ServiceBase>> services_;
diff --git a/icey/src/icey_async_await.cpp b/icey/src/icey_async_await.cpp
new file mode 100644
index 0000000..466f2f3
--- /dev/null
+++ b/icey/src/icey_async_await.cpp
@@ -0,0 +1,337 @@
+#include <icey/icey_async_await.hpp>
+
+namespace icey {
+
+/// A subscription + buffer for transforms that allows for asynchronous lookups and to subscribe on
+/// a single transform between two coordinate systems. It is otherwise implemented similarly to the
+/// tf2_ros::TransformListener but offering a well-developed asynchronous API.
+/// It subscribes on the topic /tf and listens for relevant transforms (i.e. ones we subscribed to
+/// or the ones we requested a lookup). If any relevant transform was received, it notifies via a
+/// callback.
+///
+/// Why not using `tf2_ros::AsyncBuffer` ? Due to multiple issues with it: (1) It uses
+/// the `std::future/std::promise` primitives that are effectively useless. (2)
+/// tf2_ros::AsyncBuffer::waitForTransform has a bug: We cannot make another lookup in the callback
+/// of a lookup (it holds a (non-reentrant) mutex locked while calling the user callback), making it
+/// impossible to chain asynchronous operations.
+///
+/// @sa This class is used to implement the `TransformSubscriptionStream` and the `TransformBuffer`.
+struct TransformBufferImpl {
+  using TransformMsg = geometry_msgs::msg::TransformStamped;
+  using TransformsMsg = tf2_msgs::msg::TFMessage::ConstSharedPtr;
+  using OnTransform = std::function<void(const TransformMsg &)>;
+  using OnError = std::function<void(const tf2::TransformException &)>;
+  using GetFrame = std::function<std::string()>;
+
+  /// We make this class non-copyable since it captures the this-pointer in clojures.
+  TransformBufferImpl(const TransformBufferImpl &) = delete;
+  TransformBufferImpl(TransformBufferImpl &&) = delete;
+  TransformBufferImpl &operator=(const TransformBufferImpl &) = delete;
+  TransformBufferImpl &operator=(TransformBufferImpl &&) = delete;
+
+  /// A transform request stores a request for looking up a transform between two coordinate
+  /// systems. Either (1) at a particular time with a timeout, or (2) as a subscription. When
+  /// "subscribing" to a transform, we yield a transform each time it changes.
+  struct TransformRequest {
+    TransformRequest(const GetFrame &target_frame, const GetFrame &source_frame,
+                     OnTransform on_transform, OnError on_error,
+                     std::optional<Time> _maybe_time = {})
+        : target_frame(target_frame),
+          source_frame(source_frame),
+          on_transform(on_transform),
+          on_error(on_error),
+          maybe_time(_maybe_time) {}
+    GetFrame target_frame;
+    GetFrame source_frame;
+    std::optional<TransformMsg> last_received_transform;
+    OnTransform on_transform;
+    OnError on_error;
+    std::optional<Time> maybe_time;
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
+    std::atomic_bool finished{false};
+    mutable std::mutex state_mutex;
+#endif
+  };
+
+  /// A request for a transform lookup: It represents effectively a single call to the async_lookup
+  /// function. Even if you call async_lookup with the exact same arguments (same frames and time),
+  /// this will count as two separate requests.
+  using RequestHandle = std::shared_ptr<TransformRequest>;
+
+  explicit TransformBufferImpl(std::weak_ptr<NodeBase> node) : node_(node) { init(); }
+
+  /// @brief Subscribe to a single transform between two coordinate systems. Every time this
+  /// transform changes, the `on_transform` callback function is called. More precisely, every time
+  /// a message arrives on the `/tf` or `/tf_static` topic, a lookup is attempted. If the lookup
+  /// fails, `on_error` is called. If the lookup succeeds and if the looked up transform is
+  // different to the previously emitted one, the `on_transform` callback is called.
+  void add_subscription(const GetFrame &target_frame, const GetFrame &source_frame,
+                        const OnTransform &on_transform, const OnError &on_error) {
+    std::lock_guard<std::recursive_mutex> lock{mutex_};
+    requests_.emplace(
+        std::make_shared<TransformRequest>(target_frame, source_frame, on_transform, on_error));
+  }
+
+  /// @brief Queries the TF buffer for a transform at the given time between the given frames. It
+  /// does not wait but instead only returns something if the transform is already in the buffer.
+  ///
+  /// @param target_frame
+  /// @param source_frame
+  /// @param time
+  /// @return The transform or the TF error if the transform is not in the buffer.
+  Result<geometry_msgs::msg::TransformStamped, std::string> get_from_buffer(
+      std::string target_frame, std::string source_frame, const Time &time) const {
+    try {
+      const tf2::TimePoint legacy_timepoint = tf2_ros::fromRclcpp(rclcpp_from_chrono(time));
+      // Note that this call does not wait, the transform must already have arrived.
+      auto tf = buffer_->lookupTransform(target_frame, source_frame, legacy_timepoint);
+      return Ok(tf);
+    } catch (const tf2::TransformException &e) {
+      return Err(std::string(e.what()));
+    }
+  }
+
+  /// @brief Makes an asynchronous lookup for a for a transform at the given time between the given
+  /// frames. Callback-based API.
+  ///
+  /// @param target_frame
+  /// @param source_frame
+  /// @param time
+  /// @param timeout
+  /// @param on_transform The callback that is called with the requested transform after it becomes
+  /// available
+  /// @param on_error The callback that is called if a timeout occurs.
+  /// @return The "handle", identifying this request. You can use this handle to call
+  /// `cancel_request` if you want to cancel the request.
+  /// @warning Currently the timeout is measured with wall-time, i.e. does not consider sim-time due
+  /// to the limitation of ROS 2 Humble only offering wall-timers
+  RequestHandle lookup(const std::string &target_frame, const std::string &source_frame, Time time,
+                       const Duration &timeout, OnTransform on_transform, OnError on_error) {
+    auto request{std::make_shared<TransformRequest>([target_frame]() { return target_frame; },
+                                                    [source_frame]() { return source_frame; },
+                                                    on_transform, on_error, time)};
+
+    auto weak_request = std::weak_ptr<TransformRequest>(request);
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
+    std::lock_guard<std::recursive_mutex> lock{mutex_};
+#endif
+    requests_.emplace(request);
+    node_.lock()->add_task_for(
+        uint64_t(request.get()), timeout, [this, on_error, request = weak_request]() {
+          if (auto req = request.lock()) {
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
+            bool expected = false;
+            if (!req->finished.compare_exchange_strong(expected, true)) {
+              return;
+            }
+            std::lock_guard<std::recursive_mutex> lock{mutex_};
+#endif
+            requests_.erase(req);  // Destroy the request
+            on_error(tf2::TimeoutException{"Timed out waiting for transform"});
+          }
+        });
+    return request;
+  }
+
+  /// @brief Does an asynchronous lookup for a single transform that can be awaited using `co_await`
+  ///
+  /// @param target_frame
+  /// @param source_frame
+  /// @param time At which time to get the transform
+  /// @param timeout How long to wait for the transform
+  /// @return A future that resolves with the transform or with an error if a timeout occurs
+  impl::Promise<geometry_msgs::msg::TransformStamped, std::string> lookup(
+      const std::string &target_frame, const std::string &source_frame, const Time &time,
+      const Duration &timeout) {
+    return impl::Promise<geometry_msgs::msg::TransformStamped, std::string>(
+        [this, target_frame, source_frame, time, timeout](auto &promise) {
+          auto request_handle = this->lookup(
+              target_frame, source_frame, time, timeout,
+              [&promise](const geometry_msgs::msg::TransformStamped &tf) { promise.resolve(tf); },
+              [&promise](const tf2::TransformException &ex) { promise.reject(ex.what()); });
+        });
+  }
+
+  /// @brief Same as `lookup`, but accepts a ROS time point
+  ///
+  /// @param target_frame
+  /// @param source_frame
+  /// @param time At which time to get the transform
+  /// @param timeout How long to wait for the transform
+  /// @return A future that resolves with the transform or with an error if a timeout occurs
+  impl::Promise<geometry_msgs::msg::TransformStamped, std::string> lookup(
+      const std::string &target_frame, const std::string &source_frame, const rclcpp::Time &time,
+      const Duration &timeout) {
+    return lookup(target_frame, source_frame, icey::rclcpp_to_chrono(time), timeout);
+  }
+
+  /// Cancel a transform request: This means that the registered callbacks will no longer be called.
+  /// If the given request does not exist, this function does nothing.
+  bool cancel_request(uint64_t request_id) {
+    std::lock_guard<std::recursive_mutex> lock{mutex_};
+    requests_.erase(request);
+    return node_.lock()->cancel_task_for(request_id);
+  }
+
+  /// We take a tf2_ros::Buffer instead of a tf2::BufferImpl only to be able to use ROS-time API
+  /// (internally TF2 has it's own timestamps...), not because we need to wait on anything (that's
+  /// what tf2_ros::Buffer does in addition to tf2::BufferImpl).
+  std::shared_ptr<tf2_ros::Buffer> buffer_;
+
+protected:
+  void init() {
+    init_tf_buffer();
+    message_subscription_tf_ = node_.lock()->create_subscription<tf2_msgs::msg::TFMessage>(
+        "/tf", [this](TransformsMsg msg) { on_tf_message(msg, false); },
+        tf2_ros::DynamicListenerQoS());
+    message_subscription_tf_static_ = node_.lock()->create_subscription<tf2_msgs::msg::TFMessage>(
+        "/tf_static", [this](TransformsMsg msg) { on_tf_message(msg, true); },
+        tf2_ros::StaticListenerQoS());
+  }
+
+  void init_tf_buffer() {
+    /// Mind that the official example regarding the piece of code below is incomplete:
+    /// ([official](https://docs.ros.org/en/jazzy/Tutorials/Intermediate/Tf2/Writing-A-Tf2-Listener-Cpp.html))
+    /// . I'm following this example instead:
+    /// https://github.com/ros-perception/imu_pipeline/blob/ros2/imu_transformer/src/imu_transformer.cpp#L16
+    /// See also the following discussions on why this code needs to be this way:
+    /// https://answers.ros.org/question/372608/?sort=votes
+    /// https://github.com/ros-navigation/navigation2/issues/1182
+    /// https://github.com/ros2/geometry2/issues/446
+    buffer_ =
+        std::make_shared<tf2_ros::Buffer>(node_.lock()->get_node_clock_interface()->get_clock());
+    auto timer_interface = std::make_shared<tf2_ros::CreateTimerROS>(
+        node_.lock()->get_node_base_interface(), node_.lock()->get_node_timers_interface());
+    buffer_->setCreateTimerInterface(timer_interface);
+  }
+
+  /// Store the received transforms in the buffer.
+  void store_in_buffer(const tf2_msgs::msg::TFMessage &msg_in, bool is_static) {
+    std::string authority = "Authority undetectable";
+    for (const auto &transform : msg_in.transforms) {
+      try {
+        buffer_->setTransform(transform, authority, is_static);
+      } catch (const tf2::TransformException &ex) {
+        std::string temp = ex.what();
+        RCLCPP_ERROR(node_.lock()->get_node_logging_interface()->get_logger(),
+                     "Failure to set received transform from %s to %s with error: %s\n",
+                     transform.child_frame_id.c_str(), transform.header.frame_id.c_str(),
+                     temp.c_str());
+      }
+    }
+  }
+
+  /// This simply looks up the transform in the buffer at the latest stamp and checks if it
+  /// changed with respect to the previously received one. If the transform has changed, we know
+  /// we have to notify. Returns true when it notified about a changed transform (called
+  /// on_transform) and false otherwise.
+  bool maybe_notify(TransformRequest &info) {
+    try {
+      /// Note that this does not wait/thread-sleep etc. This is simply a lookup in a
+      /// std::vector/tree.
+      geometry_msgs::msg::TransformStamped tf_msg =
+          buffer_->lookupTransform(info.target_frame(), info.source_frame(), tf2::TimePointZero);
+      bool changed;
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
+      {
+        std::lock_guard<std::mutex> lock{info.state_mutex};
+        changed = !info.last_received_transform || tf_msg != *info.last_received_transform;
+        if (changed) info.last_received_transform = tf_msg;
+      }
+#else
+      changed = !info.last_received_transform || tf_msg != *info.last_received_transform;
+      if (changed) info.last_received_transform = tf_msg;
+#endif
+      if (changed) {
+        info.on_transform(tf_msg);
+        return true;
+      }
+    } catch (const tf2::TransformException &e) {
+      info.on_error(e);
+    }
+    return false;
+  }
+
+  bool maybe_notify_specific_time(RequestHandle request) {
+    try {
+      /// Note that this does not wait/thread-sleep etc. This is simply a lookup in a
+      /// std::vector/tree.
+      geometry_msgs::msg::TransformStamped tf_msg = buffer_->lookupTransform(
+          request->target_frame(), request->source_frame(), request->maybe_time.value());
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
+      bool expected = false;
+      if (!request->finished.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
+                                                     std::memory_order_acquire)) {
+        return false;
+      }
+#endif
+      request->on_transform(tf_msg);
+      /// If the request is destroyed gracefully (lookup succeeded), cancel the associated task
+      /// timer
+      node_.lock()->cancel_task_for(uint64_t(request.get()));
+      return true;
+    } catch (
+        const tf2::TransformException &e) {  /// TODO we could catch for extrapolation here as well
+      /// For any other error, we continue waiting
+    }
+    return false;
+  }
+
+  void notify_if_any_relevant_transform_was_received() {
+/// Iterate all requests, notify and maybe erase them if they are requests for a specific time
+#if ICEY_ASYNC_AWAIT_THREAD_SAFE
+    std::vector<RequestHandle> requests_to_delete;
+    std::vector<RequestHandle> requests;
+    {
+      std::lock_guard<std::recursive_mutex> lock{mutex_};
+      requests.reserve(requests_.size());
+      for (const auto &req : requests_) requests.push_back(req);
+    }
+    for (auto req : requests) {
+      if (req->maybe_time) {
+        if (maybe_notify_specific_time(req)) {
+          requests_to_delete.push_back(req);
+        }
+      } else {
+        // If it is a regular subscription, is is persistend and never erased
+        maybe_notify(*req);
+      }
+    }
+    std::lock_guard<std::recursive_mutex> lock{mutex_};
+    for (const auto &k : requests_to_delete) requests_.erase(k);
+#else
+    std::erase_if(requests_, [this](auto req) {
+      if (req->maybe_time) {
+        return maybe_notify_specific_time(req);
+      } else {
+        // If it is a regular subscription, is is persistend and never erased
+        maybe_notify(*req);
+        return false;
+      }
+    });
+#endif
+  }
+
+  void on_tf_message(const TransformsMsg &msg, bool is_static) {
+    store_in_buffer(*msg, is_static);
+    notify_if_any_relevant_transform_was_received();
+  }
+
+  std::weak_ptr<NodeBase> node_;  /// Hold weak reference to the NodeBase because the Context owns
+                                  /// the NodeBase as well, so we avoid circular reference
+
+  rclcpp::Subscription<tf2_msgs::msg::TFMessage>::SharedPtr message_subscription_tf_;
+  rclcpp::Subscription<tf2_msgs::msg::TFMessage>::SharedPtr message_subscription_tf_static_;
+
+  std::recursive_mutex mutex_;
+  std::unordered_set<RequestHandle> requests_;
+};
+
+TransformBuffer &TransformBuffer::init(std::weak_ptr<NodeBase> node_base) {
+  if (!impl_) {
+    impl_ = std::make_shared<TransformBufferImpl>(node_base);
+  }
+  return *this;
+}
+
+}  // namespace icey
\ No newline at end of file

From 9942358159dcf00264302b46262a0783a8bea2f5 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Mon, 23 Feb 2026 15:28:26 +0100
Subject: [PATCH 39/40] Compiling, had to change the interface a bit because
 other parts of the code depended on TFBufferImpl

---
 icey/include/icey/icey_async_await.hpp | 37 +++++++------
 icey/include/icey/icey_rx.hpp          | 27 +++++-----
 icey/src/icey_async_await.cpp          | 73 ++++++++++++++++++--------
 3 files changed, 86 insertions(+), 51 deletions(-)

diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index 8814633..c54c959 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -38,13 +38,13 @@ using Clock = std::chrono::system_clock;
 using Time = std::chrono::time_point<Clock>;
 using Duration = Clock::duration;
 
-static rclcpp::Time rclcpp_from_chrono(const Time &time_point) {
+[[maybe_unused]] static rclcpp::Time rclcpp_from_chrono(const Time &time_point) {
   return rclcpp::Time(std::chrono::time_point_cast<std::chrono::nanoseconds>(time_point)
                           .time_since_epoch()
                           .count());
 }
 
-static Time rclcpp_to_chrono(const rclcpp::Time &time_point) {
+[[maybe_unused]] static Time rclcpp_to_chrono(const rclcpp::Time &time_point) {
   return Time(std::chrono::nanoseconds(time_point.nanoseconds()));
 }
 
@@ -237,18 +237,21 @@ struct NodeBase {
 };
 
 struct TransformBufferImpl;
-
-/// A TransformBuffer offers a modern, asynchronous interface for looking up transforms at a given
+/// A TransformBuffer offers an async/await interface for looking up transforms at a given
 /// point in time. This class is lightweight pointer to underlying implementation and can therefore
 /// be copied and passed around by value (PIMPL idiom)
 struct TransformBuffer {
   using RequestHandle = uint64_t;
   using OnTransform = std::function<void(const geometry_msgs::msg::TransformStamped &)>;
   using OnError = std::function<void(const tf2::TransformException &)>;
+  using GetFrame = std::function<std::string()>;
 
   /// Initializes the transform buffer by starting the subscriptions on TF. Returns *this;
   /// Does nothing if already initialized.
-  TransformBuffer &init(std:weak_ptr<NodeBase> node_base);
+  TransformBuffer &init(std::weak_ptr<NodeBase> node_base);
+
+  /// Return the underlying tf2_ros::Buffer.
+  std::shared_ptr<tf2_ros::Buffer> get_buffer() const;
 
   /// @brief Makes an asynchronous lookup for a for a transform at the given time between the given
   /// frames. Callback-based API.
@@ -265,16 +268,20 @@ struct TransformBuffer {
   /// @warning Currently the timeout is measured with wall-time, i.e. does not consider sim-time due
   /// to the limitation of ROS 2 Humble only offering wall-timers
   uint64_t lookup(const std::string &target_frame, const std::string &source_frame, Time time,
-                       const Duration &timeout, OnTransform on_transform, OnError on_error) {
-    return impl_->lookup(target_frame, source_frame, time, timeout, on_transform, on_error);
-  }
+                  const Duration &timeout, OnTransform on_transform, OnError on_error);
+
+  /// @brief Subscribe to a single transform between two coordinate systems. Every time this
+  /// transform changes, the `on_transform` callback function is called. More precisely, every time
+  /// a message arrives on the `/tf` or `/tf_static` topic, a lookup is attempted. If the lookup
+  /// fails, `on_error` is called. If the lookup succeeds and if the looked up transform is
+  // different to the previously emitted one, the `on_transform` callback is called.
+  void add_subscription(const GetFrame &target_frame, const GetFrame &source_frame,
+                        const OnTransform &on_transform, const OnError &on_error);
 
   /// Cancel a transform request: This means that the registered callbacks will no longer be called.
   /// If the given request does not exist, this function does nothing, in this case it returns
   /// false. If a request was cleaned up, this function returns true.
-  bool cancel_request(uint64_t request_id) {
-    return impl_->cancel_request(request_id);
-  }
+  bool cancel_request(uint64_t request_id);
 
   /// @brief Does an asynchronous lookup for a single transform that can be awaited using `co_await`
   ///
@@ -285,9 +292,7 @@ struct TransformBuffer {
   /// @return A future that resolves with the transform or with an error if a timeout occurs
   impl::Promise<geometry_msgs::msg::TransformStamped, std::string> lookup(
       const std::string &target_frame, const std::string &source_frame, const Time &time,
-      const Duration &timeout) {
-    return impl_->lookup(target_frame, source_frame, time, timeout);
-  }
+      const Duration &timeout);
 
   /// @brief Same as `lookup`, but accepts a ROS time point
   ///
@@ -298,9 +303,7 @@ struct TransformBuffer {
   /// @return A future that resolves with the transform or with an error if a timeout occurs
   impl::Promise<geometry_msgs::msg::TransformStamped, std::string> lookup(
       const std::string &target_frame, const std::string &source_frame, const rclcpp::Time &time,
-      const Duration &timeout) {
-    return impl_->lookup(target_frame, source_frame, time, timeout);
-  }
+      const Duration &timeout);
 
 private:
   std::shared_ptr<TransformBufferImpl> impl_;
diff --git a/icey/include/icey/icey_rx.hpp b/icey/include/icey/icey_rx.hpp
index 959b624..8dc3a2a 100644
--- a/icey/include/icey/icey_rx.hpp
+++ b/icey/include/icey/icey_rx.hpp
@@ -274,8 +274,8 @@ class Context : public ContextAsyncAwait,
   template <class OnTransform, class OnError>
   void add_tf_subscription(GetValue<std::string> target_frame, GetValue<std::string> source_frame,
                            OnTransform &&on_transform, OnError &&on_error) {
-    this->add_tf_listener_if_needed();
-    tf_buffer_impl_->add_subscription(target_frame, source_frame, on_transform, on_error);
+    this->create_transform_buffer().add_subscription(target_frame, source_frame, on_transform,
+                                                     on_error);
   }
 
   auto add_tf_broadcaster_if_needed() {
@@ -1316,7 +1316,7 @@ template <class Message>
 struct TransformSynchronizerImpl {
   using Self = TransformSynchronizerImpl<Message>;
   /// The book owns it.
-  Weak<TransformBufferImpl> tf_listener;
+  std::weak_ptr<tf2_ros::Buffer> tf_buffer;
   std::string target_frame;
   std::shared_ptr<SimpleFilterAdapter<Message>> input_filter;
   std::shared_ptr<tf2_ros::MessageFilter<Message>> synchronizer;
@@ -1327,13 +1327,14 @@ struct TransformSynchronizerImpl {
 
   void create_synchronizer(Context &context, const std::string &_target_frame,
                            const Duration &lookup_timeout) {
-    tf_listener = context.add_tf_listener_if_needed();
+    auto buf = context.create_transform_buffer();
+    tf_buffer = buf.get_buffer();
     target_frame = _target_frame;
     input_filter = std::make_shared<SimpleFilterAdapter<Message>>(context);
     /// The argument "0" means here infinite message queue size. We set it so
     /// because we must buffer every message for as long as we are waiting for a transform.
     synchronizer = std::make_shared<tf2_ros::MessageFilter<Message>>(
-        *input_filter->impl(), *tf_listener->buffer_, target_frame, 0,
+        *input_filter->impl(), *tf_buffer.lock(), target_frame, 0,
         context.node_base()->get_node_logging_interface(),
         context.node_base()->get_node_clock_interface(), lookup_timeout);
 
@@ -1341,16 +1342,18 @@ struct TransformSynchronizerImpl {
   }
 
   void on_message(typename Message::SharedPtr message) {
-    const auto timestamp = rclcpp_to_chrono(rclcpp::Time(message->header.stamp));
-    auto maybe_transform =
-        this->tf_listener->get_from_buffer(target_frame, message->header.frame_id, timestamp);
-    if (maybe_transform.has_value())
-      static_cast<Derived *>(this)->put_value(std::make_tuple(message, maybe_transform.value()));
-    else  /// Invariant trap since I don't own the tf2_ros code and therefore can't prove it is
-          /// correct:
+    try {
+      // Note that this call does not wait, the transform must already have arrived.
+      auto transform = tf_buffer.lock()->lookupTransform(target_frame, message->header.frame_id,
+                                                         rclcpp::Time(message->header.stamp));
+      static_cast<Derived *>(this)->put_value(std::make_tuple(message, transform));
+    } catch (const tf2::TransformException &e) {
+      /// Invariant trap since I don't own the tf2_ros code and therefore can't prove it is
+      /// correct:
       throw std::logic_error(
           "Invariant broke: tf2_ros::MessageFilter broke the promise that the transform is "
           "available");
+    }
   }
 };
 
diff --git a/icey/src/icey_async_await.cpp b/icey/src/icey_async_await.cpp
index 466f2f3..cfeb36b 100644
--- a/icey/src/icey_async_await.cpp
+++ b/icey/src/icey_async_await.cpp
@@ -22,13 +22,6 @@ struct TransformBufferImpl {
   using OnTransform = std::function<void(const TransformMsg &)>;
   using OnError = std::function<void(const tf2::TransformException &)>;
   using GetFrame = std::function<std::string()>;
-
-  /// We make this class non-copyable since it captures the this-pointer in clojures.
-  TransformBufferImpl(const TransformBufferImpl &) = delete;
-  TransformBufferImpl(TransformBufferImpl &&) = delete;
-  TransformBufferImpl &operator=(const TransformBufferImpl &) = delete;
-  TransformBufferImpl &operator=(TransformBufferImpl &&) = delete;
-
   /// A transform request stores a request for looking up a transform between two coordinate
   /// systems. Either (1) at a particular time with a timeout, or (2) as a subscription. When
   /// "subscribing" to a transform, we yield a transform each time it changes.
@@ -56,8 +49,15 @@ struct TransformBufferImpl {
   /// A request for a transform lookup: It represents effectively a single call to the async_lookup
   /// function. Even if you call async_lookup with the exact same arguments (same frames and time),
   /// this will count as two separate requests.
+  /// TODO do not use the address, ABA problem !
   using RequestHandle = std::shared_ptr<TransformRequest>;
 
+  /// We make this class non-copyable since it captures the this-pointer in clojures.
+  TransformBufferImpl(const TransformBufferImpl &) = delete;
+  TransformBufferImpl(TransformBufferImpl &&) = delete;
+  TransformBufferImpl &operator=(const TransformBufferImpl &) = delete;
+  TransformBufferImpl &operator=(TransformBufferImpl &&) = delete;
+
   explicit TransformBufferImpl(std::weak_ptr<NodeBase> node) : node_(node) { init(); }
 
   /// @brief Subscribe to a single transform between two coordinate systems. Every time this
@@ -68,8 +68,9 @@ struct TransformBufferImpl {
   void add_subscription(const GetFrame &target_frame, const GetFrame &source_frame,
                         const OnTransform &on_transform, const OnError &on_error) {
     std::lock_guard<std::recursive_mutex> lock{mutex_};
-    requests_.emplace(
-        std::make_shared<TransformRequest>(target_frame, source_frame, on_transform, on_error));
+    auto req =
+        std::make_shared<TransformRequest>(target_frame, source_frame, on_transform, on_error);
+    requests_.emplace(uint64_t(req.get()), req);
   }
 
   /// @brief Queries the TF buffer for a transform at the given time between the given frames. It
@@ -105,8 +106,8 @@ struct TransformBufferImpl {
   /// `cancel_request` if you want to cancel the request.
   /// @warning Currently the timeout is measured with wall-time, i.e. does not consider sim-time due
   /// to the limitation of ROS 2 Humble only offering wall-timers
-  RequestHandle lookup(const std::string &target_frame, const std::string &source_frame, Time time,
-                       const Duration &timeout, OnTransform on_transform, OnError on_error) {
+  uint64_t lookup(const std::string &target_frame, const std::string &source_frame, Time time,
+                  const Duration &timeout, OnTransform on_transform, OnError on_error) {
     auto request{std::make_shared<TransformRequest>([target_frame]() { return target_frame; },
                                                     [source_frame]() { return source_frame; },
                                                     on_transform, on_error, time)};
@@ -115,7 +116,7 @@ struct TransformBufferImpl {
 #if ICEY_ASYNC_AWAIT_THREAD_SAFE
     std::lock_guard<std::recursive_mutex> lock{mutex_};
 #endif
-    requests_.emplace(request);
+    requests_.emplace(uint64_t(request.get()), request);
     node_.lock()->add_task_for(
         uint64_t(request.get()), timeout, [this, on_error, request = weak_request]() {
           if (auto req = request.lock()) {
@@ -126,11 +127,11 @@ struct TransformBufferImpl {
             }
             std::lock_guard<std::recursive_mutex> lock{mutex_};
 #endif
-            requests_.erase(req);  // Destroy the request
+            requests_.erase(uint64_t(req.get()));  // Destroy the request
             on_error(tf2::TimeoutException{"Timed out waiting for transform"});
           }
         });
-    return request;
+    return uint64_t(request.get());
   }
 
   /// @brief Does an asynchronous lookup for a single transform that can be awaited using `co_await`
@@ -169,7 +170,7 @@ struct TransformBufferImpl {
   /// If the given request does not exist, this function does nothing.
   bool cancel_request(uint64_t request_id) {
     std::lock_guard<std::recursive_mutex> lock{mutex_};
-    requests_.erase(request);
+    requests_.erase(request_id);
     return node_.lock()->cancel_task_for(request_id);
   }
 
@@ -280,17 +281,17 @@ struct TransformBufferImpl {
   void notify_if_any_relevant_transform_was_received() {
 /// Iterate all requests, notify and maybe erase them if they are requests for a specific time
 #if ICEY_ASYNC_AWAIT_THREAD_SAFE
-    std::vector<RequestHandle> requests_to_delete;
-    std::vector<RequestHandle> requests;
+    std::vector<uint64_t> requests_to_delete;
+    std::unordered_map<uint64_t, RequestHandle> requests_copy;
+    /// TODO do something more clever than copying the entire hashtable under a lock
     {
       std::lock_guard<std::recursive_mutex> lock{mutex_};
-      requests.reserve(requests_.size());
-      for (const auto &req : requests_) requests.push_back(req);
+      requests_copy = requests_;
     }
-    for (auto req : requests) {
+    for (auto [req_id, req] : requests_copy) {
       if (req->maybe_time) {
         if (maybe_notify_specific_time(req)) {
-          requests_to_delete.push_back(req);
+          requests_to_delete.push_back(req_id);
         }
       } else {
         // If it is a regular subscription, is is persistend and never erased
@@ -324,7 +325,7 @@ struct TransformBufferImpl {
   rclcpp::Subscription<tf2_msgs::msg::TFMessage>::SharedPtr message_subscription_tf_static_;
 
   std::recursive_mutex mutex_;
-  std::unordered_set<RequestHandle> requests_;
+  std::unordered_map<uint64_t, RequestHandle> requests_;
 };
 
 TransformBuffer &TransformBuffer::init(std::weak_ptr<NodeBase> node_base) {
@@ -334,4 +335,32 @@ TransformBuffer &TransformBuffer::init(std::weak_ptr<NodeBase> node_base) {
   return *this;
 }
 
+uint64_t TransformBuffer::lookup(const std::string &target_frame, const std::string &source_frame,
+                                 Time time, const Duration &timeout, OnTransform on_transform,
+                                 OnError on_error) {
+  return impl_->lookup(target_frame, source_frame, time, timeout, on_transform, on_error);
+}
+
+bool TransformBuffer::cancel_request(uint64_t request_id) {
+  return impl_->cancel_request(request_id);
+}
+
+void TransformBuffer::add_subscription(const GetFrame &target_frame, const GetFrame &source_frame,
+                                       const OnTransform &on_transform, const OnError &on_error) {
+  impl_->add_subscription(target_frame, source_frame, on_transform, on_error);
+}
+
+impl::Promise<geometry_msgs::msg::TransformStamped, std::string> TransformBuffer::lookup(
+    const std::string &target_frame, const std::string &source_frame, const Time &time,
+    const Duration &timeout) {
+  return impl_->lookup(target_frame, source_frame, time, timeout);
+}
+
+impl::Promise<geometry_msgs::msg::TransformStamped, std::string> TransformBuffer::lookup(
+    const std::string &target_frame, const std::string &source_frame, const rclcpp::Time &time,
+    const Duration &timeout) {
+  return impl_->lookup(target_frame, source_frame, time, timeout);
+}
+
+std::shared_ptr<tf2_ros::Buffer> TransformBuffer::get_buffer() const { return impl_->buffer_; }
 }  // namespace icey
\ No newline at end of file

From 1e8c64a696747978841bf401d54a82846f6f1302 Mon Sep 17 00:00:00 2001
From: Ivo Ivanov <ivo.ivanov@tha.de>
Date: Fri, 27 Feb 2026 20:58:09 +0100
Subject: [PATCH 40/40] Unused headers, added copyright notice

---
 icey/include/icey/icey_async_await.hpp |  2 --
 icey/src/icey_async_await.cpp          | 11 ++++++++++-
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/icey/include/icey/icey_async_await.hpp b/icey/include/icey/icey_async_await.hpp
index c54c959..93915b0 100644
--- a/icey/include/icey/icey_async_await.hpp
+++ b/icey/include/icey/icey_async_await.hpp
@@ -25,8 +25,6 @@
 #include "rclcpp_lifecycle/lifecycle_node.hpp"
 #include "tf2_msgs/msg/tf_message.hpp"
 #include "tf2_ros/buffer.hpp"
-#include "tf2_ros/create_timer_ros.hpp"
-#include "tf2_ros/qos.hpp"
 
 namespace icey {
 
diff --git a/icey/src/icey_async_await.cpp b/icey/src/icey_async_await.cpp
index cfeb36b..6ee7974 100644
--- a/icey/src/icey_async_await.cpp
+++ b/icey/src/icey_async_await.cpp
@@ -1,5 +1,14 @@
+/// Copyright © 2025 Technische Hochschule Augsburg
+/// Copyright 2018 Open Source Robotics Foundation, Inc.
+/// All rights reserved.
+/// Author: Ivo Ivanov
+/// This software is licensed under the Apache License, Version 2.0.
+
 #include <icey/icey_async_await.hpp>
 
+#include "tf2_ros/create_timer_ros.hpp"
+#include "tf2_ros/qos.hpp"
+
 namespace icey {
 
 /// A subscription + buffer for transforms that allows for asynchronous lookups and to subscribe on
@@ -146,7 +155,7 @@ struct TransformBufferImpl {
       const Duration &timeout) {
     return impl::Promise<geometry_msgs::msg::TransformStamped, std::string>(
         [this, target_frame, source_frame, time, timeout](auto &promise) {
-          auto request_handle = this->lookup(
+          (void)this->lookup(
               target_frame, source_frame, time, timeout,
               [&promise](const geometry_msgs::msg::TransformStamped &tf) { promise.resolve(tf); },
               [&promise](const tf2::TransformException &ex) { promise.reject(ex.what()); });