diff --git a/include/ylt/coro_io/client_pool.hpp b/include/ylt/coro_io/client_pool.hpp
index 43f536eb3..a5c656cb8 100644
--- a/include/ylt/coro_io/client_pool.hpp
+++ b/include/ylt/coro_io/client_pool.hpp
@@ -257,9 +257,8 @@ class client_pool : public std::enable_shared_from_this<
             this->weak_from_this(), clients,
             (std::max)(collect_time, std::chrono::milliseconds{50}),
             pool_config_.idle_queue_per_max_clear_count)
-            .via(coro_io::get_global_executor())
-            .start([](auto&&) {
-            });
+            .directlyStart([](auto&&) {
+            },coro_io::get_global_executor());
       }
     }
   }
diff --git a/include/ylt/coro_io/coro_io.hpp b/include/ylt/coro_io/coro_io.hpp
index 3992116ca..e26fab75c 100644
--- a/include/ylt/coro_io/coro_io.hpp
+++ b/include/ylt/coro_io/coro_io.hpp
@@ -429,66 +429,6 @@ async_simple::coro::Lazy<std::pair<
   });
 }
 
-template <typename T>
-inline decltype(auto) select_impl(T &pair) {
-  using Func = std::tuple_element_t<1, std::remove_cvref_t<T>>;
-  using ValueType =
-      typename std::tuple_element_t<0, std::remove_cvref_t<T>>::ValueType;
-  using return_type = std::invoke_result_t<Func, async_simple::Try<ValueType>>;
-
-  auto &callback = std::get<1>(pair);
-  if constexpr (coro_io::is_lazy_v<return_type>) {
-    auto executor = std::get<0>(pair).getExecutor();
-    return std::make_pair(
-        std::move(std::get<0>(pair)),
-        [executor, callback = std::move(callback)](auto &&val) {
-          if (executor) {
-            callback(std::move(val)).via(executor).start([](auto &&) {
-            });
-          }
-          else {
-            callback(std::move(val)).start([](auto &&) {
-            });
-          }
-        });
-  }
-  else {
-    return pair;
-  }
-}
-
-template <typename... T>
-inline auto select(T &&...args) {
-  return async_simple::coro::collectAny(select_impl(args)...);
-}
-
-template <typename T, typename Callback>
-inline auto select(std::vector<T> vec, Callback callback) {
-  if constexpr (coro_io::is_lazy_v<Callback>) {
-    std::vector<async_simple::Executor *> executors;
-    for (auto &lazy : vec) {
-      executors.push_back(lazy.getExecutor());
-    }
-
-    return async_simple::coro::collectAny(
-        std::move(vec),
-        [executors, callback = std::move(callback)](size_t index, auto &&val) {
-          auto executor = executors[index];
-          if (executor) {
-            callback(index, std::move(val)).via(executor).start([](auto &&) {
-            });
-          }
-          else {
-            callback(index, std::move(val)).start([](auto &&) {
-            });
-          }
-        });
-  }
-  else {
-    return async_simple::coro::collectAny(std::move(vec), std::move(callback));
-  }
-}
-
 template <typename Socket, typename AsioBuffer>
 std::pair<asio::error_code, size_t> read_some(Socket &sock,
                                               AsioBuffer &&buffer) {
diff --git a/include/ylt/coro_io/detail/client_queue.hpp b/include/ylt/coro_io/detail/client_queue.hpp
index 449e28d76..137d65f57 100644
--- a/include/ylt/coro_io/detail/client_queue.hpp
+++ b/include/ylt/coro_io/detail/client_queue.hpp
@@ -80,6 +80,7 @@ class client_queue {
     if (size_[index]) {
       std::size_t result =
           queue_[index].try_dequeue_bulk(fake_iter{}, max_clear_cnt);
+
       size_[index] -= result;
       return result;
     }
diff --git a/include/ylt/coro_io/io_context_pool.hpp b/include/ylt/coro_io/io_context_pool.hpp
index 9e02e3bbe..0e725f9eb 100644
--- a/include/ylt/coro_io/io_context_pool.hpp
+++ b/include/ylt/coro_io/io_context_pool.hpp
@@ -17,10 +17,11 @@
 #include <async_simple/Executor.h>
 #include <async_simple/coro/Lazy.h>
 
-#include <asio/dispatch.hpp>
 #include <asio/io_context.hpp>
+#include <asio/post.hpp>
 #include <asio/steady_timer.hpp>
 #include <atomic>
+#include <cstdint>
 #include <future>
 #include <iostream>
 #include <memory>
@@ -28,6 +29,8 @@
 #include <thread>
 #include <type_traits>
 #include <vector>
+
+#include "asio/dispatch.hpp"
 #ifdef __linux__
 #include <pthread.h>
 #include <sched.h>
@@ -51,25 +54,25 @@ class ExecutorWrapper : public async_simple::Executor {
   using context_t = std::remove_cvref_t<decltype(executor_.context())>;
 
   virtual bool schedule(Func func) override {
-    if constexpr (requires(ExecutorImpl e) { e.post(std::move(func)); }) {
-      executor_.dispatch(std::move(func));
+    asio::post(executor_, std::move(func));
+    return true;
+  }
+
+  virtual bool schedule(Func func, uint64_t hint) override {
+    if (hint >=
+        static_cast<uint64_t>(async_simple::Executor::Priority::YIELD)) {
+      asio::post(executor_, std::move(func));
     }
     else {
       asio::dispatch(executor_, std::move(func));
     }
-
     return true;
   }
 
   virtual bool checkin(Func func, void *ctx) override {
     using context_t = std::remove_cvref_t<decltype(executor_.context())>;
     auto &executor = *(context_t *)ctx;
-    if constexpr (requires(ExecutorImpl e) { e.post(std::move(func)); }) {
-      executor.post(std::move(func));
-    }
-    else {
-      asio::dispatch(executor, std::move(func));
-    }
+    asio::post(executor, std::move(func));
     return true;
   }
   virtual void *checkout() override { return &executor_.context(); }
@@ -99,6 +102,14 @@ class ExecutorWrapper : public async_simple::Executor {
       fn();
     });
   }
+  void schedule(Func func, Duration dur, uint64_t hint,
+                async_simple::Slot *slot = nullptr) override {
+    auto timer = std::make_unique<asio::steady_timer>(executor_, dur);
+    auto tm = timer.get();
+    tm->async_wait([fn = std::move(func), timer = std::move(timer)](auto ec) {
+      fn();
+    });
+  }
 };
 
 template <typename ExecutorImpl = asio::io_context>
diff --git a/include/ylt/coro_rpc/impl/coro_connection.hpp b/include/ylt/coro_rpc/impl/coro_connection.hpp
index be52bc77c..67b6c00d8 100644
--- a/include/ylt/coro_rpc/impl/coro_connection.hpp
+++ b/include/ylt/coro_rpc/impl/coro_connection.hpp
@@ -122,6 +122,17 @@ context_info_t<rpc_protocol> *&set_context();
 
 class coro_connection : public std::enable_shared_from_this<coro_connection> {
  public:
+  template <typename rpc_protocol_t>
+  struct connection_lazy_ctx : public async_simple::coro::LazyLocalBase {
+    inline static char tag;
+    // init LazyLocalBase by unique address
+    connection_lazy_ctx(std::shared_ptr<context_info_t<rpc_protocol_t>> info)
+        : LazyLocalBase(&tag), info_(std::move(info)) {}
+    static bool classof(const LazyLocalBase *base) {
+      return base->getTypeTag() == &tag;
+    }
+    std::shared_ptr<context_info_t<rpc_protocol_t>> info_;
+  };
   /*!
    *
    * @param io_context
@@ -276,26 +287,30 @@ class coro_connection : public std::enable_shared_from_this<coro_connection> {
         auto coro_handler = router.get_coro_handler(key);
         set_rpc_return_by_callback();
         router.route_coro(coro_handler, payload, serialize_proto.value(), key)
-            .via(executor_)
-            .setLazyLocal((void *)context_info.get())
-            .start([context_info](auto &&result) mutable {
-              std::pair<coro_rpc::err_code, std::string> &ret = result.value();
-              if (ret.first)
-                AS_UNLIKELY {
-                  ELOGI << "rpc error in function:"
-                        << context_info->get_rpc_function_name()
-                        << ". error code:" << ret.first.ec
-                        << ". message : " << ret.second;
-                }
-              auto executor = context_info->conn_->get_executor();
-              executor->schedule([context_info = std::move(context_info),
-                                  ret = std::move(ret)]() mutable {
-                context_info->conn_->template direct_response_msg<rpc_protocol>(
-                    ret.first, ret.second, context_info->req_head_,
-                    std::move(context_info->resp_attachment_),
-                    std::move(context_info->complete_handler_));
-              });
-            });
+            .template setLazyLocal<connection_lazy_ctx<rpc_protocol>>(
+                context_info)
+            .directlyStart(
+                [context_info](auto &&result) mutable {
+                  std::pair<coro_rpc::err_code, std::string> &ret =
+                      result.value();
+                  if (ret.first)
+                    AS_UNLIKELY {
+                      ELOGI << "rpc error in function:"
+                            << context_info->get_rpc_function_name()
+                            << ". error code:" << ret.first.ec
+                            << ". message : " << ret.second;
+                    }
+                  auto executor = context_info->conn_->get_executor();
+                  executor->schedule([context_info = std::move(context_info),
+                                      ret = std::move(ret)]() mutable {
+                    context_info->conn_
+                        ->template direct_response_msg<rpc_protocol>(
+                            ret.first, ret.second, context_info->req_head_,
+                            std::move(context_info->resp_attachment_),
+                            std::move(context_info->complete_handler_));
+                  });
+                },
+                executor_);
       }
       else {
         coro_rpc::detail::set_context<rpc_protocol>() = context_info.get();
diff --git a/include/ylt/coro_rpc/impl/coro_rpc_client.hpp b/include/ylt/coro_rpc/impl/coro_rpc_client.hpp
index 8ce0e8335..be718868e 100644
--- a/include/ylt/coro_rpc/impl/coro_rpc_client.hpp
+++ b/include/ylt/coro_rpc/impl/coro_rpc_client.hpp
@@ -345,7 +345,7 @@ class coro_rpc_client {
 
   void close() {
     // ELOG_INFO << "client_id " << config_.client_id << " close";
-    close_socket(control_);
+    close_socket_async(control_);
   }
 
   bool set_req_attachment(std::string_view attachment) {
@@ -375,18 +375,19 @@ class coro_rpc_client {
     bool value = false;
   };
 
-  void reset() {
-    close_socket(control_);
+  async_simple::coro::Lazy<void> reset() {
+    co_await close_socket(control_);
     control_->socket_ =
         asio::ip::tcp::socket(control_->executor_.get_asio_executor());
     control_->is_timeout_ = false;
     control_->has_closed_ = false;
+    co_return;
   }
   static bool is_ok(coro_rpc::err_code ec) noexcept { return !ec; }
 
   [[nodiscard]] async_simple::coro::Lazy<coro_rpc::err_code> connect_impl() {
     if (should_reset_) {
-      reset();
+      co_await reset();
     }
     else {
       should_reset_ = true;
@@ -413,17 +414,15 @@ class coro_rpc_client {
     std::error_code err_code;
     timer_->cancel(err_code);
 
-    if (ec) {
-      if (control_->is_timeout_) {
-        co_return errc::timed_out;
-      }
-      co_return errc::not_connected;
-    }
-
     if (control_->is_timeout_) {
       ELOG_WARN << "client_id " << config_.client_id << " connect timeout";
       co_return errc::timed_out;
     }
+    else if (ec) {
+      ELOG_WARN << "client_id " << config_.client_id
+                << " failed:" << ec.message();
+      co_return errc::not_connected;
+    }
     if (config_.enable_tcp_no_delay == true) {
       control_->socket_.set_option(asio::ip::tcp::no_delay(true), ec);
     }
@@ -482,7 +481,7 @@ class coro_rpc_client {
     }
     if (auto self = socket_watcher.lock()) {
       self->is_timeout_ = is_timeout;
-      close_socket(self);
+      close_socket_async(self);
       co_return true;
     }
     co_return false;
@@ -710,18 +709,40 @@ class coro_rpc_client {
           executor_(executor) {}
   };
 
-  static void close_socket(
+  static void close_socket_async(
       std::shared_ptr<coro_rpc_client::control_t> control) {
     bool expected = false;
     if (!control->has_closed_.compare_exchange_strong(expected, true)) {
       return;
     }
-    control->executor_.schedule([control]() {
-      asio::error_code ignored_ec;
-      control->socket_.shutdown(asio::ip::tcp::socket::shutdown_both,
-                                ignored_ec);
-      control->socket_.close(ignored_ec);
+    asio::dispatch(control->executor_.get_asio_executor(), [control]() {
+      assert(&control->executor_.get_asio_executor().context() ==
+             &control->socket_.get_executor().context());
+      control->has_closed_ = true;
+      asio::error_code ec;
+      control->socket_.shutdown(asio::ip::tcp::socket::shutdown_both, ec);
+      control->socket_.close(ec);
     });
+    return;
+  }
+
+  static async_simple::coro::Lazy<void> close_socket(
+      std::shared_ptr<coro_rpc_client::control_t> control) {
+    bool expected = false;
+    if (!control->has_closed_.compare_exchange_strong(expected, true)) {
+      co_return;
+    }
+    co_await coro_io::post(
+        [control = control.get()]() {
+          assert(&control->executor_.get_asio_executor().context() ==
+                 &control->socket_.get_executor().context());
+          control->has_closed_ = true;
+          asio::error_code ec;
+          control->socket_.shutdown(asio::ip::tcp::socket::shutdown_both, ec);
+          control->socket_.close(ec);
+        },
+        &control->executor_);
+    co_return;
   }
 
 #ifdef UNIT_TEST_INJECT
@@ -861,7 +882,7 @@ class coro_rpc_client {
         break;
       }
     } while (true);
-    close_socket(controller);
+    close_socket_async(controller);
     send_err_response(controller.get(), ret.first);
     co_return;
   }
@@ -891,7 +912,7 @@ class coro_rpc_client {
         handle_response_buffer<T>(ret.buffer_.read_buf_, ret.errc_, has_error);
     if (has_error) {
       if (auto w = watcher.lock(); w) {
-        close_socket(std::move(w));
+        close_socket_async(std::move(w));
       }
     }
     if (result) {
diff --git a/include/ylt/coro_rpc/impl/protocol/coro_rpc_protocol.hpp b/include/ylt/coro_rpc/impl/protocol/coro_rpc_protocol.hpp
index c22fcbc80..f06d278c7 100644
--- a/include/ylt/coro_rpc/impl/protocol/coro_rpc_protocol.hpp
+++ b/include/ylt/coro_rpc/impl/protocol/coro_rpc_protocol.hpp
@@ -213,9 +213,10 @@ using context = coro_rpc::context_base<return_msg_type,
 
 template <typename rpc_protocol = coro_rpc::protocol::coro_rpc_protocol>
 async_simple::coro::Lazy<context_info_t<rpc_protocol>*> get_context_in_coro() {
-  auto* ctx = co_await async_simple::coro::LazyLocals{};
+  auto* ctx = co_await async_simple::coro::CurrentLazyLocals<
+      coro_connection::connection_lazy_ctx<rpc_protocol>>{};
   assert(ctx != nullptr);
-  co_return (context_info_t<rpc_protocol>*) ctx;
+  co_return ctx->info_.get();
 }
 
 namespace detail {
diff --git a/include/ylt/thirdparty/async_simple/Collect.h b/include/ylt/thirdparty/async_simple/Collect.h
index 937b86333..4cb7ccc6e 100644
--- a/include/ylt/thirdparty/async_simple/Collect.h
+++ b/include/ylt/thirdparty/async_simple/Collect.h
@@ -16,14 +16,13 @@
 #ifndef ASYNC_SIMPLE_COLLECT_H
 #define ASYNC_SIMPLE_COLLECT_H
 
-#include <exception>
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <iterator>
 #include <vector>
-#include "async_simple/Common.h"
 #include "async_simple/Future.h"
 #include "async_simple/Try.h"
 
-#include <iostream>
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 
diff --git a/include/ylt/thirdparty/async_simple/Common.h b/include/ylt/thirdparty/async_simple/Common.h
index bde017e6d..c8e7ddd33 100644
--- a/include/ylt/thirdparty/async_simple/Common.h
+++ b/include/ylt/thirdparty/async_simple/Common.h
@@ -16,47 +16,11 @@
 #ifndef ASYNC_SIMPLE_COMMON_H
 #define ASYNC_SIMPLE_COMMON_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <stdexcept>
+#include "async_simple/CommonMacros.h"
 
-#if __has_cpp_attribute(likely) && __has_cpp_attribute(unlikely)
-#define AS_LIKELY [[likely]]
-#define AS_UNLIKELY [[unlikely]]
-#else
-#define AS_LIKELY
-#define AS_UNLIKELY
-#endif
-
-#ifdef _WIN32
-#define AS_INLINE
-#else
-#define AS_INLINE __attribute__((__always_inline__)) inline
-#endif
-
-#ifdef __clang__
-#if __has_feature(address_sanitizer)
-#define AS_INTERNAL_USE_ASAN 1
-#endif  // __has_feature(address_sanitizer)
-#endif  // __clang__
-
-#ifdef __GNUC__
-#ifdef __SANITIZE_ADDRESS__  // GCC
-#define AS_INTERNAL_USE_ASAN 1
-#endif  // __SANITIZE_ADDRESS__
-#endif  // __GNUC__
-
-#if defined(__alibaba_clang__) && \
-    __has_cpp_attribute(ACC::coro_only_destroy_when_complete)
-#define CORO_ONLY_DESTROY_WHEN_DONE [[ACC::coro_only_destroy_when_complete]]
-#else
-#define CORO_ONLY_DESTROY_WHEN_DONE
-#endif
-
-#if defined(__alibaba_clang__) && \
-    __has_cpp_attribute(ACC::elideable_after_await)
-#define ELIDEABLE_AFTER_AWAIT [[ACC::elideable_after_await]]
-#else
-#define ELIDEABLE_AFTER_AWAIT
-#endif
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 // Different from assert, logicAssert is meaningful in
diff --git a/include/ylt/thirdparty/async_simple/CommonMacros.h b/include/ylt/thirdparty/async_simple/CommonMacros.h
new file mode 100644
index 000000000..75f434876
--- /dev/null
+++ b/include/ylt/thirdparty/async_simple/CommonMacros.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2024, Alibaba Group Holding Limited;
+ *
+ * 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 ASYNC_SIMPLE_COMMON_MACROS_H
+#define ASYNC_SIMPLE_COMMON_MACROS_H
+
+#if __has_cpp_attribute(likely) && __has_cpp_attribute(unlikely)
+#define AS_LIKELY [[likely]]
+#define AS_UNLIKELY [[unlikely]]
+#else
+#define AS_LIKELY
+#define AS_UNLIKELY
+#endif
+
+#ifdef _WIN32
+#define AS_INLINE
+#else
+#define AS_INLINE __attribute__((__always_inline__)) inline
+#endif
+
+#ifdef __clang__
+#if __has_feature(address_sanitizer)
+#define AS_INTERNAL_USE_ASAN 1
+#endif  // __has_feature(address_sanitizer)
+#endif  // __clang__
+
+#ifdef __GNUC__
+#ifdef __SANITIZE_ADDRESS__  // GCC
+#define AS_INTERNAL_USE_ASAN 1
+#endif  // __SANITIZE_ADDRESS__
+#endif  // __GNUC__
+
+#if defined(__alibaba_clang__) && \
+    __has_cpp_attribute(ACC::coro_only_destroy_when_complete)
+#define CORO_ONLY_DESTROY_WHEN_DONE [[ACC::coro_only_destroy_when_complete]]
+#else
+#define CORO_ONLY_DESTROY_WHEN_DONE
+#endif
+
+#if defined(__alibaba_clang__) && \
+    __has_cpp_attribute(ACC::elideable_after_await)
+#define ELIDEABLE_AFTER_AWAIT [[ACC::elideable_after_await]]
+#else
+#define ELIDEABLE_AFTER_AWAIT
+#endif
+
+#endif
diff --git a/include/ylt/thirdparty/async_simple/Executor.h b/include/ylt/thirdparty/async_simple/Executor.h
index d1edfedf8..c7aaf1967 100644
--- a/include/ylt/thirdparty/async_simple/Executor.h
+++ b/include/ylt/thirdparty/async_simple/Executor.h
@@ -16,14 +16,22 @@
 #ifndef ASYNC_SIMPLE_EXECUTOR_H
 #define ASYNC_SIMPLE_EXECUTOR_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <chrono>
+#include <cstdint>
 #include <functional>
+#include <future>
+#include <memory>
+#include <ratio>
 #include <string>
 #include <thread>
 #include "async_simple/MoveWrapper.h"
+#include "async_simple/Signal.h"
 #include "async_simple/experimental/coroutine.h"
 #include "async_simple/util/move_only_function.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 // Stat information for an executor.
 // It contains the number of pending task
@@ -89,12 +97,39 @@ class Executor {
     // should guarantee that the func would be executed.
     virtual bool schedule(Func func) = 0;
 
+    // 4-bits priority, less level is more important. Default
+    // value of async-simple schedule is DEFAULT. For scheduling level >=
+    // YIELD, if executor always execute the work immediately if other
+    // works, it may cause dead lock. are waiting.
+    enum class Priority {
+        HIGHEST = 0x0,
+        DEFAULT = 0x7,
+        YIELD = 0x8,
+        LOWEST = 0xF
+    };
+
+    // Low 16-bit of schedule_info is reserved for async-simple, and the lowest
+    // 4-bit is stand for priority level. The implementation of scheduling logic
+    // isn't necessary, which is determined by implementation. However, to avoid
+    // spinlock/yield deadlock, when priority level >= YIELD, scheduler
+    // can't always execute the work immediately when other works are
+    // waiting.
+    virtual bool schedule(Func func, uint64_t schedule_info) {
+        return schedule(std::move(func));
+    }
+
     // Schedule a move only functor
     bool schedule_move_only(util::move_only_function<void()> func) {
         MoveWrapper<decltype(func)> tmp(std::move(func));
         return schedule([func = tmp]() { func.get()(); });
     }
 
+    bool schedule_move_only(util::move_only_function<void()> func,
+                            uint64_t schedule_info) {
+        MoveWrapper<decltype(func)> tmp(std::move(func));
+        return schedule([func = tmp]() { func.get()(); }, schedule_info);
+    }
+
     // Return true if caller runs in the executor.
     virtual bool currentThreadInExecutor() const {
         throw std::logic_error("Not implemented");
@@ -119,11 +154,15 @@ class Executor {
 
     const std::string &name() const { return _name; }
 
-    // Use
-    //  co_await executor.after(sometime)
+    // Use co_await executor.after(sometime)
     // to schedule current execution after some time.
     TimeAwaitable after(Duration dur);
 
+    // Use co_await executor.after(sometime)
+    // to schedule current execution after some time.
+    TimeAwaitable after(Duration dur, uint64_t schedule_info,
+                        Slot *slot = nullptr);
+
     // IOExecutor accepts IO read/write requests.
     // Return nullptr if the executor doesn't offer an IOExecutor.
     virtual IOExecutor *getIOExecutor() {
@@ -132,8 +171,21 @@ class Executor {
 
 protected:
     virtual void schedule(Func func, Duration dur) {
-        std::thread([this, func = std::move(func), dur]() {
-            std::this_thread::sleep_for(dur);
+        return schedule(func, dur,
+                        static_cast<uint64_t>(Executor::Priority::DEFAULT),
+                        nullptr);
+    }
+    virtual void schedule(Func func, Duration dur, uint64_t schedule_info,
+                          Slot *slot = nullptr) {
+        std::thread([this, func = std::move(func), dur, slot]() {
+            auto promise = std::make_unique<std::promise<void>>();
+            auto future = promise->get_future();
+            bool hasnt_canceled = signalHelper{Terminate}.tryEmplace(
+                slot, [p = std::move(promise)](SignalType, Signal *) {
+                    p->set_value();
+                });
+            if (hasnt_canceled)
+                future.wait_for(dur);
             schedule(std::move(func));
         }).detach();
     }
@@ -145,37 +197,59 @@ class Executor {
 // Awaiter to implement Executor::after.
 class Executor::TimeAwaiter {
 public:
-    TimeAwaiter(Executor *ex, Executor::Duration dur) : _ex(ex), _dur(dur) {}
+    TimeAwaiter(Executor *ex, Executor::Duration dur, uint64_t schedule_info,
+                Slot *slot)
+        : _ex(ex), _dur(dur), _schedule_info(schedule_info), _slot(slot) {}
 
 public:
-    bool await_ready() const noexcept { return false; }
+    bool await_ready() const noexcept {
+        return signalHelper{Terminate}.hasCanceled(_slot);
+    }
 
     template <typename PromiseType>
-    void await_suspend(std::coroutine_handle<PromiseType> continuation) {
-        _ex->schedule(std::move(continuation), _dur);
+    void await_suspend(coro::CoroHandle<PromiseType> continuation) {
+        _ex->schedule(std::move(continuation), _dur, _schedule_info, _slot);
+    }
+    void await_resume() {
+        signalHelper{Terminate}.checkHasCanceled(
+            _slot, "async_simple's timer is canceled!");
     }
-    void await_resume() const noexcept {}
 
 private:
     Executor *_ex;
     Executor::Duration _dur;
+    uint64_t _schedule_info;
+    Slot *_slot;
 };
 
 // Awaitable to implement Executor::after.
 class Executor::TimeAwaitable {
 public:
-    TimeAwaitable(Executor *ex, Executor::Duration dur) : _ex(ex), _dur(dur) {}
+    TimeAwaitable(Executor *ex, Executor::Duration dur, uint64_t schedule_info,
+                  Slot *slot)
+        : _ex(ex), _dur(dur), _schedule_info(schedule_info), _slot(slot) {}
 
-    auto coAwait(Executor *) { return Executor::TimeAwaiter(_ex, _dur); }
+    auto coAwait(Executor *) {
+        return Executor::TimeAwaiter(_ex, _dur, _schedule_info, _slot);
+    }
 
 private:
     Executor *_ex;
     Executor::Duration _dur;
+    uint64_t _schedule_info;
+    Slot *_slot;
 };
 
 Executor::TimeAwaitable inline Executor::after(Executor::Duration dur) {
-    return Executor::TimeAwaitable(this, dur);
-};
+    return Executor::TimeAwaitable(
+        this, dur, static_cast<uint64_t>(Executor::Priority::DEFAULT), nullptr);
+}
+
+Executor::TimeAwaitable inline Executor::after(Executor::Duration dur,
+                                               uint64_t schedule_info,
+                                               Slot *slot) {
+    return Executor::TimeAwaitable(this, dur, schedule_info, slot);
+}
 
 }  // namespace async_simple
 
diff --git a/include/ylt/thirdparty/async_simple/Future.h b/include/ylt/thirdparty/async_simple/Future.h
index 014e9578a..b54192ffd 100644
--- a/include/ylt/thirdparty/async_simple/Future.h
+++ b/include/ylt/thirdparty/async_simple/Future.h
@@ -16,13 +16,18 @@
 #ifndef ASYNC_SIMPLE_FUTURE_H
 #define ASYNC_SIMPLE_FUTURE_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
+#include <condition_variable>
+#include <mutex>
 #include <type_traits>
+
 #include "async_simple/Executor.h"
 #include "async_simple/FutureState.h"
 #include "async_simple/LocalState.h"
-#include "async_simple/Promise.h"
 #include "async_simple/Traits.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 template <typename T>
diff --git a/include/ylt/thirdparty/async_simple/FutureState.h b/include/ylt/thirdparty/async_simple/FutureState.h
index 7f4958399..c411a6d80 100644
--- a/include/ylt/thirdparty/async_simple/FutureState.h
+++ b/include/ylt/thirdparty/async_simple/FutureState.h
@@ -16,20 +16,19 @@
 #ifndef ASYNC_SIMPLE_FUTURESTATE_H
 #define ASYNC_SIMPLE_FUTURESTATE_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <atomic>
-#include <iostream>
-
 #include <cassert>
-#include <condition_variable>
-#include <functional>
-#include <mutex>
+#include <iostream>
 #include <stdexcept>
-#include <thread>
+
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
 #include "async_simple/Try.h"
 #include "async_simple/util/move_only_function.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 // Details about the State of Future/Promise,
diff --git a/include/ylt/thirdparty/async_simple/IOExecutor.h b/include/ylt/thirdparty/async_simple/IOExecutor.h
index 4facbbce3..f8759ed7b 100644
--- a/include/ylt/thirdparty/async_simple/IOExecutor.h
+++ b/include/ylt/thirdparty/async_simple/IOExecutor.h
@@ -16,8 +16,11 @@
 #ifndef ASYNC_SIMPLE_IO_EXECUTOR_H
 #define ASYNC_SIMPLE_IO_EXECUTOR_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
+#include <cstdint>
 #include <functional>
-#include <string>
+
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 
diff --git a/include/ylt/thirdparty/async_simple/LocalState.h b/include/ylt/thirdparty/async_simple/LocalState.h
index 297de380c..b414af4ac 100644
--- a/include/ylt/thirdparty/async_simple/LocalState.h
+++ b/include/ylt/thirdparty/async_simple/LocalState.h
@@ -17,18 +17,15 @@
 #ifndef ASYNC_SIMPLE_LOCALSTATE_H
 #define ASYNC_SIMPLE_LOCALSTATE_H
 
-#include <atomic>
-
-#include <condition_variable>
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <functional>
-#include <mutex>
-#include <stdexcept>
-#include <thread>
 #include <utility>
-#include "async_simple/Common.h"
+
 #include "async_simple/Executor.h"
 #include "async_simple/Try.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 // A component of Future/Promise. LocalState is owned by
diff --git a/include/ylt/thirdparty/async_simple/MoveWrapper.h b/include/ylt/thirdparty/async_simple/MoveWrapper.h
index 0fbfb9b4a..af55902c7 100644
--- a/include/ylt/thirdparty/async_simple/MoveWrapper.h
+++ b/include/ylt/thirdparty/async_simple/MoveWrapper.h
@@ -17,9 +17,10 @@
 #ifndef ASYNC_SIMPLE_MOVEWRAPPER_H
 #define ASYNC_SIMPLE_MOVEWRAPPER_H
 
-#include <exception>
+#ifndef ASYNC_SIMPLE_USE_MODULES
+#include <utility>
 
-#include "async_simple/Common.h"
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 
@@ -27,23 +28,23 @@ namespace async_simple {
 // copy as move.
 template <typename T>
 class MoveWrapper {
- public:
-  MoveWrapper() = default;
-  MoveWrapper(T&& value) : _value(std::move(value)) {}
+public:
+    MoveWrapper() = default;
+    MoveWrapper(T&& value) : _value(std::move(value)) {}
 
-  MoveWrapper(const MoveWrapper& other) : _value(std::move(other._value)) {}
-  MoveWrapper(MoveWrapper&& other) : _value(std::move(other._value)) {}
+    MoveWrapper(const MoveWrapper& other) : _value(std::move(other._value)) {}
+    MoveWrapper(MoveWrapper&& other) : _value(std::move(other._value)) {}
 
-  MoveWrapper& operator=(const MoveWrapper&) = delete;
-  MoveWrapper& operator=(MoveWrapper&&) = delete;
+    MoveWrapper& operator=(const MoveWrapper&) = delete;
+    MoveWrapper& operator=(MoveWrapper&&) = delete;
 
-  T& get() { return _value; }
-  const T& get() const { return _value; }
+    T& get() { return _value; }
+    const T& get() const { return _value; }
 
-  ~MoveWrapper() {}
+    ~MoveWrapper() {}
 
- private:
-  mutable T _value;
+private:
+    mutable T _value;
 };
 
 }  // namespace async_simple
diff --git a/include/ylt/thirdparty/async_simple/Promise.h b/include/ylt/thirdparty/async_simple/Promise.h
index 083e840ca..985fc42b5 100644
--- a/include/ylt/thirdparty/async_simple/Promise.h
+++ b/include/ylt/thirdparty/async_simple/Promise.h
@@ -16,10 +16,13 @@
 #ifndef ASYNC_SIMPLE_PROMISE_H
 #define ASYNC_SIMPLE_PROMISE_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <exception>
 #include "async_simple/Common.h"
 #include "async_simple/Future.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 template <typename T>
diff --git a/include/ylt/thirdparty/async_simple/Signal.h b/include/ylt/thirdparty/async_simple/Signal.h
new file mode 100644
index 000000000..8f5dfd302
--- /dev/null
+++ b/include/ylt/thirdparty/async_simple/Signal.h
@@ -0,0 +1,493 @@
+/*
+ * Copyright (c) 2024, Alibaba Group Holding Limited;
+ *
+ * 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 ASYNC_SIMPLE_SIGNAL_H
+#define ASYNC_SIMPLE_SIGNAL_H
+
+#ifndef ASYNC_SIMPLE_USE_MODULES
+
+#include <assert.h>
+#include <any>
+#include <atomic>
+#include <bit>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+
+#include "async_simple/Common.h"
+#include "util/move_only_function.h"
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
+namespace async_simple {
+
+enum SignalType : uint64_t {
+    None = 0,
+    // low 32 bit signal only trigger once.
+    // regist those signal's handler after triggered will failed and return
+    // false.
+    Terminate = 1,  // signal type: terminate
+    // 1-16 bits reserve for async-simple
+    // 17-32 bits could used for user-defined signal
+
+    // high 32 bit signal, could trigger multiple times, emplace an handler
+    // 33-48 bits reserve for async-simple
+    // 49-64 bits could used for user-defined signal
+    // after signal triggered will always success and return true.
+    All = UINT64_MAX,
+};
+
+class Slot;
+
+namespace detail {
+struct SignalSlotSharedState;
+constexpr uint64_t high32bits_mask = uint64_t{UINT32_MAX} << 32;
+constexpr uint64_t MinMultiTriggerSignal = 1ull << 32;
+}  // namespace detail
+
+// The Signal type is used to emit a signal, whereas a Slot is used to
+// receive signals. We can create a signal using factory methods and bind
+// multiple Slots to the same Signal. When the Signal emits a signal, all
+// bound `Slot`s will receive the corresponding signal.
+// The Signal's life-time is not shorter than the bound Slots. Because those
+// slots owns a shared_ptr of signal.
+class Signal : public std::enable_shared_from_this<Signal> {
+    friend class Slot;
+    friend struct detail::SignalSlotSharedState;
+
+private:
+    // A list to manage different type of signal's handler.
+    detail::SignalSlotSharedState& registSlot(SignalType filter);
+    SignalType UpdateState(std::atomic<uint64_t>& state, SignalType type) {
+        uint64_t expected = state.load(std::memory_order_acquire);
+        uint64_t validSignal;
+        do {
+            validSignal = (expected | type) ^ expected;
+        } while (validSignal &&
+                 !state.compare_exchange_weak(expected, expected | type,
+                                              std::memory_order_release));
+        // high 32 bits signal is always valid, they can be trigger multiple
+        // times. low 32 bits signal only trigger once.
+        return static_cast<SignalType>(validSignal |
+                                       (type & detail::high32bits_mask));
+    }
+
+    struct PrivateConstructTag {};
+
+public:
+    Signal(PrivateConstructTag){};
+    // Same type Signal can only trigger once. This function emit a signal to
+    // binding slots, then execute the slot callback functions. It will return
+    // the signal which success triggered. If no signal success triggger, return
+    // SignalType::none.
+    SignalType emit(SignalType state) noexcept;
+
+    // Return now signal type.
+    SignalType state() const noexcept {
+        return static_cast<SignalType>(_state.load(std::memory_order_acquire));
+    }
+    // Create Signal by Factory function.
+    //
+    template <typename T = Signal>
+    static std::shared_ptr<T> create() {
+        static_assert(std::is_base_of_v<Signal, T>,
+                      "T should be signal or derived from Signal");
+        return std::make_shared<T>(PrivateConstructTag{});
+    }
+    virtual ~Signal();
+
+private:
+    // Default _state is zero. It's value means what signal type has triggered.
+    // It was updated by UpdateState(). If a signal is low 32bits, it can't emit
+    // multiple times.
+    std::atomic<uint64_t> _state;
+    std::atomic<detail::SignalSlotSharedState*> _slotsHead;
+};
+namespace detail {
+// Each Slot has a reference to SignalSlotSharedState.
+// SignalSlotSharedState lifetime is managed by Signal.
+// It will destructed when Signal destructed.
+struct SignalSlotSharedState {
+    // The type of Signal Handler
+    using Handler = util::move_only_function<void(SignalType, Signal*)>;
+    // The type of Transfer Signal Handler
+    using ChainedSignalHandler = util::move_only_function<void(SignalType)>;
+    struct HandlerManager {
+        uint8_t _index;
+        std::atomic<Handler*> _handler;
+        HandlerManager* _next;
+        HandlerManager(uint8_t index, HandlerManager* next)
+            : _index(index), _next(next) {}
+        void releaseNodes() {
+            for (HandlerManager* tmp = _next; tmp != nullptr; tmp = _next) {
+                _next = _next->_next;
+                delete tmp;
+            }
+            delete this;
+        }
+        ~HandlerManager();
+        static inline Handler emittedTag;
+    };
+    static bool isMultiTriggerSignal(SignalType type) {
+        return type >= MinMultiTriggerSignal;
+    }
+    SignalSlotSharedState(SignalType filter)
+        : _handlerManager(), _filter(filter), _next(nullptr) {}
+    ~SignalSlotSharedState();
+    void releaseNodes() {
+        for (SignalSlotSharedState *node = this->_next, *next_node;
+             node != nullptr; node = next_node) {
+            next_node = node->_next;
+            delete node;
+        }
+        delete this;
+    }
+    bool triggered(SignalType state) const noexcept {
+        return static_cast<uint64_t>(state) &
+               static_cast<uint64_t>(_filter.load(std::memory_order_acquire));
+    }
+    void setFilter(SignalType filter) noexcept {
+        _filter.store(filter, std::memory_order_release);
+    }
+    SignalType getFilter() const noexcept {
+        return _filter.load(std::memory_order_acquire);
+    }
+    void invoke(SignalType type, SignalType signal, Signal* self,
+                std::atomic<Handler*>& handlerPtr);
+    void operator()(SignalType type, Signal* self);
+    std::atomic<HandlerManager*> _handlerManager;
+    std::atomic<ChainedSignalHandler*> _chainedSignalHandler;
+    std::atomic<SignalType> _filter;
+    SignalSlotSharedState* _next;
+};
+}  // namespace detail
+
+// `Slot` is used to receive signals for an asynchronous task. We can create a
+// signal through factory methods and bind multiple `Slot`s to the same
+// `Signal`. When a `Signal` is triggered, all `Slot`s will receive the
+// corresponding signal. When construct Slot, we should bing it to a signal and
+// extend the signal's life-time by own a shared_ptr of signal. Since each
+// asynchronous task should own its own `Slot`, slot objects are not
+// thread-safe. We prohibit the concurrent invocation of the public interface of
+// the same `Slot`.
+
+class Slot {
+    friend class Signal;
+
+public:
+    // regist a slot to signal
+    Slot(Signal* signal, SignalType filter = SignalType::All)
+        : _signal(signal->shared_from_this()),
+          _node(signal->registSlot(filter)){};
+    Slot(const Slot&) = delete;
+
+public:
+    // Register a signal handler. Returns false if the signal has
+    // already been triggered(and signal can't trigger twice).
+    template <typename... Args>
+    [[nodiscard]] bool emplace(SignalType type, Args&&... args) {
+        static_assert(sizeof...(args) >= 1,
+                      "we dont allow emplace an empty signal handler");
+        logicAssert(std::popcount(static_cast<uint64_t>(type)) == 1,
+                    "It's not allow to emplace for multiple signals");
+        // trigger-once signal has already been triggered
+        if (!detail::SignalSlotSharedState::isMultiTriggerSignal(type) &&
+            (signal()->state() & type)) {
+            return false;
+        }
+        auto handler = std::make_unique<detail::SignalSlotSharedState::Handler>(
+            std::forward<Args>(args)...);
+        auto oldHandlerPtr = loadHandler<true>(type);
+        auto oldHandler = oldHandlerPtr->load(std::memory_order_acquire);
+        if (oldHandler ==
+            &detail::SignalSlotSharedState::HandlerManager::emittedTag) {
+            return false;
+        }
+        auto new_handler = handler.release();
+        if (!oldHandlerPtr->compare_exchange_strong(
+                oldHandler, new_handler, std::memory_order_release)) {
+            // if slot is triggered and new emplace handler doesn't exec, return
+            // false
+            assert(oldHandler ==
+                   &detail::SignalSlotSharedState::HandlerManager::emittedTag);
+            delete new_handler;
+            return false;
+        }
+        delete oldHandler;
+        return true;
+    }
+    // Clear the signal handler. If return false, it indicates
+    // that the signal handler has been executed or handler is empty
+    bool clear(SignalType type) {
+        logicAssert(std::popcount(static_cast<uint64_t>(type)) == 1,
+                    "It's not allow to emplace for multiple signals");
+        auto oldHandlerPtr = loadHandler<false>(type);
+        if (oldHandlerPtr == nullptr) {
+            return false;
+        }
+        auto oldHandler = oldHandlerPtr->load(std::memory_order_acquire);
+        if (oldHandler ==
+                &detail::SignalSlotSharedState::HandlerManager::emittedTag ||
+            oldHandler == nullptr) {
+            return false;
+        }
+        if (!oldHandlerPtr->compare_exchange_strong(
+                oldHandler, nullptr, std::memory_order_release)) {
+            assert(oldHandler ==
+                   &detail::SignalSlotSharedState::HandlerManager::emittedTag);
+            return false;
+        }
+        delete oldHandler;
+        return true;
+    }
+
+    class FilterGuard {
+        friend class Slot;
+
+    public:
+        ~FilterGuard() noexcept { _slot->_node.setFilter(_oldFilter); }
+
+    private:
+        FilterGuard(Slot* slot, SignalType newFilter) noexcept
+            : _slot(slot), _oldFilter(_slot->getFilter()) {
+            auto filter = static_cast<uint64_t>(_oldFilter) &
+                          static_cast<uint64_t>(newFilter);
+            _slot->_node.setFilter(static_cast<SignalType>(filter));
+        }
+        Slot* _slot;
+        SignalType _oldFilter;
+    };
+
+    // Filter signals within the specified scope. If signal type & filter is 0,
+    // then the signal type will not be triggered within this scope. Nested
+    // filters are allowed.
+    // The returned guard object can be used to restore the previous filter.
+    // It's life-time must shorter than Slot.
+    [[nodiscard]] FilterGuard setScopedFilter(SignalType filter) noexcept {
+        return FilterGuard{this, filter};
+    }
+    // Set the current scope's filter.
+    void setFilter(SignalType filter) noexcept { _node.setFilter(filter); }
+
+    // Get the current scope's filter.
+    SignalType getFilter() const noexcept { return _node.getFilter(); }
+
+    // Check whether the filtered signal has emitted.
+    // if return true, the signal has emitted(but handler may hasn't execute
+    // now)
+    bool hasTriggered(SignalType type) const noexcept {
+        return _node.triggered(
+            static_cast<SignalType>(signal()->state() & type));
+    }
+    bool canceled() const noexcept {
+        return hasTriggered(SignalType::Terminate);
+    }
+
+    // The slot holds ownership of the corresponding signal, so the signal's
+    // lifetime is always no shorter than the slot's. To extend the signal's
+    // lifetime, you can call signal()->shared_from_this(), or start a new
+    // coroutine with the signal.
+    Signal* signal() const noexcept { return _signal.get(); }
+
+    // bind a chained signal to this slot. all triggered signal will transfer to
+    // this chainedSignal.
+    void chainedSignal(Signal* chainedSignal) {
+        if (chainedSignal == nullptr) {
+            _node._chainedSignalHandler = nullptr;
+            return;
+        }
+
+        _node._chainedSignalHandler.store(
+            new detail::SignalSlotSharedState::ChainedSignalHandler(
+                [chainedSignal =
+                     chainedSignal->weak_from_this()](SignalType type) {
+                    if (auto signal = chainedSignal.lock(); signal != nullptr) {
+                        signal->emit(type);
+                    }
+                }),
+            std::memory_order_release);
+    }
+    ~Slot() {
+        delete _node._chainedSignalHandler.exchange(nullptr,
+                                                    std::memory_order_release);
+    }
+
+private:
+    template <bool should_emplace>
+    std::atomic<detail::SignalSlotSharedState::Handler*>* loadHandler(
+        SignalType type) {
+        uint8_t index = std::countr_zero(static_cast<uint64_t>(type));
+        if (auto iter = _handlerTables.find(index);
+            iter != _handlerTables.end()) {
+            return iter->second;
+        }
+        if constexpr (!should_emplace) {
+            return nullptr;
+        } else {
+            auto handlerManager =
+                _node._handlerManager.load(std::memory_order_acquire);
+            auto newManager = new detail::SignalSlotSharedState::HandlerManager(
+                index, handlerManager);
+            // It's ok here, write only has once thread
+            _node._handlerManager.store(newManager, std::memory_order_release);
+            _handlerTables.emplace(index, &newManager->_handler);
+            return &newManager->_handler;
+        }
+    }
+
+    // TODO: may be flatmap better?
+    std::unordered_map<uint8_t,
+                       std::atomic<detail::SignalSlotSharedState::Handler*>*>
+        _handlerTables;
+    std::shared_ptr<Signal> _signal;
+    detail::SignalSlotSharedState& _node;
+};
+
+class SignalException : public std::runtime_error {
+private:
+    SignalType _signal;
+
+public:
+    explicit SignalException(SignalType signal, std::string msg = "")
+        : std::runtime_error(std::move(msg)), _signal(signal) {}
+    SignalType value() const { return _signal; }
+};
+
+// those helper cancel functions are used for coroutine await_resume,
+// await_suspend & await_ready
+
+struct signalHelper {
+    signalHelper(SignalType sign) : _sign(sign) {}
+    template <typename... Args>
+    [[nodiscard]] bool tryEmplace(Slot* slot, Args&&... args) noexcept {
+        if (slot &&
+            !slot->emplace(_sign,
+                           std::forward<Args>(args)...)) {  // has canceled
+            return false;
+        }
+        return true;
+    }
+
+    void checkHasCanceled(Slot* slot, std::string error_msg = "") {
+        if (slot && !slot->clear(_sign) && slot->canceled()) {
+            if (error_msg.empty()) {
+                error_msg =
+                    "async-simple signal triggered and throw exception, signal "
+                    "no: " +
+                    std::to_string(std::countr_zero(uint64_t{_sign}));
+            }
+            // TODO: may add option for user to wait signal handler finished?
+            throw SignalException{_sign, std::move(error_msg)};
+        }
+    }
+
+    bool hasCanceled(const Slot* slot) noexcept {
+        return slot && slot->hasTriggered(_sign);
+    }
+    SignalType _sign;
+};
+
+inline void detail::SignalSlotSharedState::invoke(
+    SignalType type, SignalType signal, Signal* self,
+    std::atomic<SignalSlotSharedState::Handler*>& handlerPtr) {
+    if (!isMultiTriggerSignal(type)) {
+        if (auto* handler = handlerPtr.exchange(
+                &SignalSlotSharedState::HandlerManager::emittedTag,
+                std::memory_order_acq_rel);
+            handler != nullptr) {
+            (*handler)(signal, self);
+            delete handler;
+        }
+    } else {
+        if (auto* handler = handlerPtr.load(std::memory_order_acquire);
+            handler != nullptr) {
+            (*handler)(signal, self);
+        }
+    }
+}
+
+inline void detail::SignalSlotSharedState::operator()(SignalType type,
+                                                      Signal* self) {
+    uint64_t state = type & _filter.load(std::memory_order_acquire);
+    auto handlerManager = _handlerManager.load(std::memory_order_acquire);
+    if (auto* handler = _chainedSignalHandler.load(std::memory_order_acquire);
+        handler != nullptr && state) {
+        (*handler)(static_cast<SignalType>(state));
+    }
+    while (state && handlerManager) {
+        SignalType nowSignal =
+            static_cast<SignalType>(uint64_t{1} << handlerManager->_index);
+        if (nowSignal & state) {
+            invoke(nowSignal, static_cast<SignalType>(state), self,
+                   handlerManager->_handler);
+            state ^= nowSignal;
+        }
+        handlerManager = handlerManager->_next;
+    }
+}
+
+inline detail::SignalSlotSharedState::~SignalSlotSharedState() {
+    if (auto manager = _handlerManager.load(std::memory_order_acquire);
+        manager) {
+        manager->releaseNodes();
+    }
+}
+
+inline SignalType Signal::emit(SignalType state) noexcept {
+    if (state != SignalType::None) {
+        SignalType vaildSignal = UpdateState(_state, state);
+        if (vaildSignal) {
+            for (detail::SignalSlotSharedState* node =
+                     _slotsHead.load(std::memory_order_acquire);
+                 node != nullptr; node = node->_next) {
+                (*node)(vaildSignal, this);
+            }
+        }
+        return vaildSignal;
+    }
+    return SignalType::None;
+}
+
+inline detail::SignalSlotSharedState& Signal::registSlot(SignalType filter) {
+    auto next_node = _slotsHead.load(std::memory_order_acquire);
+    auto* node = new detail::SignalSlotSharedState{filter};
+    node->_next = next_node;
+    while (!_slotsHead.compare_exchange_weak(node->_next, node,
+                                             std::memory_order_release,
+                                             std::memory_order_relaxed))
+        ;
+    return *node;
+}
+
+inline Signal::~Signal() {
+    if (auto node = _slotsHead.load(std::memory_order_acquire);
+        node != nullptr) {
+        node->releaseNodes();
+    }
+}
+
+inline detail::SignalSlotSharedState::HandlerManager::~HandlerManager() {
+    auto handler = _handler.load(std::memory_order_acquire);
+    if (handler != &HandlerManager::emittedTag) {
+        delete _handler;
+    }
+}
+
+}  // namespace async_simple
+
+#endif  // ASYNC_SIMPLE_SIGNAL_H
\ No newline at end of file
diff --git a/include/ylt/thirdparty/async_simple/Traits.h b/include/ylt/thirdparty/async_simple/Traits.h
index 60b32a09a..409ae3d03 100644
--- a/include/ylt/thirdparty/async_simple/Traits.h
+++ b/include/ylt/thirdparty/async_simple/Traits.h
@@ -16,10 +16,10 @@
 #ifndef ASYNC_SIMPLE_TRAITS_H
 #define ASYNC_SIMPLE_TRAITS_H
 
-#include <exception>
-#include "async_simple/Common.h"
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include "async_simple/Try.h"
-#include "async_simple/Unit.h"
+
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 
diff --git a/include/ylt/thirdparty/async_simple/Try.h b/include/ylt/thirdparty/async_simple/Try.h
index 8ec401893..2a13d544e 100644
--- a/include/ylt/thirdparty/async_simple/Try.h
+++ b/include/ylt/thirdparty/async_simple/Try.h
@@ -16,15 +16,17 @@
 #ifndef ASYNC_SIMPLE_TRY_H
 #define ASYNC_SIMPLE_TRY_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <cassert>
 #include <exception>
 #include <functional>
-#include <new>
 #include <utility>
 #include <variant>
 #include "async_simple/Common.h"
 #include "async_simple/Unit.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 // Forward declaration
@@ -70,8 +72,7 @@ class Try {
     }
 
     template <class... U>
-    Try(U&&... value)
-        requires std::is_constructible_v<T, U...>
+    Try(U&&... value) requires std::is_constructible_v<T, U...>
         : _value(std::in_place_type<T>, std::forward<U>(value)...) {}
 
     Try(std::exception_ptr error) : _value(error) {}
@@ -174,7 +175,7 @@ class Try<void> {
     bool hasError() const { return _error.operator bool(); }
 
     void setException(std::exception_ptr error) { _error = error; }
-    std::exception_ptr getException() { return _error; }
+    std::exception_ptr getException() const { return _error; }
 
 private:
     std::exception_ptr _error;
diff --git a/include/ylt/thirdparty/async_simple/Unit.h b/include/ylt/thirdparty/async_simple/Unit.h
index 4217282d9..6989300db 100644
--- a/include/ylt/thirdparty/async_simple/Unit.h
+++ b/include/ylt/thirdparty/async_simple/Unit.h
@@ -16,10 +16,6 @@
 #ifndef ASYNC_SIMPLE_UNIT_H
 #define ASYNC_SIMPLE_UNIT_H
 
-#include <exception>
-#include "async_simple/Common.h"
-#include "async_simple/Try.h"
-
 namespace async_simple {
 
 // Unit plays the role of a simplest type in case we couldn't
diff --git a/include/ylt/thirdparty/async_simple/async_simple.cppm b/include/ylt/thirdparty/async_simple/async_simple.cppm
new file mode 100644
index 000000000..3d3a9df45
--- /dev/null
+++ b/include/ylt/thirdparty/async_simple/async_simple.cppm
@@ -0,0 +1,77 @@
+// There unhandled macro uses found in the body:
+//	'CPU_SETSIZE' defined in /usr/include/sched.h:82:10
+//	'CPU_ISSET' defined in /usr/include/sched.h:85:10
+//	'CPU_ZERO' defined in /usr/include/sched.h:87:10
+//	'CPU_SET' defined in /usr/include/sched.h:83:10
+module;
+// WARNING: Detected unhandled non interesting includes.
+// It is not suggested mix includes and imports from the compiler's
+// perspective. Since it may introduce redeclarations within different
+// translation units and the compiler is not able to handle such patterns
+// efficiently.
+//
+// See
+// https://clang.llvm.org/docs/StandardCPlusPlusModules.html#performance-tips
+#include <stdio.h>
+#include <cassert>
+#include <climits>
+#include <version>
+
+#ifdef __linux__
+#include <sched.h>
+#endif
+
+export module async_simple;
+import std;
+#define ASYNC_SIMPLE_USE_MODULES
+export extern "C++" {
+  #include "util/move_only_function.h"
+  #include "coro/Traits.h"
+  #include "MoveWrapper.h"
+  #include "experimental/coroutine.h"
+  #include "Executor.h"
+  #include "CommonMacros.h"
+  #include "Common.h"
+  #include "Unit.h"
+  #include "Try.h"
+  #include "FutureState.h"
+  #include "LocalState.h"
+  #include "Traits.h"
+  #include "Future.h"
+  #include "Promise.h"
+  #include "coro/DetachedCoroutine.h"
+  #include "coro/ViaCoroutine.h"
+  #include "coro/Lazy.h"
+  #include "uthread/internal/thread_impl.h"
+  #include "uthread/Await.h"
+  #include "uthread/Latch.h"
+  #include "uthread/internal/thread.h"
+  #include "uthread/Uthread.h"
+  #include "uthread/Async.h"
+  #include "coro/ConditionVariable.h"
+  #include "coro/SpinLock.h"
+  #include "coro/Latch.h"
+  #include "coro/CountEvent.h"
+  #include "coro/Collect.h"
+  #include "IOExecutor.h"
+  #include "coro/SharedMutex.h"
+  #include "uthread/Collect.h"
+  #include "executors/SimpleIOExecutor.h"
+  #include "coro/Mutex.h"
+  #include "Collect.h"
+  #include "util/Condition.h"
+  #include "coro/Dispatch.h"
+  #include "coro/Sleep.h"
+  #include "util/Queue.h"
+  #include "util/ThreadPool.h"
+  #include "coro/ResumeBySchedule.h"
+  #include "coro/FutureAwaiter.h"
+  #include "coro/SyncAwait.h"
+  #include "executors/SimpleExecutor.h"
+  #include "coro/Semaphore.h"
+  // There are some bugs in clang lower versions.
+#if defined(__clang_major__)  && __clang_major__ >= 17
+  #include "coro/PromiseAllocator.h"
+  #include "coro/Generator.h"
+#endif
+}
diff --git a/include/ylt/thirdparty/async_simple/coro/Collect.h b/include/ylt/thirdparty/async_simple/coro/Collect.h
index 16f239672..cb224556a 100644
--- a/include/ylt/thirdparty/async_simple/coro/Collect.h
+++ b/include/ylt/thirdparty/async_simple/coro/Collect.h
@@ -16,21 +16,26 @@
 #ifndef ASYNC_SIMPLE_CORO_COLLECT_H
 #define ASYNC_SIMPLE_CORO_COLLECT_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <array>
 #include <exception>
 #include <memory>
-#include <optional>
+#include <system_error>
 #include <type_traits>
 #include <utility>
 #include <variant>
 #include <vector>
 #include "async_simple/Common.h"
+#include "async_simple/Signal.h"
 #include "async_simple/Try.h"
 #include "async_simple/Unit.h"
 #include "async_simple/coro/CountEvent.h"
 #include "async_simple/coro/Lazy.h"
+#include "async_simple/coro/LazyLocalBase.h"
 #include "async_simple/experimental/coroutine.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace coro {
 
@@ -48,12 +53,17 @@ namespace detail {
 template <typename T>
 struct CollectAnyResult {
     CollectAnyResult() : _idx(static_cast<size_t>(-1)), _value() {}
-    CollectAnyResult(size_t idx, std::add_rvalue_reference_t<T> value) requires(
-        !std::is_void_v<T>)
+    CollectAnyResult(size_t idx, std::add_rvalue_reference_t<T> value)
         : _idx(idx), _value(std::move(value)) {}
 
     CollectAnyResult(const CollectAnyResult&) = delete;
     CollectAnyResult& operator=(const CollectAnyResult&) = delete;
+    CollectAnyResult& operator=(CollectAnyResult&& other) {
+        _idx = std::move(other._idx);
+        _value = std::move(other._value);
+        other._idx = static_cast<size_t>(-1);
+        return *this;
+    }
     CollectAnyResult(CollectAnyResult&& other)
         : _idx(std::move(other._idx)), _value(std::move(other._value)) {
         other._idx = static_cast<size_t>(-1);
@@ -84,177 +94,124 @@ struct CollectAnyResult {
 #endif
 };
 
-template <typename LazyType, typename InAlloc, typename Callback = Unit>
+template <>
+struct CollectAnyResult<void> {
+    CollectAnyResult() : _idx(static_cast<size_t>(-1)), _value() {}
+    CollectAnyResult(size_t idx) : _idx(idx) {}
+
+    CollectAnyResult(const CollectAnyResult&) = delete;
+    CollectAnyResult& operator=(const CollectAnyResult&) = delete;
+    CollectAnyResult& operator=(CollectAnyResult&& other) {
+        _idx = std::move(other._idx);
+        _value = std::move(other._value);
+        other._idx = static_cast<size_t>(-1);
+        return *this;
+    }
+    CollectAnyResult(CollectAnyResult&& other)
+        : _idx(std::move(other._idx)), _value(std::move(other._value)) {
+        other._idx = static_cast<size_t>(-1);
+    }
+
+    size_t _idx;
+    Try<void> _value;
+
+    size_t index() const { return _idx; }
+
+    bool hasError() const { return _value.hasError(); }
+    // Require hasError() == true. Otherwise it is UB to call
+    // this method.
+    std::exception_ptr getException() const { return _value.getException(); }
+};
+
+template <typename LazyType, typename InAlloc>
 struct CollectAnyAwaiter {
     using ValueType = typename LazyType::ValueType;
     using ResultType = CollectAnyResult<ValueType>;
 
-    CollectAnyAwaiter(std::vector<LazyType, InAlloc>&& input)
-        : _input(std::move(input)), _result(nullptr) {}
-
-    CollectAnyAwaiter(std::vector<LazyType, InAlloc>&& input, Callback callback)
-        : _input(std::move(input)),
+    CollectAnyAwaiter(Slot* slot, SignalType SignalType,
+                      std::vector<LazyType, InAlloc>&& input)
+        : _slot(slot),
+          _SignalType(SignalType),
           _result(nullptr),
-          _callback(std::move(callback)) {}
+          _input(std::move(input)) {}
 
     CollectAnyAwaiter(const CollectAnyAwaiter&) = delete;
     CollectAnyAwaiter& operator=(const CollectAnyAwaiter&) = delete;
     CollectAnyAwaiter(CollectAnyAwaiter&& other)
-        : _input(std::move(other._input)),
+        : _slot(other._slot),
+          _SignalType(other._SignalType),
           _result(std::move(other._result)),
-          _callback(std::move(other._callback)) {}
+          _input(std::move(other._input)) {}
 
     bool await_ready() const noexcept {
-        return _input.empty() ||
-               (_result && _result->_idx != static_cast<size_t>(-1));
+        return _input.empty() || signalHelper{Terminate}.hasCanceled(_slot);
     }
 
-    void await_suspend(std::coroutine_handle<> continuation) {
+    bool await_suspend(std::coroutine_handle<> continuation) {
         auto promise_type =
             std::coroutine_handle<LazyPromiseBase>::from_address(
                 continuation.address())
                 .promise();
+
         auto executor = promise_type._executor;
-        // we should take care of input's life-time after resume.
-        std::vector<LazyType, InAlloc> input(std::move(_input));
-        // Make local copies to shared_ptr to avoid deleting objects too early
-        // if any coroutine finishes before this function.
-        auto result = std::make_shared<ResultType>();
-        auto event = std::make_shared<detail::CountEvent>(input.size());
-        auto callback = std::move(_callback);
-
-        _result = result;
-        for (size_t i = 0;
-             i < input.size() && (result->_idx == static_cast<size_t>(-1));
-             ++i) {
-            if (!input[i]._coro.promise()._executor) {
-                input[i]._coro.promise()._executor = executor;
-            }
 
-            if constexpr (std::is_same_v<Callback, Unit>) {
-                (void)callback;
-                input[i].start([i, size = input.size(), r = result,
-                                c = continuation,
-                                e = event](Try<ValueType>&& result) mutable {
-                    assert(e != nullptr);
+        // Make local copies to shared_ptr to avoid deleting objects too early
+        // if coroutine resume before this function.
+        auto input = std::move(_input);
+        auto event = std::make_shared<detail::CountEvent>(input.size() + 1);
+        auto signal = Signal::create();
+        if (_slot)
+            _slot->chainedSignal(signal.get());
+        if (!signalHelper{Terminate}.tryEmplace(
+                _slot, [c = continuation, e = event, size = input.size()](
+                           SignalType type, Signal*) mutable {
                     auto count = e->downCount();
-                    if (count == size + 1) {
-                        r->_idx = i;
-                        r->_value = std::move(result);
+                    if (count > size + 1) {
                         c.resume();
                     }
-                });
-            } else {
-                input[i].start([i, size = input.size(), r = result,
-                                c = continuation, e = event,
-                                callback](Try<ValueType>&& result) mutable {
+                })) {  // has canceled
+            return false;
+        }
+
+        for (size_t i = 0; i < input.size(); ++i) {
+            if (!input[i]._coro.promise()._executor) {
+                input[i]._coro.promise()._executor = executor;
+            }
+            std::unique_ptr<LazyLocalBase> local;
+            local = std::make_unique<LazyLocalBase>(signal.get());
+            input[i]._coro.promise()._lazy_local = local.get();
+            input[i].start(
+                [this, i, size = input.size(), c = continuation, e = event,
+                 local = std::move(local)](Try<ValueType>&& result) mutable {
                     assert(e != nullptr);
                     auto count = e->downCount();
-                    if (count == size + 1) {
-                        r->_idx = i;
-                        (void)(*callback)(i, std::move(result));
+                    // n+1: n coro + 1 cancel handler
+                    if (count > size + 1) {
+                        _result = std::make_unique<ResultType>();
+                        _result->_idx = i;
+                        _result->_value = std::move(result);
+                        if (auto ptr = local->getSlot(); ptr) {
+                            ptr->signal()->emit(_SignalType);
+                        }
                         c.resume();
                     }
                 });
-            }
         }  // end for
+        return true;
     }
     auto await_resume() {
-        if constexpr (std::is_same_v<Callback, Unit>) {
-            assert(_result != nullptr);
-            return std::move(*_result);
-        } else {
-            return _result->index();
+        signalHelper{Terminate}.checkHasCanceled(
+            _slot, "async_simple::CollectAny is canceled!");
+        if (_result == nullptr) {
+            return ResultType{};
         }
+        return std::move(*_result);
     }
 
+    Slot* _slot;
+    SignalType _SignalType;
+    std::unique_ptr<ResultType> _result;
     std::vector<LazyType, InAlloc> _input;
-    std::shared_ptr<ResultType> _result;
-    [[no_unique_address]] Callback _callback;
-};
-
-template <typename... Ts>
-struct CollectAnyVariadicPairAwaiter {
-    using InputType = std::tuple<Ts...>;
-
-    CollectAnyVariadicPairAwaiter(Ts&&... inputs)
-        : _input(std::move(inputs)...), _result(nullptr) {}
-
-    CollectAnyVariadicPairAwaiter(InputType&& inputs)
-        : _input(std::move(inputs)), _result(nullptr) {}
-
-    CollectAnyVariadicPairAwaiter(const CollectAnyVariadicPairAwaiter&) =
-        delete;
-    CollectAnyVariadicPairAwaiter& operator=(
-        const CollectAnyVariadicPairAwaiter&) = delete;
-    CollectAnyVariadicPairAwaiter(CollectAnyVariadicPairAwaiter&& other)
-        : _input(std::move(other._input)), _result(std::move(other._result)) {}
-
-    bool await_ready() const noexcept {
-        return _result && _result->has_value();
-    }
-
-    void await_suspend(std::coroutine_handle<> continuation) {
-        auto promise_type =
-            std::coroutine_handle<LazyPromiseBase>::from_address(
-                continuation.address())
-                .promise();
-        auto executor = promise_type._executor;
-        auto event =
-            std::make_shared<detail::CountEvent>(std::tuple_size<InputType>());
-        auto result = std::make_shared<std::optional<size_t>>();
-        _result = result;
-
-        auto input = std::move(_input);
-
-        [&]<size_t... I>(std::index_sequence<I...>) {
-            (
-                [&](auto& lazy, auto& callback) {
-                    if (result->has_value()) {
-                        return;
-                    }
-
-                    if (!lazy._coro.promise()._executor) {
-                        lazy._coro.promise()._executor = executor;
-                    }
-
-                    lazy.start([result, event, continuation,
-                                callback](auto&& res) mutable {
-                        auto count = event->downCount();
-                        if (count == std::tuple_size<InputType>() + 1) {
-                            (void)callback(std::move(res));
-                            *result = I;
-                            continuation.resume();
-                        }
-                    });
-                }(std::get<0>(std::get<I>(input)),
-                  std::get<1>(std::get<I>(input))),
-                ...);
-        }
-        (std::make_index_sequence<sizeof...(Ts)>());
-    }
-
-    auto await_resume() {
-        assert(_result != nullptr);
-        return std::move(_result->value());
-    }
-
-    std::tuple<Ts...> _input;
-    std::shared_ptr<std::optional<size_t>> _result;
-};
-
-template <typename... Ts>
-struct SimpleCollectAnyVariadicPairAwaiter {
-    using InputType = std::tuple<Ts...>;
-
-    InputType _inputs;
-
-    SimpleCollectAnyVariadicPairAwaiter(Ts&&... inputs)
-        : _inputs(std::move(inputs)...) {}
-
-    auto coAwait(Executor* ex) {
-        return CollectAnyVariadicPairAwaiter(std::move(_inputs));
-    }
 };
 
 template <template <typename> typename LazyType, typename... Ts>
@@ -262,26 +219,35 @@ struct CollectAnyVariadicAwaiter {
     using ResultType = std::variant<Try<Ts>...>;
     using InputType = std::tuple<LazyType<Ts>...>;
 
-    CollectAnyVariadicAwaiter(LazyType<Ts>&&... inputs)
-        : _input(std::make_unique<InputType>(std::move(inputs)...)),
+    CollectAnyVariadicAwaiter(Slot* slot, SignalType SignalType,
+                              LazyType<Ts>&&... inputs)
+        : _slot(slot),
+          _SignalType(SignalType),
+          _input(std::make_unique<InputType>(std::move(inputs)...)),
           _result(nullptr) {}
 
-    CollectAnyVariadicAwaiter(InputType&& inputs)
-        : _input(std::make_unique<InputType>(std::move(inputs))),
+    CollectAnyVariadicAwaiter(Slot* slot, SignalType SignalType,
+                              InputType&& inputs)
+        : _slot(slot),
+          _SignalType(SignalType),
+          _input(std::make_unique<InputType>(std::move(inputs))),
           _result(nullptr) {}
 
     CollectAnyVariadicAwaiter(const CollectAnyVariadicAwaiter&) = delete;
     CollectAnyVariadicAwaiter& operator=(const CollectAnyVariadicAwaiter&) =
         delete;
     CollectAnyVariadicAwaiter(CollectAnyVariadicAwaiter&& other)
-        : _input(std::move(other._input)), _result(std::move(other._result)) {}
+        : _slot(other._slot),
+          _SignalType(other._SignalType),
+          _input(std::move(other._input)),
+          _result(std::move(other._result)) {}
 
     bool await_ready() const noexcept {
-        return _result && _result->has_value();
+        return signalHelper{Terminate}.hasCanceled(_slot);
     }
 
     template <size_t... index>
-    void await_suspend_impl(std::index_sequence<index...>,
+    bool await_suspend_impl(std::index_sequence<index...>,
                             std::coroutine_handle<> continuation) {
         auto promise_type =
             std::coroutine_handle<LazyPromiseBase>::from_address(
@@ -289,77 +255,89 @@ struct CollectAnyVariadicAwaiter {
                 .promise();
         auto executor = promise_type._executor;
 
+        // Make local copies to avoid deleting objects too early
+        // if coroutine resume before this function.
         auto input = std::move(_input);
-        // Make local copies to shared_ptr to avoid deleting objects too early
-        // if any coroutine finishes before this function.
-        auto result = std::make_shared<std::optional<ResultType>>();
-        auto event =
-            std::make_shared<detail::CountEvent>(std::tuple_size<InputType>());
-
-        _result = result;
 
+        auto event = std::make_shared<detail::CountEvent>(
+            std::tuple_size<InputType>() + 1);
+        auto signal = Signal::create();
+        if (_slot)
+            _slot->chainedSignal(signal.get());
+        if (!signalHelper{Terminate}.tryEmplace(
+                _slot, [c = continuation, e = event](SignalType type,
+                                                     Signal*) mutable {
+                    auto count = e->downCount();
+                    if (count > std::tuple_size<InputType>() + 1) {
+                        c.resume();
+                    }
+                })) {  // has canceled
+            return false;
+        }
         (
             [&]() {
-                if (result->has_value()) {
-                    return;
+                auto& element = std::get<index>(*input);
+                if (!element._coro.promise()._executor) {
+                    element._coro.promise()._executor = executor;
                 }
-                if (!std::get<index>(*input)._coro.promise()._executor) {
-                    std::get<index>(*input)._coro.promise()._executor =
-                        executor;
-                }
-                std::get<index>(*input).start(
-                    [r = result, c = continuation,
-                     e = event](std::variant_alternative_t<index, ResultType>&&
-                                    res) mutable {
-                        assert(e != nullptr);
+                std::unique_ptr<LazyLocalBase> local;
+                local = std::make_unique<LazyLocalBase>(signal.get());
+                element._coro.promise()._lazy_local = local.get();
+                element.start(
+                    [this, c = continuation, e = event,
+                     local = std::move(local)](
+                        std::variant_alternative_t<index, ResultType>&&
+                            res) mutable {
                         auto count = e->downCount();
-                        if (count == std::tuple_size<InputType>() + 1) {
-                            *r = ResultType{std::in_place_index_t<index>(),
-                                            std::move(res)};
+                        // n+1: n coro + 1 cancel handler
+                        if (count > std::tuple_size<InputType>() + 1) {
+                            _result = std::make_unique<ResultType>(
+                                std::in_place_index_t<index>(), std::move(res));
+                            if (auto ptr = local->getSlot(); ptr) {
+                                ptr->signal()->emit(_SignalType);
+                            }
                             c.resume();
                         }
                     });
             }(),
             ...);
+        return true;
     }
 
-    void await_suspend(std::coroutine_handle<> continuation) {
-        await_suspend_impl(std::make_index_sequence<sizeof...(Ts)>{},
-                           std::move(continuation));
+    bool await_suspend(std::coroutine_handle<> continuation) {
+        return await_suspend_impl(std::make_index_sequence<sizeof...(Ts)>{},
+                                  std::move(continuation));
     }
 
     auto await_resume() {
-        assert(_result != nullptr);
-        return std::move(_result->value());
+        signalHelper{Terminate}.checkHasCanceled(
+            _slot, "async_simple::CollectAny is canceled!");
+        return std::move(*_result);
     }
 
+    async_simple::Slot* _slot;
+    SignalType _SignalType;
     std::unique_ptr<std::tuple<LazyType<Ts>...>> _input;
-    std::shared_ptr<std::optional<ResultType>> _result;
+    std::unique_ptr<ResultType> _result;
 };
 
-template <typename T, typename InAlloc, typename Callback = Unit>
+template <typename T, typename InAlloc>
 struct SimpleCollectAnyAwaitable {
     using ValueType = T;
     using LazyType = Lazy<T>;
     using VectorType = std::vector<LazyType, InAlloc>;
 
+    async_simple::Slot* _slot;
+    SignalType _SignalType;
     VectorType _input;
-    [[no_unique_address]] Callback _callback;
-
-    SimpleCollectAnyAwaitable(std::vector<LazyType, InAlloc>&& input)
-        : _input(std::move(input)) {}
 
-    SimpleCollectAnyAwaitable(std::vector<LazyType, InAlloc>&& input,
-                              Callback callback)
-        : _input(std::move(input)), _callback(std::move(callback)) {}
+    SimpleCollectAnyAwaitable(async_simple::Slot* slot, SignalType SignalType,
+                              std::vector<LazyType, InAlloc>&& input)
+        : _slot(slot), _SignalType(SignalType), _input(std::move(input)) {}
 
     auto coAwait(Executor* ex) {
-        if constexpr (std::is_same_v<Callback, Unit>) {
-            return CollectAnyAwaiter<LazyType, InAlloc>(std::move(_input));
-        } else {
-            return CollectAnyAwaiter<LazyType, InAlloc, Callback>(
-                std::move(_input), std::move(_callback));
-        }
+        return CollectAnyAwaiter<LazyType, InAlloc>(_slot, _SignalType,
+                                                    std::move(_input));
     }
 };
 
@@ -367,13 +345,17 @@ template <template <typename> typename LazyType, typename... Ts>
 struct SimpleCollectAnyVariadicAwaiter {
     using InputType = std::tuple<LazyType<Ts>...>;
 
+    Slot* _slot;
+    SignalType _SignalType;
     InputType _inputs;
 
-    SimpleCollectAnyVariadicAwaiter(LazyType<Ts>&&... inputs)
-        : _inputs(std::move(inputs)...) {}
+    SimpleCollectAnyVariadicAwaiter(Slot* slot, SignalType SignalType,
+                                    LazyType<Ts>&&... inputs)
+        : _slot(slot), _SignalType(SignalType), _inputs(std::move(inputs)...) {}
 
     auto coAwait(Executor* ex) {
-        return CollectAnyVariadicAwaiter(std::move(_inputs));
+        return CollectAnyVariadicAwaiter<LazyType, Ts...>(_slot, _SignalType,
+                                                          std::move(_inputs));
     }
 };
 
@@ -381,8 +363,13 @@ template <class Container, typename OAlloc, bool Para = false>
 struct CollectAllAwaiter {
     using ValueType = typename Container::value_type::ValueType;
 
-    CollectAllAwaiter(Container&& input, OAlloc outAlloc)
-        : _input(std::move(input)), _output(outAlloc), _event(_input.size()) {
+    CollectAllAwaiter(Slot* slot, SignalType SignalType, Container&& input,
+                      OAlloc outAlloc)
+        : _slot(slot),
+          _SignalType(SignalType),
+          _input(std::move(input)),
+          _output(outAlloc),
+          _event(_input.size()) {
         _output.resize(_input.size());
     }
     CollectAllAwaiter(CollectAllAwaiter&& other) = default;
@@ -396,16 +383,31 @@ struct CollectAllAwaiter {
             std::coroutine_handle<LazyPromiseBase>::from_address(
                 continuation.address())
                 .promise();
+        _signal = Signal::create();
+        if (_slot)
+            _slot->chainedSignal(_signal.get());
+
         auto executor = promise_type._executor;
         for (size_t i = 0; i < _input.size(); ++i) {
             auto& exec = _input[i]._coro.promise()._executor;
             if (exec == nullptr) {
                 exec = executor;
             }
-            auto&& func = [this, i]() {
-                _input[i].start([this, i](Try<ValueType>&& result) {
+            std::unique_ptr<LazyLocalBase> local;
+            local = std::make_unique<LazyLocalBase>(_signal.get());
+            _input[i]._coro.promise()._lazy_local = local.get();
+            auto&& func = [this, i, local = std::move(local)]() mutable {
+                _input[i].start([this, i, local = std::move(local)](
+                                    Try<ValueType>&& result) {
                     _output[i] = std::move(result);
-                    auto awaitingCoro = _event.down();
+                    std::size_t oldCount;
+                    auto size = _input.size();
+                    auto signal = _signal;
+                    auto signalType = _SignalType;
+                    auto awaitingCoro = _event.down(oldCount, 1);
+                    if (oldCount == size) {
+                        signal->emit(signalType);
+                    }
                     if (awaitingCoro) {
                         awaitingCoro.resume();
                     }
@@ -414,7 +416,7 @@ struct CollectAllAwaiter {
             if (Para == true && _input.size() > 1) {
                 if (exec != nullptr)
                     AS_LIKELY {
-                        exec->schedule(func);
+                        exec->schedule_move_only(std::move(func));
                         continue;
                     }
             }
@@ -428,22 +430,31 @@ struct CollectAllAwaiter {
     }
     inline auto await_resume() { return std::move(_output); }
 
+    Slot* _slot;
+    SignalType _SignalType;
     Container _input;
     std::vector<Try<ValueType>, OAlloc> _output;
     detail::CountEvent _event;
+    std::shared_ptr<Signal> _signal;
 };  // CollectAllAwaiter
 
 template <class Container, typename OAlloc, bool Para = false>
 struct SimpleCollectAllAwaitable {
+    Slot* _slot;
+    SignalType _SignalType;
     Container _input;
     OAlloc _out_alloc;
 
-    SimpleCollectAllAwaitable(Container&& input, OAlloc out_alloc)
-        : _input(std::move(input)), _out_alloc(out_alloc) {}
+    SimpleCollectAllAwaitable(Slot* slot, SignalType SignalType,
+                              Container&& input, OAlloc out_alloc)
+        : _slot(slot),
+          _SignalType(SignalType),
+          _input(std::move(input)),
+          _out_alloc(out_alloc) {}
 
     auto coAwait(Executor* ex) {
-        return CollectAllAwaiter<Container, OAlloc, Para>(std::move(_input),
-                                                          _out_alloc);
+        return CollectAllAwaiter<Container, OAlloc, Para>(
+            _slot, _SignalType, std::move(_input), _out_alloc);
     }
 };  // SimpleCollectAllAwaitable
 
@@ -460,19 +471,21 @@ struct is_lazy<Lazy<T>> : std::true_type {};
 template <bool Para, class Container,
           typename T = typename Container::value_type::ValueType,
           typename OAlloc = std::allocator<Try<T>>>
-inline auto collectAllImpl(Container input, OAlloc out_alloc = OAlloc()) {
+inline auto collectAllImpl(Slot* slot, SignalType SignalType, Container input,
+                           OAlloc out_alloc = OAlloc()) {
     using LazyType = typename Container::value_type;
     using AT = std::conditional_t<
         is_lazy<LazyType>::value,
         detail::SimpleCollectAllAwaitable<Container, OAlloc, Para>,
         detail::CollectAllAwaiter<Container, OAlloc, Para>>;
-    return AT(std::move(input), out_alloc);
+    return AT(slot, SignalType, std::move(input), out_alloc);
 }
 
 template <bool Para, class Container,
           typename T = typename Container::value_type::ValueType,
           typename OAlloc = std::allocator<Try<T>>>
-inline auto collectAllWindowedImpl(size_t maxConcurrency,
+inline auto collectAllWindowedImpl(Slot* slot, SignalType SignalType,
+                                   size_t maxConcurrency,
                                    bool yield /*yield between two batchs*/,
                                    Container input, OAlloc out_alloc = OAlloc())
     -> Lazy<std::vector<Try<T>, OAlloc>> {
@@ -488,7 +501,7 @@ inline auto collectAllWindowedImpl(size_t maxConcurrency,
     // input_size <= maxConcurrency size;
     // act just like CollectAll.
     if (maxConcurrency == 0 || input_size <= maxConcurrency) {
-        co_return co_await AT(std::move(input), out_alloc);
+        co_return co_await AT(slot, SignalType, std::move(input), out_alloc);
     }
     size_t start = 0;
     while (start < input_size) {
@@ -499,7 +512,8 @@ inline auto collectAllWindowedImpl(size_t maxConcurrency,
             std::make_move_iterator(input.begin() + start),
             std::make_move_iterator(input.begin() + end));
         start = end;
-        for (auto& t : co_await AT(std::move(tmp_group), out_alloc)) {
+        for (auto& t :
+             co_await AT(slot, SignalType, std::move(tmp_group), out_alloc)) {
             output.push_back(std::move(t));
         }
         if (yield) {
@@ -516,25 +530,38 @@ struct CollectAllVariadicAwaiter {
     using ResultType = std::tuple<Try<Ts>...>;
     using InputType = std::tuple<LazyType<Ts>...>;
 
-    CollectAllVariadicAwaiter(LazyType<Ts>&&... inputs)
-        : _inputs(std::move(inputs)...), _event(sizeof...(Ts)) {}
-    CollectAllVariadicAwaiter(InputType&& inputs)
-        : _inputs(std::move(inputs)), _event(sizeof...(Ts)) {}
+    CollectAllVariadicAwaiter(Slot* slot, SignalType SignalType,
+                              LazyType<Ts>&&... inputs)
+        : _slot(slot),
+          _SignalType(SignalType),
+          _inputs(std::move(inputs)...),
+          _event(sizeof...(Ts)) {}
+    CollectAllVariadicAwaiter(Slot* slot, SignalType SignalType,
+                              InputType&& inputs)
+        : _slot(slot),
+          _SignalType(SignalType),
+          _inputs(std::move(inputs)),
+          _event(sizeof...(Ts)) {}
 
     CollectAllVariadicAwaiter(const CollectAllVariadicAwaiter&) = delete;
     CollectAllVariadicAwaiter& operator=(const CollectAllVariadicAwaiter&) =
         delete;
     CollectAllVariadicAwaiter(CollectAllVariadicAwaiter&&) = default;
 
-    bool await_ready() const noexcept { return false; }
+    constexpr bool await_ready() const noexcept { return false; }
 
     template <size_t... index>
     void await_suspend_impl(std::index_sequence<index...>,
                             std::coroutine_handle<> continuation) {
+        _signal = Signal::create();
+        if (_slot)
+            _slot->chainedSignal(_signal.get());
+
         auto promise_type =
             std::coroutine_handle<LazyPromiseBase>::from_address(
                 continuation.address())
                 .promise();
+
         auto executor = promise_type._executor;
 
         _event.setAwaitingCoro(continuation);
@@ -546,10 +573,20 @@ struct CollectAllVariadicAwaiter {
                 if (exec == nullptr) {
                     exec = executor;
                 }
-                auto func = [&]() {
-                    lazy.start([&](auto&& res) {
+                std::unique_ptr<LazyLocalBase> local;
+                local = std::make_unique<LazyLocalBase>(_signal.get());
+                lazy._coro.promise()._lazy_local = local.get();
+                auto func = [&, local = std::move(local)]() mutable {
+                    lazy.start([&, local = std::move(local), this](auto&& res) {
                         result = std::move(res);
-                        if (auto awaitingCoro = _event.down(); awaitingCoro) {
+                        std::size_t oldCount;
+                        auto signal = _signal;
+                        auto signalType = _SignalType;
+                        auto awaitingCoro = _event.down(oldCount, 1);
+                        if (oldCount == sizeof...(Ts)) {
+                            signal->emit(signalType);
+                        }
+                        if (awaitingCoro) {
                             awaitingCoro.resume();
                         }
                     });
@@ -557,7 +594,7 @@ struct CollectAllVariadicAwaiter {
 
                 if constexpr (Para == true && sizeof...(Ts) > 1) {
                     if (exec != nullptr)
-                        AS_LIKELY { exec->schedule(std::move(func)); }
+                        AS_LIKELY { exec->schedule_move_only(std::move(func)); }
                     else
                         AS_UNLIKELY { func(); }
                 } else {
@@ -578,153 +615,162 @@ struct CollectAllVariadicAwaiter {
 
     auto await_resume() { return std::move(_results); }
 
+    Slot* _slot;
+    SignalType _SignalType;
     InputType _inputs;
     ResultType _results;
     detail::CountEvent _event;
+    std::shared_ptr<Signal> _signal;
 };
 
 template <bool Para, template <typename> typename LazyType, typename... Ts>
 struct SimpleCollectAllVariadicAwaiter {
     using InputType = std::tuple<LazyType<Ts>...>;
 
-    SimpleCollectAllVariadicAwaiter(LazyType<Ts>&&... inputs)
-        : _input(std::move(inputs)...) {}
+    SimpleCollectAllVariadicAwaiter(Slot* slot, SignalType SignalType,
+                                    LazyType<Ts>&&... inputs)
+        : _slot(slot), _SignalType(SignalType), _input(std::move(inputs)...) {}
 
     auto coAwait(Executor* ex) {
         return CollectAllVariadicAwaiter<Para, LazyType, Ts...>(
-            std::move(_input));
+            _slot, _SignalType, std::move(_input));
     }
 
+    Slot* _slot;
+    SignalType _SignalType;
     InputType _input;
 };
 
 template <bool Para, template <typename> typename LazyType, typename... Ts>
-inline auto collectAllVariadicImpl(LazyType<Ts>&&... awaitables) {
+inline auto collectAllVariadicImpl(Slot* slot, SignalType SignalType,
+                                   LazyType<Ts>&&... awaitables) {
     static_assert(sizeof...(Ts) > 0);
     using AT = std::conditional_t<
-        is_lazy<LazyType<void>>::value && !Para,
+        is_lazy<LazyType<void>>::value,
         SimpleCollectAllVariadicAwaiter<Para, LazyType, Ts...>,
         CollectAllVariadicAwaiter<Para, LazyType, Ts...>>;
-    return AT(std::move(awaitables)...);
+    return AT(slot, SignalType, std::move(awaitables)...);
 }
 
 // collectAny
 template <typename T, template <typename> typename LazyType,
-          typename IAlloc = std::allocator<LazyType<T>>,
-          typename Callback = Unit>
-inline auto collectAnyImpl(std::vector<LazyType<T>, IAlloc> input,
-                           Callback callback = {}) {
-    using AT = std::conditional_t<
-        std::is_same_v<LazyType<T>, Lazy<T>>,
-        detail::SimpleCollectAnyAwaitable<T, IAlloc, Callback>,
-        detail::CollectAnyAwaiter<LazyType<T>, IAlloc, Callback>>;
-    return AT(std::move(input), std::move(callback));
+          typename IAlloc = std::allocator<LazyType<T>>>
+inline auto collectAnyImpl(Slot* slot, SignalType SignalType,
+                           std::vector<LazyType<T>, IAlloc> input) {
+    using AT =
+        std::conditional_t<std::is_same_v<LazyType<T>, Lazy<T>>,
+                           detail::SimpleCollectAnyAwaitable<T, IAlloc>,
+                           detail::CollectAnyAwaiter<LazyType<T>, IAlloc>>;
+    return AT(slot, SignalType, std::move(input));
 }
 
 // collectAnyVariadic
 template <template <typename> typename LazyType, typename... Ts>
-inline auto CollectAnyVariadicImpl(LazyType<Ts>&&... inputs) {
+inline auto CollectAnyVariadicImpl(Slot* slot, SignalType SignalType,
+                                   LazyType<Ts>&&... inputs) {
     using AT =
         std::conditional_t<is_lazy<LazyType<void>>::value,
                            SimpleCollectAnyVariadicAwaiter<LazyType, Ts...>,
                            CollectAnyVariadicAwaiter<LazyType, Ts...>>;
-    return AT(std::move(inputs)...);
+    return AT(slot, SignalType, std::move(inputs)...);
 }
 
-// collectAnyVariadicPair
-template <typename T, typename... Ts>
-inline auto CollectAnyVariadicPairImpl(T&& input, Ts&&... inputs) {
-    using U = std::tuple_element_t<0, std::remove_cvref_t<T>>;
-    using AT = std::conditional_t<is_lazy<U>::value,
-                                  SimpleCollectAnyVariadicPairAwaiter<T, Ts...>,
-                                  CollectAnyVariadicPairAwaiter<T, Ts...>>;
-    return AT(std::move(input), std::move(inputs)...);
-}
 }  // namespace detail
 
-template <typename T, template <typename> typename LazyType,
+template <SignalType SignalType = SignalType::None, typename T,
+          template <typename> typename LazyType,
           typename IAlloc = std::allocator<LazyType<T>>>
-inline auto collectAny(std::vector<LazyType<T>, IAlloc>&& input) {
-    return detail::collectAnyImpl(std::move(input));
-}
-
-template <typename T, template <typename> typename LazyType,
-          typename IAlloc = std::allocator<LazyType<T>>, typename Callback>
-inline auto collectAny(std::vector<LazyType<T>, IAlloc>&& input,
-                       Callback callback) {
-    auto cb = std::make_shared<Callback>(std::move(callback));
-    return detail::collectAnyImpl(std::move(input), std::move(cb));
-}
-
-template <template <typename> typename LazyType, typename... Ts>
-inline auto collectAny(LazyType<Ts>... awaitables) {
-    static_assert(sizeof...(Ts), "collectAny need at least one param!");
-    return detail::CollectAnyVariadicImpl(std::move(awaitables)...);
+inline Lazy<detail::CollectAnyResult<typename LazyType<T>::ValueType>>
+collectAny(std::vector<LazyType<T>, IAlloc>&& input) {
+    auto slot = co_await CurrentSlot{};
+    co_return co_await detail::collectAnyImpl(slot, SignalType,
+                                              std::move(input));
 }
 
-// collectAny with std::pair<Lazy, CallbackFunction>
-template <typename... Ts>
-inline auto collectAny(Ts&&... inputs) {
+template <SignalType SignalType = SignalType::None,
+          template <typename> typename LazyType, typename... Ts>
+inline Lazy<std::variant<Try<Ts>...>> collectAny(LazyType<Ts>... awaitables) {
     static_assert(sizeof...(Ts), "collectAny need at least one param!");
-    return detail::CollectAnyVariadicPairImpl(std::move(inputs)...);
+    auto slot = co_await CurrentSlot{};
+    co_return co_await detail::CollectAnyVariadicImpl(slot, SignalType,
+                                                      std::move(awaitables)...);
 }
 
 // The collectAll() function can be used to co_await on a vector of LazyType
 // tasks in **one thread**,and producing a vector of Try values containing each
 // of the results.
-template <typename T, template <typename> typename LazyType,
+template <SignalType SignalType = SignalType::None, typename T,
+          template <typename> typename LazyType,
           typename IAlloc = std::allocator<LazyType<T>>,
           typename OAlloc = std::allocator<Try<T>>>
-inline auto collectAll(std::vector<LazyType<T>, IAlloc>&& input,
-                       OAlloc out_alloc = OAlloc()) {
-    return detail::collectAllImpl<false>(std::move(input), out_alloc);
+inline Lazy<std::vector<Try<typename LazyType<T>::ValueType>, OAlloc>>
+collectAll(std::vector<LazyType<T>, IAlloc>&& input,
+           OAlloc out_alloc = OAlloc()) {
+    auto slot = co_await CurrentSlot{};
+    co_return co_await detail::collectAllImpl<false>(
+        slot, SignalType, std::move(input), out_alloc);
 }
 
 // Like the collectAll() function above, The collectAllPara() function can be
 // used to concurrently co_await on a vector LazyType tasks in executor,and
 // producing a vector of Try values containing each of the results.
-template <typename T, template <typename> typename LazyType,
+template <SignalType SignalType = SignalType::None, typename T,
+          template <typename> typename LazyType,
           typename IAlloc = std::allocator<LazyType<T>>,
           typename OAlloc = std::allocator<Try<T>>>
-inline auto collectAllPara(std::vector<LazyType<T>, IAlloc>&& input,
-                           OAlloc out_alloc = OAlloc()) {
-    return detail::collectAllImpl<true>(std::move(input), out_alloc);
+inline Lazy<std::vector<Try<typename LazyType<T>::ValueType>, OAlloc>>
+collectAllPara(std::vector<LazyType<T>, IAlloc>&& input,
+               OAlloc out_alloc = OAlloc()) {
+    auto slot = co_await CurrentSlot{};
+    co_return co_await detail::collectAllImpl<true>(
+        slot, SignalType, std::move(input), out_alloc);
 }
 
 // This collectAll function can be used to co_await on some different kinds of
 // LazyType tasks in one thread,and producing a tuple of Try values containing
 // each of the results.
-template <template <typename> typename LazyType, typename... Ts>
+template <SignalType SignalType = SignalType::None,
+          template <typename> typename LazyType, typename... Ts>
 // The temporary object's life-time which binding to reference(inputs) won't
 // be extended to next time of coroutine resume. Just Copy inputs to avoid
 // crash.
-inline auto collectAll(LazyType<Ts>... inputs) {
+inline Lazy<std::tuple<Try<typename LazyType<Ts>::ValueType>...>> collectAll(
+    LazyType<Ts>... inputs) {
     static_assert(sizeof...(Ts), "collectAll need at least one param!");
-    return detail::collectAllVariadicImpl<false>(std::move(inputs)...);
+    auto slot = co_await CurrentSlot{};
+    co_return co_await detail::collectAllVariadicImpl<false>(
+        slot, SignalType, std::move(inputs)...);
 }
 
 // Like the collectAll() function above, This collectAllPara() function can be
 // used to concurrently co_await on some different kinds of LazyType tasks in
 // executor,and producing a tuple of Try values containing each of the results.
-template <template <typename> typename LazyType, typename... Ts>
-inline auto collectAllPara(LazyType<Ts>... inputs) {
+template <SignalType SignalType = SignalType::None,
+          template <typename> typename LazyType, typename... Ts>
+inline Lazy<std::tuple<Try<typename LazyType<Ts>::ValueType>...>>
+collectAllPara(LazyType<Ts>... inputs) {
     static_assert(sizeof...(Ts), "collectAllPara need at least one param!");
-    return detail::collectAllVariadicImpl<true>(std::move(inputs)...);
+    auto slot = co_await CurrentSlot{};
+    co_return co_await detail::collectAllVariadicImpl<true>(
+        slot, SignalType, std::move(inputs)...);
 }
 
 // Await each of the input LazyType tasks in the vector, allowing at most
 // 'maxConcurrency' of these input tasks to be awaited in one thread. yield is
 // true: yield collectAllWindowedPara from thread when a 'maxConcurrency' of
 // tasks is done.
-template <typename T, template <typename> typename LazyType,
+template <SignalType SignalType = SignalType::None, typename T,
+          template <typename> typename LazyType,
           typename IAlloc = std::allocator<LazyType<T>>,
           typename OAlloc = std::allocator<Try<T>>>
-inline auto collectAllWindowed(size_t maxConcurrency,
-                               bool yield /*yield between two batchs*/,
-                               std::vector<LazyType<T>, IAlloc>&& input,
-                               OAlloc out_alloc = OAlloc()) {
-    return detail::collectAllWindowedImpl<true>(maxConcurrency, yield,
-                                                std::move(input), out_alloc);
+inline Lazy<std::vector<Try<typename LazyType<T>::ValueType>, OAlloc>>
+collectAllWindowed(size_t maxConcurrency,
+                   bool yield /*yield between two batchs*/,
+                   std::vector<LazyType<T>, IAlloc>&& input,
+                   OAlloc out_alloc = OAlloc()) {
+    auto slot = co_await CurrentSlot{};
+    co_return co_await detail::collectAllWindowedImpl<true>(
+        slot, SignalType, maxConcurrency, yield, std::move(input), out_alloc);
 }
 
 // Await each of the input LazyType tasks in the vector, allowing at most
@@ -732,15 +778,18 @@ inline auto collectAllWindowed(size_t maxConcurrency,
 // point in time.
 // yield is true: yield collectAllWindowedPara from thread when a
 // 'maxConcurrency' of tasks is done.
-template <typename T, template <typename> typename LazyType,
+template <SignalType SignalType = SignalType::None, typename T,
+          template <typename> typename LazyType,
           typename IAlloc = std::allocator<LazyType<T>>,
           typename OAlloc = std::allocator<Try<T>>>
-inline auto collectAllWindowedPara(size_t maxConcurrency,
-                                   bool yield /*yield between two batchs*/,
-                                   std::vector<LazyType<T>, IAlloc>&& input,
-                                   OAlloc out_alloc = OAlloc()) {
-    return detail::collectAllWindowedImpl<false>(maxConcurrency, yield,
-                                                 std::move(input), out_alloc);
+inline Lazy<std::vector<Try<typename LazyType<T>::ValueType>, OAlloc>>
+collectAllWindowedPara(size_t maxConcurrency,
+                       bool yield /*yield between two batchs*/,
+                       std::vector<LazyType<T>, IAlloc>&& input,
+                       OAlloc out_alloc = OAlloc()) {
+    auto slot = co_await CurrentSlot{};
+    co_return co_await detail::collectAllWindowedImpl<false>(
+        slot, SignalType, maxConcurrency, yield, std::move(input), out_alloc);
 }
 
 }  // namespace coro
diff --git a/include/ylt/thirdparty/async_simple/coro/ConditionVariable.h b/include/ylt/thirdparty/async_simple/coro/ConditionVariable.h
index 3bb9402f2..b65d4f80f 100644
--- a/include/ylt/thirdparty/async_simple/coro/ConditionVariable.h
+++ b/include/ylt/thirdparty/async_simple/coro/ConditionVariable.h
@@ -16,8 +16,12 @@
 #ifndef ASYNC_SIMPLE_CORO_CONDITION_VARIABLE_H
 #define ASYNC_SIMPLE_CORO_CONDITION_VARIABLE_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
+#include <mutex>
 #include "async_simple/coro/Lazy.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace coro {
 
diff --git a/include/ylt/thirdparty/async_simple/coro/CountEvent.h b/include/ylt/thirdparty/async_simple/coro/CountEvent.h
index 62e22dc3c..ad33b3784 100644
--- a/include/ylt/thirdparty/async_simple/coro/CountEvent.h
+++ b/include/ylt/thirdparty/async_simple/coro/CountEvent.h
@@ -16,10 +16,13 @@
 #ifndef ASYNC_SIMPLE_CORO_EVENT_H
 #define ASYNC_SIMPLE_CORO_EVENT_H
 
-#include <exception>
-#include "async_simple/Common.h"
-#include "async_simple/Executor.h"
-#include "async_simple/coro/Lazy.h"
+#ifndef ASYNC_SIMPLE_USE_MODULES
+#include <atomic>
+#include <cstddef>
+#include <utility>
+#include "async_simple/experimental/coroutine.h"
+
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 
@@ -38,9 +41,13 @@ class CountEvent {
           _awaitingCoro(std::exchange(other._awaitingCoro, nullptr)) {}
 
     [[nodiscard]] CoroHandle<> down(size_t n = 1) {
+        std::size_t oldCount;
+        return down(oldCount, n);
+    }
+    [[nodiscard]] CoroHandle<> down(size_t& oldCount, std::size_t n) {
         // read acquire and write release, _awaitingCoro store can not be
         // reordered after this barrier
-        auto oldCount = _count.fetch_sub(n, std::memory_order_acq_rel);
+        oldCount = _count.fetch_sub(n, std::memory_order_acq_rel);
         if (oldCount == 1) {
             auto awaitingCoro = _awaitingCoro;
             _awaitingCoro = nullptr;
diff --git a/include/ylt/thirdparty/async_simple/coro/DetachedCoroutine.h b/include/ylt/thirdparty/async_simple/coro/DetachedCoroutine.h
index ca11e5a6a..e1f6d6a9e 100644
--- a/include/ylt/thirdparty/async_simple/coro/DetachedCoroutine.h
+++ b/include/ylt/thirdparty/async_simple/coro/DetachedCoroutine.h
@@ -16,13 +16,13 @@
 #ifndef ASYNC_SIMPLE_CORO_DETACHED_COROUTINE_H
 #define ASYNC_SIMPLE_CORO_DETACHED_COROUTINE_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <stdio.h>
-#include <atomic>
 #include <exception>
-#include <mutex>
-#include "async_simple/Common.h"
 #include "async_simple/experimental/coroutine.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 namespace coro {
@@ -76,6 +76,15 @@ struct ReadyAwaiter {
     T _value;
 };
 
+template <>
+struct ReadyAwaiter<void> {
+    ReadyAwaiter() {}
+
+    bool await_ready() const noexcept { return true; }
+    void await_suspend(CoroHandle<>) const noexcept {}
+    void await_resume() noexcept { return; }
+};
+
 }  // namespace coro
 }  // namespace async_simple
 
diff --git a/include/ylt/thirdparty/async_simple/coro/Dispatch.h b/include/ylt/thirdparty/async_simple/coro/Dispatch.h
index e79009e9a..a90513e2e 100644
--- a/include/ylt/thirdparty/async_simple/coro/Dispatch.h
+++ b/include/ylt/thirdparty/async_simple/coro/Dispatch.h
@@ -17,6 +17,7 @@
 #ifndef ASYNC_SIMPLE_CORO_DISPATCH_H
 #define ASYNC_SIMPLE_CORO_DISPATCH_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
 #include "async_simple/coro/Lazy.h"
@@ -25,6 +26,8 @@
 #include <cassert>
 #include <type_traits>
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace coro {
 
@@ -33,24 +36,22 @@ namespace detail {
 // based on c++ coroutine common abi.
 // it is not supported that the PromiseType's align is larger than the size of
 // two function pointer.
-inline std::coroutine_handle<> GetContinuationFromHandle(
-    std::coroutine_handle<> h) {
+inline CoroHandle<> GetContinuationFromHandle(CoroHandle<> h) {
     constexpr size_t promise_offset = 2 * sizeof(void*);
     char* ptr = static_cast<char*>(h.address());
     ptr = ptr + promise_offset;
-    return std::coroutine_handle<>::from_address(
+    return CoroHandle<>::from_address(
         *static_cast<void**>(static_cast<void*>(ptr)));
 }
 
-inline void ChangeLaziessExecutorTo(std::coroutine_handle<> h, Executor* ex) {
+inline void ChangeLaziessExecutorTo(CoroHandle<> h, Executor* ex) {
     while (true) {
-        std::coroutine_handle<> continuation = GetContinuationFromHandle(h);
+        CoroHandle<> continuation = GetContinuationFromHandle(h);
         if (!continuation.address()) {
             break;
         }
         auto& promise =
-            std::coroutine_handle<LazyPromiseBase>::from_address(h.address())
-                .promise();
+            CoroHandle<LazyPromiseBase>::from_address(h.address()).promise();
         promise._executor = ex;
         h = continuation;
     }
@@ -65,7 +66,7 @@ class DispatchAwaiter {
     bool await_ready() const noexcept { return false; }
 
     template <typename PromiseType>
-    bool await_suspend(std::coroutine_handle<PromiseType> h) {
+    bool await_suspend(CoroHandle<PromiseType> h) {
         static_assert(std::is_base_of<LazyPromiseBase, PromiseType>::value,
                       "dispatch is only allowed to be called by Lazy");
         if (h.promise()._executor == _ex) {
diff --git a/include/ylt/thirdparty/async_simple/coro/FutureAwaiter.h b/include/ylt/thirdparty/async_simple/coro/FutureAwaiter.h
index b54c90444..b8ac96dab 100644
--- a/include/ylt/thirdparty/async_simple/coro/FutureAwaiter.h
+++ b/include/ylt/thirdparty/async_simple/coro/FutureAwaiter.h
@@ -16,12 +16,15 @@
 #ifndef ASYNC_SIMPLE_CORO_FUTURE_AWAITER_H
 #define ASYNC_SIMPLE_CORO_FUTURE_AWAITER_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include "async_simple/Future.h"
 #include "async_simple/coro/Lazy.h"
 #include "async_simple/experimental/coroutine.h"
 
 #include <type_traits>
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 namespace coro::detail {
@@ -32,7 +35,7 @@ struct FutureAwaiter {
     bool await_ready() { return future_.hasResult(); }
 
     template <typename PromiseType>
-    void await_suspend(std::coroutine_handle<PromiseType> continuation) {
+    void await_suspend(CoroHandle<PromiseType> continuation) {
         static_assert(std::is_base_of_v<LazyPromiseBase, PromiseType>,
                       "FutureAwaiter is only allowed to be called by Lazy");
         Executor* ex = continuation.promise()._executor;
@@ -48,7 +51,10 @@ struct FutureAwaiter {
             }
         });
     }
-    auto await_resume() { return std::move(future_.value()); }
+    auto await_resume() {
+        if constexpr (!std::is_same_v<T, void>)
+            return std::move(future_.value());
+    }
 };
 }  // namespace coro::detail
 
diff --git a/include/ylt/thirdparty/async_simple/coro/Generator.h b/include/ylt/thirdparty/async_simple/coro/Generator.h
index 21096efc4..75284cc7a 100644
--- a/include/ylt/thirdparty/async_simple/coro/Generator.h
+++ b/include/ylt/thirdparty/async_simple/coro/Generator.h
@@ -22,14 +22,16 @@
 #warning "Clang 15 is not supported for Generator due to some issues."
 #endif
 
-#if __has_include(<generator>)
+#if defined(__cpp_lib_generator) && __has_include(<generator>)
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <generator>
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple::coro {
 
 template <class Ref, class V = void, class Allocator = void>
-using Generator = std::generator<Ref, V, AlloAllocator>;
+using Generator = std::generator<Ref, V, Allocator>;
 
 }  // namespace async_simple::coro
 
@@ -42,6 +44,7 @@ using elements_of = std::ranges::elements_of<R, Alloc>;
 
 #else
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <cassert>
 #include <concepts>
 #include <cstddef>
@@ -53,6 +56,7 @@ using elements_of = std::ranges::elements_of<R, Alloc>;
 #include "async_simple/Common.h"
 #include "async_simple/coro/PromiseAllocator.h"
 #include "async_simple/experimental/coroutine.h"
+#endif
 
 namespace async_simple::ranges {
 
diff --git a/include/ylt/thirdparty/async_simple/coro/Latch.h b/include/ylt/thirdparty/async_simple/coro/Latch.h
index c8bb266c7..bbf3d14f2 100644
--- a/include/ylt/thirdparty/async_simple/coro/Latch.h
+++ b/include/ylt/thirdparty/async_simple/coro/Latch.h
@@ -17,13 +17,14 @@
 #ifndef ASYNC_SIMPLE_CORO_LATCH_H
 #define ASYNC_SIMPLE_CORO_LATCH_H
 
-#include <chrono>
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <cstddef>
 #include "async_simple/coro/ConditionVariable.h"
 #include "async_simple/coro/Lazy.h"
-#include "async_simple/coro/Mutex.h"
 #include "async_simple/coro/SpinLock.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple::coro {
 
 // The latch class is a downward counter of type std::size_t which can be
diff --git a/include/ylt/thirdparty/async_simple/coro/Lazy.h b/include/ylt/thirdparty/async_simple/coro/Lazy.h
index 1ece44c8d..e58418053 100644
--- a/include/ylt/thirdparty/async_simple/coro/Lazy.h
+++ b/include/ylt/thirdparty/async_simple/coro/Lazy.h
@@ -16,18 +16,28 @@
 #ifndef ASYNC_SIMPLE_CORO_LAZY_H
 #define ASYNC_SIMPLE_CORO_LAZY_H
 
-#include <atomic>
-#include <concepts>
+#include <system_error>
+#ifndef ASYNC_SIMPLE_USE_MODULES
+
 #include <cstddef>
 #include <cstdio>
 #include <exception>
+#include <memory>
+#include <type_traits>
+#include <utility>
 #include <variant>
 #include "async_simple/Common.h"
+#include "async_simple/Executor.h"
+#include "async_simple/Signal.h"
 #include "async_simple/Try.h"
 #include "async_simple/coro/DetachedCoroutine.h"
+#include "async_simple/coro/LazyLocalBase.h"
+#include "async_simple/coro/PromiseAllocator.h"
 #include "async_simple/coro/ViaCoroutine.h"
 #include "async_simple/experimental/coroutine.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 class Executor;
@@ -48,8 +58,16 @@ class Lazy;
 // This would suspend the executing coroutine.
 struct Yield {};
 
-template <typename T = void>
-struct LazyLocals {};
+template <typename T = LazyLocalBase>
+struct CurrentLazyLocals {};
+
+// co_await CurrentSlot{} could return the point to current
+// Slot. Return nullptr if lazy don't binding to signal.
+struct CurrentSlot {};
+
+// co_await ForbidSignal{} could forbid Signal in lazy. After
+// calling this, call `co_await CurrentSlot{}` will return nullptr.
+struct ForbidSignal {};
 
 namespace detail {
 template <class, typename OAlloc, bool Para>
@@ -58,7 +76,7 @@ struct CollectAllAwaiter;
 template <bool Para, template <typename> typename LazyType, typename... Ts>
 struct CollectAllVariadicAwaiter;
 
-template <typename LazyType, typename IAlloc, typename Callback>
+template <typename LazyType, typename IAlloc>
 struct CollectAnyAwaiter;
 
 template <template <typename> typename LazyType, typename... Ts>
@@ -71,7 +89,7 @@ struct CollectAnyVariadicPairAwaiter;
 
 namespace detail {
 
-class LazyPromiseBase {
+class LazyPromiseBase : public PromiseAllocator<void, true> {
 public:
     // Resume the caller waiting to the current coroutine. Note that we need
     // destroy the frame for the current coroutine explicitly. Since after
@@ -91,8 +109,11 @@ class LazyPromiseBase {
     };
 
     struct YieldAwaiter {
-        YieldAwaiter(Executor* executor) : _executor(executor) {}
-        bool await_ready() const noexcept { return false; }
+        YieldAwaiter(Executor* executor, Slot* slot)
+            : _executor(executor), _slot(slot) {}
+        bool await_ready() const noexcept {
+            return signalHelper{Terminate}.hasCanceled(_slot);
+        }
         template <typename PromiseType>
         void await_suspend(std::coroutine_handle<PromiseType> handle) {
             static_assert(
@@ -101,12 +122,21 @@ class LazyPromiseBase {
 
             logicAssert(_executor,
                         "Yielding is only meaningful with an executor!");
-            _executor->schedule(std::move(handle));
+            // schedule_info is YIELD here, which avoid executor always
+            // run handle immediately when other works are waiting, which may
+            // cause deadlock.
+            _executor->schedule(
+                std::move(handle),
+                static_cast<uint64_t>(Executor::Priority::YIELD));
+        }
+        void await_resume() const {
+            signalHelper{Terminate}.checkHasCanceled(
+                _slot, "async_simple::Yield/SpinLock is canceled!");
         }
-        void await_resume() noexcept {}
 
     private:
         Executor* _executor;
+        Slot* _slot;
     };
 
 public:
@@ -126,24 +156,44 @@ class LazyPromiseBase {
     }
 
     template <typename T>
-    auto await_transform(LazyLocals<T>) {
-        return ReadyAwaiter<T*>(static_cast<T*>(_lazy_local));
+    auto await_transform(CurrentLazyLocals<T>) {
+        return ReadyAwaiter<T*>(_lazy_local ? dynamicCast<T>(_lazy_local)
+                                            : nullptr);
+    }
+
+    auto await_transform(CurrentSlot) {
+        return ReadyAwaiter<Slot*>(_lazy_local ? _lazy_local->getSlot()
+                                               : nullptr);
+    }
+
+    auto await_transform(ForbidSignal) {
+        if (_lazy_local) {
+            _lazy_local->forbidSignal();
+        }
+        return ReadyAwaiter<void>();
     }
 
-    auto await_transform(Yield) { return YieldAwaiter(_executor); }
+    auto await_transform(Yield) {
+        return YieldAwaiter(_executor,
+                            _lazy_local ? _lazy_local->getSlot() : nullptr);
+    }
 
     /// IMPORTANT: _continuation should be the first member due to the
     /// requirement of dbg script.
     std::coroutine_handle<> _continuation;
     Executor* _executor;
-    void* _lazy_local;
+    LazyLocalBase* _lazy_local;
 };
 
 template <typename T>
 class LazyPromise : public LazyPromiseBase {
 public:
-    static_assert(alignof(T) <= alignof(::max_align_t),
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-alignof-expression"
+    static_assert(alignof(T) <= alignof(std::max_align_t),
                   "async_simple doesn't allow Lazy with over aligned object");
+#endif
 
     LazyPromise() noexcept {}
     ~LazyPromise() noexcept {}
@@ -273,6 +323,9 @@ struct LazyAwaiterBase {
     }
 };
 
+template <typename T, typename CB>
+concept isLazyCallback = std::is_invocable_v<CB, Try<T>>;
+
 template <typename T, bool reschedule>
 class LazyBase {
 public:
@@ -293,13 +346,13 @@ class LazyBase {
                                    PromiseType>,
                 "'co_await Lazy' is only allowed to be called by Lazy or "
                 "DetachedCoroutine");
-
             // current coro started, caller becomes my continuation
             this->_handle.promise()._continuation = continuation;
             if constexpr (std::is_base_of<LazyPromiseBase,
                                           PromiseType>::value) {
-                this->_handle.promise()._lazy_local =
-                    continuation.promise()._lazy_local;
+                LazyLocalBase*& local = this->_handle.promise()._lazy_local;
+                if (local == nullptr)
+                    local = continuation.promise()._lazy_local;
             }
             return awaitSuspendImpl();
         }
@@ -357,7 +410,7 @@ class LazyBase {
     Executor* getExecutor() { return _coro.promise()._executor; }
 
     template <typename F>
-    void start(F&& callback) requires(std::is_invocable_v<F&&, Try<T>>) {
+    void start(F&& callback) requires(isLazyCallback<T, F>) {
         logicAssert(this->_coro.operator bool(),
                     "Lazy do not have a coroutine_handle "
                     "Maybe the allocation failed or you're using a used Lazy");
@@ -390,7 +443,7 @@ class LazyBase {
     template <bool, template <typename> typename, typename...>
     friend struct detail::CollectAllVariadicAwaiter;
 
-    template <typename LazyType, typename IAlloc, typename Callback>
+    template <typename LazyType, typename IAlloc>
     friend struct detail::CollectAnyAwaiter;
 
     template <template <typename> typename LazyType, typename... Ts>
@@ -479,10 +532,57 @@ class LazyBase {
 // If any awaitable wants to derive the executor instance from its caller, it
 // should implement `coAwait(Executor*)` member method. Then the caller would
 // pass its executor instance to the awaitable.
+
+template <typename T>
+concept isDerivedFromLazyLocal = std::is_base_of_v<LazyLocalBase, T> &&
+    (std::is_same_v<LazyLocalBase, T> || requires(const T* base) {
+        std::is_same_v<decltype(T::classof(base)), bool>;
+    });
+
+namespace detail {
+inline void moveSlotFromContinuation(LazyLocalBase* nowLocal,
+                                     LazyLocalBase* preLocal) {
+    if (preLocal) {
+        // We only allow continuation has a local with LazyLocalBase type, which
+        // is designed for calling collectAll/collectAny with lazy has local
+        // variable.
+        if (preLocal->getTypeTag() == nullptr && preLocal->getSlot() &&
+            nowLocal->getSlot() == nullptr) {
+            nowLocal->_slot = std::move(preLocal->_slot);
+        } else {
+            logicAssert(false, "we dont allowed set lazy local twice");
+        }
+    }
+}
+}  // namespace detail
+
 template <typename T = void>
 class [[nodiscard]] CORO_ONLY_DESTROY_WHEN_DONE ELIDEABLE_AFTER_AWAIT Lazy
     : public detail::LazyBase<T, /*reschedule=*/false> {
     using Base = detail::LazyBase<T, false>;
+    template <isDerivedFromLazyLocal LazyLocal>
+    static Lazy<T> setLazyLocalImpl(Lazy<T> self, LazyLocal local) {
+        detail::moveSlotFromContinuation(&local, co_await CurrentLazyLocals{});
+        self._coro.promise()._lazy_local = &local;
+        co_return co_await std::move(self);
+    }
+    template <isDerivedFromLazyLocal LazyLocal>
+    static Lazy<T> setLazyLocalImpl(Lazy<T> self,
+                                    std::unique_ptr<LazyLocal> local) {
+        detail::moveSlotFromContinuation(local.get(),
+                                         co_await CurrentLazyLocals{});
+        self._coro.promise()._lazy_local = local.get();
+        co_return co_await std::move(self);
+    }
+
+    template <isDerivedFromLazyLocal LazyLocal>
+    static Lazy<T> setLazyLocalImpl(Lazy<T> self,
+                                    std::shared_ptr<LazyLocal> local) {
+        detail::moveSlotFromContinuation(local.get(),
+                                         co_await CurrentLazyLocals{});
+        self._coro.promise()._lazy_local = local.get();
+        co_return co_await std::move(self);
+    }
 
 public:
     using Base::Base;
@@ -494,16 +594,14 @@ class [[nodiscard]] CORO_ONLY_DESTROY_WHEN_DONE ELIDEABLE_AFTER_AWAIT Lazy
         logicAssert(this->_coro.operator bool(),
                     "Lazy do not have a coroutine_handle "
                     "Maybe the allocation failed or you're using a used Lazy");
-
         this->_coro.promise()._executor = ex;
         return RescheduleLazy<T>(std::exchange(this->_coro, nullptr));
     }
 
     // Bind an executor only. Don't re-schedule.
     //
-    // Users shouldn't use `setEx` directly. `setEx` is designed
-    // for internal purpose only. See uthread/Await.h/await for details.
-    Lazy<T> setEx(Executor* ex) && {
+    // This function is deprecated, please use start(cb,ex) instead of setEx.
+    [[deprecated]] Lazy<T> setEx(Executor* ex) && {
         logicAssert(this->_coro.operator bool(),
                     "Lazy do not have a coroutine_handle "
                     "Maybe the allocation failed or you're using a used Lazy");
@@ -511,6 +609,48 @@ class [[nodiscard]] CORO_ONLY_DESTROY_WHEN_DONE ELIDEABLE_AFTER_AWAIT Lazy
         return Lazy<T>(std::exchange(this->_coro, nullptr));
     }
 
+    template <isDerivedFromLazyLocal LazyLocal = LazyLocalBase>
+    Lazy<T> setLazyLocal(std::unique_ptr<LazyLocal> base) && {
+        logicAssert(this->_coro.operator bool(),
+                    "Lazy do not have a coroutine_handle "
+                    "Maybe the allocation failed or you're using a used Lazy");
+        return setLazyLocalImpl(std::move(*this), std::move(base));
+    }
+
+    template <isDerivedFromLazyLocal LazyLocal = LazyLocalBase>
+    Lazy<T> setLazyLocal(std::shared_ptr<LazyLocal> base) && {
+        logicAssert(this->_coro.operator bool(),
+                    "Lazy do not have a coroutine_handle "
+                    "Maybe the allocation failed or you're using a used Lazy");
+        return setLazyLocalImpl(std::move(*this), std::move(base));
+    }
+
+    template <isDerivedFromLazyLocal LazyLocal = LazyLocalBase,
+              typename... Args>
+    Lazy<T> setLazyLocal(Args&&... args) && {
+        logicAssert(this->_coro.operator bool(),
+                    "Lazy do not have a coroutine_handle "
+                    "Maybe the allocation failed or you're using a used Lazy");
+        if constexpr (std::is_move_constructible_v<LazyLocal>) {
+            return setLazyLocalImpl<LazyLocal>(
+                std::move(*this), LazyLocal{std::forward<Args>(args)...});
+        } else {
+            return setLazyLocalImpl<LazyLocal>(
+                std::move(*this),
+                std::make_unique<LazyLocal>(std::forward<Args>(args)...));
+        }
+    }
+
+    using Base::start;
+
+    // Bind an executor and start coroutine without scheduling immediately.
+    template <typename F>
+    void directlyStart(F&& callback, Executor* executor) requires(
+        detail::isLazyCallback<T, F>) {
+        this->_coro.promise()._executor = executor;
+        return start(std::forward<F>(callback));
+    }
+
     auto coAwait(Executor* ex) {
         logicAssert(this->_coro.operator bool(),
                     "Lazy do not have a coroutine_handle "
@@ -525,6 +665,8 @@ class [[nodiscard]] CORO_ONLY_DESTROY_WHEN_DONE ELIDEABLE_AFTER_AWAIT Lazy
     friend class RescheduleLazy<T>;
 };
 
+// dispatch a lazy to executor, dont reschedule immediately
+
 // A RescheduleLazy is a Lazy with an executor. The executor of a RescheduleLazy
 // wouldn't/shouldn't be nullptr. So we needn't check it.
 //
@@ -550,14 +692,6 @@ class [[nodiscard]] RescheduleLazy
         });
     }
 
-    RescheduleLazy<T> setLazyLocal(void* lazy_local) && {
-        logicAssert(this->_coro.operator bool(),
-                    "Lazy do not have a coroutine_handle "
-                    "Maybe the allocation failed or you're using a used Lazy");
-        this->_coro.promise()._lazy_local = lazy_local;
-        return RescheduleLazy<T>(std::exchange(this->_coro, nullptr));
-    }
-
     [[deprecated(
         "RescheduleLazy should be only allowed in DetachedCoroutine")]] auto
     operator co_await() {
diff --git a/include/ylt/thirdparty/async_simple/coro/LazyLocalBase.h b/include/ylt/thirdparty/async_simple/coro/LazyLocalBase.h
new file mode 100644
index 000000000..974875a2d
--- /dev/null
+++ b/include/ylt/thirdparty/async_simple/coro/LazyLocalBase.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2024, Alibaba Group Holding Limited;
+ *
+ * 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 ASYNC_SIMPLE_CORO_LAZYLOCALBASE_H
+#define ASYNC_SIMPLE_CORO_LAZYLOCALBASE_H
+
+#ifndef ASYNC_SIMPLE_USE_MODULES
+
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "async_simple/Common.h"
+#include "async_simple/Signal.h"
+
+#endif  // ASYNC_SIMPLE_USE_MODULES
+namespace async_simple::coro {
+class LazyLocalBase;
+namespace detail {
+
+void moveSlotFromContinuation(LazyLocalBase* nowLocal, LazyLocalBase* preLocal);
+}
+// User can derived user-defined class from Lazy Local variable to implement
+// user-define lazy local value by implement static function T::classof(const
+// LazyLocalBase*).
+
+// For example:
+// struct mylocal : public LazyLocalBase {
+
+//     inline static char tag; // support a not-null unique address for type
+//     checking
+//     // init LazyLocalBase by unique address
+//     mylocal(std::string sv) : LazyLocalBase(&tag), name(std::move(sv)) {}
+//     // derived class support implement T::classof(LazyLocalBase*), which
+//     check if this object is-a derived class of T static bool
+//     classof(const LazyLocalBase*) {
+//         return base->getTypeTag() == &tag;
+//     }
+
+//     std::string name;
+
+// };
+class LazyLocalBase {
+protected:
+    LazyLocalBase(char* typeinfo, Signal* signal = nullptr,
+                  SignalType type = SignalType::All)
+        : _typeinfo(typeinfo) {
+        assert(typeinfo != nullptr);
+    };
+
+public:
+    LazyLocalBase(LazyLocalBase&&) = default;
+    const char* getTypeTag() const noexcept { return _typeinfo; }
+    Slot* getSlot() const noexcept { return _slot.get(); }
+
+    void forbidSignal() noexcept { _slot = nullptr; }
+    virtual ~LazyLocalBase(){};
+    LazyLocalBase(Signal* signal, SignalType type = SignalType::All)
+        : _typeinfo(nullptr), _slot(std::make_unique<Slot>(signal, type)) {}
+    friend void detail::moveSlotFromContinuation(LazyLocalBase* nowLocal,
+                                                 LazyLocalBase* preLocal);
+
+protected:
+    char* _typeinfo;
+    std::unique_ptr<Slot> _slot;
+};
+
+template <typename T>
+const T* dynamicCast(const LazyLocalBase* base) noexcept {
+    assert(base != nullptr);
+    if constexpr (std::is_same_v<T, LazyLocalBase>) {
+        return base;
+    } else {
+        if (T::classof(base)) {
+            return static_cast<T*>(base);
+        } else {
+            return nullptr;
+        }
+    }
+}
+template <typename T>
+T* dynamicCast(LazyLocalBase* base) noexcept {
+    assert(base != nullptr);
+    if constexpr (std::is_same_v<T, LazyLocalBase>) {
+        return base;
+    } else {
+        if (T::classof(base)) {
+            return static_cast<T*>(base);
+        } else {
+            return nullptr;
+        }
+    }
+}
+// namespace async_simple::coro
+}  // namespace async_simple::coro
+#endif
\ No newline at end of file
diff --git a/include/ylt/thirdparty/async_simple/coro/Mutex.h b/include/ylt/thirdparty/async_simple/coro/Mutex.h
index 1c85bd86c..7e4df81b9 100644
--- a/include/ylt/thirdparty/async_simple/coro/Mutex.h
+++ b/include/ylt/thirdparty/async_simple/coro/Mutex.h
@@ -23,10 +23,13 @@
 #ifndef ASYNC_SIMPLE_CORO__MUTEXH
 #define ASYNC_SIMPLE_CORO__MUTEXH
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <atomic>
 #include <mutex>
 #include "async_simple/experimental/coroutine.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace coro {
 
@@ -157,7 +160,7 @@ class Mutex {
     private:
         friend Mutex;
 
-        std::coroutine_handle<> _awaitingCoroutine;
+        CoroHandle<> _awaitingCoroutine;
         LockAwaiter* _next;
     };
 
diff --git a/include/ylt/thirdparty/async_simple/coro/PromiseAllocator.h b/include/ylt/thirdparty/async_simple/coro/PromiseAllocator.h
index b712f94b9..e0d08c73b 100644
--- a/include/ylt/thirdparty/async_simple/coro/PromiseAllocator.h
+++ b/include/ylt/thirdparty/async_simple/coro/PromiseAllocator.h
@@ -17,6 +17,8 @@
 #ifndef ASYNC_SIMPLE_CORO_PROMISEALLOCATOR_H
 #define ASYNC_SIMPLE_CORO_PROMISEALLOCATOR_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
+#include <algorithm>
 #include <concepts>
 #include <cstring>
 #include <memory>
@@ -28,6 +30,8 @@
 // The reason why `__cpp_sized_deallocation` is not enabled is that it will
 // cause ABI breaking
 #if defined(__clang__) && defined(__GLIBCXX__)
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 void operator delete[](void* p, std::size_t sz) noexcept;
 #endif
 
@@ -69,7 +73,7 @@ concept HasRealPointers = std::same_as<Alloc, void> ||
  * stateless_void_example(std::allocator_arg, std::allocator<float>{});
  *
  */
-template <class Allocator>
+template <class Allocator, bool no_except_new = false>
 class PromiseAllocator {
 private:
     using Alloc = Rebind<Allocator>;
@@ -150,7 +154,7 @@ class PromiseAllocator {
 };
 
 template <>
-class PromiseAllocator<void> {  // type-erased allocator
+class PromiseAllocator<void, false> {  // type-erased allocator
 private:
     using DeallocFn = void (*)(void*, size_t);
 
@@ -236,8 +240,117 @@ class PromiseAllocator<void> {  // type-erased allocator
         return Allocate(al, size);
     }
 
-    static void operator delete(void* const ptr,
-                                std::size_t size) noexcept {
+    static void operator delete(void* const ptr, std::size_t size) noexcept {
+        DeallocFn dealloc;
+        ::memcpy(&dealloc, static_cast<const char*>(ptr) + size,
+                 sizeof(DeallocFn));
+        return dealloc(ptr, size);
+    }
+};
+
+template <>
+class PromiseAllocator<void, true> {  // type-erased allocator
+private:
+    using DeallocFn = void (*)(void*, size_t);
+
+    template <class ProtoAlloc>
+    static void* Allocate(const ProtoAlloc& proto, std::size_t size) noexcept {
+        using Alloc = Rebind<ProtoAlloc>;
+        auto al = static_cast<Alloc>(proto);
+
+        if constexpr (std::default_initializable<Alloc> &&
+                      std::allocator_traits<Alloc>::is_always_equal::value) {
+            // don't store stateless allocator
+            const DeallocFn dealloc = [](void* const ptr, const size_t size) {
+                Alloc al{};
+                const size_t count =
+                    (size + sizeof(DeallocFn) + sizeof(Aligned_block) - 1) /
+                    sizeof(Aligned_block);
+                al.deallocate(static_cast<Aligned_block*>(ptr), count);
+            };
+
+            const size_t count =
+                (size + sizeof(DeallocFn) + sizeof(Aligned_block) - 1) /
+                sizeof(Aligned_block);
+            void* ptr = nullptr;
+            try {
+                ptr = al.allocate(count);
+            } catch (...) {
+                return nullptr;
+            }
+            ::memcpy(static_cast<char*>(ptr) + size, &dealloc, sizeof(dealloc));
+            return ptr;
+        } else {
+            // store stateful allocator
+            static constexpr size_t Align =
+                (::std::max)(alignof(Alloc), sizeof(Aligned_block));
+
+            const DeallocFn dealloc = [](void* const ptr, size_t size) {
+                size += sizeof(DeallocFn);
+                const auto al_address = (reinterpret_cast<uintptr_t>(ptr) +
+                                         size + alignof(Alloc) - 1) &
+                                        ~(alignof(Alloc) - 1);
+                auto& stored_al = *reinterpret_cast<const Alloc*>(al_address);
+                Alloc al{::std::move(stored_al)};
+                stored_al.~Alloc();
+
+                const size_t count =
+                    (size + sizeof(al) + Align - 1) / sizeof(Aligned_block);
+                al.deallocate(static_cast<Aligned_block*>(ptr), count);
+            };
+
+            const size_t count =
+                (size + sizeof(DeallocFn) + sizeof(al) + Align - 1) /
+                sizeof(Aligned_block);
+            void* ptr = nullptr;
+            try {
+                ptr = al.allocate(count);
+            } catch (...) {
+                return nullptr;
+            }
+            ::memcpy(static_cast<char*>(ptr) + size, &dealloc, sizeof(dealloc));
+            size += sizeof(DeallocFn);
+            const auto al_address =
+                (reinterpret_cast<uintptr_t>(ptr) + size + alignof(Alloc) - 1) &
+                ~(alignof(Alloc) - 1);
+            ::new (reinterpret_cast<void*>(al_address)) Alloc{::std::move(al)};
+            return ptr;
+        }
+    }
+
+public:
+    static void* operator new(
+        const std::size_t size) noexcept {  // default: new/delete
+        void* const ptr =
+            ::operator new[](size + sizeof(DeallocFn), std::nothrow);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        const DeallocFn dealloc = [](void* const ptr, const size_t size) {
+            ::operator delete[](ptr, size + sizeof(DeallocFn));
+        };
+        ::memcpy(static_cast<char*>(ptr) + size, &dealloc, sizeof(DeallocFn));
+        return ptr;
+    }
+
+    template <class Alloc, class... Args>
+    static void* operator new(const std::size_t size, std::allocator_arg_t,
+                              const Alloc& al, const Args&...) noexcept {
+        static_assert(HasRealPointers<Alloc>,
+                      "coroutine allocators must use true pointers");
+        return Allocate(al, size);
+    }
+
+    template <class This, class Alloc, class... Args>
+    static void* operator new(const std::size_t size, const This&,
+                              std::allocator_arg_t, const Alloc& al,
+                              const Args&...) noexcept {
+        static_assert(HasRealPointers<Alloc>,
+                      "coroutine allocators must be true pointers");
+        return Allocate(al, size);
+    }
+
+    static void operator delete(void* const ptr, std::size_t size) noexcept {
         DeallocFn dealloc;
         ::memcpy(&dealloc, static_cast<const char*>(ptr) + size,
                  sizeof(DeallocFn));
diff --git a/include/ylt/thirdparty/async_simple/coro/ResumeBySchedule.h b/include/ylt/thirdparty/async_simple/coro/ResumeBySchedule.h
index 4d7e64d88..97a0bfffa 100644
--- a/include/ylt/thirdparty/async_simple/coro/ResumeBySchedule.h
+++ b/include/ylt/thirdparty/async_simple/coro/ResumeBySchedule.h
@@ -16,6 +16,7 @@
 #ifndef ASYNC_RESUME_BY_SCHEDULE_H
 #define ASYNC_RESUME_BY_SCHEDULE_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include "async_simple/Executor.h"
 #include "async_simple/Future.h"
 #include "async_simple/coro/Lazy.h"
@@ -24,6 +25,8 @@
 #include <type_traits>
 #include <utility>
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple::coro {
 
 namespace detail {
@@ -36,7 +39,7 @@ class FutureResumeByScheduleAwaiter {
     bool await_ready() { return _future.hasResult(); }
 
     template <typename PromiseType>
-    void await_suspend(std::coroutine_handle<PromiseType> continuation) {
+    void await_suspend(CoroHandle<PromiseType> continuation) {
         static_assert(std::is_base_of_v<LazyPromiseBase, PromiseType>,
                       "FutureResumeByScheduleAwaiter is only allowed to be "
                       "called by Lazy");
diff --git a/include/ylt/thirdparty/async_simple/coro/Semaphore.h b/include/ylt/thirdparty/async_simple/coro/Semaphore.h
index 6085f3789..7e0f10207 100644
--- a/include/ylt/thirdparty/async_simple/coro/Semaphore.h
+++ b/include/ylt/thirdparty/async_simple/coro/Semaphore.h
@@ -16,12 +16,14 @@
 #ifndef ASYNC_SIMPLE_CORO_SEMAHORE_H
 #define ASYNC_SIMPLE_CORO_SEMAHORE_H
 
-#include <chrono>
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <cstddef>
-#include "async_simple/Common.h"
+#include <limits>
 #include "async_simple/coro/ConditionVariable.h"
 #include "async_simple/coro/SpinLock.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple::coro {
 
 // Analogous to `std::counting_semaphore`, but it's for `Lazy`.
diff --git a/include/ylt/thirdparty/async_simple/coro/SharedMutex.h b/include/ylt/thirdparty/async_simple/coro/SharedMutex.h
index 117854868..8ef04fc4d 100644
--- a/include/ylt/thirdparty/async_simple/coro/SharedMutex.h
+++ b/include/ylt/thirdparty/async_simple/coro/SharedMutex.h
@@ -13,13 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <cassert>
 #include <climits>
 
 #include "async_simple/coro/ConditionVariable.h"
 #include "async_simple/coro/Lazy.h"
-#include "async_simple/coro/Mutex.h"
 #include "async_simple/coro/SpinLock.h"
+
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple::coro {
 
 template <typename Lock>
diff --git a/include/ylt/thirdparty/async_simple/coro/Sleep.h b/include/ylt/thirdparty/async_simple/coro/Sleep.h
index 749559396..c16e82ee5 100644
--- a/include/ylt/thirdparty/async_simple/coro/Sleep.h
+++ b/include/ylt/thirdparty/async_simple/coro/Sleep.h
@@ -16,9 +16,14 @@
 #ifndef ASYNC_SIMPLE_CORO_SLEEP_H
 #define ASYNC_SIMPLE_CORO_SLEEP_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
+#include <cstdint>
+#include <system_error>
 #include <thread>
 #include "async_simple/Executor.h"
 #include "async_simple/coro/Lazy.h"
+#include <iostream>
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 namespace coro {
@@ -26,21 +31,38 @@ namespace coro {
 // Returns an awaitable that would return after dur times.
 //
 // e.g. co_await sleep(100s);
+
 template <typename Rep, typename Period>
-Lazy<void> sleep(std::chrono::duration<Rep, Period> dur) {
+Lazy<void> sleep(Executor* ex, std::chrono::duration<Rep, Period> dur,
+                 uint64_t schedule_hint) {
+    auto slot = co_await CurrentSlot{};
+    co_await ex->after(std::chrono::duration_cast<Executor::Duration>(dur),
+                       schedule_hint, slot);
+}
+
+template <typename Rep, typename Period>
+Lazy<void> sleep(Executor* ex, std::chrono::duration<Rep, Period> dur) {
+    return sleep(
+        ex, dur,
+        static_cast<uint64_t>(async_simple::Executor::Priority::DEFAULT));
+}
+
+template <typename Rep, typename Period>
+Lazy<void> sleep(std::chrono::duration<Rep, Period> dur,
+                 uint64_t schedule_hint) {
     auto ex = co_await CurrentExecutor();
     if (!ex) {
+        std::cout<<"BLOCK SLEEP"<<std::endl;
         std::this_thread::sleep_for(dur);
         co_return;
     }
-    co_return co_await ex->after(
-        std::chrono::duration_cast<Executor::Duration>(dur));
+    co_return co_await sleep(ex, dur, schedule_hint);
 }
 
 template <typename Rep, typename Period>
-Lazy<void> sleep(Executor* ex, std::chrono::duration<Rep, Period> dur) {
-    co_return co_await ex->after(
-        std::chrono::duration_cast<Executor::Duration>(dur));
+Lazy<void> sleep(std::chrono::duration<Rep, Period> dur) {
+    return sleep(
+        dur, static_cast<uint64_t>(async_simple::Executor::Priority::DEFAULT));
 }
 
 }  // namespace coro
diff --git a/include/ylt/thirdparty/async_simple/coro/SpinLock.h b/include/ylt/thirdparty/async_simple/coro/SpinLock.h
index 5d7000c2f..9a0ddeec0 100644
--- a/include/ylt/thirdparty/async_simple/coro/SpinLock.h
+++ b/include/ylt/thirdparty/async_simple/coro/SpinLock.h
@@ -16,9 +16,13 @@
 #ifndef ASYNC_SIMPLE_CORO_SPIN_LOCK_H
 #define ASYNC_SIMPLE_CORO_SPIN_LOCK_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
+#include <mutex>
 #include <thread>
 #include "async_simple/coro/Lazy.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace coro {
 
@@ -31,7 +35,7 @@ class SpinLock {
         return !_locked.exchange(true, std::memory_order_acquire);
     }
 
-    Lazy<> coLock() noexcept {
+    Lazy<> coLock() {
         auto counter = _spinCount;
         while (!tryLock()) {
             while (_locked.load(std::memory_order_relaxed)) {
@@ -58,7 +62,7 @@ class SpinLock {
 
     void unlock() noexcept { _locked.store(false, std::memory_order_release); }
 
-    Lazy<std::unique_lock<SpinLock>> coScopedLock() noexcept {
+    Lazy<std::unique_lock<SpinLock>> coScopedLock() {
         co_await coLock();
         co_return std::unique_lock<SpinLock>{*this, std::adopt_lock};
     }
diff --git a/include/ylt/thirdparty/async_simple/coro/SyncAwait.h b/include/ylt/thirdparty/async_simple/coro/SyncAwait.h
index 5dedbdf9f..78233e284 100644
--- a/include/ylt/thirdparty/async_simple/coro/SyncAwait.h
+++ b/include/ylt/thirdparty/async_simple/coro/SyncAwait.h
@@ -16,13 +16,14 @@
 #ifndef ASYNC_SIMPLE_CORO_SYNC_AWAIT_H
 #define ASYNC_SIMPLE_CORO_SYNC_AWAIT_H
 
-#include <exception>
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
 #include "async_simple/Try.h"
-#include "async_simple/experimental/coroutine.h"
 #include "async_simple/util/Condition.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace coro {
 
diff --git a/include/ylt/thirdparty/async_simple/coro/Traits.h b/include/ylt/thirdparty/async_simple/coro/Traits.h
index 7b5477c14..ed30183f9 100644
--- a/include/ylt/thirdparty/async_simple/coro/Traits.h
+++ b/include/ylt/thirdparty/async_simple/coro/Traits.h
@@ -16,9 +16,10 @@
 #ifndef ASYNC_SIMPLE_CORO_TRAITS_H
 #define ASYNC_SIMPLE_CORO_TRAITS_H
 
-#include <exception>
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <utility>
-#include "async_simple/Common.h"
+
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 
diff --git a/include/ylt/thirdparty/async_simple/coro/ViaCoroutine.h b/include/ylt/thirdparty/async_simple/coro/ViaCoroutine.h
index 29066fa2f..d3e202718 100644
--- a/include/ylt/thirdparty/async_simple/coro/ViaCoroutine.h
+++ b/include/ylt/thirdparty/async_simple/coro/ViaCoroutine.h
@@ -25,16 +25,15 @@
 #ifndef ASYNC_SIMPLE_CORO_VIA_COROUTINE_H
 #define ASYNC_SIMPLE_CORO_VIA_COROUTINE_H
 
-#include <exception>
-#include "async_simple/Common.h"
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include "async_simple/Executor.h"
 #include "async_simple/coro/Traits.h"
 
-#include <atomic>
 #include <cassert>
-#include <mutex>
 #include <utility>
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace coro {
 
diff --git a/include/ylt/thirdparty/async_simple/executors/SimpleExecutor.h b/include/ylt/thirdparty/async_simple/executors/SimpleExecutor.h
index 8265c7007..e42d5c55f 100644
--- a/include/ylt/thirdparty/async_simple/executors/SimpleExecutor.h
+++ b/include/ylt/thirdparty/async_simple/executors/SimpleExecutor.h
@@ -16,13 +16,14 @@
 #ifndef FUTURE_SIMPLE_EXECUTOR_H
 #define FUTURE_SIMPLE_EXECUTOR_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <functional>
 
 #include "async_simple/Executor.h"
 #include "async_simple/executors/SimpleIOExecutor.h"
 #include "async_simple/util/ThreadPool.h"
 
-#include <thread>
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 
diff --git a/include/ylt/thirdparty/async_simple/executors/SimpleIOExecutor.h b/include/ylt/thirdparty/async_simple/executors/SimpleIOExecutor.h
index c316b53cc..93bd966e7 100644
--- a/include/ylt/thirdparty/async_simple/executors/SimpleIOExecutor.h
+++ b/include/ylt/thirdparty/async_simple/executors/SimpleIOExecutor.h
@@ -16,6 +16,7 @@
 #ifndef FUTURE_SIMPLE_IO_EXECUTOR_H
 #define FUTURE_SIMPLE_IO_EXECUTOR_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include "async_simple/IOExecutor.h"
 
 #if !__has_include(<libaio.h>) && !defined(ASYNC_SIMPLE_HAS_NOT_AIO)
@@ -27,6 +28,8 @@
 #endif
 #include <thread>
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 
 namespace executors {
diff --git a/include/ylt/thirdparty/async_simple/experimental/coroutine.h b/include/ylt/thirdparty/async_simple/experimental/coroutine.h
index b01bfccc6..a6d93ec53 100644
--- a/include/ylt/thirdparty/async_simple/experimental/coroutine.h
+++ b/include/ylt/thirdparty/async_simple/experimental/coroutine.h
@@ -45,6 +45,7 @@ template <class P> struct hash<coroutine_handle<P>>;
 
  */
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #if __has_include(<version>)
 // Use <version> to detect standard library. In case libstdc++ doesn't implement
 // <version>, it shouldn't own <coroutine> too.
@@ -57,7 +58,8 @@ template <class P> struct hash<coroutine_handle<P>>;
 // And the outdated <experimental/coroutine> is available for clang only(need to
 // exclude msvc).
 #if (__cplusplus <= 201703L && !defined(_MSC_VER)) || \
-    (defined(__clang__) && defined(__GLIBCXX__))
+    (defined(__clang__) && defined(__GLIBCXX__) && \
+     (__GLIBCXX__ < 20210408))
 #define USE_SELF_DEFINED_COROUTINE
 #endif
 
@@ -402,6 +404,7 @@ using std::experimental::suspend_never;
 }  // namespace std
 
 #endif /* HAS_NON_EXPERIMENTAL_COROUTINE */
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 namespace coro {
diff --git a/include/ylt/thirdparty/async_simple/std.mock.cppm b/include/ylt/thirdparty/async_simple/std.mock.cppm
new file mode 100644
index 000000000..49d147330
--- /dev/null
+++ b/include/ylt/thirdparty/async_simple/std.mock.cppm
@@ -0,0 +1,1863 @@
+// FIXME: This is a workaround implementation for std module
+// to ease the use of modules. Please replace this with the official std module
+// when that is available.
+module;
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <concepts>
+#include <condition_variable>
+#include <coroutine>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <exception>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <new>
+#include <optional>
+#include <queue>
+#include <ranges>
+#include <ratio>
+#include <semaphore>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-warning-option"
+#pragma clang diagnostic ignored "-Wreserved-module-identifier"
+#endif
+
+export module std;
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+export namespace std {
+using std::vector;
+using std::operator==;
+using std::operator<=>;
+using std::erase;
+using std::erase_if;
+using std::swap;
+namespace pmr {
+using std::pmr::vector;
+}
+using std::hash;
+}  // namespace std
+
+export namespace std {
+using std::advance;
+using std::bidirectional_iterator;
+using std::bidirectional_iterator_tag;
+using std::contiguous_iterator;
+using std::contiguous_iterator_tag;
+using std::disable_sized_sentinel_for;
+using std::distance;
+using std::forward_iterator;
+using std::forward_iterator_tag;
+using std::incrementable;
+using std::incrementable_traits;
+using std::indirect_binary_predicate;
+using std::indirect_equivalence_relation;
+using std::indirect_result_t;
+using std::indirect_strict_weak_order;
+using std::indirect_unary_predicate;
+using std::indirectly_comparable;
+using std::indirectly_copyable;
+using std::indirectly_copyable_storable;
+using std::indirectly_movable;
+using std::indirectly_movable_storable;
+using std::indirectly_readable;
+using std::indirectly_readable_traits;
+using std::indirectly_regular_unary_invocable;
+using std::indirectly_swappable;
+using std::indirectly_unary_invocable;
+using std::indirectly_writable;
+using std::input_iterator;
+using std::input_iterator_tag;
+using std::input_or_output_iterator;
+using std::iter_common_reference_t;
+using std::iter_difference_t;
+using std::iter_reference_t;
+using std::iter_rvalue_reference_t;
+using std::iter_value_t;
+using std::iterator_traits;
+using std::mergeable;
+using std::next;
+using std::output_iterator;
+using std::output_iterator_tag;
+using std::permutable;
+using std::prev;
+using std::projected;
+using std::random_access_iterator;
+using std::random_access_iterator_tag;
+using std::sentinel_for;
+using std::sized_sentinel_for;
+using std::sortable;
+using std::weakly_incrementable;
+namespace ranges {
+using std::ranges::advance;
+using std::ranges::distance;
+using std::ranges::next;
+using std::ranges::prev;
+}  // namespace ranges
+using std::reverse_iterator;
+using std::operator==;
+using std::operator!=;
+using std::operator<;
+using std::operator>;
+using std::operator<=;
+using std::operator>=;
+using std::operator<=>;
+using std::operator-;
+using std::operator+;
+using std::back_insert_iterator;
+using std::back_inserter;
+using std::begin;
+using std::cbegin;
+using std::cend;
+using std::common_iterator;
+using std::counted_iterator;
+using std::crbegin;
+using std::crend;
+using std::data;
+using std::default_sentinel;
+using std::default_sentinel_t;
+using std::empty;
+using std::end;
+using std::front_insert_iterator;
+using std::front_inserter;
+using std::insert_iterator;
+using std::inserter;
+using std::istream_iterator;
+using std::istreambuf_iterator;
+using std::iterator;
+using std::make_move_iterator;
+using std::make_reverse_iterator;
+using std::move_iterator;
+using std::move_sentinel;
+using std::ostream_iterator;
+using std::ostreambuf_iterator;
+using std::rbegin;
+using std::rend;
+using std::size;
+using std::ssize;
+using std::unreachable_sentinel;
+using std::unreachable_sentinel_t;
+}  // namespace std
+
+export namespace std {
+using std::memchr;
+using std::memcmp;
+using std::memcpy;
+using std::memmove;
+using std::memset;
+using std::size_t;
+using std::strcat;
+using std::strchr;
+using std::strcmp;
+using std::strcoll;
+using std::strcpy;
+using std::strcspn;
+using std::strerror;
+using std::strlen;
+using std::strncat;
+using std::strncmp;
+using std::strncpy;
+using std::strpbrk;
+using std::strrchr;
+using std::strspn;
+using std::strstr;
+using std::strtok;
+using std::strxfrm;
+}  // namespace std
+// Workaround to ease the use.
+export {
+    using ::memchr;
+    using ::memcmp;
+    using ::memcpy;
+    using ::memmove;
+    using ::memset;
+    using ::size_t;
+    using ::strcat;
+    using ::strchr;
+    using ::strcmp;
+    using ::strcoll;
+    using ::strcpy;
+    using ::strcspn;
+    using ::strerror;
+    using ::strlen;
+    using ::strncat;
+    using ::strncmp;
+    using ::strncpy;
+    using ::strpbrk;
+    using ::strrchr;
+    using ::strspn;
+    using ::strstr;
+    using ::strtok;
+    using ::strxfrm;
+}
+
+export namespace std {
+using std::clearerr;
+using std::fclose;
+using std::feof;
+using std::ferror;
+using std::fflush;
+using std::fgetc;
+using std::fgetpos;
+using std::fgets;
+using std::FILE;
+using std::fopen;
+using std::fpos_t;
+using std::fprintf;
+using std::fputc;
+using std::fputs;
+using std::fread;
+using std::freopen;
+using std::fscanf;
+using std::fseek;
+using std::fsetpos;
+using std::ftell;
+using std::fwrite;
+using std::getc;
+using std::getchar;
+using std::perror;
+using std::printf;
+using std::putc;
+using std::putchar;
+using std::puts;
+using std::remove;
+using std::rename;
+using std::rewind;
+using std::scanf;
+using std::setbuf;
+using std::setvbuf;
+using std::size_t;
+using std::snprintf;
+using std::sprintf;
+using std::sscanf;
+using std::tmpfile;
+using std::tmpnam;
+using std::ungetc;
+using std::vfprintf;
+using std::vfscanf;
+using std::vprintf;
+using std::vscanf;
+using std::vsnprintf;
+using std::vsprintf;
+using std::vsscanf;
+}  // namespace std
+
+export namespace std {
+using std::get;
+using std::get_if;
+using std::holds_alternative;
+using std::variant;
+using std::variant_alternative;
+using std::variant_alternative_t;
+using std::variant_npos;
+using std::variant_size;
+using std::variant_size_v;
+using std::operator==;
+using std::operator!=;
+using std::operator<;
+using std::operator>;
+using std::operator<=;
+using std::operator>=;
+using std::operator<=>;
+using std::bad_variant_access;
+using std::hash;
+using std::monostate;
+using std::swap;
+using std::visit;
+}  // namespace std
+
+export namespace std {
+using std::bind;
+using std::bind_front;
+using std::bit_and;
+using std::bit_not;
+using std::bit_or;
+using std::bit_xor;
+using std::compare_three_way;
+using std::cref;
+using std::divides;
+using std::equal_to;
+using std::greater;
+using std::greater_equal;
+using std::identity;
+using std::invoke;
+using std::is_bind_expression;
+using std::is_bind_expression_v;
+using std::is_placeholder;
+using std::is_placeholder_v;
+using std::less;
+using std::less_equal;
+using std::logical_and;
+using std::logical_not;
+using std::logical_or;
+using std::minus;
+using std::modulus;
+using std::multiplies;
+using std::negate;
+using std::not_equal_to;
+using std::not_fn;
+using std::plus;
+using std::ref;
+using std::reference_wrapper;
+namespace placeholders {
+using std::placeholders::_1;
+using std::placeholders::_10;
+using std::placeholders::_2;
+using std::placeholders::_3;
+using std::placeholders::_4;
+using std::placeholders::_5;
+using std::placeholders::_6;
+using std::placeholders::_7;
+using std::placeholders::_8;
+using std::placeholders::_9;
+}  // namespace placeholders
+using std::bad_function_call;
+using std::function;
+using std::mem_fn;
+using std::swap;
+using std::operator==;
+using std::boyer_moore_horspool_searcher;
+using std::boyer_moore_searcher;
+using std::default_searcher;
+using std::hash;
+namespace ranges {
+using std::ranges::equal_to;
+using std::ranges::greater;
+using std::ranges::greater_equal;
+using std::ranges::less;
+using std::ranges::less_equal;
+using std::ranges::not_equal_to;
+}  // namespace ranges
+}  // namespace std
+
+export namespace std {
+using std::align;
+using std::allocator;
+using std::allocator_arg;
+using std::allocator_arg_t;
+using std::allocator_traits;
+using std::assume_aligned;
+using std::make_obj_using_allocator;
+using std::pointer_traits;
+using std::to_address;
+using std::uninitialized_construct_using_allocator;
+using std::uses_allocator;
+using std::uses_allocator_construction_args;
+using std::uses_allocator_v;
+using std::operator==;
+using std::addressof;
+using std::uninitialized_default_construct;
+using std::uninitialized_default_construct_n;
+namespace ranges {
+using std::ranges::uninitialized_default_construct;
+using std::ranges::uninitialized_default_construct_n;
+}  // namespace ranges
+using std::uninitialized_value_construct;
+using std::uninitialized_value_construct_n;
+namespace ranges {
+using std::ranges::uninitialized_value_construct;
+using std::ranges::uninitialized_value_construct_n;
+}  // namespace ranges
+using std::uninitialized_copy;
+using std::uninitialized_copy_n;
+namespace ranges {
+using std::ranges::uninitialized_copy;
+using std::ranges::uninitialized_copy_n;
+using std::ranges::uninitialized_copy_n_result;
+using std::ranges::uninitialized_copy_result;
+}  // namespace ranges
+using std::uninitialized_move;
+using std::uninitialized_move_n;
+namespace ranges {
+using std::ranges::uninitialized_move;
+using std::ranges::uninitialized_move_n;
+using std::ranges::uninitialized_move_n_result;
+using std::ranges::uninitialized_move_result;
+}  // namespace ranges
+using std::uninitialized_fill;
+using std::uninitialized_fill_n;
+namespace ranges {
+using std::ranges::uninitialized_fill;
+using std::ranges::uninitialized_fill_n;
+}  // namespace ranges
+using std::construct_at;
+namespace ranges {
+using std::ranges::construct_at;
+}
+using std::destroy;
+using std::destroy_at;
+using std::destroy_n;
+namespace ranges {
+using std::ranges::destroy;
+using std::ranges::destroy_at;
+using std::ranges::destroy_n;
+}  // namespace ranges
+using std::default_delete;
+using std::make_unique;
+using std::unique_ptr;
+using std::operator<;
+using std::operator>;
+using std::operator<=;
+using std::operator>=;
+using std::operator<=>;
+using std::operator<<;
+using std::allocate_shared;
+using std::atomic_compare_exchange_strong;
+using std::atomic_compare_exchange_strong_explicit;
+using std::atomic_compare_exchange_weak;
+using std::atomic_compare_exchange_weak_explicit;
+using std::atomic_exchange;
+using std::atomic_exchange_explicit;
+using std::atomic_is_lock_free;
+using std::atomic_load;
+using std::atomic_load_explicit;
+using std::atomic_store;
+using std::atomic_store_explicit;
+using std::bad_weak_ptr;
+using std::const_pointer_cast;
+using std::dynamic_pointer_cast;
+using std::enable_shared_from_this;
+using std::get_deleter;
+using std::hash;
+using std::make_shared;
+using std::owner_less;
+using std::reinterpret_pointer_cast;
+using std::shared_ptr;
+using std::static_pointer_cast;
+using std::swap;
+using std::weak_ptr;
+}  // namespace std
+
+export namespace std {
+using std::cerr;
+using std::cin;
+using std::clog;
+using std::cout;
+using std::wcerr;
+using std::wcin;
+using std::wclog;
+using std::wcout;
+}  // namespace std
+
+export namespace std {
+using std::ifstream;
+}
+
+export namespace std {
+namespace ranges {
+using std::ranges::in_found_result;
+using std::ranges::in_fun_result;
+using std::ranges::in_in_out_result;
+using std::ranges::in_in_result;
+using std::ranges::in_out_out_result;
+using std::ranges::in_out_result;
+using std::ranges::min_max_result;
+}  // namespace ranges
+using std::all_of;
+namespace ranges {
+using std::ranges::all_of;
+}
+using std::any_of;
+namespace ranges {
+using std::ranges::any_of;
+}
+using std::none_of;
+namespace ranges {
+using std::ranges::none_of;
+}
+using std::for_each;
+namespace ranges {
+using std::ranges::for_each;
+using std::ranges::for_each_result;
+}  // namespace ranges
+using std::for_each_n;
+namespace ranges {
+using std::ranges::for_each_n;
+using std::ranges::for_each_n_result;
+}  // namespace ranges
+using std::find;
+using std::find_if;
+using std::find_if_not;
+namespace ranges {
+using std::ranges::find;
+using std::ranges::find_if;
+using std::ranges::find_if_not;
+}  // namespace ranges
+namespace ranges {}
+using std::find_end;
+namespace ranges {
+using std::ranges::find_end;
+}
+using std::find_first_of;
+namespace ranges {
+using std::ranges::find_first_of;
+}
+using std::adjacent_find;
+namespace ranges {
+using std::ranges::adjacent_find;
+}
+using std::count;
+using std::count_if;
+namespace ranges {
+using std::ranges::count;
+using std::ranges::count_if;
+}  // namespace ranges
+using std::mismatch;
+namespace ranges {
+using std::ranges::mismatch;
+using std::ranges::mismatch_result;
+}  // namespace ranges
+using std::equal;
+namespace ranges {
+using std::ranges::equal;
+}
+using std::is_permutation;
+namespace ranges {
+using std::ranges::is_permutation;
+}
+using std::search;
+namespace ranges {
+using std::ranges::search;
+}
+using std::search_n;
+namespace ranges {
+using std::ranges::search_n;
+}
+namespace ranges {}
+using std::copy;
+namespace ranges {
+using std::ranges::copy;
+using std::ranges::copy_result;
+}  // namespace ranges
+using std::copy_n;
+namespace ranges {
+using std::ranges::copy_n;
+using std::ranges::copy_n_result;
+}  // namespace ranges
+using std::copy_if;
+namespace ranges {
+using std::ranges::copy_if;
+using std::ranges::copy_if_result;
+}  // namespace ranges
+using std::copy_backward;
+namespace ranges {
+using std::ranges::copy_backward;
+using std::ranges::copy_backward_result;
+}  // namespace ranges
+using std::move;
+namespace ranges {
+using std::ranges::move;
+using std::ranges::move_result;
+}  // namespace ranges
+using std::move_backward;
+namespace ranges {
+using std::ranges::move_backward;
+using std::ranges::move_backward_result;
+}  // namespace ranges
+using std::swap_ranges;
+namespace ranges {
+using std::ranges::swap_ranges;
+using std::ranges::swap_ranges_result;
+}  // namespace ranges
+using std::iter_swap;
+using std::transform;
+namespace ranges {
+using std::ranges::binary_transform_result;
+using std::ranges::transform;
+using std::ranges::unary_transform_result;
+}  // namespace ranges
+using std::replace;
+using std::replace_if;
+namespace ranges {
+using std::ranges::replace;
+using std::ranges::replace_if;
+}  // namespace ranges
+using std::replace_copy;
+using std::replace_copy_if;
+namespace ranges {
+using std::ranges::replace_copy;
+using std::ranges::replace_copy_if;
+using std::ranges::replace_copy_if_result;
+using std::ranges::replace_copy_result;
+}  // namespace ranges
+using std::fill;
+using std::fill_n;
+namespace ranges {
+using std::ranges::fill;
+using std::ranges::fill_n;
+}  // namespace ranges
+using std::generate;
+using std::generate_n;
+namespace ranges {
+using std::ranges::generate;
+using std::ranges::generate_n;
+}  // namespace ranges
+using std::remove;
+using std::remove_if;
+namespace ranges {
+using std::ranges::remove;
+using std::ranges::remove_if;
+}  // namespace ranges
+using std::remove_copy;
+using std::remove_copy_if;
+namespace ranges {
+using std::ranges::remove_copy;
+using std::ranges::remove_copy_if;
+using std::ranges::remove_copy_if_result;
+using std::ranges::remove_copy_result;
+}  // namespace ranges
+using std::unique;
+namespace ranges {
+using std::ranges::unique;
+}
+using std::unique_copy;
+namespace ranges {
+using std::ranges::unique_copy;
+using std::ranges::unique_copy_result;
+}  // namespace ranges
+using std::reverse;
+namespace ranges {
+using std::ranges::reverse;
+}
+using std::reverse_copy;
+namespace ranges {
+using std::ranges::reverse_copy;
+using std::ranges::reverse_copy_result;
+}  // namespace ranges
+using std::rotate;
+namespace ranges {
+using std::ranges::rotate;
+}
+using std::rotate_copy;
+namespace ranges {
+using std::ranges::rotate_copy;
+using std::ranges::rotate_copy_result;
+}  // namespace ranges
+using std::sample;
+namespace ranges {
+using std::ranges::sample;
+}
+using std::shuffle;
+namespace ranges {
+using std::ranges::shuffle;
+}
+using std::shift_left;
+namespace ranges {}
+using std::shift_right;
+namespace ranges {}
+using std::sort;
+namespace ranges {
+using std::ranges::sort;
+}
+using std::stable_sort;
+namespace ranges {
+using std::ranges::stable_sort;
+}
+using std::partial_sort;
+namespace ranges {
+using std::ranges::partial_sort;
+}
+using std::partial_sort_copy;
+namespace ranges {
+using std::ranges::partial_sort_copy;
+using std::ranges::partial_sort_copy_result;
+}  // namespace ranges
+using std::is_sorted;
+using std::is_sorted_until;
+namespace ranges {
+using std::ranges::is_sorted;
+using std::ranges::is_sorted_until;
+}  // namespace ranges
+using std::nth_element;
+namespace ranges {
+using std::ranges::nth_element;
+}
+using std::lower_bound;
+namespace ranges {
+using std::ranges::lower_bound;
+}
+using std::upper_bound;
+namespace ranges {
+using std::ranges::upper_bound;
+}
+using std::equal_range;
+namespace ranges {
+using std::ranges::equal_range;
+}
+using std::binary_search;
+namespace ranges {
+using std::ranges::binary_search;
+}
+using std::is_partitioned;
+namespace ranges {
+using std::ranges::is_partitioned;
+}
+using std::partition;
+namespace ranges {
+using std::ranges::partition;
+}
+using std::stable_partition;
+namespace ranges {
+using std::ranges::stable_partition;
+}
+using std::partition_copy;
+namespace ranges {
+using std::ranges::partition_copy;
+using std::ranges::partition_copy_result;
+}  // namespace ranges
+using std::partition_point;
+namespace ranges {
+using std::ranges::partition_point;
+}
+using std::merge;
+namespace ranges {
+using std::ranges::merge;
+using std::ranges::merge_result;
+}  // namespace ranges
+using std::inplace_merge;
+namespace ranges {
+using std::ranges::inplace_merge;
+}
+using std::includes;
+namespace ranges {
+using std::ranges::includes;
+}
+using std::set_union;
+namespace ranges {
+using std::ranges::set_union;
+using std::ranges::set_union_result;
+}  // namespace ranges
+using std::set_intersection;
+namespace ranges {
+using std::ranges::set_intersection;
+using std::ranges::set_intersection_result;
+}  // namespace ranges
+using std::set_difference;
+namespace ranges {
+using std::ranges::set_difference;
+using std::ranges::set_difference_result;
+}  // namespace ranges
+using std::set_symmetric_difference;
+namespace ranges {
+using std::ranges::set_symmetric_difference;
+using std::ranges::set_symmetric_difference_result;
+}  // namespace ranges
+using std::push_heap;
+namespace ranges {
+using std::ranges::push_heap;
+}
+using std::pop_heap;
+namespace ranges {
+using std::ranges::pop_heap;
+}
+using std::make_heap;
+namespace ranges {
+using std::ranges::make_heap;
+}
+using std::sort_heap;
+namespace ranges {
+using std::ranges::sort_heap;
+}
+using std::is_heap;
+namespace ranges {
+using std::ranges::is_heap;
+}
+using std::is_heap_until;
+namespace ranges {
+using std::ranges::is_heap_until;
+}
+using std::min;
+namespace ranges {
+using std::ranges::min;
+}
+using std::max;
+namespace ranges {
+using std::ranges::max;
+}
+using std::minmax;
+namespace ranges {
+using std::ranges::minmax;
+using std::ranges::minmax_result;
+}  // namespace ranges
+using std::min_element;
+namespace ranges {
+using std::ranges::min_element;
+}
+using std::max_element;
+namespace ranges {
+using std::ranges::max_element;
+}
+using std::minmax_element;
+namespace ranges {
+using std::ranges::minmax_element;
+using std::ranges::minmax_element_result;
+}  // namespace ranges
+using std::clamp;
+namespace ranges {
+using std::ranges::clamp;
+}
+using std::lexicographical_compare;
+namespace ranges {
+using std::ranges::lexicographical_compare;
+}
+using std::lexicographical_compare_three_way;
+using std::next_permutation;
+namespace ranges {
+using std::ranges::next_permutation;
+using std::ranges::next_permutation_result;
+}  // namespace ranges
+using std::prev_permutation;
+namespace ranges {
+using std::ranges::prev_permutation;
+using std::ranges::prev_permutation_result;
+}  // namespace ranges
+}  // namespace std
+
+export namespace std {
+using std::adopt_lock;
+using std::adopt_lock_t;
+using std::call_once;
+using std::defer_lock;
+using std::defer_lock_t;
+using std::lock;
+using std::lock_guard;
+using std::mutex;
+using std::once_flag;
+using std::recursive_mutex;
+using std::recursive_timed_mutex;
+using std::scoped_lock;
+using std::swap;
+using std::timed_mutex;
+using std::try_lock;
+using std::try_to_lock;
+using std::try_to_lock_t;
+using std::unique_lock;
+}  // namespace std
+
+export namespace std {
+using std::condition_variable;
+using std::condition_variable_any;
+using std::cv_status;
+using std::notify_all_at_thread_exit;
+}  // namespace std
+
+export namespace std {
+using std::atomic;
+using std::atomic_bool;
+using std::atomic_char;
+using std::atomic_char16_t;
+using std::atomic_char32_t;
+using std::atomic_char8_t;
+using std::atomic_compare_exchange_strong;
+using std::atomic_compare_exchange_strong_explicit;
+using std::atomic_compare_exchange_weak;
+using std::atomic_compare_exchange_weak_explicit;
+using std::atomic_exchange;
+using std::atomic_exchange_explicit;
+using std::atomic_fetch_add;
+using std::atomic_fetch_add_explicit;
+using std::atomic_fetch_and;
+using std::atomic_fetch_and_explicit;
+using std::atomic_fetch_or;
+using std::atomic_fetch_or_explicit;
+using std::atomic_fetch_sub;
+using std::atomic_fetch_sub_explicit;
+using std::atomic_fetch_xor;
+using std::atomic_fetch_xor_explicit;
+using std::atomic_flag;
+using std::atomic_flag_clear;
+using std::atomic_flag_clear_explicit;
+using std::atomic_flag_test_and_set;
+using std::atomic_flag_test_and_set_explicit;
+using std::atomic_init;
+using std::atomic_int;
+using std::atomic_int16_t;
+using std::atomic_int32_t;
+using std::atomic_int64_t;
+using std::atomic_int8_t;
+using std::atomic_int_fast16_t;
+using std::atomic_int_fast32_t;
+using std::atomic_int_fast64_t;
+using std::atomic_int_fast8_t;
+using std::atomic_int_least16_t;
+using std::atomic_int_least32_t;
+using std::atomic_int_least64_t;
+using std::atomic_int_least8_t;
+using std::atomic_intmax_t;
+using std::atomic_intptr_t;
+using std::atomic_is_lock_free;
+using std::atomic_llong;
+using std::atomic_load;
+using std::atomic_load_explicit;
+using std::atomic_long;
+using std::atomic_notify_all;
+using std::atomic_notify_one;
+using std::atomic_ptrdiff_t;
+using std::atomic_ref;
+using std::atomic_schar;
+using std::atomic_short;
+using std::atomic_signal_fence;
+using std::atomic_size_t;
+using std::atomic_store;
+using std::atomic_store_explicit;
+using std::atomic_thread_fence;
+using std::atomic_uchar;
+using std::atomic_uint;
+using std::atomic_uint16_t;
+using std::atomic_uint32_t;
+using std::atomic_uint64_t;
+using std::atomic_uint8_t;
+using std::atomic_uint_fast16_t;
+using std::atomic_uint_fast32_t;
+using std::atomic_uint_fast64_t;
+using std::atomic_uint_fast8_t;
+using std::atomic_uint_least16_t;
+using std::atomic_uint_least32_t;
+using std::atomic_uint_least64_t;
+using std::atomic_uint_least8_t;
+using std::atomic_uintmax_t;
+using std::atomic_uintptr_t;
+using std::atomic_ullong;
+using std::atomic_ulong;
+using std::atomic_ushort;
+using std::atomic_wait;
+using std::atomic_wait_explicit;
+using std::atomic_wchar_t;
+using std::kill_dependency;
+using std::memory_order;
+using std::memory_order_acq_rel;
+using std::memory_order_acquire;
+using std::memory_order_consume;
+using std::memory_order_relaxed;
+using std::memory_order_release;
+using std::memory_order_seq_cst;
+}  // namespace std
+
+export namespace std {
+using std::coroutine_handle;
+using std::coroutine_traits;
+using std::operator==;
+using std::operator<=>;
+using std::hash;
+using std::noop_coroutine;
+using std::noop_coroutine_handle;
+using std::noop_coroutine_promise;
+using std::suspend_always;
+using std::suspend_never;
+}  // namespace std
+
+export namespace std {
+using std::byte;
+using std::max_align_t;
+using std::nullptr_t;
+using std::ptrdiff_t;
+using std::size_t;
+using std::operator<<=;
+using std::operator<<;
+using std::operator>>=;
+using std::operator>>;
+using std::operator|=;
+using std::operator|;
+using std::operator&=;
+using std::operator&;
+using std::operator^=;
+using std::operator^;
+using std::operator~;
+using std::to_integer;
+}  // namespace std
+// Ease the use
+export {
+    using ::max_align_t;
+    using ::ptrdiff_t;
+    using ::size_t;
+}
+
+export namespace std {
+using std::bad_exception;
+using std::current_exception;
+using std::exception;
+using std::exception_ptr;
+using std::get_terminate;
+using std::make_exception_ptr;
+using std::nested_exception;
+using std::rethrow_exception;
+using std::rethrow_if_nested;
+using std::set_terminate;
+using std::terminate;
+using std::terminate_handler;
+using std::throw_with_nested;
+using std::uncaught_exception;
+using std::uncaught_exceptions;
+}  // namespace std
+
+export namespace std {
+using std::as_const;
+using std::cmp_equal;
+using std::cmp_greater;
+using std::cmp_greater_equal;
+using std::cmp_less;
+using std::cmp_less_equal;
+using std::cmp_not_equal;
+using std::declval;
+using std::exchange;
+using std::forward;
+using std::in_range;
+using std::index_sequence;
+using std::index_sequence_for;
+using std::integer_sequence;
+using std::make_index_sequence;
+using std::make_integer_sequence;
+using std::move;
+using std::move_if_noexcept;
+using std::pair;
+using std::swap;
+using std::operator==;
+using std::operator<=>;
+using std::get;
+using std::in_place;
+using std::in_place_index;
+using std::in_place_index_t;
+using std::in_place_t;
+using std::in_place_type;
+using std::in_place_type_t;
+using std::make_pair;
+using std::piecewise_construct;
+using std::piecewise_construct_t;
+using std::tuple_element;
+using std::tuple_size;
+namespace rel_ops {
+using rel_ops::operator!=;
+using rel_ops::operator>;
+using rel_ops::operator<=;
+using rel_ops::operator>=;
+}  // namespace rel_ops
+}  // namespace std
+
+export namespace std {
+namespace ranges {
+using std::ranges::begin;
+using std::ranges::bidirectional_range;
+using std::ranges::borrowed_range;
+using std::ranges::cbegin;
+using std::ranges::cdata;
+using std::ranges::cend;
+using std::ranges::common_range;
+using std::ranges::contiguous_range;
+using std::ranges::crbegin;
+using std::ranges::crend;
+using std::ranges::data;
+using std::ranges::disable_sized_range;
+using std::ranges::empty;
+using std::ranges::enable_borrowed_range;
+using std::ranges::enable_view;
+using std::ranges::end;
+using std::ranges::forward_range;
+using std::ranges::get;
+using std::ranges::input_range;
+using std::ranges::iterator_t;
+using std::ranges::output_range;
+using std::ranges::random_access_range;
+using std::ranges::range;
+using std::ranges::range_difference_t;
+using std::ranges::range_reference_t;
+using std::ranges::range_rvalue_reference_t;
+using std::ranges::range_size_t;
+using std::ranges::range_value_t;
+using std::ranges::rbegin;
+using std::ranges::rend;
+using std::ranges::sentinel_t;
+using std::ranges::size;
+using std::ranges::sized_range;
+using std::ranges::ssize;
+using std::ranges::subrange;
+using std::ranges::subrange_kind;
+using std::ranges::view;
+using std::ranges::view_base;
+using std::ranges::view_interface;
+using std::ranges::viewable_range;
+}  // namespace ranges
+using std::ranges::get;
+namespace ranges {
+using std::ranges::borrowed_iterator_t;
+using std::ranges::borrowed_subrange_t;
+using std::ranges::dangling;
+using std::ranges::empty_view;
+namespace views {
+using std::ranges::views::empty;
+}
+using std::ranges::single_view;
+namespace views {
+using std::ranges::views::single;
+}
+using std::ranges::iota_view;
+namespace views {
+using std::ranges::views::iota;
+}
+using std::ranges::basic_istream_view;
+using std::ranges::istream_view;
+namespace views {
+using std::ranges::views::all;
+using std::ranges::views::all_t;
+}  // namespace views
+using std::ranges::filter_view;
+using std::ranges::ref_view;
+namespace views {
+using std::ranges::views::filter;
+}
+using std::ranges::transform_view;
+namespace views {
+using std::ranges::views::transform;
+}
+using std::ranges::take_view;
+namespace views {
+using std::ranges::views::take;
+}
+using std::ranges::take_while_view;
+namespace views {
+using std::ranges::views::take_while;
+}
+using std::ranges::drop_view;
+namespace views {
+using std::ranges::views::drop;
+}
+using std::ranges::drop_while_view;
+namespace views {
+using std::ranges::views::drop_while;
+}
+using std::ranges::join_view;
+namespace views {
+using std::ranges::views::join;
+}
+using std::ranges::lazy_split_view;
+using std::ranges::split_view;
+namespace views {
+using std::ranges::views::lazy_split;
+using std::ranges::views::split;
+}  // namespace views
+namespace views {
+using std::ranges::views::counted;
+}
+using std::ranges::common_view;
+namespace views {
+using std::ranges::views::common;
+}
+using std::ranges::reverse_view;
+namespace views {
+using std::ranges::views::reverse;
+}
+using std::ranges::elements_view;
+using std::ranges::keys_view;
+using std::ranges::values_view;
+namespace views {
+using std::ranges::views::elements;
+using std::ranges::views::keys;
+using std::ranges::views::values;
+}  // namespace views
+}  // namespace ranges
+namespace views = ranges::views;
+using std::tuple_element;
+using std::tuple_size;
+}  // namespace std
+
+export namespace std {
+using std::atto;
+using std::centi;
+using std::deca;
+using std::deci;
+using std::exa;
+using std::femto;
+using std::giga;
+using std::hecto;
+using std::kilo;
+using std::mega;
+using std::micro;
+using std::milli;
+using std::nano;
+using std::peta;
+using std::pico;
+using std::ratio;
+using std::ratio_add;
+using std::ratio_divide;
+using std::ratio_equal;
+using std::ratio_equal_v;
+using std::ratio_greater;
+using std::ratio_greater_equal;
+using std::ratio_greater_equal_v;
+using std::ratio_greater_v;
+using std::ratio_less;
+using std::ratio_less_equal;
+using std::ratio_less_equal_v;
+using std::ratio_less_v;
+using std::ratio_multiply;
+using std::ratio_not_equal;
+using std::ratio_not_equal_v;
+using std::ratio_subtract;
+using std::tera;
+}  // namespace std
+
+export namespace std {
+using std::float_denorm_style;
+using std::float_round_style;
+using std::numeric_limits;
+}  // namespace std
+
+export namespace std {
+using std::binary_semaphore;
+using std::counting_semaphore;
+}  // namespace std
+
+export namespace std {
+using std::domain_error;
+using std::invalid_argument;
+using std::length_error;
+using std::logic_error;
+using std::out_of_range;
+using std::overflow_error;
+using std::range_error;
+using std::runtime_error;
+using std::underflow_error;
+}  // namespace std
+
+export namespace std {
+using std::_Exit;
+using std::abort;
+using std::abs;
+using std::aligned_alloc;
+using std::at_quick_exit;
+using std::atexit;
+using std::atof;
+using std::atoi;
+using std::atol;
+using std::atoll;
+using std::bsearch;
+using std::calloc;
+using std::div;
+using std::div_t;
+using std::exit;
+using std::free;
+using std::getenv;
+using std::labs;
+using std::ldiv;
+using std::ldiv_t;
+using std::llabs;
+using std::lldiv;
+using std::lldiv_t;
+using std::malloc;
+using std::mblen;
+using std::mbstowcs;
+using std::mbtowc;
+using std::qsort;
+using std::quick_exit;
+using std::rand;
+using std::realloc;
+using std::size_t;
+using std::srand;
+using std::strtod;
+using std::strtof;
+using std::strtol;
+using std::strtold;
+using std::strtoll;
+using std::strtoul;
+using std::strtoull;
+using std::system;
+using std::wcstombs;
+using std::wctomb;
+}  // namespace std
+
+export namespace std {
+namespace chrono {
+using std::chrono::duration;
+using std::chrono::time_point;
+}  // namespace chrono
+using std::common_type;
+namespace chrono {
+using std::chrono::duration_values;
+using std::chrono::treat_as_floating_point;
+using std::chrono::treat_as_floating_point_v;
+using std::chrono::operator+;
+using std::chrono::operator-;
+using std::chrono::operator*;
+using std::chrono::operator/;
+using std::chrono::operator%;
+using std::chrono::operator==;
+using std::chrono::operator<;
+using std::chrono::operator>;
+using std::chrono::operator<=;
+using std::chrono::operator>=;
+using std::chrono::operator<=>;
+using std::chrono::ceil;
+using std::chrono::duration_cast;
+using std::chrono::floor;
+using std::chrono::round;
+using std::chrono::abs;
+using std::chrono::day;
+using std::chrono::days;
+using std::chrono::file_clock;
+using std::chrono::file_time;
+using std::chrono::hh_mm_ss;
+using std::chrono::high_resolution_clock;
+using std::chrono::hours;
+using std::chrono::is_am;
+using std::chrono::is_pm;
+using std::chrono::last_spec;
+using std::chrono::local_days;
+using std::chrono::local_seconds;
+using std::chrono::local_t;
+using std::chrono::local_time;
+using std::chrono::make12;
+using std::chrono::make24;
+using std::chrono::microseconds;
+using std::chrono::milliseconds;
+using std::chrono::minutes;
+using std::chrono::month;
+using std::chrono::month_day;
+using std::chrono::month_day_last;
+using std::chrono::month_weekday;
+using std::chrono::month_weekday_last;
+using std::chrono::months;
+using std::chrono::nanoseconds;
+using std::chrono::seconds;
+using std::chrono::steady_clock;
+using std::chrono::sys_days;
+using std::chrono::sys_seconds;
+using std::chrono::sys_time;
+using std::chrono::system_clock;
+using std::chrono::time_point_cast;
+using std::chrono::weekday;
+using std::chrono::weekday_indexed;
+using std::chrono::weekday_last;
+using std::chrono::weeks;
+using std::chrono::year;
+using std::chrono::year_month;
+using std::chrono::year_month_day;
+using std::chrono::year_month_day_last;
+using std::chrono::year_month_weekday;
+using std::chrono::year_month_weekday_last;
+using std::chrono::years;
+}  // namespace chrono
+namespace chrono {
+using std::chrono::April;
+using std::chrono::August;
+using std::chrono::December;
+using std::chrono::February;
+using std::chrono::Friday;
+using std::chrono::January;
+using std::chrono::July;
+using std::chrono::June;
+using std::chrono::last;
+using std::chrono::March;
+using std::chrono::May;
+using std::chrono::Monday;
+using std::chrono::November;
+using std::chrono::October;
+using std::chrono::Saturday;
+using std::chrono::September;
+using std::chrono::Sunday;
+using std::chrono::Thursday;
+using std::chrono::Tuesday;
+using std::chrono::Wednesday;
+}  // namespace chrono
+}  // namespace std
+export namespace std::inline literals::inline chrono_literals {
+using std::literals::chrono_literals::operator""h;
+using std::literals::chrono_literals::operator""min;
+using std::literals::chrono_literals::operator""s;
+using std::literals::chrono_literals::operator""ms;
+using std::literals::chrono_literals::operator""us;
+using std::literals::chrono_literals::operator""ns;
+using std::literals::chrono_literals::operator""d;
+using std::literals::chrono_literals::operator""y;
+}  // namespace std::inline literals::inline chrono_literals
+
+export namespace std {
+using std::basic_string;
+using std::char_traits;
+using std::operator+;
+using std::operator==;
+using std::operator<=>;
+using std::swap;
+using std::operator>>;
+using std::operator<<;
+using std::erase;
+using std::erase_if;
+using std::getline;
+using std::stod;
+using std::stof;
+using std::stoi;
+using std::stol;
+using std::stold;
+using std::stoll;
+using std::stoul;
+using std::stoull;
+using std::string;
+using std::to_string;
+using std::to_wstring;
+using std::u16string;
+using std::u32string;
+using std::u8string;
+using std::wstring;
+namespace pmr {
+using std::pmr::basic_string;
+using std::pmr::string;
+using std::pmr::u16string;
+using std::pmr::u32string;
+using std::pmr::u8string;
+using std::pmr::wstring;
+}  // namespace pmr
+using std::hash;
+inline namespace literals {
+inline namespace string_literals {
+using std::literals::string_literals::operator""s;
+}
+}  // namespace literals
+}  // namespace std
+
+export namespace std {
+using std::array;
+using std::operator==;
+using std::operator<=>;
+using std::get;
+using std::swap;
+using std::to_array;
+using std::tuple_element;
+using std::tuple_size;
+}  // namespace std
+
+export namespace std {
+using std::bad_optional_access;
+using std::nullopt;
+using std::nullopt_t;
+using std::optional;
+using std::operator==;
+using std::operator!=;
+using std::operator<;
+using std::operator>;
+using std::operator<=;
+using std::operator>=;
+using std::operator<=>;
+using std::hash;
+using std::make_optional;
+using std::swap;
+}  // namespace std
+
+export namespace std {
+using std::assignable_from;
+using std::common_reference_with;
+using std::common_with;
+using std::constructible_from;
+using std::convertible_to;
+using std::copy_constructible;
+using std::copyable;
+using std::default_initializable;
+using std::derived_from;
+using std::destructible;
+using std::equality_comparable;
+using std::equality_comparable_with;
+using std::equivalence_relation;
+using std::floating_point;
+using std::integral;
+using std::invocable;
+using std::movable;
+using std::move_constructible;
+using std::predicate;
+using std::regular;
+using std::regular_invocable;
+using std::relation;
+using std::same_as;
+using std::semiregular;
+using std::signed_integral;
+using std::strict_weak_order;
+using std::swappable;
+using std::swappable_with;
+using std::totally_ordered;
+using std::totally_ordered_with;
+using std::unsigned_integral;
+}  // namespace std
+
+export namespace std {
+using std::int16_t;
+using std::int32_t;
+using std::int64_t;
+using std::int8_t;
+using std::int_fast16_t;
+using std::int_fast32_t;
+using std::int_fast64_t;
+using std::int_fast8_t;
+using std::int_least16_t;
+using std::int_least32_t;
+using std::int_least64_t;
+using std::int_least8_t;
+using std::intmax_t;
+using std::intptr_t;
+using std::uint16_t;
+using std::uint32_t;
+using std::uint64_t;
+using std::uint8_t;
+using std::uint_fast16_t;
+using std::uint_fast32_t;
+using std::uint_fast64_t;
+using std::uint_fast8_t;
+using std::uint_least16_t;
+using std::uint_least32_t;
+using std::uint_least64_t;
+using std::uint_least8_t;
+using std::uintmax_t;
+using std::uintptr_t;
+}  // namespace std
+// FIXME: Ease the use.
+export {
+    using ::int16_t;
+    using ::int32_t;
+    using ::int64_t;
+    using ::int8_t;
+    using ::int_fast16_t;
+    using ::int_fast32_t;
+    using ::int_fast64_t;
+    using ::int_fast8_t;
+    using ::int_least16_t;
+    using ::int_least32_t;
+    using ::int_least64_t;
+    using ::int_least8_t;
+    using ::intmax_t;
+    using ::intptr_t;
+    using ::uint16_t;
+    using ::uint32_t;
+    using ::uint64_t;
+    using ::uint8_t;
+    using ::uint_fast16_t;
+    using ::uint_fast32_t;
+    using ::uint_fast64_t;
+    using ::uint_fast8_t;
+    using ::uint_least16_t;
+    using ::uint_least32_t;
+    using ::uint_least64_t;
+    using ::uint_least8_t;
+    using ::uintmax_t;
+    using ::uintptr_t;
+}
+
+export namespace std {
+using std::queue;
+using std::operator==;
+using std::operator!=;
+using std::operator<;
+using std::operator>;
+using std::operator<=;
+using std::operator>=;
+using std::operator<=>;
+using std::priority_queue;
+using std::swap;
+using std::uses_allocator;
+}  // namespace std
+
+export namespace std {
+using std::align_val_t;
+using std::bad_alloc;
+using std::bad_array_new_length;
+using std::destroying_delete;
+using std::destroying_delete_t;
+using std::get_new_handler;
+using std::launder;
+using std::new_handler;
+using std::nothrow;
+using std::nothrow_t;
+using std::set_new_handler;
+}  // namespace std
+export {
+    using ::operator new;
+    using ::operator delete;
+    using ::operator new[];
+    using ::operator delete[];
+}
+
+export namespace std {
+using std::apply;
+using std::forward_as_tuple;
+using std::get;
+using std::ignore;
+using std::make_from_tuple;
+using std::make_tuple;
+using std::tie;
+using std::tuple;
+using std::tuple_cat;
+using std::tuple_element;
+using std::tuple_element_t;
+using std::tuple_size;
+using std::operator==;
+using std::operator<=>;
+using std::swap;
+using std::tuple_size_v;
+using std::uses_allocator;
+}  // namespace std
+
+export namespace std {
+using std::add_const;
+using std::add_const_t;
+using std::add_cv;
+using std::add_cv_t;
+using std::add_lvalue_reference;
+using std::add_lvalue_reference_t;
+using std::add_pointer;
+using std::add_pointer_t;
+using std::add_rvalue_reference;
+using std::add_rvalue_reference_t;
+using std::add_volatile;
+using std::add_volatile_t;
+using std::aligned_storage;
+using std::aligned_storage_t;
+using std::aligned_union;
+using std::aligned_union_t;
+using std::alignment_of;
+using std::alignment_of_v;
+using std::basic_common_reference;
+using std::bool_constant;
+using std::common_reference;
+using std::common_reference_t;
+using std::common_type;
+using std::common_type_t;
+using std::conditional;
+using std::conditional_t;
+using std::conjunction;
+using std::conjunction_v;
+using std::decay;
+using std::decay_t;
+using std::disjunction;
+using std::disjunction_v;
+using std::enable_if;
+using std::enable_if_t;
+using std::extent;
+using std::extent_v;
+using std::false_type;
+using std::has_unique_object_representations;
+using std::has_unique_object_representations_v;
+using std::has_virtual_destructor;
+using std::has_virtual_destructor_v;
+using std::integral_constant;
+using std::invoke_result;
+using std::invoke_result_t;
+using std::is_abstract;
+using std::is_abstract_v;
+using std::is_aggregate;
+using std::is_aggregate_v;
+using std::is_arithmetic;
+using std::is_arithmetic_v;
+using std::is_array;
+using std::is_array_v;
+using std::is_assignable;
+using std::is_assignable_v;
+using std::is_base_of;
+using std::is_base_of_v;
+using std::is_bounded_array;
+using std::is_bounded_array_v;
+using std::is_class;
+using std::is_class_v;
+using std::is_compound;
+using std::is_compound_v;
+using std::is_const;
+using std::is_const_v;
+using std::is_constant_evaluated;
+using std::is_constructible;
+using std::is_constructible_v;
+using std::is_convertible;
+using std::is_convertible_v;
+using std::is_copy_assignable;
+using std::is_copy_assignable_v;
+using std::is_copy_constructible;
+using std::is_copy_constructible_v;
+using std::is_default_constructible;
+using std::is_default_constructible_v;
+using std::is_destructible;
+using std::is_destructible_v;
+using std::is_empty;
+using std::is_empty_v;
+using std::is_enum;
+using std::is_enum_v;
+using std::is_final;
+using std::is_final_v;
+using std::is_floating_point;
+using std::is_floating_point_v;
+using std::is_function;
+using std::is_function_v;
+using std::is_fundamental;
+using std::is_fundamental_v;
+using std::is_integral;
+using std::is_integral_v;
+using std::is_invocable;
+using std::is_invocable_r;
+using std::is_invocable_r_v;
+using std::is_invocable_v;
+using std::is_lvalue_reference;
+using std::is_lvalue_reference_v;
+using std::is_member_function_pointer;
+using std::is_member_function_pointer_v;
+using std::is_member_object_pointer;
+using std::is_member_object_pointer_v;
+using std::is_member_pointer;
+using std::is_member_pointer_v;
+using std::is_move_assignable;
+using std::is_move_assignable_v;
+using std::is_move_constructible;
+using std::is_move_constructible_v;
+using std::is_nothrow_assignable;
+using std::is_nothrow_assignable_v;
+using std::is_nothrow_constructible;
+using std::is_nothrow_constructible_v;
+using std::is_nothrow_convertible;
+using std::is_nothrow_convertible_v;
+using std::is_nothrow_copy_assignable;
+using std::is_nothrow_copy_assignable_v;
+using std::is_nothrow_copy_constructible;
+using std::is_nothrow_copy_constructible_v;
+using std::is_nothrow_default_constructible;
+using std::is_nothrow_default_constructible_v;
+using std::is_nothrow_destructible;
+using std::is_nothrow_destructible_v;
+using std::is_nothrow_invocable;
+using std::is_nothrow_invocable_r;
+using std::is_nothrow_invocable_r_v;
+using std::is_nothrow_invocable_v;
+using std::is_nothrow_move_assignable;
+using std::is_nothrow_move_assignable_v;
+using std::is_nothrow_move_constructible;
+using std::is_nothrow_move_constructible_v;
+using std::is_nothrow_swappable;
+using std::is_nothrow_swappable_v;
+using std::is_nothrow_swappable_with;
+using std::is_nothrow_swappable_with_v;
+using std::is_null_pointer;
+using std::is_null_pointer_v;
+using std::is_object;
+using std::is_object_v;
+using std::is_pod;
+using std::is_pod_v;
+using std::is_pointer;
+using std::is_pointer_v;
+using std::is_polymorphic;
+using std::is_polymorphic_v;
+using std::is_reference;
+using std::is_reference_v;
+using std::is_rvalue_reference;
+using std::is_rvalue_reference_v;
+using std::is_same;
+using std::is_same_v;
+using std::is_scalar;
+using std::is_scalar_v;
+using std::is_signed;
+using std::is_signed_v;
+using std::is_standard_layout;
+using std::is_standard_layout_v;
+using std::is_swappable;
+using std::is_swappable_v;
+using std::is_swappable_with;
+using std::is_swappable_with_v;
+using std::is_trivial;
+using std::is_trivial_v;
+using std::is_trivially_assignable;
+using std::is_trivially_assignable_v;
+using std::is_trivially_constructible;
+using std::is_trivially_constructible_v;
+using std::is_trivially_copy_assignable;
+using std::is_trivially_copy_assignable_v;
+using std::is_trivially_copy_constructible;
+using std::is_trivially_copy_constructible_v;
+using std::is_trivially_copyable;
+using std::is_trivially_copyable_v;
+using std::is_trivially_default_constructible;
+using std::is_trivially_default_constructible_v;
+using std::is_trivially_destructible;
+using std::is_trivially_destructible_v;
+using std::is_trivially_move_assignable;
+using std::is_trivially_move_assignable_v;
+using std::is_trivially_move_constructible;
+using std::is_trivially_move_constructible_v;
+using std::is_unbounded_array;
+using std::is_unbounded_array_v;
+using std::is_union;
+using std::is_union_v;
+using std::is_unsigned;
+using std::is_unsigned_v;
+using std::is_void;
+using std::is_void_v;
+using std::is_volatile;
+using std::is_volatile_v;
+using std::make_signed;
+using std::make_signed_t;
+using std::make_unsigned;
+using std::make_unsigned_t;
+using std::negation;
+using std::negation_v;
+using std::rank;
+using std::rank_v;
+using std::remove_all_extents;
+using std::remove_all_extents_t;
+using std::remove_const;
+using std::remove_const_t;
+using std::remove_cv;
+using std::remove_cv_t;
+using std::remove_cvref;
+using std::remove_cvref_t;
+using std::remove_extent;
+using std::remove_extent_t;
+using std::remove_pointer;
+using std::remove_pointer_t;
+using std::remove_reference;
+using std::remove_reference_t;
+using std::remove_volatile;
+using std::remove_volatile_t;
+using std::true_type;
+using std::type_identity;
+using std::type_identity_t;
+using std::underlying_type;
+using std::underlying_type_t;
+using std::unwrap_ref_decay;
+using std::unwrap_ref_decay_t;
+using std::unwrap_reference;
+using std::unwrap_reference_t;
+using std::void_t;
+}  // namespace std
+
+export namespace std {
+using std::jthread;
+using std::swap;
+using std::thread;
+namespace this_thread {
+using std::this_thread::get_id;
+using std::this_thread::sleep_for;
+using std::this_thread::sleep_until;
+using std::this_thread::yield;
+}  // namespace this_thread
+using std::operator==;
+using std::operator<=>;
+using std::operator<<;
+using std::hash;
+}  // namespace std
+
+#if defined(__GLIBCXX__) || defined(__GLIBCPP__)
+export namespace __gnu_cxx {
+using __gnu_cxx::operator==;
+using __gnu_cxx::operator-;
+}  // namespace __gnu_cxx
+#endif
diff --git a/include/ylt/thirdparty/async_simple/uthread/Async.h b/include/ylt/thirdparty/async_simple/uthread/Async.h
index a8c6ccae6..685e2c758 100644
--- a/include/ylt/thirdparty/async_simple/uthread/Async.h
+++ b/include/ylt/thirdparty/async_simple/uthread/Async.h
@@ -34,10 +34,14 @@
 #ifndef ASYNC_SIMPLE_UTHREAD_ASYNC_H
 #define ASYNC_SIMPLE_UTHREAD_ASYNC_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <memory>
 #include <type_traits>
+#include <tuple>
 #include "async_simple/uthread/Uthread.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace uthread {
 
diff --git a/include/ylt/thirdparty/async_simple/uthread/Await.h b/include/ylt/thirdparty/async_simple/uthread/Await.h
index 082403219..27dc126a6 100644
--- a/include/ylt/thirdparty/async_simple/uthread/Await.h
+++ b/include/ylt/thirdparty/async_simple/uthread/Await.h
@@ -24,11 +24,14 @@
 #ifndef ASYNC_SIMPLE_UTHREAD_AWAIT_H
 #define ASYNC_SIMPLE_UTHREAD_AWAIT_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <type_traits>
 #include "async_simple/Future.h"
 #include "async_simple/coro/Lazy.h"
 #include "async_simple/uthread/internal/thread_impl.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace uthread {
 
@@ -95,8 +98,7 @@ decltype(auto) await(Executor* ex, Fn&& fn, Args&&... args) requires
         co_return;
     };
     lazy(std::forward<Fn>(fn), std::forward<Args>(args)...)
-        .setEx(ex)
-        .start([](auto&&) {});
+        .directlyStart([](auto&&) {}, ex);
     return await(std::move(f));
 }
 
diff --git a/include/ylt/thirdparty/async_simple/uthread/Collect.h b/include/ylt/thirdparty/async_simple/uthread/Collect.h
index 98ca0d81f..a18b80105 100644
--- a/include/ylt/thirdparty/async_simple/uthread/Collect.h
+++ b/include/ylt/thirdparty/async_simple/uthread/Collect.h
@@ -41,11 +41,14 @@
 #ifndef ASYNC_SIMPLE_UTHREAD_COLLECT_H
 #define ASYNC_SIMPLE_UTHREAD_COLLECT_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <type_traits>
 #include "async_simple/Future.h"
 #include "async_simple/uthread/Async.h"
 #include "async_simple/uthread/Await.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace uthread {
 
diff --git a/include/ylt/thirdparty/async_simple/uthread/Latch.h b/include/ylt/thirdparty/async_simple/uthread/Latch.h
index 57704789b..76e53ce0f 100644
--- a/include/ylt/thirdparty/async_simple/uthread/Latch.h
+++ b/include/ylt/thirdparty/async_simple/uthread/Latch.h
@@ -16,8 +16,13 @@
 #ifndef ASYNC_SIMPLE_UTHREAD_LATCH_H
 #define ASYNC_SIMPLE_UTHREAD_LATCH_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <type_traits>
 #include "async_simple/Future.h"
+#include "async_simple/Promise.h"
+#include "async_simple/uthread/Await.h"
+
+#endif  // ASYNC_SIMPLE_USE_MODULES
 
 namespace async_simple {
 namespace uthread {
diff --git a/include/ylt/thirdparty/async_simple/uthread/Uthread.h b/include/ylt/thirdparty/async_simple/uthread/Uthread.h
index f808c51f7..9ce9312ad 100644
--- a/include/ylt/thirdparty/async_simple/uthread/Uthread.h
+++ b/include/ylt/thirdparty/async_simple/uthread/Uthread.h
@@ -16,9 +16,12 @@
 #ifndef ASYNC_SIMPLE_UTHREAD_UTHREAD_H
 #define ASYNC_SIMPLE_UTHREAD_UTHREAD_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <memory>
 #include "async_simple/uthread/internal/thread.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace uthread {
 
diff --git a/include/ylt/thirdparty/async_simple/uthread/internal/thread.h b/include/ylt/thirdparty/async_simple/uthread/internal/thread.h
index c54b89000..8558e41e5 100644
--- a/include/ylt/thirdparty/async_simple/uthread/internal/thread.h
+++ b/include/ylt/thirdparty/async_simple/uthread/internal/thread.h
@@ -23,17 +23,20 @@
 #ifndef ASYNC_SIMPLE_UTHREAD_INTERNAL_THREAD_H
 #define ASYNC_SIMPLE_UTHREAD_INTERNAL_THREAD_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <memory>
-#include <type_traits>
 
 #include "async_simple/Future.h"
+#include "async_simple/Promise.h"
 #include "async_simple/uthread/internal/thread_impl.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace uthread {
 namespace internal {
 
-static constexpr size_t default_base_stack_size = 512 * 1024;
+inline constexpr size_t default_base_stack_size = 512 * 1024;
 size_t get_base_stack_size();
 
 class thread_context {
diff --git a/include/ylt/thirdparty/async_simple/uthread/internal/thread_impl.h b/include/ylt/thirdparty/async_simple/uthread/internal/thread_impl.h
index f3e4943df..af2fe5d26 100644
--- a/include/ylt/thirdparty/async_simple/uthread/internal/thread_impl.h
+++ b/include/ylt/thirdparty/async_simple/uthread/internal/thread_impl.h
@@ -23,8 +23,11 @@
 #ifndef ASYNC_SIMPLE_UTHREAD_INTERNAL_UTHREAD_IMPL_H
 #define ASYNC_SIMPLE_UTHREAD_INTERNAL_UTHREAD_IMPL_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include "async_simple/Common.h"
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace uthread {
 namespace internal {
diff --git a/include/ylt/thirdparty/async_simple/util/Condition.h b/include/ylt/thirdparty/async_simple/util/Condition.h
index 23c2bcc0d..58912bbc8 100644
--- a/include/ylt/thirdparty/async_simple/util/Condition.h
+++ b/include/ylt/thirdparty/async_simple/util/Condition.h
@@ -19,6 +19,7 @@
 #ifndef ASYNC_SIMPLE_UTIL_CONDITION_H
 #define ASYNC_SIMPLE_UTIL_CONDITION_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #if __has_include(<semaphore>)
 #include <semaphore>
 #else
@@ -27,6 +28,8 @@
 #include <mutex>
 #endif
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple {
 namespace util {
 
diff --git a/include/ylt/thirdparty/async_simple/util/Queue.h b/include/ylt/thirdparty/async_simple/util/Queue.h
index d852d8c39..de8e1f690 100644
--- a/include/ylt/thirdparty/async_simple/util/Queue.h
+++ b/include/ylt/thirdparty/async_simple/util/Queue.h
@@ -24,11 +24,14 @@
 #ifndef ASYNC_SIMPLE_QUEUE_H
 #define ASYNC_SIMPLE_QUEUE_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <condition_variable>
 #include <mutex>
 #include <queue>
 #include <utility>
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple::util {
 
 template <typename T>
diff --git a/include/ylt/thirdparty/async_simple/util/ThreadPool.h b/include/ylt/thirdparty/async_simple/util/ThreadPool.h
index 52073e1e0..0a00a10c3 100644
--- a/include/ylt/thirdparty/async_simple/util/ThreadPool.h
+++ b/include/ylt/thirdparty/async_simple/util/ThreadPool.h
@@ -24,14 +24,19 @@
 #ifndef FUTURE_THREAD_POOL_H
 #define FUTURE_THREAD_POOL_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <atomic>
 #include <cassert>
 #include <functional>
 #include <iostream>
 #include <thread>
 #include <vector>
+#include <cstdlib>
 
 #include "async_simple/util/Queue.h"
+
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple::util {
 class ThreadPool {
 public:
@@ -76,7 +81,7 @@ class ThreadPool {
 };
 
 #ifdef __linux__
-static void getCurrentCpus(std::vector<uint32_t> &ids) {
+inline void getCurrentCpus(std::vector<uint32_t> &ids) {
     cpu_set_t set;
     ids.clear();
     if (sched_getaffinity(0, sizeof(set), &set) == 0)
@@ -186,7 +191,7 @@ inline ThreadPool::ERROR_TYPE ThreadPool::scheduleById(std::function<void()> fn,
             }
         }
 
-        id = rand() % _threadNum;
+        id = std::rand() % _threadNum;
         _queues[id].push(
             WorkItem{/*canSteal = */ _enableWorkSteal, std::move(fn)});
     } else {
diff --git a/include/ylt/thirdparty/async_simple/util/move_only_function.h b/include/ylt/thirdparty/async_simple/util/move_only_function.h
index 976b85721..bd2577b20 100644
--- a/include/ylt/thirdparty/async_simple/util/move_only_function.h
+++ b/include/ylt/thirdparty/async_simple/util/move_only_function.h
@@ -19,11 +19,14 @@
 #ifndef ASYNC_SIMPLE_UTIL_MOVE_ONLY_FUNCTION_H
 #define ASYNC_SIMPLE_UTIL_MOVE_ONLY_FUNCTION_H
 
+#ifndef ASYNC_SIMPLE_USE_MODULES
 #include <cstddef>
 #include <functional>
 #include <memory>
 #include <type_traits>
 
+#endif  // ASYNC_SIMPLE_USE_MODULES
+
 namespace async_simple::util {
 
 template <typename Signature>
diff --git a/src/coro_http/tests/test_cinatra.cpp b/src/coro_http/tests/test_cinatra.cpp
index 4266037e5..a532e19d4 100644
--- a/src/coro_http/tests/test_cinatra.cpp
+++ b/src/coro_http/tests/test_cinatra.cpp
@@ -1124,101 +1124,8 @@ TEST_CASE("test coro channel") {
   CHECK(val == 42);
 }
 
-async_simple::coro::Lazy<void> test_select_channel() {
-  using namespace coro_io;
-  using namespace async_simple;
-  using namespace async_simple::coro;
-
-  auto ch1 = coro_io::create_channel<int>(1000);
-  auto ch2 = coro_io::create_channel<int>(1000);
-
-  co_await async_send(ch1, 41);
-  co_await async_send(ch2, 42);
-
-  std::array<int, 2> arr{41, 42};
-  int val;
-
-  size_t index =
-      co_await select(std::pair{async_receive(ch1),
-                                [&val](auto value) {
-                                  auto [ec, r] = value.value();
-                                  val = r;
-                                }},
-                      std::pair{async_receive(ch2), [&val](auto value) {
-                                  auto [ec, r] = value.value();
-                                  val = r;
-                                }});
-
-  CHECK(val == arr[index]);
-
-  co_await async_send(ch1, 41);
-  co_await async_send(ch2, 42);
-
-  std::vector<Lazy<std::pair<std::error_code, int>>> vec;
-  vec.push_back(async_receive(ch1));
-  vec.push_back(async_receive(ch2));
-
-  index = co_await select(std::move(vec), [&](size_t i, auto result) {
-    val = result.value().second;
-  });
-  CHECK(val == arr[index]);
-
-  period_timer timer1(coro_io::get_global_executor());
-  timer1.expires_after(100ms);
-  period_timer timer2(coro_io::get_global_executor());
-  timer2.expires_after(200ms);
-
-  int val1;
-  index = co_await select(std::pair{timer1.async_await(),
-                                    [&](auto val) {
-                                      CHECK(val.value());
-                                      val1 = 0;
-                                    }},
-                          std::pair{timer2.async_await(), [&](auto val) {
-                                      CHECK(val.value());
-                                      val1 = 0;
-                                    }});
-  CHECK(index == val1);
-
-  int val2;
-  index = co_await select(std::pair{coro_io::post([] {
-                                    }),
-                                    [&](auto) {
-                                      std::cout << "post1\n";
-                                      val2 = 0;
-                                    }},
-                          std::pair{coro_io::post([] {
-                                    }),
-                                    [&](auto) {
-                                      std::cout << "post2\n";
-                                      val2 = 1;
-                                    }});
-  CHECK(index == val2);
-
-  co_await async_send(ch1, 43);
-  auto lazy = coro_io::post([] {
-  });
-
-  int val3 = -1;
-  index = co_await select(std::pair{async_receive(ch1),
-                                    [&](auto result) {
-                                      val3 = result.value().second;
-                                    }},
-                          std::pair{std::move(lazy), [&](auto) {
-                                      val3 = 0;
-                                    }});
-
-  if (index == 0) {
-    CHECK(val3 == 43);
-  }
-  else if (index == 1) {
-    CHECK(val3 == 0);
-  }
-}
-
 TEST_CASE("test select coro channel") {
   using namespace coro_io;
-  async_simple::coro::syncAwait(test_select_channel());
 
   auto ch = coro_io::create_channel<int>(1000);
 
diff --git a/src/coro_io/tests/CMakeLists.txt b/src/coro_io/tests/CMakeLists.txt
index e5f95839b..97995dbb8 100644
--- a/src/coro_io/tests/CMakeLists.txt
+++ b/src/coro_io/tests/CMakeLists.txt
@@ -1,7 +1,7 @@
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output/tests)
 add_executable(coro_io_test
         test_corofile.cpp
-        test_channel.cpp
+        test_load_blancer.cpp
         test_client_pool.cpp
         test_rate_limiter.cpp
         test_coro_channel.cpp
diff --git a/src/coro_io/tests/test_coro_channel.cpp b/src/coro_io/tests/test_coro_channel.cpp
index a130b35ad..ba415dfd6 100644
--- a/src/coro_io/tests/test_coro_channel.cpp
+++ b/src/coro_io/tests/test_coro_channel.cpp
@@ -44,20 +44,15 @@ async_simple::coro::Lazy<void> test_select_channel() {
   co_await async_send(ch2, 42);
 
   std::array<int, 2> arr{41, 42};
-  int val;
 
-  size_t index =
-      co_await select(std::pair{async_receive(ch1),
-                                [&val](auto value) {
-                                  auto [ec, r] = value.value();
-                                  val = r;
-                                }},
-                      std::pair{async_receive(ch2), [&val](auto value) {
-                                  auto [ec, r] = value.value();
-                                  val = r;
-                                }});
+  auto result = co_await collectAny(async_receive(ch1), async_receive(ch2));
+  int val = std::visit(
+      [&val](auto& v) {
+        return static_cast<int>(v.value().second);
+      },
+      result);
 
-  CHECK(val == arr[index]);
+  CHECK(val == arr[result.index()]);
 
   co_await async_send(ch1, 41);
   co_await async_send(ch2, 42);
@@ -66,62 +61,17 @@ async_simple::coro::Lazy<void> test_select_channel() {
   vec.push_back(async_receive(ch1));
   vec.push_back(async_receive(ch2));
 
-  index = co_await select(std::move(vec), [&](size_t i, auto result) {
-    val = result.value().second;
-  });
-  CHECK(val == arr[index]);
+  auto result2 = co_await collectAny(std::move(vec));
+  val = result2.value().second;
+  CHECK(val == arr[result2.index()]);
 
   period_timer timer1(coro_io::get_global_executor());
   timer1.expires_after(100ms);
   period_timer timer2(coro_io::get_global_executor());
   timer2.expires_after(200ms);
+  auto val1 = co_await collectAny(timer1.async_await(), timer2.async_await());
 
-  int val1;
-  index = co_await select(std::pair{timer1.async_await(),
-                                    [&](auto val) {
-                                      CHECK(val.value());
-                                      val1 = 0;
-                                    }},
-                          std::pair{timer2.async_await(), [&](auto val) {
-                                      CHECK(val.value());
-                                      val1 = 0;
-                                    }});
-  CHECK(index == val1);
-
-  int val2;
-  index = co_await select(std::pair{coro_io::post([] {
-                                    }),
-                                    [&](auto) {
-                                      std::cout << "post1\n";
-                                      val2 = 0;
-                                    }},
-                          std::pair{coro_io::post([] {
-                                    }),
-                                    [&](auto) {
-                                      std::cout << "post2\n";
-                                      val2 = 1;
-                                    }});
-  CHECK(index == val2);
-
-  co_await async_send(ch1, 43);
-  auto lazy = coro_io::post([] {
-  });
-
-  int val3 = -1;
-  index = co_await select(std::pair{async_receive(ch1),
-                                    [&](auto result) {
-                                      val3 = result.value().second;
-                                    }},
-                          std::pair{std::move(lazy), [&](auto) {
-                                      val3 = 0;
-                                    }});
-
-  if (index == 0) {
-    CHECK(val3 == 43);
-  }
-  else if (index == 1) {
-    CHECK(val3 == 0);
-  }
+  CHECK(val1.index() == 0);
 }
 
 void callback_lazy() {
@@ -135,29 +85,19 @@ void callback_lazy() {
     co_return 42;
   };
 
-  auto collectAnyLazy = [](auto&&... args) mutable -> Lazy<size_t> {
-    co_return co_await collectAny(std::move(args)...);
-  };
-
-  syncAwait(
-      collectAnyLazy(std::pair{test1(), [&](auto&& val) mutable -> Lazy<void> {
-                                 CHECK(val.value() == 42);
-                                 int r = co_await test0();
-                                 int result = r + val.value();
-                                 CHECK(result == 83);
-                               }}));
-
   std::vector<Lazy<int>> input;
   input.push_back(test1());
 
-  auto index = syncAwait(collectAnyLazy(
-      std::move(input), [&test0](size_t index, auto val) mutable -> Lazy<void> {
-        CHECK(val.value() == 42);
-        int r = co_await test0();
-        int result = r + val.value();
-        CHECK(result == 83);
-      }));
-  CHECK(index == 0);
+  syncAwait([&](std::vector<Lazy<int>> input) -> Lazy<void> {
+    auto result = co_await collectAny(std::move(input));
+    CHECK(result.index() == 0);
+    CHECK(result.value() == 42);
+    int r = co_await test0();
+    int r2 = r + result.value();
+    CHECK(r2 == 83);
+    co_return;
+  }(std::move(input)));
+
 #endif
 }
 
diff --git a/src/coro_io/tests/test_channel.cpp b/src/coro_io/tests/test_load_blancer.cpp
similarity index 98%
rename from src/coro_io/tests/test_channel.cpp
rename to src/coro_io/tests/test_load_blancer.cpp
index cd308dc7f..83d8859d8 100644
--- a/src/coro_io/tests/test_channel.cpp
+++ b/src/coro_io/tests/test_load_blancer.cpp
@@ -230,15 +230,19 @@ TEST_CASE("test server down") {
           });
       CHECK(res.has_value());
     }
+
     server1.stop();
+    ELOG_INFO << "server1 stop";
     for (int i = 0; i < 100; ++i) {
       auto res = co_await load_blancer.send_request(
           [&i, &hosts](
               coro_rpc::coro_rpc_client &client,
               std::string_view host) -> async_simple::coro::Lazy<void> {
-            co_await client.call<hello>();
-            if (i > 0)
+            auto res = co_await client.call<hello>();
+            if (i > 0) {
+              CHECK(res.has_value());
               CHECK(host == hosts[1]);
+            }
             co_return;
           });
       if (i > 2)