From 6cd64d2bb7fe0ee536d008a3be94d2ea72f45ca6 Mon Sep 17 00:00:00 2001
From: BartolomeyKant <notevill@gmail.com>
Date: Mon, 16 Mar 2026 15:31:39 +0500
Subject: [PATCH 1/8] make ToAeContext const

---
 aether/ae_context.h | 8 ++++++--
 aether/aether.cpp   | 4 ++--
 aether/aether.h     | 2 +-
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/aether/ae_context.h b/aether/ae_context.h
index d42f91f4..b4b55cee 100644
--- a/aether/ae_context.h
+++ b/aether/ae_context.h
@@ -34,19 +34,21 @@ struct AeCtxTable {
 };
 
 struct AeCtx {
+  bool operator<=>(AeCtx const&) const = default;
+
   void* obj;
   AeCtxTable const* vtable;
 };
 
 template <typename T>
-concept AeContextual = requires(T& t) {
+concept AeContextual = requires(T const& t) {
   { t.ToAeContext() } -> std::same_as<AeCtx>;
 };
 
 class AeContext {
  public:
   template <AeContextual T>
-  constexpr AeContext(T& obj)  // NOLINT(*explicit-constructor)
+  constexpr AeContext(T const& obj)  // NOLINT(*explicit-constructor)
       : ctx_{obj.ToAeContext()} {}
 
   Aether& aether() const { return ctx_.vtable->aether_getter(ctx_.obj); }
@@ -54,6 +56,8 @@ class AeContext {
     return ctx_.vtable->scheduler_getter(ctx_.obj);
   }
 
+  bool operator<=>(AeContext const&) const = default;
+
  private:
   AeCtx ctx_;
 };
diff --git a/aether/aether.cpp b/aether/aether.cpp
index 14e112c8..d1a549e4 100644
--- a/aether/aether.cpp
+++ b/aether/aether.cpp
@@ -54,14 +54,14 @@ Aether::operator ActionContext() const {
   return ActionContext{*action_processor};
 }
 
-AeCtx Aether::ToAeContext() {
+AeCtx Aether::ToAeContext() const {
   static constexpr AeCtxTable ae_table{
       [](void* obj) -> Aether& { return *static_cast<Aether*>(obj); },
       [](void* obj) -> TaskScheduler& {
         return *static_cast<Aether*>(obj)->task_scheduler;
       },
   };
-  return AeCtx{this, &ae_table};
+  return AeCtx{const_cast<Aether*>(this), &ae_table};  // NOLINT(*const-cast)
 }
 
 Client::ptr Aether::CreateClient(ClientConfig const& config,
diff --git a/aether/aether.h b/aether/aether.h
index 4226ffbb..abe93f1e 100644
--- a/aether/aether.h
+++ b/aether/aether.h
@@ -85,7 +85,7 @@ class Aether : public Obj {
 
   // User-facing API.
   operator ActionContext() const;
-  AeCtx ToAeContext();
+  AeCtx ToAeContext() const;
 
   ObjPtr<Client> CreateClient(ClientConfig const& config,
                               std::string const& client_id);

From 57eb89ab35e44b612322e9b5004f0e1d36e7f73c Mon Sep 17 00:00:00 2001
From: BartolomeyKant <notevill@gmail.com>
Date: Mon, 16 Mar 2026 15:32:02 +0500
Subject: [PATCH 2/8] TEMPORARY add call to task scheduler and action processor
 together

---
 aether/aether.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/aether/aether.cpp b/aether/aether.cpp
index d1a549e4..dd9dba9e 100644
--- a/aether/aether.cpp
+++ b/aether/aether.cpp
@@ -47,7 +47,9 @@ Aether::Aether(ObjProp prop)
 Aether::~Aether() { AE_TELE_DEBUG(AetherDestroyed); }
 
 void Aether::Update(TimePoint current_time) {
-  update_time = action_processor->Update(current_time);
+  task_scheduler->Update(current_time);
+  action_processor->Update(current_time);
+  update_time = current_time + 100ms;
 }
 
 Aether::operator ActionContext() const {

From 9d3019e2f808b59b5ce3b0adb721a47ee337e13a Mon Sep 17 00:00:00 2001
From: BartolomeyKant <notevill@gmail.com>
Date: Mon, 16 Mar 2026 15:32:39 +0500
Subject: [PATCH 3/8] add TypeLisToTemplate_t

---
 aether/meta/type_list.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/aether/meta/type_list.h b/aether/meta/type_list.h
index 82d4dd11..c4e212ef 100644
--- a/aether/meta/type_list.h
+++ b/aether/meta/type_list.h
@@ -117,6 +117,9 @@ struct TypeListToTemplate<T, TypeList<Ts...>> {
   using type = T<Ts...>;
 };
 
+template <template <typename...> typename T, typename TList>
+using TypeListToTemplate_t = typename TypeListToTemplate<T, TList>::type;
+
 /**
  * \brief Revers type list
  */

From 586942e3c784f3bd7f95703a280726404bfff077 Mon Sep 17 00:00:00 2001
From: BartolomeyKant <notevill@gmail.com>
Date: Thu, 19 Mar 2026 17:07:17 +0500
Subject: [PATCH 4/8] add iterator type

---
 aether/types/iterator.h | 163 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 163 insertions(+)
 create mode 100644 aether/types/iterator.h

diff --git a/aether/types/iterator.h b/aether/types/iterator.h
new file mode 100644
index 00000000..b8661a41
--- /dev/null
+++ b/aether/types/iterator.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AETHER_TYPES_ITERATOR_H_
+#define AETHER_TYPES_ITERATOR_H_
+
+#include <iterator>
+#include <concepts>
+#include <optional>
+
+namespace ae {
+namespace iterator_internal {
+template <typename T>
+  requires(std::is_integral_v<T>)
+class Range {
+ public:
+  using value_type = T;
+
+  Range(T start, T end, T step = 1) noexcept
+      : start_{start}, end_{end}, step_{step}, reverse_{start_ > end_} {}
+
+  std::optional<T> Next() noexcept {
+    if (!reverse_ && (start_ <= end_)) {
+      auto val = start_;
+      start_ += step_;
+      return val;
+    }
+    if (reverse_ && (start_ >= end_)) {
+      auto val = start_;
+      start_ -= step_;
+      return val;
+    }
+    return std::nullopt;
+  }
+
+ private:
+  T start_;
+  T const end_;
+  T const step_;
+  bool reverse_;
+};
+
+template <typename T>
+  requires(requires { typename std::iterator_traits<T>::value_type; })
+class Iter {
+ public:
+  using value_type = typename std::iterator_traits<T>::value_type;
+  using deref_type = decltype(*std::declval<T&>());
+
+  template <typename U>
+  struct Opt {
+    explicit constexpr Opt(U* ref) noexcept : ref_{ref} {}
+
+    explicit constexpr operator bool() const noexcept { return has_value(); }
+    constexpr bool has_value() const noexcept { return ref_ != nullptr; }
+    constexpr decltype(auto) value() const noexcept {
+      assert(ref_ != nullptr && "Deref null value");
+      return *ref_;
+    }
+    constexpr decltype(auto) operator*() const noexcept { return *ref_; }
+
+   private:
+    U* ref_{};
+  };
+
+  constexpr Iter(T&& begin, T&& end) noexcept
+      : begin_{std::move(begin)}, end_{std::move(end)} {}
+
+  constexpr auto Next() noexcept {
+    using val = std::remove_pointer_t<decltype(&*begin_)>;
+    if (begin_ != end_) {
+      return Opt<val>{&*begin_++};
+    }
+    return Opt<val>{nullptr};
+  }
+
+ private:
+  T begin_;
+  T const end_;
+};
+
+};  // namespace iterator_internal
+
+template <typename T>
+concept IsIter = requires(T t) {
+  typename T::value_type;
+  // check if next return something bool like
+  { !!t.Next() } -> std::same_as<bool>;
+  { *t.Next() } -> std::convertible_to<typename T::value_type>;
+};
+
+using iterator_internal::Iter;
+using iterator_internal::Range;
+}  // namespace ae
+
+#if AE_TESTS
+#  include "tests/inline.h"
+
+#  include <string>
+
+namespace tests::iterator_h {
+using namespace ae;  // NOLINT
+
+AE_TEST_INLINE(test_IsIterConcept) {
+  std::string hello = "Hello World!";
+  auto str_iter = Iter{hello.begin(), hello.end()};
+  static_assert(IsIter<decltype(str_iter)>);
+
+  auto range_iter = Range{0, 10};
+  static_assert(IsIter<decltype(range_iter)>);
+  TEST_PASS();
+}
+
+AE_TEST_INLINE(test_StrIter) {
+  std::string const hello = "Hello!";
+  auto str_iter = Iter{hello.begin(), hello.end()};
+
+  TEST_ASSERT_EQUAL('H', *str_iter.Next());
+  TEST_ASSERT_EQUAL('e', *str_iter.Next());
+  TEST_ASSERT_EQUAL('l', *str_iter.Next());
+  TEST_ASSERT_EQUAL('l', *str_iter.Next());
+  TEST_ASSERT_EQUAL('o', *str_iter.Next());
+  TEST_ASSERT_EQUAL('!', *str_iter.Next());
+  TEST_ASSERT_EQUAL(false, str_iter.Next().has_value());
+
+  auto str_empty_iter = Iter{hello.end(), hello.end()};
+  TEST_ASSERT_EQUAL(false, str_empty_iter.Next().has_value());
+}
+
+AE_TEST_INLINE(test_RangeIter) {
+  auto range_iter = Range{0, 5, 2};
+
+  TEST_ASSERT_EQUAL(0, *range_iter.Next());
+  TEST_ASSERT_EQUAL(2, *range_iter.Next());
+  TEST_ASSERT_EQUAL(4, *range_iter.Next());
+  TEST_ASSERT_EQUAL(false, !!range_iter.Next());
+
+  auto reverse_range = Range{5, 0};
+  TEST_ASSERT_EQUAL(5, *reverse_range.Next());
+  TEST_ASSERT_EQUAL(4, *reverse_range.Next());
+  TEST_ASSERT_EQUAL(3, *reverse_range.Next());
+  TEST_ASSERT_EQUAL(2, *reverse_range.Next());
+  TEST_ASSERT_EQUAL(1, *reverse_range.Next());
+  TEST_ASSERT_EQUAL(0, *reverse_range.Next());
+  TEST_ASSERT_EQUAL(false, !!reverse_range.Next());
+}
+}  // namespace tests::iterator_h
+#endif
+
+#endif  // AETHER_TYPES_ITERATOR_H_

From cf0a04f5271b1ce8cc3e12c368d3bafeeea20a73 Mon Sep 17 00:00:00 2001
From: BartolomeyKant <notevill@gmail.com>
Date: Mon, 16 Mar 2026 15:31:19 +0500
Subject: [PATCH 5/8] add executors

---
 .gitmodules                                   |   4 +
 aether/CMakeLists.txt                         |  14 +-
 aether/all.h                                  |   1 +
 aether/executors/any_sender.h                 |  38 +++
 aether/executors/async_wait.h                 | 206 ++++++++++++++
 aether/executors/executors.h                  |  40 +++
 aether/executors/for_range.h                  | 252 ++++++++++++++++++
 aether/executors/make_sender.h                |  71 +++++
 aether/executors/scheduler_on_tasks.h         |  74 +++++
 aether/misc/defer.h                           |   4 +-
 aether/serial_ports/esp32_serial_port.cpp     |   2 +-
 aether/serial_ports/unix_serial_port.cpp      |   2 +-
 aether/serial_ports/win_serial_port.cpp       |   2 +-
 .../sockets/lwip_cb_tcp_socket.cpp            |  10 +-
 .../sockets/lwip_cb_udp_socket.cpp            |  12 +-
 .../sockets/lwip_tcp_socket.cpp               |   6 +-
 .../sockets/lwip_udp_socket.cpp               |   4 +-
 .../sockets/unix_tcp_socket.cpp               |   6 +-
 .../sockets/unix_udp_socket.cpp               |   4 +-
 .../system_sockets/sockets/win_socket.cpp     |   2 +-
 .../system_sockets/sockets/win_tcp_socket.cpp |   6 +-
 .../system_sockets/sockets/win_udp_socket.cpp |   4 +-
 aether/warning_disable.h                      |   1 -
 third_party/stdexec                           |   1 +
 24 files changed, 729 insertions(+), 37 deletions(-)
 create mode 100644 aether/executors/any_sender.h
 create mode 100644 aether/executors/async_wait.h
 create mode 100644 aether/executors/executors.h
 create mode 100644 aether/executors/for_range.h
 create mode 100644 aether/executors/make_sender.h
 create mode 100644 aether/executors/scheduler_on_tasks.h
 create mode 160000 third_party/stdexec

diff --git a/.gitmodules b/.gitmodules
index 27a1e12a..f6acfd3f 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -60,3 +60,7 @@
 	path = third_party/gcem
 	url = https://github.com/aethernetio/gcem.git
 	branch = master
+[submodule "third_party/stdexec"]
+	path = third_party/stdexec
+	url = https://github.com/aethernetio/stdexec.git
+	branch = main
diff --git a/aether/CMakeLists.txt b/aether/CMakeLists.txt
index 4b0549cb..5d44f4d3 100644
--- a/aether/CMakeLists.txt
+++ b/aether/CMakeLists.txt
@@ -41,7 +41,9 @@ list(APPEND common_dependencies
     "../third_party/gcem"
     "../third_party/etl"
     "../third_party/aethernet-numeric"
+    "../third_party/stdexec"
 )
+set(STDEXEC_BUILD_EXAMPLES Off)
 
 # for etl
 set(GIT_DIR_LOOKUP_POLICY ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR)
@@ -359,7 +361,8 @@ if(REGULAR_CMAKE_PROJECT)
                                         sodium
                                         hydrogen
                                         gcem
-                                        etl)
+                                        etl
+                                        stdexec)
   target_link_libraries(${PROJECT_NAME} PRIVATE c-ares )
 
   set(TARGET_NAME "${PROJECT_NAME}")
@@ -416,7 +419,8 @@ else()
                                          sodium
                                          hydrogen
                                          gcem
-                                         etl)
+                                         etl
+                                         stdexec)
   else()
     #ERROR
     message(SEND_ERROR "You must specify the CMAKE version!")
@@ -538,10 +542,12 @@ elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
         PRIVATE
             /W4
             /WX
+            /w15262 #implisitfallthrough
             /wd4388 #Wno-sign-compare
             /wd4389 #Wno-sign-compare
-            /wd4244
-            /w15262 #implisitfallthrough
+        PUBLIC
+            /wd4100 /wd4101 /wd4127 /wd4244 /wd4324
+            /wd4456 /wd4459 /wd4714
             )
   target_compile_options(${TARGET_NAME} PUBLIC /Zc:preprocessor)
 endif()
diff --git a/aether/all.h b/aether/all.h
index c29f2b6f..b0867ee5 100644
--- a/aether/all.h
+++ b/aether/all.h
@@ -24,6 +24,7 @@
 #include "aether/ae_context.h"
 #include "aether/aether_app.h"
 
+#include "aether/executors/executors.h"
 #include "aether/actions/action.h"
 #include "aether/actions/action_ptr.h"
 #include "aether/actions/action_context.h"
diff --git a/aether/executors/any_sender.h b/aether/executors/any_sender.h
new file mode 100644
index 00000000..2bab3f26
--- /dev/null
+++ b/aether/executors/any_sender.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef AETHER_EXECUTORS_ANY_SENDER_H_
+#define AETHER_EXECUTORS_ANY_SENDER_H_
+
+#include <exception>
+
+#include "third_party/stdexec/include/exec/any_sender_of.hpp"
+
+namespace ae::ex {
+// provide the list of signatures in form
+// set_value_t(type...), set_error_t(type)
+// !Note set_error_t must take one type, while set_value_t may not have any
+template <typename... Signs>
+using AnySender = typename experimental::execution::any_receiver_ref<
+    stdexec::completion_signatures<Signs...,
+                                   // add std::exception_ptr by default, because
+                                   // it's to easy to add it while building
+                                   // senders chain
+                                   stdexec::set_error_t(std::exception_ptr)>
+    // ~['_']~
+    >::template any_sender<>;
+}  // namespace ae::ex
+
+#endif  // AETHER_EXECUTORS_ANY_SENDER_H_
diff --git a/aether/executors/async_wait.h b/aether/executors/async_wait.h
new file mode 100644
index 00000000..79237941
--- /dev/null
+++ b/aether/executors/async_wait.h
@@ -0,0 +1,206 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AETHER_EXECUTORS_ASYNC_WAIT_H_
+#define AETHER_EXECUTORS_ASYNC_WAIT_H_
+
+#include <cstdlib>
+
+#include <tuple>
+#include <variant>
+#include <optional>
+#include <functional>
+#include <type_traits>
+
+#include "aether/types/result.h"
+#include "aether/meta/type_list.h"
+#include "aether/executors/scheduler_on_tasks.h"
+
+#include "third_party/stdexec/include/stdexec/execution.hpp"
+
+namespace ae::ex {
+
+namespace async_wait_internal {
+template <template <typename> typename Filter, typename T>
+struct FilterList;
+
+template <template <typename> typename Filter, typename T, typename... Ts>
+struct FilterList<Filter, TypeList<T, Ts...>> {
+  using type = JoinedTypeList_t<
+      std::conditional_t<!Filter<T>::value, TypeList<T>, TypeList<>>,
+      typename FilterList<Filter, TypeList<Ts...>>::type>;
+};
+
+template <template <typename> typename Filter>
+struct FilterList<Filter, TypeList<>> {
+  using type = TypeList<>;
+};
+
+template <stdexec::sender Sender, typename Env>
+struct SenderTraits {
+  static constexpr auto cs = stdexec::get_completion_signatures<Sender, Env>();
+  using ValueList =
+      stdexec::__value_types_t<decltype(cs), stdexec::__q<TypeList>,
+                               stdexec::__q<stdexec::__msingle>>;
+  using ErrorList =
+      stdexec::__error_types_t<decltype(cs), stdexec::__q<TypeList>,
+                               stdexec::__q<stdexec::__msingle>>;
+
+  static_assert((TypeListSize_v<ValueList> > 0),
+                "Value list must not be empty");
+
+  using ValueType =
+      std::conditional_t<(TypeListSize_v<ValueList> > 1),
+                         TypeListToTemplate_t<std::tuple, ValueList>,
+                         TypeAt_t<0, ValueList>>;
+
+  template <typename T>
+  struct FilterExceptionPtr {
+    static constexpr bool value =
+        std::is_same_v<std::decay_t<T>, std::exception_ptr>;
+  };
+
+  using FilteredErrorList =
+      typename FilterList<FilterExceptionPtr, ErrorList>::type;
+
+  using ErrorType =
+      std::conditional_t<(TypeListSize_v<FilteredErrorList> > 1),
+                         TypeListToTemplate_t<std::variant, FilteredErrorList>,
+                         TypeAt_t<0, FilteredErrorList>>;
+};
+
+class WaiterBase {
+ public:
+  constexpr explicit WaiterBase(AeContext const& context) noexcept
+      : context_{context} {}
+
+  [[nodiscard]] constexpr auto get_scheduler() const noexcept {
+    return SchedulerOnTasks{context_};
+  }
+
+ private:
+  AeContext context_;
+};
+
+struct Env {
+ public:
+  [[nodiscard]]
+  constexpr auto query(stdexec::get_scheduler_t) const noexcept {
+    return waiter->get_scheduler();
+  }
+
+  [[nodiscard]]
+  constexpr auto query(stdexec::get_delegation_scheduler_t) const noexcept {
+    return waiter->get_scheduler();
+  }
+
+  [[nodiscard]]
+  constexpr auto query(stdexec::__root_t) const noexcept -> bool {
+    return true;
+  }
+
+  WaiterBase* waiter;
+};
+
+template <typename State>
+class Receiver {
+ public:
+  using receiver_concept = stdexec::receiver_t;
+  using value_type = typename State::value_type;
+  using error_type = typename State::error_type;
+
+  constexpr explicit Receiver(State& state) : state_{&state} {}
+
+  template <typename... U>
+  constexpr void set_value(U&&... u) && noexcept {
+    static_assert(std::is_constructible_v<value_type, U...>,
+                  "Must be constractible from argument list");
+    state_->wait_result.emplace(value_type{std::forward<U>(u)...});
+    state_->Finish();
+  }
+
+  template <typename E>
+  constexpr void set_error(E&& e) && noexcept {
+    if constexpr (std::is_same_v<std::decay_t<E>, std::exception_ptr>) {
+      // exceptions does not supported
+      std::abort();
+    } else {
+      static_assert(std::is_constructible_v<error_type, std::decay_t<E>>,
+                    "Error type mismatch");
+      state_->wait_result.emplace(error_type{std::forward<E>(e)});
+      state_->Finish();
+    }
+  }
+
+  constexpr void set_stopped() && noexcept { state_->Finish(); }
+
+  constexpr auto get_env() & noexcept { return state_->env; }
+
+ private:
+  State* state_;
+};
+
+template <typename ValueType, typename ErrorType, typename Cb>
+struct State {
+  using value_type = ValueType;
+  using error_type = ErrorType;
+
+  void Finish() { std::invoke(cb, std::move(wait_result)); }
+
+  std::optional<Result<ValueType, ErrorType>> wait_result;
+  Cb cb;
+  Env env;
+};
+
+}  // namespace async_wait_internal
+
+template <stdexec::sender Sender, typename Callback>
+class AsyncWaiter : async_wait_internal::WaiterBase {
+  using SenderTraits =
+      async_wait_internal::SenderTraits<Sender, async_wait_internal::Env>;
+  using State =
+      async_wait_internal::State<typename SenderTraits::ValueType,
+                                 typename SenderTraits::ErrorType, Callback>;
+  using WaitResultType = decltype(std::declval<State>().wait_result);
+  using Receiver = async_wait_internal::Receiver<State>;
+  using Operation = stdexec::connect_result_t<Sender, Receiver>;
+
+  static_assert(std::is_invocable_v<Callback, WaitResultType&&>,
+                "Callback must be invocable with result");
+
+ public:
+  explicit constexpr AsyncWaiter(AeContext const& context, Sender&& sender,
+                                 Callback&& cb)
+      : async_wait_internal::WaiterBase{context},
+        state_{.wait_result = {}, .cb = std::move(cb), .env = {this}},
+        op_{stdexec::connect(std::move(sender), Receiver{state_})} {
+    stdexec::start(op_);
+  }
+
+ private:
+  State state_;
+  Operation op_;
+};
+
+template <stdexec::sender Sender, typename Callback>
+auto MakeAsyncWaiter(AeContext const& context, Sender&& sender,
+                     Callback&& callback) {
+  return AsyncWaiter<std::decay_t<Sender>, std::decay_t<Callback>>{
+      context, std::forward<Sender>(sender), std::forward<Callback>(callback)};
+}
+}  // namespace ae::ex
+
+#endif  // AETHER_EXECUTORS_ASYNC_WAIT_H_
diff --git a/aether/executors/executors.h b/aether/executors/executors.h
new file mode 100644
index 00000000..c18759c2
--- /dev/null
+++ b/aether/executors/executors.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AETHER_EXECUTORS_EXECUTORS_H_
+#define AETHER_EXECUTORS_EXECUTORS_H_
+
+#include "aether/warning_disable.h"
+
+// IWYU pragma: begin_exports
+DISABLE_WARNING_PUSH()
+IGNORE_IMPLICIT_CONVERSION()
+#include "third_party/stdexec/include/stdexec/execution.hpp"
+DISABLE_WARNING_POP()
+
+#include "aether/executors/for_range.h"
+#include "aether/executors/any_sender.h"
+#include "aether/executors/make_sender.h"
+#include "aether/executors/async_wait.h"
+#include "aether/executors/scheduler_on_tasks.h"
+// IWYU pragma: end_exports
+
+namespace ae::ex {
+using namespace STDEXEC;                  // NOLINT(*using-namespace)
+using namespace experimental::execution;  // NOLINT(*using-namespace)
+}  // namespace ae::ex
+
+#endif  // AETHER_EXECUTORS_EXECUTORS_H_
diff --git a/aether/executors/for_range.h b/aether/executors/for_range.h
new file mode 100644
index 00000000..882dfc6e
--- /dev/null
+++ b/aether/executors/for_range.h
@@ -0,0 +1,252 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AETHER_EXECUTORS_FOR_RANGE_H_
+#define AETHER_EXECUTORS_FOR_RANGE_H_
+
+#include <utility>
+#include <optional>
+#include <type_traits>
+
+#include "third_party/stdexec/include/stdexec/execution.hpp"
+
+#include "aether/types/iterator.h"
+
+namespace ae::ex {
+namespace for_range_internal {
+struct ContinueT {};
+
+template <typename T>
+struct IsContinue : std::false_type {};
+template <>
+struct IsContinue<ContinueT> : std::true_type {};
+template <typename T>
+static constexpr inline bool IsContinue_v = IsContinue<T>::value;
+
+template <typename Receiver>
+struct OperationBase {
+  explicit constexpr OperationBase(Receiver&& r) noexcept
+      : recv{std::move(r)} {}
+
+  virtual constexpr void Repeat() noexcept {}
+
+  Receiver recv;
+
+ protected:
+  ~OperationBase() noexcept = default;
+};
+
+template <typename R>
+struct Receiver {
+  using receiver_concept = stdexec::receiver_t;
+
+  template <typename U>
+  constexpr void set_value(U&& val) && noexcept {
+    using value_type = std::decay_t<U>;
+    if constexpr (IsContinue_v<value_type>) {
+      operation->Repeat();
+    } else {
+      stdexec::set_value(std::move(operation->recv), std::forward<U>(val));
+    }
+  }
+
+  template <typename E>
+  constexpr void set_error(E&& e) && noexcept {
+    using value_type = std::decay_t<E>;
+    if constexpr (IsContinue_v<value_type>) {
+      operation->Repeat();
+    } else {
+      stdexec::set_error(std::move(operation->recv), std::forward<E>(e));
+    }
+  }
+
+  constexpr void set_stopped() && noexcept {
+    stdexec::set_stopped(std::move(operation->recv));
+  }
+
+  [[nodiscard]]
+  constexpr auto get_env() const& noexcept {
+    return stdexec::get_env(operation->recv);
+  }
+
+  OperationBase<R>* operation;
+};
+
+template <typename R, typename Iter, typename Fn>
+class Operation final : public OperationBase<R> {
+ public:
+  using value_type = typename Iter::value_type;
+  using sender_type = std::decay_t<std::invoke_result_t<Fn, value_type>>;
+  using op_type = stdexec::connect_result_t<sender_type, Receiver<R>>;
+
+  constexpr Operation(R&& recv, Iter&& iter, Fn&& fn) noexcept
+      : OperationBase<R>{std::move(recv)},
+        iter_{std::move(iter)},
+        fn_{std::move(fn)} {}
+
+  constexpr void start() & noexcept { Repeat(); }
+
+  constexpr void Repeat() noexcept override {
+    op_.reset();
+    if (auto v = iter_.Next(); !!v) {
+      op_.__emplace_from(stdexec::connect, std::invoke(fn_, *v),
+                         Receiver<R>{.operation = this});
+      stdexec::start(*op_);
+    } else {
+      // just finish with empty value
+      stdexec::set_stopped(std::move(OperationBase<R>::recv));
+    }
+  }
+
+ private:
+  Iter iter_;
+  Fn fn_;
+  stdexec::__optional<op_type> op_;
+};
+
+/**
+ * \brief Run a for range loop on begin,end and invoke fn with it's elements.
+ * fn should return the sender which then connected and invoked.
+ * sender should return it's value with Finish and Continue wrappers
+ */
+template <IsIter Iter, typename Fn>
+class ForRangeSender {
+ public:
+  using sender_concept = stdexec::sender_t;
+
+  using value_type = typename Iter::value_type;
+  using sender_type = std::invoke_result_t<Fn, value_type>;
+
+  constexpr ForRangeSender(Iter&& iter, Fn&& fn) noexcept
+      : iter_{std::move(iter)}, fn_{std::move(fn)} {}
+
+  template <typename R>
+  constexpr auto connect(R&& recv) && noexcept {
+    return Operation{std::forward<R>(recv), std::move(iter_), std::move(fn_)};
+  }
+
+  template <typename Sender, typename... Env>
+  static constexpr auto get_completion_signatures() noexcept {
+    using sender_completions =
+        decltype(stdexec::get_completion_signatures<sender_type, Env...>());
+
+    return stdexec::__transform_completion_signatures(
+        sender_completions{}, transform_values, transform_errors,
+        stdexec::__keep_completion<stdexec::set_stopped_t>{},
+        stdexec::completion_signatures<stdexec::set_stopped_t()>{});
+  }
+
+ private:
+  static constexpr auto transform_values = []<typename... Args>() {
+    auto convert = []<typename Arg>() {
+      if constexpr (IsContinue_v<Arg>) {
+        return stdexec::completion_signatures<>{};
+      } else {
+        return stdexec::completion_signatures<stdexec::set_value_t(Arg)>{};
+      }
+    };
+
+    return stdexec::__concat_completion_signatures(
+        convert.template operator()<Args>()...);
+  };
+
+  static constexpr auto transform_errors = []<typename... Args>() {
+    auto convert = []<typename Arg>() {
+      if constexpr (IsContinue_v<Arg>) {
+        return stdexec::completion_signatures<>{};
+      } else {
+        return stdexec::completion_signatures<stdexec::set_error_t(Arg)>{};
+      }
+    };
+
+    return stdexec::__concat_completion_signatures(
+        convert.template operator()<Args>()...);
+  };
+
+  Iter iter_;
+  Fn fn_;
+};
+
+struct MakeForRangeSender {
+  template <IsIter Iter, typename Fn>
+    requires(std::invocable<Fn, typename Iter::value_type>)
+  constexpr auto operator()(Iter&& iter, Fn&& fn) const noexcept {
+    return ForRangeSender{std::forward<Iter>(iter), std::forward<Fn>(fn)};
+  }
+};
+
+}  // namespace for_range_internal
+
+static constexpr inline auto for_continue = for_range_internal::ContinueT{};
+
+static constexpr inline auto for_range =
+    for_range_internal::MakeForRangeSender{};
+
+}  // namespace ae::ex
+
+#if AE_TESTS
+#  include "tests/inline.h"
+
+#  include <array>
+
+#  include "aether/executors/make_sender.h"
+
+namespace tests::for_range_h {
+namespace ex {
+using namespace stdexec;  // NOLINT
+using namespace ae::ex;   // NOLINT
+}  // namespace ex
+AE_TEST_INLINE(test_ForRangeSender) {
+  int counter = 0;
+  auto for_range = ex::for_range(ae::Range{0, 4}, [&](int i) noexcept {
+    return ex::just(i) | ex::let_value([&](int v) noexcept {
+             counter++;
+             return ex::make_sender<
+                 ex::set_value_t(int),
+                 ex::set_error_t(decltype(ex::for_continue))>([v](auto&& r) {
+               if (v >= 3) {
+                 ex::set_value(std::forward<decltype(r)>(r), v);
+               } else {
+                 ex::set_error(std::forward<decltype(r)>(r), ex::for_continue);
+               }
+             });
+           });
+  });
+
+  auto v = ex::sync_wait(std::move(for_range));
+
+  TEST_ASSERT_TRUE(v.has_value());
+  TEST_ASSERT_EQUAL(3, std::get<0>(v.value()));
+  TEST_ASSERT_EQUAL(4, counter);
+}
+
+AE_TEST_INLINE(test_ReturnFirstValueX2) {
+  std::array values = {12, 42, 33, 14};
+  auto for_range = ex::for_range(
+      ae::Iter{values.begin(), values.end()}, [](auto const& i) noexcept {
+        return ex::just(i) |
+               ex::then([](auto const& i) noexcept { return i * 2; });
+      });
+  auto v = ex::sync_wait(std::move(for_range));
+  TEST_ASSERT_TRUE(v.has_value());
+  TEST_ASSERT_EQUAL(24, std::get<0>(v.value()));
+}
+
+}  // namespace tests::for_range_h
+
+#endif
+
+#endif  // AETHER_EXECUTORS_FOR_RANGE_H_
diff --git a/aether/executors/make_sender.h b/aether/executors/make_sender.h
new file mode 100644
index 00000000..43724d7b
--- /dev/null
+++ b/aether/executors/make_sender.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AETHER_EXECUTORS_MAKE_SENDER_H_
+#define AETHER_EXECUTORS_MAKE_SENDER_H_
+
+#include <functional>
+
+#include "third_party/stdexec/include/stdexec/execution.hpp"
+
+namespace ae::ex {
+namespace make_sender_internal {
+template <typename Func, typename... Sigs>
+class GenSender {
+ public:
+  template <typename R>
+  struct Operation {
+    void start() & noexcept { std::invoke(f_, std::move(r_)); }
+    R r_;
+    Func f_;
+  };
+
+  using sender_concept = stdexec::sender_t;
+
+  template <typename...>
+  static consteval auto get_completion_signatures() noexcept
+      -> stdexec::completion_signatures<Sigs...> {
+    return {};
+  }
+
+  explicit constexpr GenSender(Func&& f) noexcept : f_{std::move(f)} {}
+
+  template <stdexec::receiver R>
+    requires(std::invocable<Func, R &&>)
+  constexpr auto connect(R&& r) && noexcept {
+    return Operation{.r_ = std::forward<R>(r), .f_ = std::move(f_)};
+  }
+
+ private:
+  Func f_;
+};
+
+template <typename... Sigs>
+struct MakeSender {
+  template <typename F>
+  constexpr auto operator()(F&& f) const noexcept {
+    return GenSender<std::decay_t<F>, Sigs...>{std::forward<F>(f)};
+  };
+};
+}  // namespace make_sender_internal
+
+template <typename... Sigs>
+static constexpr inline auto make_sender =
+    make_sender_internal::MakeSender<Sigs...>{};
+
+}  // namespace ae::ex
+
+#endif  // AETHER_EXECUTORS_MAKE_SENDER_H_
diff --git a/aether/executors/scheduler_on_tasks.h b/aether/executors/scheduler_on_tasks.h
new file mode 100644
index 00000000..97a1234a
--- /dev/null
+++ b/aether/executors/scheduler_on_tasks.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AETHER_EXECUTORS_SCHEDULER_ON_TASKS_H_
+#define AETHER_EXECUTORS_SCHEDULER_ON_TASKS_H_
+
+#include "third_party/stdexec/include/stdexec/execution.hpp"
+
+#include "aether/ae_context.h"
+
+namespace ae::ex {
+namespace scheduler_on_tasks_internal {
+
+template <typename R>
+struct Operation {
+  void start() noexcept {
+    // just run new task and set value to receiver there
+    ae_context.scheduler().Task([&]() { stdexec::set_value(std::move(recv)); });
+  }
+
+  R recv;
+  AeContext ae_context;
+};
+
+struct Sender {
+  using sender_concept = stdexec::sender_t;
+
+  template <typename Self>
+  static consteval auto get_completion_signatures() noexcept {
+    return stdexec::completion_signatures<stdexec::set_value_t()>{};
+  }
+
+  template <typename R>
+  constexpr auto connect(R&& recv) && noexcept {
+    return Operation<R>{.recv = std::forward<R>(recv),
+                        .ae_context = std::move(ae_context)};
+  }
+
+  AeContext ae_context;
+};
+}  // namespace scheduler_on_tasks_internal
+
+class SchedulerOnTasks {
+ public:
+  using scheduler_concept = stdexec::scheduler_t;
+
+  constexpr explicit SchedulerOnTasks(AeContext const& context) noexcept
+      : ae_context_{context} {}
+
+  constexpr auto schedule() const noexcept {
+    return scheduler_on_tasks_internal::Sender{.ae_context = ae_context_};
+  }
+
+  bool operator==(SchedulerOnTasks const&) const = default;
+
+ private:
+  AeContext ae_context_;
+};
+}  // namespace ae::ex
+
+#endif  // AETHER_EXECUTORS_SCHEDULER_ON_TASKS_H_
diff --git a/aether/misc/defer.h b/aether/misc/defer.h
index 0856bce8..c94abf62 100644
--- a/aether/misc/defer.h
+++ b/aether/misc/defer.h
@@ -63,7 +63,7 @@ constexpr auto operator<<(MakeScopeExit, TCallable&& cb) {
 }
 }  // namespace ae
 
-#define defer_at MakeScopeExit{} <<
-#define defer auto AE_UNIQUE_NAME(SCOPE_GUARD) = defer_at
+#define ae_defer_at MakeScopeExit{} <<
+#define ae_defer auto AE_UNIQUE_NAME(SCOPE_GUARD) = ae_defer_at
 
 #endif  // AETHER_MISC_DEFER_H_
diff --git a/aether/serial_ports/esp32_serial_port.cpp b/aether/serial_ports/esp32_serial_port.cpp
index d73d5fe2..58ea8a9a 100644
--- a/aether/serial_ports/esp32_serial_port.cpp
+++ b/aether/serial_ports/esp32_serial_port.cpp
@@ -136,7 +136,7 @@ uart_port_t Esp32SerialPort::OpenPort(SerialInit const& serial_init) {
     return UART_NUM_MAX;
   }
 
-  auto close_on_exit = defer_at[&] { uart_driver_delete(uart_num); };
+  auto close_on_exit = ae_defer_at[&] { uart_driver_delete(uart_num); };
 
   if (!SetOptions(uart_num, serial_init)) {
     return UART_NUM_MAX;
diff --git a/aether/serial_ports/unix_serial_port.cpp b/aether/serial_ports/unix_serial_port.cpp
index bbde358f..90979fae 100644
--- a/aether/serial_ports/unix_serial_port.cpp
+++ b/aether/serial_ports/unix_serial_port.cpp
@@ -116,7 +116,7 @@ int UnixSerialPort::OpenPort(SerialInit const& serial_init) {
                    strerror(errno));
     return kInvalidPort;
   }
-  auto close_on_exit = defer_at[&] { close(fd); };
+  auto close_on_exit = ae_defer_at[&] { close(fd); };
 
   if (!SetOptions(fd, serial_init)) {
     return kInvalidPort;
diff --git a/aether/serial_ports/win_serial_port.cpp b/aether/serial_ports/win_serial_port.cpp
index 63693429..076aec87 100644
--- a/aether/serial_ports/win_serial_port.cpp
+++ b/aether/serial_ports/win_serial_port.cpp
@@ -204,7 +204,7 @@ void* WinSerialPort::OpenPort(SerialInit const& serial_init) {
 
   SetCommMask(fd, EV_RXCHAR);
 
-  auto close_on_exit = defer_at[&] { CloseHandle(fd); };
+  auto close_on_exit = ae_defer_at[&] { CloseHandle(fd); };
 
   if (!SetOptions(fd, serial_init)) {
     return INVALID_HANDLE_VALUE;
diff --git a/aether/transport/system_sockets/sockets/lwip_cb_tcp_socket.cpp b/aether/transport/system_sockets/sockets/lwip_cb_tcp_socket.cpp
index ab817097..4efd19db 100644
--- a/aether/transport/system_sockets/sockets/lwip_cb_tcp_socket.cpp
+++ b/aether/transport/system_sockets/sockets/lwip_cb_tcp_socket.cpp
@@ -47,7 +47,7 @@ std::optional<std::size_t> LwipCBTcpSocket::Send(Span<std::uint8_t> data) {
   assert((pcb_ != nullptr) && "Not connected to the server");
 
   LOCK_TCPIP_CORE();
-  defer[&] { UNLOCK_TCPIP_CORE(); };
+  ae_defer[&] { UNLOCK_TCPIP_CORE(); };
 
   err_t err = tcp_write(pcb_, data.data(), static_cast<u16_t>(data.size()),
                         TCP_WRITE_FLAG_COPY);
@@ -89,10 +89,10 @@ ISocket& LwipCBTcpSocket::Connect(AddressPort const& destination,
   connected_cb_ = std::move(connected_cb);
   connection_state_ = ConnectionState::kConnecting;
 
-  defer[&] { OnConnectionEvent(); };
+  ae_defer[&] { OnConnectionEvent(); };
 
   LOCK_TCPIP_CORE();
-  defer[] { UNLOCK_TCPIP_CORE(); };
+  ae_defer[] { UNLOCK_TCPIP_CORE(); };
 
   pcb_ = tcp_new();
   if (pcb_ == nullptr) {
@@ -101,7 +101,7 @@ ISocket& LwipCBTcpSocket::Connect(AddressPort const& destination,
     return *this;
   }
 
-  auto on_failed = defer_at[&] {
+  auto on_failed = ae_defer_at[&] {
     tcp_close(pcb_);
     pcb_ = nullptr;
   };
@@ -148,7 +148,7 @@ err_t LwipCBTcpSocket::TcpClientRecv(void* arg, struct tcp_pcb* tpcb,
                                      struct pbuf* p, err_t err) {
   auto* self = static_cast<LwipCBTcpSocket*>(arg);
 
-  defer[&] {
+  ae_defer[&] {
     if (p != nullptr) {
       pbuf_free(p);
     }
diff --git a/aether/transport/system_sockets/sockets/lwip_cb_udp_socket.cpp b/aether/transport/system_sockets/sockets/lwip_cb_udp_socket.cpp
index 2ed2fb31..aa1d42bf 100644
--- a/aether/transport/system_sockets/sockets/lwip_cb_udp_socket.cpp
+++ b/aether/transport/system_sockets/sockets/lwip_cb_udp_socket.cpp
@@ -50,9 +50,9 @@ std::optional<std::size_t> LwipCBUdpSocket::Send(Span<std::uint8_t> data) {
   assert(pcb_ != nullptr && "Not connected to the server");
 
   LOCK_TCPIP_CORE();
-  defer[] { UNLOCK_TCPIP_CORE(); };
+  ae_defer[] { UNLOCK_TCPIP_CORE(); };
 
-  defer[&] {
+  ae_defer[&] {
     if (p != nullptr) {
       pbuf_free(p);
     }
@@ -95,10 +95,10 @@ ISocket& LwipCBUdpSocket::Connect(AddressPort const& destination,
                                   ConnectedCb connected_cb) {
   err_t err;
   auto connection_state = ConnectionState::kConnecting;
-  defer[&] { connected_cb(connection_state); };
+  ae_defer[&] { connected_cb(connection_state); };
 
   LOCK_TCPIP_CORE();
-  defer[] { UNLOCK_TCPIP_CORE(); };
+  ae_defer[] { UNLOCK_TCPIP_CORE(); };
 
   pcb_ = udp_new();
   if (pcb_ == nullptr) {
@@ -106,7 +106,7 @@ ISocket& LwipCBUdpSocket::Connect(AddressPort const& destination,
     connection_state = ConnectionState::kConnectionFailed;
     return *this;
   }
-  auto on_failed = defer_at[&] {
+  auto on_failed = ae_defer_at[&] {
     udp_remove(pcb_);
     pcb_ = nullptr;
   };
@@ -146,7 +146,7 @@ void LwipCBUdpSocket::UdpClientRecv(void* arg, struct udp_pcb* upcb,
                                     u16_t port) {
   auto* self = static_cast<LwipCBUdpSocket*>(arg);
 
-  defer[&] {
+  ae_defer[&] {
     if (p != nullptr) {
       pbuf_free(p);
     }
diff --git a/aether/transport/system_sockets/sockets/lwip_tcp_socket.cpp b/aether/transport/system_sockets/sockets/lwip_tcp_socket.cpp
index 193b2971..0d73004a 100644
--- a/aether/transport/system_sockets/sockets/lwip_tcp_socket.cpp
+++ b/aether/transport/system_sockets/sockets/lwip_tcp_socket.cpp
@@ -91,7 +91,7 @@ int LwipTcpSocket::MakeSocket() {
   }
 
   // close the socket if not created
-  defer[&] {
+  ae_defer[&] {
     if (!created) {
       close(sock);
     }
@@ -122,7 +122,7 @@ ISocket& LwipTcpSocket::Connect(AddressPort const& destination,
   assert((socket_ != kInvalidSocket) && "Socket is not initialized");
   connected_cb_ = std::move(connected_cb);
 
-  defer[&]() {
+  ae_defer[&]() {
     // wait for all events to detect connection
     poller_->Event(socket_,
                    EventType::kRead | EventType::kWrite | EventType::kError,
@@ -160,7 +160,7 @@ void LwipTcpSocket::OnPollerEvent(EventType event) {
 }
 
 void LwipTcpSocket::OnConnectionEvent() {
-  defer[&]() {
+  ae_defer[&]() {
     if (connected_cb_) {
       AE_TELED_DEBUG("LwIp TCP socket connectioin event {}", connection_state_);
       connected_cb_(connection_state_);
diff --git a/aether/transport/system_sockets/sockets/lwip_udp_socket.cpp b/aether/transport/system_sockets/sockets/lwip_udp_socket.cpp
index b3ea004c..b82e0ef6 100644
--- a/aether/transport/system_sockets/sockets/lwip_udp_socket.cpp
+++ b/aether/transport/system_sockets/sockets/lwip_udp_socket.cpp
@@ -42,7 +42,7 @@ int LwipUdpSocket::MakeSocket() {
   }
 
   // close the socket if not created
-  defer[&] {
+  ae_defer[&] {
     if (!created) {
       close(sock);
     }
@@ -65,7 +65,7 @@ ISocket& LwipUdpSocket::Connect(AddressPort const& destination,
   // UDP connection means binding socket to a destination address
   assert((socket_ != kInvalidSocket) && "Socket is not initialized");
 
-  defer[&]() {
+  ae_defer[&]() {
     Poll();
     AE_TELED_DEBUG("LwIp UDP socket connectioin event {}", connection_state_);
     connected_cb(connection_state_);
diff --git a/aether/transport/system_sockets/sockets/unix_tcp_socket.cpp b/aether/transport/system_sockets/sockets/unix_tcp_socket.cpp
index 8599c4a7..716b5efe 100644
--- a/aether/transport/system_sockets/sockets/unix_tcp_socket.cpp
+++ b/aether/transport/system_sockets/sockets/unix_tcp_socket.cpp
@@ -90,7 +90,7 @@ int UnixTcpSocket::MakeSocket() {
   }
 
   // close the socket if it fails to setup
-  defer[&] {
+  ae_defer[&] {
     if (!created) {
       close(sock);
     }
@@ -114,7 +114,7 @@ ISocket& UnixTcpSocket::Connect(AddressPort const& destination,
   assert((socket_ != kInvalidSocket) && "Socket is not initialized");
   connected_cb_ = std::move(connected_cb);
 
-  defer[&]() {
+  ae_defer[&]() {
     // add poll for all events to detect connection
     poller_->Event(socket_,
                    EventType::kRead | EventType::kError | EventType::kWrite,
@@ -150,7 +150,7 @@ void UnixTcpSocket::OnPollerEvent(EventType event) {
 }
 
 void UnixTcpSocket::OnConnectionEvent() {
-  defer[&]() {
+  ae_defer[&]() {
     if (connected_cb_) {
       connected_cb_(connection_state_);
     }
diff --git a/aether/transport/system_sockets/sockets/unix_udp_socket.cpp b/aether/transport/system_sockets/sockets/unix_udp_socket.cpp
index 834b3ce1..e09852df 100644
--- a/aether/transport/system_sockets/sockets/unix_udp_socket.cpp
+++ b/aether/transport/system_sockets/sockets/unix_udp_socket.cpp
@@ -46,7 +46,7 @@ int UnixUdpSocket::MakeSocket() {
   }
 
   // close socket on error
-  defer[&] {
+  ae_defer[&] {
     if (!created) {
       close(sock);
     }
@@ -66,7 +66,7 @@ ISocket& UnixUdpSocket::Connect(AddressPort const& destination,
   // UDP connection means binding socket to a destination address
   assert((socket_ != kInvalidSocket) && "Socket is not initialized");
   ConnectionState connection_state{ConnectionState::kNone};
-  defer[&]() {
+  ae_defer[&]() {
     Poll();
     connected_cb(connection_state);
   };
diff --git a/aether/transport/system_sockets/sockets/win_socket.cpp b/aether/transport/system_sockets/sockets/win_socket.cpp
index eae46f0d..fe77ab49 100644
--- a/aether/transport/system_sockets/sockets/win_socket.cpp
+++ b/aether/transport/system_sockets/sockets/win_socket.cpp
@@ -114,7 +114,7 @@ void WinSocket::PollEvent(LPOVERLAPPED overlapped) {
 }
 
 void WinSocket::OnRead() {
-  defer[&]() {
+  ae_defer[&]() {
     // request new recv after all
     RequestRecv();
   };
diff --git a/aether/transport/system_sockets/sockets/win_tcp_socket.cpp b/aether/transport/system_sockets/sockets/win_tcp_socket.cpp
index 5bce4e58..5f5e7b42 100644
--- a/aether/transport/system_sockets/sockets/win_tcp_socket.cpp
+++ b/aether/transport/system_sockets/sockets/win_tcp_socket.cpp
@@ -57,7 +57,7 @@ WinTcpSocket::WinTcpSocket(IPoller& poller)
     return;
   }
   // close socket on error
-  defer[&] {
+  ae_defer[&] {
     if (!created) {
       ::closesocket(sock);
     }
@@ -91,7 +91,7 @@ ISocket& WinTcpSocket::Connect(AddressPort const& destination,
 
   connected_cb_ = std::move(connected_cb);
 
-  defer[&]() {
+  ae_defer[&]() {
     Poll();
     connected_cb_(connection_state_);
   };
@@ -160,7 +160,7 @@ WinTcpSocket::ConnectionState WinTcpSocket::TestConnectionState() {
 
 void WinTcpSocket::PollEvent(LPOVERLAPPED overlapped) {
   if (connection_state_ == ConnectionState::kConnecting) {
-    defer[&]() {
+    ae_defer[&]() {
       if (connected_cb_) {
         connected_cb_(connection_state_);
       }
diff --git a/aether/transport/system_sockets/sockets/win_udp_socket.cpp b/aether/transport/system_sockets/sockets/win_udp_socket.cpp
index d8882f65..9d5cbb17 100644
--- a/aether/transport/system_sockets/sockets/win_udp_socket.cpp
+++ b/aether/transport/system_sockets/sockets/win_udp_socket.cpp
@@ -37,7 +37,7 @@ WinUdpSocket::WinUdpSocket(IPoller& poller) : WinSocket{poller, 1200} {
     return;
   }
   // close socket on error
-  defer[&] {
+  ae_defer[&] {
     if (!created) {
       ::closesocket(sock);
     }
@@ -63,7 +63,7 @@ ISocket& WinUdpSocket::Connect(AddressPort const& destination,
 
   ConnectionState connection_state{ConnectionState::kNone};
 
-  defer[&]() {
+  ae_defer[&]() {
     Poll();
     connected_cb(connection_state);
   };
diff --git a/aether/warning_disable.h b/aether/warning_disable.h
index 4d7991c5..4d111cf1 100644
--- a/aether/warning_disable.h
+++ b/aether/warning_disable.h
@@ -32,7 +32,6 @@
 #  define IGNORE_WNAN_INFINITY_DISABLED()
 
 #  define IGNORE_DEPRECATED() IGNORE_WARNING(4996)
-
 #endif
 
 #if defined __GNUC__ || defined __clang__
diff --git a/third_party/stdexec b/third_party/stdexec
new file mode 160000
index 00000000..331556e0
--- /dev/null
+++ b/third_party/stdexec
@@ -0,0 +1 @@
+Subproject commit 331556e046e76452fc25dd7e9ff88eb47c55232d

From 20b619980ac1ccd31feb5b681a7de927083b743f Mon Sep 17 00:00:00 2001
From: BartolomeyKant <notevill@gmail.com>
Date: Mon, 16 Mar 2026 15:32:56 +0500
Subject: [PATCH 6/8] add use executors in channel connection

---
 aether/channels/channel.h                     |  10 +-
 aether/channels/ethernet_channel.cpp          | 242 ++++++---------
 aether/channels/ethernet_channel.h            |  10 +-
 aether/channels/wifi_channel.cpp              | 282 +++++++-----------
 aether/channels/wifi_channel.h                |   2 +-
 .../server_connection_manager.cpp             |   6 +-
 .../server_connection_manager.h               |   6 +-
 aether/dns/dns_c_ares.cpp                     | 243 +++++++--------
 aether/dns/dns_c_ares.h                       |   5 +-
 aether/dns/dns_resolve.cpp                    |  34 +--
 aether/dns/dns_resolve.h                      |  27 +-
 aether/dns/esp32_dns_resolve.cpp              | 245 +++++++--------
 aether/dns/esp32_dns_resolve.h                |  14 +-
 aether/registration/registration.cpp          |   2 +-
 .../root_server_select_stream.cpp             |   6 +-
 .../registration/root_server_select_stream.h  |   5 +-
 .../server_connections/channel_connection.cpp |  59 ++--
 .../server_connections/channel_connection.h   |  19 +-
 .../client_server_connection.cpp              |  11 +-
 .../client_server_connection.h                |   7 +-
 .../server_connections/server_connection.cpp  |  12 +-
 aether/server_connections/server_connection.h |   6 +-
 aether/transport/transport_builder_action.h   |  40 ---
 23 files changed, 532 insertions(+), 761 deletions(-)
 delete mode 100644 aether/transport/transport_builder_action.h

diff --git a/aether/channels/channel.h b/aether/channels/channel.h
index ff16c74b..107b23f4 100644
--- a/aether/channels/channel.h
+++ b/aether/channels/channel.h
@@ -17,12 +17,18 @@
 #ifndef AETHER_CHANNELS_CHANNEL_H_
 #define AETHER_CHANNELS_CHANNEL_H_
 
+#include "aether/memory.h"
 #include "aether/obj/obj.h"
+#include "aether/executors/executors.h"
+#include "aether/stream_api/istream.h"
 #include "aether/channels/channels_types.h"
 #include "aether/channels/channel_statistics.h"
-#include "aether/transport/transport_builder_action.h"
 
 namespace ae {
+using TransportBuildSender =
+    ex::AnySender<ex::set_value_t(std::unique_ptr<ByteIStream>),
+                  ex::set_error_t(int)>;
+
 class Channel : public Obj {
   AE_OBJECT(Channel, Obj, 0)
 
@@ -36,7 +42,7 @@ class Channel : public Obj {
   /**
    * \brief Make transport from this channel.
    */
-  virtual ActionPtr<TransportBuilderAction> TransportBuilder() = 0;
+  virtual TransportBuildSender TransportBuilder() = 0;
 
   ChannelTransportProperties const& transport_properties() const;
   ChannelStatistics& channel_statistics();
diff --git a/aether/channels/ethernet_channel.cpp b/aether/channels/ethernet_channel.cpp
index 1ba9f99a..248e1e45 100644
--- a/aether/channels/ethernet_channel.cpp
+++ b/aether/channels/ethernet_channel.cpp
@@ -21,179 +21,108 @@
 
 #include "aether/memory.h"
 #include "aether/actions/action.h"
-#include "aether/types/state_machine.h"
 #include "aether/events/event_subscription.h"
 
 #include "aether/aether.h"
 #include "aether/poller/poller.h"
 #include "aether/dns/dns_resolve.h"
+#include "aether/executors/executors.h"
 
 #include "aether/channels/ethernet_transport_factory.h"
 
-#include "aether/tele/tele.h"
-
 namespace ae {
 namespace ethernet_access_point_internal {
+using ResolveSender =
+    ex::AnySender<ex::set_value_t(std::vector<Endpoint>), ex::set_error_t(int)>;
 
-class EthernetTransportBuilderAction final : public TransportBuilderAction {
- public:
-  enum class State : std::uint8_t {
-    kAddressResolve,
-    kTransportCreate,
-    kWaitTransportConnected,
-    kTransportConnected,
-    kFailed
-  };
-
-  EthernetTransportBuilderAction(ActionContext action_context,
-                                 EthernetChannel& channel, Endpoint address,
-                                 Ptr<DnsResolver> const& dns_resolver,
-                                 Ptr<IPoller> const& poller)
-      : TransportBuilderAction{action_context},
-        action_context_{action_context},
-        ethernet_channel_{&channel},
-        address_{std::move(address)},
-        resolver_{dns_resolver},
-        poller_{poller},
-        state_{State::kAddressResolve},
-        start_time_{Now()} {}
-
-  UpdateStatus Update() override {
-    if (state_.changed()) {
-      switch (state_.Acquire()) {
-        case State::kAddressResolve:
-          ResolveAddress();
-          break;
-        case State::kTransportCreate:
-          CreateTransport();
-          break;
-        case State::kWaitTransportConnected:
-          break;
-        case State::kTransportConnected:
-          return UpdateStatus::Result();
-        case State::kFailed:
-          return UpdateStatus::Error();
-      }
-    }
-    return {};
-  }
-
-  std::unique_ptr<ByteIStream> transport_stream() override {
-    return std::move(transport_stream_);
-  }
-
- private:
-  void ResolveAddress() {
-    std::visit(
-        [this](auto const& addr) {
-          DoResolverAddress(addr, address_.port, address_.protocol);
-        },
-        address_.address);
-  }
-
-  void DoResolverAddress([[maybe_unused]] NamedAddr const& name_address,
-                         [[maybe_unused]] std::uint16_t port,
-                         [[maybe_unused]] Protocol protocol) {
+ResolveSender ResolveAddress(Ptr<DnsResolver> const& resolver,
+                             NamedAddr const& addr, std::uint16_t port,
+                             Protocol protocol) {
 #if AE_SUPPORT_CLOUD_DNS
-    auto dns_resolver = resolver_.Lock();
-    assert(dns_resolver);
-    auto resolve_action = dns_resolver->Resolve(name_address, port, protocol);
-
-    address_resolve_sub_ = resolve_action->StatusEvent().Subscribe(
-        ActionHandler{OnResult{[this](auto& action) {
-                        ip_addresses_ = std::move(action.addresses);
-                        it_ = std::begin(ip_addresses_);
-                        state_ = State::kTransportCreate;
-                        Action::Trigger();
-                      }},
-                      OnError {
-                        [this]() {
-                          state_ = State::kFailed;
-                          Action::Trigger();
-                        }
-                      }});
+  return resolver->Resolve(addr, port, protocol);
 #else
-    AE_TELED_ERROR("Unable to resolve named address");
-    state_ = State::kFailed;
-    Action::Trigger();
+  // named address doesn't supported
+  return ex::just_error(1);
 #endif
-  }
-
-  template <typename TAddr>
-  void DoResolverAddress(TAddr const& ip_address, std::uint16_t port,
-                         Protocol protocol) {
-    ip_addresses_.push_back(Endpoint{{{ip_address}, port}, protocol});
-    it_ = std::begin(ip_addresses_);
-    state_ = State::kTransportCreate;
-    Action::Trigger();
-  }
-
-  void CreateTransport() {
-    state_ = State::kWaitTransportConnected;
+}
 
-    if (it_ == std::end(ip_addresses_)) {
-      state_ = State::kFailed;
-      Action::Trigger();
-      return;
-    }
-    auto poller = poller_.Lock();
-    assert(poller);
-    auto& addr = *(it_++);
-    transport_stream_ =
-        EthernetTransportFactory::Create(action_context_, poller, addr);
-
-    if (!transport_stream_) {
-      // try next address
-      state_ = State::kTransportCreate;
-      Action::Trigger();
-      return;
-    }
+ResolveSender ResolveAddress(Ptr<DnsResolver> const&, auto const& addr,
+                             std::uint16_t port, Protocol protocol) {
+  return ex::just(std::vector<Endpoint>{Endpoint{addr, port, protocol}});
+}
 
-    if (transport_stream_->stream_info().link_state == LinkState::kLinked) {
-      Connected();
-      return;
-    }
+auto CreateTransport(AeContext const& context, PtrView<IPoller> const& poller,
+                     Endpoint const& e) {
+  auto poller_ptr = poller.Lock();
+  assert(poller_ptr);
+  return EthernetTransportFactory::Create(context.aether(), poller_ptr, e);
+}
 
-    transport_stream_sub_ =
-        transport_stream_->stream_update_event().Subscribe([this]() {
-          if (transport_stream_->stream_info().link_state ==
-              LinkState::kLinked) {
-            // transport stream is connected
-            Connected();
-          } else if (transport_stream_->stream_info().link_state ==
-                     LinkState::kLinkError) {
-            // connection failed, try next address
-            state_ = State::kTransportCreate;
-            Action::Trigger();
+ex::sender auto TransportConnect(std::unique_ptr<ByteIStream>&& stream) {
+  return ex::make_sender<ex::set_value_t(std::unique_ptr<ByteIStream>),
+                         ex::set_error_t(int)>(
+      [&, s{std::move(stream)}, link_sub{Subscription{}}](auto&& recv) mutable {
+        // if already linked return stream
+        switch (s->stream_info().link_state) {
+          case LinkState::kLinked: {
+            ex::set_value(std::forward<decltype(recv)>(recv), std::move(s));
+            return;
           }
-        });
-  }
-
-  void Connected() {
-    transport_stream_sub_.Reset();
-    auto built_time = std::chrono::duration_cast<Duration>(Now() - start_time_);
-    AE_TELED_DEBUG("Transport built by {:%S}", built_time);
-    ethernet_channel_->channel_statistics().AddConnectionTime(built_time);
-    state_ = State::kTransportConnected;
-    Action::Trigger();
-  }
+          case LinkState::kLinkError: {
+            ex::set_error(std::forward<decltype(recv)>(recv), 1);
+            return;
+          }
+          default:
+            break;
+        }
+        // wait till linked
+        link_sub = s->stream_update_event().Subscribe(
+            [&, r{std::forward<decltype(recv)>(recv)}]() mutable noexcept {
+              link_sub.Reset();
+              if (s->stream_info().link_state == LinkState::kLinked) {
+                ex::set_value(std::move(r), std::move(s));
+              } else {
+                ex::set_error(std::move(r), 2);
+              }
+            });
+      });
+}
 
-  ActionContext action_context_;
-  EthernetChannel* ethernet_channel_;
-  Endpoint address_;
-  PtrView<DnsResolver> resolver_;
-  PtrView<IPoller> poller_;
-  StateMachine<State> state_;
-  std::vector<Endpoint> ip_addresses_;
-  std::vector<Endpoint>::iterator it_{};
-  std::unique_ptr<ByteIStream> transport_stream_;
-  Subscription address_resolve_sub_;
-  Subscription transport_stream_sub_;
-
-  TimePoint start_time_;
-};
+ex::sender auto MakeTransportBuilder(AeContext ae_context,
+                                     Ptr<DnsResolver> const& dns_resolver,
+                                     Ptr<IPoller> const& poller,
+                                     Endpoint address) noexcept {
+  // resolve named address to ip address
+  return std::visit(
+             [&](auto const& addr) noexcept {
+               return ResolveAddress(dns_resolver, addr, address.port,
+                                     address.protocol);
+             },
+             address.address) |
+         // create transport and wait till it connected
+         ex::let_value([c{ae_context}, p{PtrView<IPoller>{poller}}](
+                           auto const& endpoints) noexcept {
+           return ex::for_range(
+                      Iter{endpoints.begin(), endpoints.end()},
+                      [c, p](auto const& e) noexcept {
+                        return ex::just(e) |
+                               ex::then([&](auto const& e) noexcept {
+                                 return CreateTransport(c, p, e);
+                               }) |
+                               ex::let_value([](auto& s) noexcept {
+                                 return TransportConnect(std::move(s));
+                               }) |
+                               ex::upon_error([](auto&&...) noexcept {
+                                 return ex::for_continue;
+                               });
+                      }) |
+                  ex::let_stopped([]() noexcept { return ex::just_error(1); });
+         });
+}
 }  // namespace ethernet_access_point_internal
 
+EthernetChannel::EthernetChannel() = default;
+
 EthernetChannel::EthernetChannel(ObjProp prop, ObjPtr<Aether> aether,
                                  ObjPtr<DnsResolver> dns_resolver,
                                  ObjPtr<IPoller> poller, Endpoint address)
@@ -227,7 +156,9 @@ EthernetChannel::EthernetChannel(ObjProp prop, ObjPtr<Aether> aether,
   }
 }
 
-ActionPtr<TransportBuilderAction> EthernetChannel::TransportBuilder() {
+EthernetChannel::~EthernetChannel() = default;
+
+TransportBuildSender EthernetChannel::TransportBuilder() {
   auto resolver = dns_resolver_.Load();
 #if AE_SUPPORT_CLOUD_DNS
   assert(resolver && "Resolver is not loaded");
@@ -235,9 +166,8 @@ ActionPtr<TransportBuilderAction> EthernetChannel::TransportBuilder() {
   auto poller = poller_.Load();
   assert(poller && "Poller is not loaded");
 
-  return ActionPtr<
-      ethernet_access_point_internal::EthernetTransportBuilderAction>(
-      *aether_.Load().as<Aether>(), *this, address, resolver, poller);
+  return ethernet_access_point_internal::MakeTransportBuilder(
+      AeContext{*aether_.Load().as<Aether>()}, resolver, poller, address);
 }
 
 }  // namespace ae
diff --git a/aether/channels/ethernet_channel.h b/aether/channels/ethernet_channel.h
index 329e36ba..36e8f6f1 100644
--- a/aether/channels/ethernet_channel.h
+++ b/aether/channels/ethernet_channel.h
@@ -17,6 +17,7 @@
 #ifndef AETHER_CHANNELS_ETHERNET_CHANNEL_H_
 #define AETHER_CHANNELS_ETHERNET_CHANNEL_H_
 
+#include "aether/memory.h"
 #include "aether/types/address.h"
 #include "aether/channels/channel.h"
 
@@ -25,18 +26,23 @@ class Aether;
 class IPoller;
 class DnsResolver;
 
+namespace ethernet_access_point_internal {
+class EthernetChannelTransportBuilder;
+}
+
 class EthernetChannel : public Channel {
   AE_OBJECT(EthernetChannel, Channel, 0)
  public:
-  EthernetChannel() = default;
+  EthernetChannel();
 
   EthernetChannel(ObjProp prop, ObjPtr<Aether> aether,
                   ObjPtr<DnsResolver> dns_resolver, ObjPtr<IPoller> poller,
                   Endpoint address);
+  ~EthernetChannel() override;
 
   AE_OBJECT_REFLECT(AE_MMBRS(aether_, poller_, dns_resolver_, address))
 
-  ActionPtr<TransportBuilderAction> TransportBuilder() override;
+  TransportBuildSender TransportBuilder() override;
 
   Endpoint address;
 
diff --git a/aether/channels/wifi_channel.cpp b/aether/channels/wifi_channel.cpp
index 9ec0cf0e..444208c9 100644
--- a/aether/channels/wifi_channel.cpp
+++ b/aether/channels/wifi_channel.cpp
@@ -23,7 +23,7 @@
 
 #  include "aether/ptr/ptr_view.h"
 #  include "aether/actions/action.h"
-#  include "aether/types/state_machine.h"
+#  include "aether/executors/executors.h"
 #  include "aether/events/event_subscription.h"
 
 #  include "aether/aether.h"
@@ -36,185 +36,116 @@
 
 namespace ae {
 namespace wifi_channel_internal {
-class WifiTransportBuilderAction final : public TransportBuilderAction {
- public:
-  enum class State : std::uint8_t {
-    kWifiConnect,
-    kAddressResolve,
-    kTransportCreate,
-    kWaitTransportConnect,
-    kTransportConnected,
-    kFailed,
-  };
-
-  WifiTransportBuilderAction(ActionContext action_context, WifiChannel& channel,
-                             Ptr<WifiAccessPoint> const& access_point,
-                             Ptr<IPoller> const& poller,
-                             Ptr<DnsResolver> const& resolver, Endpoint address)
-      : TransportBuilderAction{action_context},
-        action_context_{action_context},
-        channel_{&channel},
-        access_point_{access_point},
-        poller_{poller},
-        resolver_{resolver},
-        address_{std::move(address)},
-        state_{State::kWifiConnect} {}
-
-  UpdateStatus Update() override {
-    if (state_.changed()) {
-      switch (state_.Acquire()) {
-        case State::kWifiConnect:
-          WifiConnect();
-          break;
-        case State::kAddressResolve:
-          ResolveAddress();
-          break;
-        case State::kTransportCreate:
-          CreateTransport();
-          break;
-        case State::kWaitTransportConnect:
-          break;
-        case State::kTransportConnected:
-          return UpdateStatus::Result();
-        case State::kFailed:
-          return UpdateStatus::Error();
-      }
-    }
-    return {};
-  }
-
-  std::unique_ptr<ByteIStream> transport_stream() override {
-    return std::move(transport_stream_);
-  }
-
- private:
-  void WifiConnect() {
-    auto access_point = access_point_.Lock();
-    assert(access_point);
-    auto connect_action = access_point->Connect();
-    wifi_connected_sub_ = connect_action->StatusEvent().Subscribe(ActionHandler{
-        OnResult{[this]() {
-          // build transport start after wifi is connected
-          start_time_ = Now();
-          state_ = State::kAddressResolve;
-          Action::Trigger();
-        }},
-        OnError{[this]() {
-          state_ = State::kFailed;
-          Action::Trigger();
-        }},
-    });
-  }
+ex::sender auto WifiConnect(Ptr<WifiAccessPoint> const& access_point) {
+  return ex::make_sender<ex::set_value_t(), ex::set_error_t(int)>(
+      [ap{PtrView<WifiAccessPoint>{access_point}},
+       connect_sub{Subscription{}}](auto&& recv) mutable noexcept {
+        auto access_point = ap.Lock();
+        assert(access_point && "Wifi access point is not loaded");
+        connect_sub = access_point->Connect()->StatusEvent().Subscribe(
+            [r{std::forward<decltype(recv)>(recv)}](
+                ActionEventStatus<WifiConnectAction> aes) mutable noexcept {
+              aes.OnResult([&]() { ex::set_value(std::move(r)); })  // ~['_']~
+                  .OnError([&]() { ex::set_error(std::move(r), 1); });
+            });
+      });
+}
 
-  void ResolveAddress() {
-    std::visit(
-        [this](auto const& addr) {
-          DoResolverAddress(addr, address_.port, address_.protocol);
-        },
-        address_.address);
-  }
+using ResolveSender =
+    ex::AnySender<ex::set_value_t(std::vector<Endpoint>), ex::set_error_t(int)>;
 
-  void DoResolverAddress([[maybe_unused]] NamedAddr const& name_address,
-                         [[maybe_unused]] std::uint16_t port,
-                         [[maybe_unused]] Protocol protocol) {
+ResolveSender ResolveAddress(PtrView<DnsResolver> const& resolver,
+                             NamedAddr const& addr, std::uint16_t port,
+                             Protocol protocol) {
 #  if AE_SUPPORT_CLOUD_DNS
-    auto dns_resolver = resolver_.Lock();
-    assert(dns_resolver);
-    auto resolve_action = dns_resolver->Resolve(name_address, port, protocol);
-
-    address_resolve_sub_ = resolve_action->StatusEvent().Subscribe(
-        ActionHandler{OnResult{[this](auto& action) {
-                        ip_addresses_ = std::move(action.addresses);
-                        it_ = std::begin(ip_addresses_);
-                        state_ = State::kTransportCreate;
-                        Action::Trigger();
-                      }},
-                      OnError {
-                        [this]() {
-                          state_ = State::kFailed;
-                          Action::Trigger();
-                        }
-                      }});
+  auto resolver_ptr = resolver.Lock();
+  assert(resolver_ptr && "Dns resolver is not loaded");
+  return resolver_ptr->Resolve(addr, port, protocol);
 #  else
-    AE_TELED_ERROR("Unable to resolve named address");
-    state_ = State::kFailed;
-    Action::Trigger();
+  // named address doesn't supported
+  return ex::just_error(1);
 #  endif
-  }
-
-  template <typename TAddr>
-  void DoResolverAddress(TAddr const& addr, std::uint16_t port,
-                         Protocol protocol) {
-    ip_addresses_.push_back(Endpoint{{addr, port}, protocol});
-    it_ = std::begin(ip_addresses_);
-    state_ = State::kTransportCreate;
-    Action::Trigger();
-  }
+}
 
-  void CreateTransport() {
-    state_ = State::kWaitTransportConnect;
+ResolveSender ResolveAddress(PtrView<DnsResolver> const&, auto const& addr,
+                             std::uint16_t port, Protocol protocol) {
+  return ex::just(std::vector<Endpoint>{Endpoint{addr, port, protocol}});
+}
 
-    if (it_ == std::end(ip_addresses_)) {
-      state_ = State::kFailed;
-      Action::Trigger();
-      return;
-    }
+auto CreateTransport(AeContext const& context, PtrView<IPoller> const& poller,
+                     Endpoint const& e) {
+  auto poller_ptr = poller.Lock();
+  assert(poller_ptr);
+  return EthernetTransportFactory::Create(context.aether(), poller_ptr, e);
+}
 
-    auto poller = poller_.Lock();
-    assert(poller);
-    auto& addr = *(it_++);
-    transport_stream_ =
-        EthernetTransportFactory::Create(action_context_, poller, addr);
-    if (!transport_stream_) {
-      // try next address
-      state_ = State::kTransportCreate;
-      Action::Trigger();
-      return;
-    }
-    if (transport_stream_->stream_info().link_state == LinkState::kLinked) {
-      Connected();
-      return;
-    }
-    transport_sub_ =
-        transport_stream_->stream_update_event().Subscribe([this]() {
-          if (transport_stream_->stream_info().link_state ==
-              LinkState::kLinked) {
-            // transport connected
-            Connected();
-          } else if (transport_stream_->stream_info().link_state ==
-                     LinkState::kLinkError) {
-            // try next address
-            state_ = State::kTransportCreate;
-            Action::Trigger();
+ex::sender auto TransportConnect(std::unique_ptr<ByteIStream>&& stream) {
+  return ex::make_sender<ex::set_value_t(std::unique_ptr<ByteIStream>),
+                         ex::set_error_t(int)>(
+      [s{std::move(stream)},
+       link_sub{Subscription{}}](auto&& recv) mutable noexcept {
+        // if already linked return stream
+        switch (s->stream_info().link_state) {
+          case LinkState::kLinked: {
+            ex::set_value(std::forward<decltype(recv)>(recv), std::move(s));
+            return;
           }
-        });
-  }
-
-  void Connected() {
-    transport_sub_.Reset();
-    auto built_time = std::chrono::duration_cast<Duration>(Now() - start_time_);
-    AE_TELED_DEBUG("Transport built by {:%S}", built_time);
-    channel_->channel_statistics().AddConnectionTime(built_time);
-    state_ = State::kTransportConnected;
-    Action::Trigger();
-  }
-
-  ActionContext action_context_;
-  WifiChannel* channel_;
-  PtrView<WifiAccessPoint> access_point_;
-  PtrView<IPoller> poller_;
-  PtrView<DnsResolver> resolver_;
-  Endpoint address_;
+          case LinkState::kLinkError: {
+            ex::set_error(std::forward<decltype(recv)>(recv), 1);
+            return;
+          }
+          default:
+            break;
+        }
+        // wait till linked
+        link_sub = s->stream_update_event().Subscribe(
+            [&, r{std::forward<decltype(recv)>(recv)}]() mutable noexcept {
+              link_sub.Reset();
+              if (s->stream_info().link_state == LinkState::kLinked) {
+                ex::set_value(std::move(r), std::move(s));
+              } else {
+                ex::set_error(std::move(r), 2);
+              }
+            });
+      });
+}
 
-  std::vector<Endpoint> ip_addresses_;
-  std::vector<Endpoint>::iterator it_{};
-  std::unique_ptr<ByteIStream> transport_stream_;
-  Subscription wifi_connected_sub_;
-  Subscription address_resolve_sub_;
-  Subscription transport_sub_;
-  StateMachine<State> state_;
-  TimePoint start_time_;
-};
+ex::sender auto MakeTransportBuilder(AeContext ae_context,
+                                     Ptr<DnsResolver> const& dns_resolver,
+                                     Ptr<IPoller> const& poller,
+                                     Ptr<WifiAccessPoint> const& access_point,
+                                     Endpoint address) noexcept {
+  return  // connect to wifi first
+      WifiConnect(access_point)
+      // resolve named address to ip address
+      | ex::let_value([a{std::move(address)},
+                       r{PtrView<DnsResolver>{dns_resolver}}]() noexcept {
+          return std::visit(
+              [&](auto const& addr) noexcept {
+                return ResolveAddress(r, addr, a.port, a.protocol);
+              },
+              a.address);
+        })
+      // create transport and wait till it connected
+      // TODO: add selection for endpoint to connect
+      | ex::let_value([c{ae_context}, p{PtrView<IPoller>{poller}}](
+                          std::vector<Endpoint> const& endpoints) noexcept {
+          return ex::for_range(Iter{endpoints.begin(), endpoints.end()},
+                               [c, p](auto const& e) noexcept {
+                                 return ex::just(e) |
+                                        ex::then([&](auto const& e) noexcept {
+                                          return CreateTransport(c, p, e);
+                                        }) |
+                                        ex::let_value([](auto& s) noexcept {
+                                          return TransportConnect(std::move(s));
+                                        }) |
+                                        ex::upon_error([](auto&&...) noexcept {
+                                          return ex::for_continue;
+                                        });
+                               }) |
+                 ex::let_stopped([]() noexcept { return ex::just_error(1); });
+        });
+}
 }  // namespace wifi_channel_internal
 
 WifiChannel::WifiChannel(ObjProp prop, ObjPtr<Aether> aether,
@@ -262,7 +193,7 @@ Duration WifiChannel::TransportBuildTimeout() const {
          std::chrono::milliseconds{AE_WIFI_CONNECTION_TIMEOUT_MS};
 }
 
-ActionPtr<TransportBuilderAction> WifiChannel::TransportBuilder() {
+TransportBuildSender WifiChannel::TransportBuilder() {
   auto resolver = resolver_.Load();
 #  if AE_SUPPORT_CLOUD_DNS
   assert(resolver && "Resolver is not loaded");
@@ -274,13 +205,8 @@ ActionPtr<TransportBuilderAction> WifiChannel::TransportBuilder() {
   assert(poller && "Poller is not loaded");
   assert(access_point && "Access point is not loaded");
 
-  return ActionPtr<wifi_channel_internal::WifiTransportBuilderAction>{
-      *aether_.Load().as<Aether>(),
-      *this,
-      access_point,
-      poller,
-      resolver,
-      address};
+  return wifi_channel_internal::MakeTransportBuilder(
+      *aether_.Load().as<Aether>(), resolver, poller, access_point, address);
 }
 
 }  // namespace ae
diff --git a/aether/channels/wifi_channel.h b/aether/channels/wifi_channel.h
index 53e1e610..40b57158 100644
--- a/aether/channels/wifi_channel.h
+++ b/aether/channels/wifi_channel.h
@@ -44,7 +44,7 @@ class WifiChannel final : public Channel {
 
   Duration TransportBuildTimeout() const override;
 
-  ActionPtr<TransportBuilderAction> TransportBuilder() override;
+  TransportBuildSender TransportBuilder() override;
 
   Endpoint address;
 
diff --git a/aether/connection_manager/server_connection_manager.cpp b/aether/connection_manager/server_connection_manager.cpp
index cc7ebd86..db1e713d 100644
--- a/aether/connection_manager/server_connection_manager.cpp
+++ b/aether/connection_manager/server_connection_manager.cpp
@@ -30,9 +30,9 @@ ServerConnectionManager::ServerConnectionFactory::CreateConnection(
   return server_connection_manager_->CreateConnection(server);
 }
 
-ServerConnectionManager::ServerConnectionManager(ActionContext action_context,
+ServerConnectionManager::ServerConnectionManager(AeContext const& ae_context,
                                                  Ptr<Client> const& client)
-    : action_context_{action_context}, client_{client} {}
+    : ae_context_{ae_context}, client_{client} {}
 
 std::unique_ptr<IServerConnectionFactory>
 ServerConnectionManager::GetServerConnectionFactory() {
@@ -51,7 +51,7 @@ RcPtr<ClientServerConnection> ServerConnectionManager::CreateConnection(
   assert(client);
 
   auto connection =
-      MakeRcPtr<ClientServerConnection>(action_context_, client, server);
+      MakeRcPtr<ClientServerConnection>(ae_context_, client, server);
 
   // check updates
   server_update_subs_ += connection->stream_update_event().Subscribe(
diff --git a/aether/connection_manager/server_connection_manager.h b/aether/connection_manager/server_connection_manager.h
index 665f0eb7..d4976402 100644
--- a/aether/connection_manager/server_connection_manager.h
+++ b/aether/connection_manager/server_connection_manager.h
@@ -21,8 +21,8 @@
 
 #include "aether/ptr/ptr.h"
 #include "aether/ptr/rc_ptr.h"
+#include "aether/ae_context.h"
 #include "aether/ptr/ptr_view.h"
-#include "aether/actions/action_context.h"
 #include "aether/server_connections/client_server_connection.h"
 #include "aether/server_connections/iserver_connection_factory.h"
 
@@ -43,7 +43,7 @@ class ServerConnectionManager {
   };
 
  public:
-  ServerConnectionManager(ActionContext action_context,
+  ServerConnectionManager(AeContext const& ae_context,
                           Ptr<Client> const& client);
 
   std::unique_ptr<IServerConnectionFactory> GetServerConnectionFactory();
@@ -55,7 +55,7 @@ class ServerConnectionManager {
  private:
   void ServerUpdate(ServerId server_id);
 
-  ActionContext action_context_;
+  AeContext ae_context_;
   PtrView<Client> client_;
   std::map<ServerId, RcPtrView<ClientServerConnection>> cached_connections_;
   MultiSubscription server_update_subs_;
diff --git a/aether/dns/dns_c_ares.cpp b/aether/dns/dns_c_ares.cpp
index 2987f206..6fef2ecc 100644
--- a/aether/dns/dns_c_ares.cpp
+++ b/aether/dns/dns_c_ares.cpp
@@ -27,47 +27,115 @@
 #  include "aether/warning_disable.h"
 
 #  include "aether/aether.h"
+#  include "aether/types/result.h"
 #  include "aether/socket_initializer.h"
-#  include "aether/actions/action_ptr.h"
-#  include "aether/actions/action_context.h"
 #  include "aether/events/multi_subscription.h"
 
+#  include "aether/executors/executors.h"
+
 #  include "aether/dns/dns_tele.h"
 
 namespace ae {
-class AresQueryAction : public Action<AresQueryAction> {
- public:
-  AresQueryAction(ActionContext action_context, NamedAddr name_address,
-                  std::uint16_t port, Protocol protocol)
-      : Action{action_context},
-        name_address_{std::move(name_address)},
-        port_{port},
-        protocol_{protocol} {}
-
-  UpdateStatus Update() {
-    if (is_result_) {
-      return UpdateStatus::Result();
+class AresImpl {
+  struct QueryContext {
+    AresImpl* ares_impl;
+    NamedAddr name_address;
+    std::uint16_t port_hint;
+    Protocol protocol_hint;
+  };
+
+  template <typename R>
+  struct Operation {
+    static void Callback(void* arg, int status, int timeouts,
+                         struct ares_addrinfo* result) {
+      auto* op = static_cast<Operation<R>*>(arg);
+      auto r = AresImpl::ProcessResult(
+          status, timeouts, result, op->ctx.port_hint, op->ctx.protocol_hint);
+      // set either value or error
+      if (r.IsOk()) {
+        ex::set_value(std::move(op->recv), std::move(r.value()));
+      } else {
+        ex::set_error(std::move(op->recv), r.error());
+      }
+    }
+
+    void start() & noexcept {
+      AE_TELE_DEBUG(kAresDnsQueryHost, "Querying host: {}", ctx.name_address);
+
+      ares_addrinfo_hints hints{};
+      // BOTH ipv4 and ipv6
+      hints.ai_family = AF_UNSPEC;
+      hints.ai_flags = ARES_AI_CANONNAME;
+      ares_getaddrinfo(ctx.ares_impl->channel_, ctx.name_address.name.c_str(),
+                       nullptr, &hints, Callback, this);
     }
-    if (is_failed_) {
-      return UpdateStatus::Error();
+
+    R recv;
+    QueryContext ctx;
+  };
+
+  struct Sender {
+    using sender_concept = stdexec::sender_t;
+    using completion_signatures =
+        stdexec::completion_signatures<ex::set_value_t(std::vector<Endpoint>&&),
+                                       ex::set_error_t(int)>;
+
+    template <typename R>
+    auto connect(R&& r) && noexcept {
+      return Operation<R>{.recv = std::forward<R>(r), .ctx = std::move(ctx)};
+    }
+
+    QueryContext ctx;
+  };
+
+ public:
+  AresImpl() {
+    ares_library_init(ARES_LIB_INIT_ALL);
+
+    int optmask = ARES_OPT_EVENT_THREAD;
+    ares_options options{};
+    options.evsys = ARES_EVSYS_DEFAULT;
+
+    /* Initialize channel to run queries, a single channel can accept unlimited
+     * queries */
+    if (auto res = ares_init_options(&channel_, &options, optmask);
+        res != ARES_SUCCESS) {
+      AE_TELE_ERROR(kAresDnsFailedInitialize,
+                    "Failed to initialize ares options: {}",
+                    ares_strerror(res));
+      assert(false);
     }
-    return {};
   }
 
-  void ProcessResult(int status, int /* timeouts */,
-                     struct ares_addrinfo* result) {
+  ~AresImpl() {
+    ares_destroy(channel_);
+    ares_library_cleanup();
+  }
+
+  Sender Query(NamedAddr const& name_address, std::uint16_t port_hint,
+               Protocol protocol_hint) {
+    return Sender{.ctx{.ares_impl = this,
+                       .name_address = name_address,
+                       .port_hint = port_hint,
+                       .protocol_hint = protocol_hint}};
+  }
+
+  static Result<std::vector<Endpoint>, int> ProcessResult(
+      int status, int /* timeouts */, struct ares_addrinfo* result,
+      std::uint16_t port_hint, Protocol protocol_hint) noexcept {
     if (status != ARES_SUCCESS) {
       AE_TELE_ERROR(kAresDnsQueryError, "Ares query error {} {}", status,
                     ares_strerror(status));
-      Failed();
-      return;
+      return Error{1};
     }
-    assert(result);
+    assert(result != nullptr);
+    ae_defer[result]() { ares_freeaddrinfo(result); };
 
+    std::vector<Endpoint> resolved_addresses;
     for (auto* node = result->nodes; node != nullptr; node = node->ai_next) {
-      auto addr_add = [this](auto const& ip) {
-        Endpoint addr{{ip, port_}, protocol_};
-        resolved_addresses_.emplace_back(std::move(addr));
+      auto addr_add = [&](auto const& ip) {
+        Endpoint addr{{ip, port_hint}, protocol_hint};
+        resolved_addresses.emplace_back(std::move(addr));
       };
 
       if (node->ai_family == AF_INET) {
@@ -92,96 +160,11 @@ class AresQueryAction : public Action<AresQueryAction> {
       }
     }
 
-    AE_TELE_DEBUG(kAresDnsQuerySuccess, "Got addresses {}",
-                  resolved_addresses_);
-    Result();
-  }
-
-  std::vector<Endpoint> const& resolved_addresses() const {
-    return resolved_addresses_;
+    AE_TELE_DEBUG(kAresDnsQuerySuccess, "Got addresses {}", resolved_addresses);
+    return Ok{std::move(resolved_addresses)};
   }
 
  private:
-  void Result() {
-    is_result_ = true;
-    Action::Trigger();
-  }
-  void Failed() {
-    is_failed_ = true;
-    Action::Trigger();
-  }
-
-  NamedAddr name_address_;
-  std::uint16_t port_;
-  Protocol protocol_;
-  std::vector<Endpoint> resolved_addresses_;
-  std::atomic_bool is_result_{false};
-  std::atomic_bool is_failed_{false};
-};
-
-class AresImpl {
- public:
-  explicit AresImpl(ActionContext action_context)
-      : action_context_{action_context} {
-    ares_library_init(ARES_LIB_INIT_ALL);
-
-    int optmask = ARES_OPT_EVENT_THREAD;
-    ares_options options{};
-    options.evsys = ARES_EVSYS_DEFAULT;
-
-    /* Initialize channel to run queries, a single channel can accept unlimited
-     * queries */
-    if (auto res = ares_init_options(&channel_, &options, optmask);
-        res != ARES_SUCCESS) {
-      AE_TELE_ERROR(kAresDnsFailedInitialize,
-                    "Failed to initialize ares options: {}",
-                    ares_strerror(res));
-      assert(false);
-    }
-  }
-
-  ~AresImpl() {
-    ares_destroy(channel_);
-    ares_library_cleanup();
-  }
-
-  ActionPtr<ResolveAction> Query(NamedAddr const& name_address,
-                                 std::uint16_t port_hint,
-                                 Protocol protocol_hint) {
-    AE_TELE_DEBUG(kAresDnsQueryHost, "Querying host: {}", name_address);
-
-    auto resolve_action = ActionPtr<ResolveAction>{action_context_};
-    auto query_action = ActionPtr<AresQueryAction>{
-        action_context_, name_address, port_hint, protocol_hint};
-
-    // connect actions
-    multi_subscription_.Push(
-        query_action->StatusEvent().Subscribe(ActionHandler{
-            OnResult{[ra{resolve_action}](auto const& action) mutable {
-              ra->SetAddress(action.resolved_addresses());
-            }},
-            OnError{[ra{resolve_action}]() mutable { ra->Failed(); }},
-        }));
-
-    ares_addrinfo_hints hints{};
-    // BOTH ipv4 and ipv6
-    hints.ai_family = AF_UNSPEC;
-    hints.ai_flags = ARES_AI_CANONNAME;
-
-    ares_getaddrinfo(
-        channel_, name_address.name.c_str(), nullptr, &hints,
-        [](void* arg, auto status, auto timeouts, auto result) {
-          auto& ares_query_action = *static_cast<AresQueryAction*>(arg);
-          ares_query_action.ProcessResult(status, timeouts, result);
-          ares_freeaddrinfo(result);
-        },
-        &*query_action);
-
-    return resolve_action;
-  }
-
- private:
-  ActionContext action_context_;
   ares_channel_t* channel_;
 
   MultiSubscription multi_subscription_;
@@ -197,13 +180,39 @@ DnsResolverCares::DnsResolverCares(ObjProp prop, ObjPtr<Aether> aether)
 
 DnsResolverCares::~DnsResolverCares() = default;
 
-ActionPtr<ResolveAction> DnsResolverCares::Resolve(
-    NamedAddr const& name_address, std::uint16_t port_hint,
-    Protocol protocol_hint) {
+struct minimal_sender {
+  using sender_concept = ex::sender_t;
+
+  // 1. Declare what this sender is capable of returning
+  using completion_signatures = ex::completion_signatures<ex::set_value_t(
+      int)  // We will call set_value with an int
+                                                          >;
+
+  // 2. Define the Operation State (the actual execution logic)
+  template <typename Receiver>
+  struct operation_state {
+    Receiver rcvr;
+
+    // The "Start" method is where the work actually happens
+    void start() noexcept { stdexec::set_value(std::move(rcvr), 1); }
+  };
+
+  // 3. Connect the blueprint (Sender) to a destination (Receiver)
+  template <stdexec::receiver Receiver>
+  auto connect(Receiver rcvr) const {
+    return operation_state<Receiver>{std::move(rcvr)};
+  }
+};
+
+ResolveSender DnsResolverCares::Resolve(NamedAddr const& name_address,
+                                        std::uint16_t port_hint,
+                                        Protocol protocol_hint) {
   if (!ares_impl_) {
-    ares_impl_ = std::make_unique<AresImpl>(*aether_.Load().as<Aether>());
+    ares_impl_ = std::make_unique<AresImpl>();
   }
-  return ares_impl_->Query(name_address, port_hint, protocol_hint);
+
+  return ares_impl_->Query(name_address, port_hint, protocol_hint) |
+         ex::continues_on(ex::SchedulerOnTasks{*aether_.Load().as<Aether>()});
 }
 
 }  // namespace ae
diff --git a/aether/dns/dns_c_ares.h b/aether/dns/dns_c_ares.h
index 491ddcdc..b738bfe2 100644
--- a/aether/dns/dns_c_ares.h
+++ b/aether/dns/dns_c_ares.h
@@ -47,9 +47,8 @@ class DnsResolverCares : public DnsResolver {
 
   AE_OBJECT_REFLECT(AE_MMBR(aether_))
 
-  ActionPtr<ResolveAction> Resolve(NamedAddr const& name_address,
-                                   std::uint16_t port_hint,
-                                   Protocol protocol_hint) override;
+  ResolveSender Resolve(NamedAddr const& name_address, std::uint16_t port_hint,
+                        Protocol protocol_hint) override;
 
  private:
   Obj::ptr aether_;
diff --git a/aether/dns/dns_resolve.cpp b/aether/dns/dns_resolve.cpp
index 85bc2ab0..5f01a3c9 100644
--- a/aether/dns/dns_resolve.cpp
+++ b/aether/dns/dns_resolve.cpp
@@ -19,37 +19,5 @@
 #if AE_SUPPORT_CLOUD_DNS
 #  include <utility>
 
-namespace ae {
-
-UpdateStatus ResolveAction::Update() const {
-  if (is_resolved) {
-    return UpdateStatus::Result();
-  }
-  if (is_failed) {
-    return UpdateStatus::Error();
-  }
-  return {};
-}
-
-void ResolveAction::SetAddress(std::vector<Endpoint> addr) {
-  addresses = std::move(addr);
-  is_resolved = true;
-  this->Trigger();
-}
-
-void ResolveAction::Failed() {
-  is_failed = true;
-  is_resolved = false;
-  this->Trigger();
-}
-
-ActionPtr<ResolveAction> DnsResolver::Resolve(
-    NamedAddr const& /* name_address */, std::uint16_t /* port_hint */,
-    Protocol /* protocol_hint */) {
-  // must be overridden
-  assert(false);
-  return {};
-}
-
-}  // namespace ae
+namespace ae {}  // namespace ae
 #endif
diff --git a/aether/dns/dns_resolve.h b/aether/dns/dns_resolve.h
index 0f9b5e06..98be40b5 100644
--- a/aether/dns/dns_resolve.h
+++ b/aether/dns/dns_resolve.h
@@ -25,25 +25,12 @@
 #if AE_SUPPORT_CLOUD_DNS
 #  include "aether/obj/obj.h"
 #  include "aether/types/address.h"
-#  include "aether/actions/action.h"
-#  include "aether/actions/action_ptr.h"
+#  include "aether/executors/executors.h"
 
 namespace ae {
-// Action to get host name resolve
-class ResolveAction : public Action<ResolveAction> {
- public:
-  using Action::Action;
-
-  UpdateStatus Update() const;
 
-  // Set ip addresses after resolve query finished
-  void SetAddress(std::vector<Endpoint> addr);
-  void Failed();
-
-  bool is_resolved{false};
-  bool is_failed{false};
-  std::vector<Endpoint> addresses;
-};
+using ResolveSender =
+    ex::AnySender<ex::set_value_t(std::vector<Endpoint>), ex::set_error_t(int)>;
 
 /**
  * \brief Base class of DNS resolver
@@ -55,17 +42,15 @@ class DnsResolver : public Obj {
   DnsResolver() = default;
 
  public:
-#  if defined AE_DISTILLATION
   explicit DnsResolver(ObjProp prop) : Obj{prop} {}
-#  endif
   ~DnsResolver() override = default;
 
   AE_OBJECT_REFLECT()
 
   // Make a host name resolve
-  virtual ActionPtr<ResolveAction> Resolve(NamedAddr const& name_address,
-                                           std::uint16_t port_hint,
-                                           Protocol protocol_hint);
+  virtual ResolveSender Resolve(NamedAddr const& name_address,
+                                std::uint16_t port_hint,
+                                Protocol protocol_hint) = 0;
 };
 }  // namespace ae
 #else
diff --git a/aether/dns/esp32_dns_resolve.cpp b/aether/dns/esp32_dns_resolve.cpp
index 11975c31..c6cc388b 100644
--- a/aether/dns/esp32_dns_resolve.cpp
+++ b/aether/dns/esp32_dns_resolve.cpp
@@ -18,178 +18,145 @@
 
 #if defined ESP32_DNS_RESOLVER_ENABLED
 
-#  include <map>
 #  include <cstdint>
 #  include <utility>
 
-#  include "freertos/FreeRTOS.h"
-#  include "freertos/task.h"
-#  include "freertos/event_groups.h"
-#  include "esp_system.h"
-#  include "esp_event.h"
-#  include "nvs_flash.h"
+// #  include "freertos/FreeRTOS.h"
+// #  include "freertos/task.h"
+// #  include "freertos/event_groups.h"
 
 #  include "lwip/err.h"
-#  include "lwip/sys.h"
 #  include "lwip/dns.h"
 #  include "lwip/tcpip.h"
 
 #  include "aether/aether.h"
-#  include "aether/actions/action_ptr.h"
-#  include "aether/actions/action_context.h"
-#  include "aether/events/multi_subscription.h"
+#  include "aether/executors/executors.h"
 
 #  include "aether/dns/dns_tele.h"
 
 namespace ae {
-
-class GetHostByNameQueryAction : public Action<GetHostByNameQueryAction> {
- public:
-  GetHostByNameQueryAction(ActionContext action_context,
-                           NamedAddr const& name_address, std::uint16_t port,
-                           Protocol protocol)
-      : Action{action_context},
-        name_address_{std::move(name_address)},
-        port_{port},
-        protocol_{protocol} {}
-
-  UpdateStatus Update() {
-    if (is_result_) {
-      return UpdateStatus::Result();
-    }
-    if (is_failed_) {
-      return UpdateStatus::Error();
-    }
-    return {};
+Result<std::vector<Endpoint>, int> ProcessQueryResult(ip_addr_t const* ipaddr,
+                                                      std::uint16_t port,
+                                                      Protocol protocol) {
+  if (ipaddr == nullptr) {
+    return Error{1};
   }
 
-  void ProcessQueryResult(ip_addr_t const* ipaddr) {
-    if (!ipaddr) {
-      Failed();
-      return;
-    }
-    auto addr_add = [this](auto const& ip) {
-      Endpoint addr{{ip, port_}, protocol_};
-      resolved_addresses_.emplace_back(std::move(addr));
-    };
+  std::vector<Endpoint> resolved_addresses;
+
+  auto addr_add = [&](auto const& ip) {
+    resolved_addresses.emplace_back(Endpoint{{ip, port}, protocol});
+  };
 
-    if (IP_IS_V4_VAL(*ipaddr)) {
+  if (IP_IS_V4_VAL(*ipaddr)) {
 #  if AE_SUPPORT_IPV4
-      IpV4Addr ipv4{};
-      auto ip4 = ip_2_ip4(ipaddr);
-      std::memcpy(&ipv4.ipv4_value,
-                  reinterpret_cast<std::uint8_t const*>(&ip4->addr),
-                  sizeof(ipv4.ipv4_value));
-      addr_add(ipv4);
+    IpV4Addr ipv4{};
+    auto ip4 = ip_2_ip4(ipaddr);
+    std::memcpy(&ipv4.ipv4_value,
+                reinterpret_cast<std::uint8_t const*>(&ip4->addr),
+                sizeof(ipv4.ipv4_value));
+    addr_add(ipv4);
 #  endif
-    } else if (IP_IS_V6_VAL(*ipaddr)) {
+  } else if (IP_IS_V6_VAL(*ipaddr)) {
 #  if AE_SUPPORT_IPV6
-      IpV6Addr ipv6{};
-      auto ip6 = ip_2_ip6(ipaddr);
-      addr.ip.set_value(reinterpret_cast<std::uint8_t const*>(&ip6->addr));
-      std::memcpy(&ipv6.ipv6_value,
-                  reinterpret_cast<std::uint8_t const*>(&ip6->addr),
-                  sizeof(ipv6.ipv6_value));
-      addr_add(ipv6);
+    IpV6Addr ipv6{};
+    auto ip6 = ip_2_ip6(ipaddr);
+    addr.ip.set_value(reinterpret_cast<std::uint8_t const*>(&ip6->addr));
+    std::memcpy(&ipv6.ipv6_value,
+                reinterpret_cast<std::uint8_t const*>(&ip6->addr),
+                sizeof(ipv6.ipv6_value));
+    addr_add(ipv6);
 #  endif
-    }
-    AE_TELE_DEBUG(kEspDnsQuerySuccess, "Got addresses {}", resolved_addresses_);
-    Result();
-  }
-
-  std::vector<Endpoint> const& resolved_addresses() const {
-    return resolved_addresses_;
   }
+  AE_TELE_DEBUG(kEspDnsQuerySuccess, "Got addresses {}", resolved_addresses);
+  return Ok{std::move(resolved_addresses)};
+}
 
-  void Failed() {
-    is_failed_ = true;
-    Action::Trigger();
-  }
+class GHbyNameResolveSender {
+ public:
+  struct State {
+    NamedAddr name_address;
+    std::uint16_t port_hint;
+    Protocol protocol_hint;
+  };
+
+  template <typename R>
+  struct Operation {
+    void start() noexcept {
+      AE_TELE_DEBUG(kEspDnsQueryHost, "Querying host: {}", state.name_address);
+
+      // make query
+      ip_addr_t cached_addr;
+      LOCK_TCPIP_CORE();
+      auto res = dns_gethostbyname(
+          state.name_address.name.c_str(), &cached_addr,
+          [](const char* /* name */, const ip_addr_t* ipaddr, void* arg) {
+            auto* op = static_cast<Operation<R>*>(arg);
+            auto r = ProcessQueryResult(ipaddr, op->state.port_hint,
+                                        op->state.protocol_hint);
+            if (r.IsOk()) {
+              ex::set_value(std::move(op->recv), std::move(r.value()));
+            } else {
+              ex::set_error(std::move(op->recv), std::move(r.error()));
+            }
+          },
+          this);
+      UNLOCK_TCPIP_CORE();
+
+      if (res == ERR_OK) {
+        // process cached value
+        auto r = ProcessQueryResult(&cached_addr, state.port_hint,
+                                    state.protocol_hint);
+        if (r.IsOk()) {
+          ex::set_value(std::move(recv), std::move(r.value()));
+        } else {
+          ex::set_error(std::move(recv), std::move(r.error()));
+        }
+      } else if (res == ERR_ARG) {
+        AE_TELE_ERROR(kEspDnsQueryError,
+                      "Dns client not initialized or invalid hostname");
+        ex::set_error(std::move(recv), 2);
+      }
+    }
 
- private:
-  void Result() {
-    is_result_ = true;
-    Action::Trigger();
+    R recv;
+    State state;
+  };
+
+  using sender_concept = ex::sender_t;
+
+  constexpr GHbyNameResolveSender(NamedAddr const& name_address,
+                                  std::uint16_t port_hint,
+                                  Protocol protocol_hint) noexcept
+      : state_{
+            .name_address = name_address,
+            .port_hint = port_hint,
+            .protocol_hint = protocol_hint,
+        } {}
+
+  template <typename...>
+  static consteval auto get_completion_signatures() noexcept {
+    return ex::completion_signatures<ex::set_value_t(std::vector<Endpoint>),
+                                     ex::set_error_t(int)>{};
   }
 
-  NamedAddr name_address_;
-  std::uint16_t port_;
-  Protocol protocol_;
-  std::vector<Endpoint> resolved_addresses_;
-  std::atomic_bool is_result_{false};
-  std::atomic_bool is_failed_{false};
-};
-
-class GethostByNameDnsResolver {
- public:
-  explicit GethostByNameDnsResolver(ActionContext action_context)
-      : action_context_{action_context} {}
-
-  ActionPtr<ResolveAction> Query(NamedAddr const& name_address,
-                                 std::uint16_t port_hint,
-                                 Protocol protocol_hint) {
-    AE_TELE_DEBUG(kEspDnsQueryHost, "Querying host: {}", name_address);
-    auto resolve_action = ActionPtr<ResolveAction>{action_context_};
-    auto query_action = ActionPtr<GetHostByNameQueryAction>{
-        action_context_, name_address, port_hint, protocol_hint};
-
-    // connect actions
-    multi_subscription_.Push(
-        query_action->StatusEvent().Subscribe(ActionHandler{
-            OnResult{[ra{resolve_action}](auto const& action) mutable {
-              ra->SetAddress(action.resolved_addresses());
-            }},
-            OnError{
-                [ra{resolve_action}](auto const&) mutable { ra->Failed(); }},
-        }));
-
-    // make query
-    ip_addr_t cached_addr;
-    LOCK_TCPIP_CORE();
-    auto res = dns_gethostbyname(
-        name_address.name.c_str(), &cached_addr,
-        [](const char* /* name */, const ip_addr_t* ipaddr,
-           void* callback_arg) {
-          auto* query_action =
-              static_cast<GetHostByNameQueryAction*>(callback_arg);
-          query_action->ProcessQueryResult(ipaddr);
-        },
-        &*query_action);
-    UNLOCK_TCPIP_CORE();
-
-    if (res == ERR_OK) {
-      query_action->ProcessQueryResult(&cached_addr);
-    } else if (res == ERR_ARG) {
-      AE_TELE_ERROR(kEspDnsQueryError,
-                    "Dns client not initialized or invalid hostname");
-      query_action->Failed();
-    }
-    return resolve_action;
+  template <ex::receiver R>
+  constexpr auto connect(R&& r) && noexcept {
+    return Operation{.recv = std::forward<R>(r), .state = std::move(state_)};
   }
 
  private:
-  ActionContext action_context_;
-  MultiSubscription multi_subscription_;
+  State state_;
 };
 
-Esp32DnsResolver::Esp32DnsResolver() = default;
-
-#  ifdef AE_DISTILLATION
 Esp32DnsResolver::Esp32DnsResolver(ObjProp prop, ObjPtr<Aether> aether)
     : DnsResolver{prop}, aether_{std::move(aether)} {}
-#  endif
 
-Esp32DnsResolver::~Esp32DnsResolver() = default;
-
-ActionPtr<ResolveAction> Esp32DnsResolver::Resolve(
-    NamedAddr const& name_address, std::uint16_t port_hint,
-    Protocol protocol_hint) {
-  if (!gethostbyname_dns_resolver_) {
-    gethostbyname_dns_resolver_ = std::make_unique<GethostByNameDnsResolver>(
-        *aether_.Load().as<Aether>());
-  }
-  return gethostbyname_dns_resolver_->Query(name_address, port_hint,
-                                            protocol_hint);
+ResolveSender Esp32DnsResolver::Resolve(NamedAddr const& name_address,
+                                        std::uint16_t port_hint,
+                                        Protocol protocol_hint) {
+  return GHbyNameResolveSender{name_address, port_hint, protocol_hint} |
+         ex::continues_on(ex::SchedulerOnTasks{*aether_.Load().as<Aether>()});
 }
 
 }  // namespace ae
diff --git a/aether/dns/esp32_dns_resolve.h b/aether/dns/esp32_dns_resolve.h
index fd176f4e..db60c800 100644
--- a/aether/dns/esp32_dns_resolve.h
+++ b/aether/dns/esp32_dns_resolve.h
@@ -24,8 +24,6 @@
 #  if (defined(ESP_PLATFORM))
 #    define ESP32_DNS_RESOLVER_ENABLED 1
 
-#    include <memory>
-
 #    include "aether/obj/obj.h"
 #    include "aether/dns/dns_resolve.h"
 
@@ -36,24 +34,18 @@ class GethostByNameDnsResolver;
 class Esp32DnsResolver : public DnsResolver {
   AE_OBJECT(Esp32DnsResolver, DnsResolver, 0)
 
-  Esp32DnsResolver();
+  Esp32DnsResolver() = default;
 
  public:
-#    ifdef AE_DISTILLATION
   Esp32DnsResolver(ObjProp prop, ObjPtr<Aether> aether);
-#    endif
-
-  ~Esp32DnsResolver() override;
 
   AE_OBJECT_REFLECT(AE_MMBR(aether_))
 
-  ActionPtr<ResolveAction> Resolve(NamedAddr const& name_address,
-                                   std::uint16_t port_hint,
-                                   Protocol protocol_hint) override;
+  ResolveSender Resolve(NamedAddr const& name_address, std::uint16_t port_hint,
+                        Protocol protocol_hint) override;
 
  private:
   Obj::ptr aether_;
-  std::unique_ptr<GethostByNameDnsResolver> gethostbyname_dns_resolver_;
 };
 }  // namespace ae
 
diff --git a/aether/registration/registration.cpp b/aether/registration/registration.cpp
index 9e1081e7..7d9da8f6 100644
--- a/aether/registration/registration.cpp
+++ b/aether/registration/registration.cpp
@@ -47,7 +47,7 @@ Registration::Registration(ActionContext action_context, Aether& aether,
       server_reg_root_api_{protocol_context_, action_context_,
                            *root_crypto_provider_->encryptor(),
                            *global_crypto_provider_->encryptor()},
-      root_server_select_stream_{action_context_, reg_cloud},
+      root_server_select_stream_{aether, reg_cloud},
       state_{State::kInitConnection},
       // TODO: add configuration
       response_timeout_{std::chrono::seconds(20)},
diff --git a/aether/registration/root_server_select_stream.cpp b/aether/registration/root_server_select_stream.cpp
index 2f85cf2e..fec51318 100644
--- a/aether/registration/root_server_select_stream.cpp
+++ b/aether/registration/root_server_select_stream.cpp
@@ -22,8 +22,8 @@
 
 namespace ae {
 RootServerSelectStream::RootServerSelectStream(
-    ActionContext action_context, Ptr<RegistrationCloud> const& cloud)
-    : action_context_{action_context}, cloud_{cloud}, server_index_{} {
+    AeContext const& ae_context, Ptr<RegistrationCloud> const& cloud)
+    : ae_context_{ae_context}, cloud_{cloud}, server_index_{} {
   SelectServer();
 }
 
@@ -75,7 +75,7 @@ void RootServerSelectStream::SelectServer() {
   }
   auto& chosen_server = cloud_ptr->servers()[server_index_++];
 
-  server_connection_.emplace(action_context_, chosen_server.Load());
+  server_connection_.emplace(ae_context_, chosen_server.Load());
 
   server_connection_->out_data_event().Subscribe(out_data_event_);
   server_connection_->server_error_event().Subscribe(
diff --git a/aether/registration/root_server_select_stream.h b/aether/registration/root_server_select_stream.h
index 0ca280fe..6071351f 100644
--- a/aether/registration/root_server_select_stream.h
+++ b/aether/registration/root_server_select_stream.h
@@ -23,6 +23,7 @@
 
 #  include <optional>
 
+#  include "aether/ae_context.h"
 #  include "aether/events/events.h"
 #  include "aether/registration_cloud.h"
 #  include "aether/stream_api/istream.h"
@@ -36,7 +37,7 @@ class RootServerSelectStream final : public ByteIStream {
   using ServerChangedEvent = Event<void()>;
   using CloudErrorEvent = Event<void()>;
 
-  RootServerSelectStream(ActionContext action_context,
+  RootServerSelectStream(AeContext const& ae_context,
                          Ptr<RegistrationCloud> const& cloud);
 
   ActionPtr<WriteAction> Write(DataBuffer&& data) override;
@@ -53,7 +54,7 @@ class RootServerSelectStream final : public ByteIStream {
   void ServerError();
   void CloudError();
 
-  ActionContext action_context_;
+  AeContext ae_context_;
   PtrView<RegistrationCloud> cloud_;
 
   std::size_t server_index_;
diff --git a/aether/server_connections/channel_connection.cpp b/aether/server_connections/channel_connection.cpp
index 482dda8c..7fdc5622 100644
--- a/aether/server_connections/channel_connection.cpp
+++ b/aether/server_connections/channel_connection.cpp
@@ -16,14 +16,12 @@
 
 #include "aether/server_connections/channel_connection.h"
 
-#include "aether/channels/channel.h"
-
 #include "aether/tele/tele.h"
 
 namespace ae {
-ChannelConnection::ChannelConnection(ActionContext action_context,
+ChannelConnection::ChannelConnection(AeContext ae_context,
                                      Ptr<Channel> const& channel)
-    : action_context_{action_context} {
+    : ae_context_{ae_context} {
   BuildTransport(channel);
 }
 
@@ -37,26 +35,41 @@ ChannelConnection::connection_state_event() {
 }
 
 void ChannelConnection::BuildTransport(Ptr<Channel> const& channel) {
-  auto builder_action = channel->TransportBuilder();
-  transport_build_sub_ = builder_action->StatusEvent().Subscribe(ActionHandler{
-      OnResult{[this](auto& builder) {
-        transport_stream_ = builder.transport_stream();
-        build_timer_->Stop();
-        connection_state_event_.Emit(true);
-      }},
-      OnError{[this]() {
-        AE_TELED_ERROR("Transport build failed");
-        build_timer_->Stop();
+  transport_build_start_ = Now();
+  auto sender = channel->TransportBuilder();
+  transport_waiter_.emplace(
+      ae_context_, std::move(sender),
+      [&, c{PtrView<Channel>{channel}}](auto&& result) {
+        assert(!!result);
+        build_timer_active_ = false;
+        if (result->IsOk()) {
+          auto channel = c.Lock();
+          assert(channel && "Channel not loaded");
+          auto build_time = std::chrono::duration_cast<Duration>(
+              Now() - transport_build_start_);
+          AE_TELED_ERROR("Transport built for {:%S}", build_time);
+          channel->channel_statistics().AddConnectionTime(build_time);
+
+          transport_stream_ = std::move(result->value());
+          assert(transport_stream_ && "Transport should be created");
+          connection_state_event_.Emit(true);
+        } else {
+          AE_TELED_ERROR("Transport build failed");
+          connection_state_event_.Emit(false);
+        }
+        transport_waiter_.reset();
+      });
+
+  // setup timeout for transport build
+  ae_context_.scheduler().DelayedTask(
+      [&]() {
+        if (!build_timer_active_) {
+          return;
+        }
+        AE_TELED_ERROR("Transport build timed out");
         connection_state_event_.Emit(false);
-      }},
-  });
-
-  build_timer_ = OwnActionPtr<TimerAction>{action_context_,
-                                           channel->TransportBuildTimeout()};
-  build_timer_->StatusEvent().Subscribe(OnResult{[this]() {
-    AE_TELED_ERROR("Transport build timed out");
-    connection_state_event_.Emit(false);
-  }});
+      },
+      channel->TransportBuildTimeout());
 }
 
 }  // namespace ae
diff --git a/aether/server_connections/channel_connection.h b/aether/server_connections/channel_connection.h
index 08918564..86bb13fc 100644
--- a/aether/server_connections/channel_connection.h
+++ b/aether/server_connections/channel_connection.h
@@ -19,11 +19,11 @@
 
 #include "aether/common.h"
 #include "aether/ptr/ptr.h"
+#include "aether/ae_context.h"
 #include "aether/events/events.h"
+#include "aether/channels/channel.h"
 #include "aether/stream_api/istream.h"
-#include "aether/actions/timer_action.h"
-#include "aether/actions/action_context.h"
-#include "aether/events/event_subscription.h"
+#include "aether/executors/executors.h"
 
 namespace ae {
 class Channel;
@@ -31,7 +31,7 @@ class ChannelConnection {
  public:
   using ConnectionStateEvent = Event<void(bool connected)>;
 
-  ChannelConnection(ActionContext action_context, Ptr<Channel> const& channel);
+  ChannelConnection(AeContext ae_context, Ptr<Channel> const& channel);
 
   AE_CLASS_NO_COPY_MOVE(ChannelConnection)
 
@@ -41,10 +41,15 @@ class ChannelConnection {
  private:
   void BuildTransport(Ptr<Channel> const& channel);
 
-  ActionContext action_context_;
+  AeContext ae_context_;
+  std::optional<ex::AsyncWaiter<
+      TransportBuildSender,
+      SmallFunction<void(
+          std::optional<Result<std::unique_ptr<ByteIStream>, int>>)>>>
+      transport_waiter_;
+  TimePoint transport_build_start_;
   std::unique_ptr<ByteIStream> transport_stream_;
-  Subscription transport_build_sub_;
-  OwnActionPtr<TimerAction> build_timer_;
+  bool build_timer_active_{};
   ConnectionStateEvent connection_state_event_;
 };
 }  // namespace ae
diff --git a/aether/server_connections/client_server_connection.cpp b/aether/server_connections/client_server_connection.cpp
index 51333913..343d94bc 100644
--- a/aether/server_connections/client_server_connection.cpp
+++ b/aether/server_connections/client_server_connection.cpp
@@ -16,6 +16,7 @@
 
 #include "aether/server_connections/client_server_connection.h"
 
+#include "aether/aether.h"
 #include "aether/server.h"
 #include "aether/client.h"
 #include "aether/crypto/ikey_provider.h"
@@ -92,18 +93,18 @@ class ClientCryptoProvider final : public ICryptoProvider {
 
 }  // namespace _internal
 
-ClientServerConnection::ClientServerConnection(ActionContext action_context,
+ClientServerConnection::ClientServerConnection(AeContext const& ae_context,
                                                Ptr<Client> const& client,
                                                Ptr<Server> const& server)
-    : action_context_{action_context},
+    : ae_context_{ae_context},
       server_{server},
       ephemeral_uid_{client->ephemeral_uid()},
       crypto_provider_{std::make_unique<_internal::ClientCryptoProvider>(
           client, server->server_id)},
       client_api_unsafe_{protocol_context_, *crypto_provider_->decryptor()},
-      login_api_{protocol_context_, action_context_,
+      login_api_{protocol_context_, ae_context_.aether(),
                  *crypto_provider_->encryptor()},
-      server_connection_{action_context_, server} {
+      server_connection_{ae_context_, server} {
   AE_TELED_DEBUG("Client server connection from {} to {}", ephemeral_uid_,
                  server->server_id);
 
@@ -167,7 +168,7 @@ void ClientServerConnection::ChannelChanged() {
     static constexpr Duration kPingDefaultInterval =
         std::chrono::milliseconds{AE_PING_INTERVAL_MS};
     // TODO: make ping interval depend on server priority
-    ping_ = OwnActionPtr<Ping>{action_context_, channel, *this,
+    ping_ = OwnActionPtr<Ping>{ae_context_.aether(), channel, *this,
                                kPingDefaultInterval};
 
     ping_sub_ = ping_->StatusEvent().Subscribe(OnError{[this]() {
diff --git a/aether/server_connections/client_server_connection.h b/aether/server_connections/client_server_connection.h
index b1baede5..751845f7 100644
--- a/aether/server_connections/client_server_connection.h
+++ b/aether/server_connections/client_server_connection.h
@@ -20,6 +20,7 @@
 #include "aether/actions/action_context.h"
 
 #include "aether/common.h"
+#include "aether/ae_context.h"
 #include "aether/ae_actions/ping.h"
 #include "aether/actions/action_ptr.h"
 #include "aether/crypto/icrypto_provider.h"
@@ -41,8 +42,8 @@ class Channel;
  */
 class ClientServerConnection {
  public:
-  ClientServerConnection(ActionContext action_context,
-                         Ptr<Client> const& client, Ptr<Server> const& server);
+  ClientServerConnection(AeContext const& ae_context, Ptr<Client> const& client,
+                         Ptr<Server> const& server);
   ~ClientServerConnection();
 
   AE_CLASS_NO_COPY_MOVE(ClientServerConnection)
@@ -61,7 +62,7 @@ class ClientServerConnection {
   void OutData(DataBuffer const& data);
   void ChannelChanged();
 
-  ActionContext action_context_;
+  AeContext ae_context_;
   PtrView<Server> server_;
   Uid ephemeral_uid_;
 
diff --git a/aether/server_connections/server_connection.cpp b/aether/server_connections/server_connection.cpp
index 5bbb94ff..94444624 100644
--- a/aether/server_connections/server_connection.cpp
+++ b/aether/server_connections/server_connection.cpp
@@ -19,17 +19,18 @@
 #include <cassert>
 #include <algorithm>
 
+#include "aether/aether.h"
 #include "aether/server.h"
 #include "aether/channels/channel.h"
 
 namespace ae {
 static constexpr std::size_t kBufferCapacity = 200;
 
-ServerConnection::ServerConnection(ActionContext action_context,
+ServerConnection::ServerConnection(AeContext const& ae_context,
                                    Ptr<Server> const& server)
-    : action_context_{action_context},
+    : ae_context_{ae_context},
       server_{server},
-      buffer_write_{action_context_,
+      buffer_write_{ae_context_.aether(),
                     MethodPtr<&ServerConnection::OnWrite>{this},
                     kBufferCapacity},
       full_connected_{false} {
@@ -147,7 +148,7 @@ void ServerConnection::SelectChannel() {
   stream_info_.max_element_size = channel_props.max_packet_size;
   stream_info_.is_writable = true;
 
-  channel_connection_.emplace(action_context_, channel);
+  channel_connection_.emplace(ae_context_, channel);
   channel_connection_->connection_state_event().Subscribe(
       [this](bool connected) {
         if (connected) {
@@ -204,7 +205,8 @@ void ServerConnection::ServerError() {
 void ServerConnection::DeferChannelError() {
   // Action is used to break SelectChannel recursion
   if (!channel_error_action_ || channel_error_action_->IsFinished()) {
-    channel_error_action_ = OwnActionPtr<ChannelErrorAction>{action_context_};
+    channel_error_action_ =
+        OwnActionPtr<ChannelErrorAction>{ae_context_.aether()};
     channel_error_action_->StatusEvent().Subscribe(
         OnResult{[this]() { ChannelError(); }});
   }
diff --git a/aether/server_connections/server_connection.h b/aether/server_connections/server_connection.h
index 0c0b69d3..e3c66598 100644
--- a/aether/server_connections/server_connection.h
+++ b/aether/server_connections/server_connection.h
@@ -19,12 +19,12 @@
 
 #include <vector>
 
+#include "aether/ae_context.h"
 #include "aether/obj/obj_ptr.h"
 #include "aether/ptr/ptr_view.h"
 #include "aether/events/events.h"
 #include "aether/stream_api/istream.h"
 #include "aether/actions/notify_action.h"
-#include "aether/actions/action_context.h"
 #include "aether/write_action/buffer_write.h"
 #include "aether/server_connections/channel_connection.h"
 
@@ -43,7 +43,7 @@ class ServerConnection final : public ByteIStream {
   using ServerErrorEvent = Event<void()>;
   using ChannelChangedEvent = Event<void()>;
 
-  ServerConnection(ActionContext action_context, Ptr<Server> const& server);
+  ServerConnection(AeContext const& ae_context, Ptr<Server> const& server);
 
   ActionPtr<WriteAction> Write(DataBuffer&& in_data) override;
   StreamUpdateEvent::Subscriber stream_update_event() override;
@@ -70,7 +70,7 @@ class ServerConnection final : public ByteIStream {
   void OnRead(DataBuffer const& data);
   ActionPtr<WriteAction> OnWrite(DataBuffer&& in_data);
 
-  ActionContext action_context_;
+  AeContext ae_context_;
   PtrView<Server> server_;
 
   BufferWrite<DataBuffer> buffer_write_;
diff --git a/aether/transport/transport_builder_action.h b/aether/transport/transport_builder_action.h
deleted file mode 100644
index 404fd258..00000000
--- a/aether/transport/transport_builder_action.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2025 Aethernet Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef AETHER_TRANSPORT_TRANSPORT_BUILDER_ACTION_H_
-#define AETHER_TRANSPORT_TRANSPORT_BUILDER_ACTION_H_
-
-#include <memory>
-
-#include "aether/actions/action.h"
-#include "aether/stream_api/istream.h"
-
-namespace ae {
-/**
- * \brief Action builds transport stream.
- */
-class TransportBuilderAction : public Action<TransportBuilderAction> {
- public:
-  using Action::Action;
-  using Action::operator=;
-
-  virtual UpdateStatus Update() = 0;
-
-  virtual std::unique_ptr<ByteIStream> transport_stream() = 0;
-};
-}  // namespace ae
-
-#endif  // AETHER_TRANSPORT_TRANSPORT_BUILDER_ACTION_H_

From 97e6a124130291cbfff342c83d7470e0b590b4e8 Mon Sep 17 00:00:00 2001
From: BartolomeyKant <notevill@gmail.com>
Date: Thu, 19 Mar 2026 21:48:13 +0500
Subject: [PATCH 7/8] change to default == operator

---
 aether/ae_context.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/aether/ae_context.h b/aether/ae_context.h
index b4b55cee..c237d7a5 100644
--- a/aether/ae_context.h
+++ b/aether/ae_context.h
@@ -34,7 +34,7 @@ struct AeCtxTable {
 };
 
 struct AeCtx {
-  bool operator<=>(AeCtx const&) const = default;
+  bool operator==(AeCtx const&) const = default;
 
   void* obj;
   AeCtxTable const* vtable;
@@ -56,7 +56,7 @@ class AeContext {
     return ctx_.vtable->scheduler_getter(ctx_.obj);
   }
 
-  bool operator<=>(AeContext const&) const = default;
+  bool operator==(AeContext const&) const = default;
 
  private:
   AeCtx ctx_;

From 5d73f00114977e70a0654cd42e02de6f8f472220 Mon Sep 17 00:00:00 2001
From: BartolomeyKant <notevill@gmail.com>
Date: Mon, 23 Mar 2026 10:34:39 +0500
Subject: [PATCH 8/8] make disable install temporary

---
 aether/CMakeLists.txt | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/aether/CMakeLists.txt b/aether/CMakeLists.txt
index 5d44f4d3..e6a6654c 100644
--- a/aether/CMakeLists.txt
+++ b/aether/CMakeLists.txt
@@ -564,15 +564,15 @@ endif()
 
 if(REGULAR_CMAKE_PROJECT AND NOT AE_BUILD_TESTS)
   ## Target installation
-  install(TARGETS   ${TARGET_NAME}
-        EXPORT        ${TARGET_NAME}Targets
-        ARCHIVE       DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY       DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${TARGET_NAME}
-        COMPONENT     library)
+  # install(TARGETS   ${TARGET_NAME}
+  #       EXPORT        ${TARGET_NAME}Targets
+  #      ARCHIVE       DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  #     LIBRARY       DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  #    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${TARGET_NAME}
+  #   COMPONENT     library)
 
   ## Target's cmake files: targets export
-  install(EXPORT  ${TARGET_NAME}Targets
-        NAMESPACE   ${TARGET_NAME}::
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${TARGET_NAME})
+  #install(EXPORT  ${TARGET_NAME}Targets
+  #     NAMESPACE   ${TARGET_NAME}::
+  #    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${TARGET_NAME})
 endif()