diff --git a/asio/include/Makefile.am b/asio/include/Makefile.am
index 347d61e248..091abed6ab 100644
--- a/asio/include/Makefile.am
+++ b/asio/include/Makefile.am
@@ -53,6 +53,7 @@ nobase_include_HEADERS = \
 	asio/co_spawn.hpp \
 	asio/completion_condition.hpp \
 	asio/compose.hpp \
+	asio/composed.hpp \
 	asio/connect.hpp \
 	asio/connect_pipe.hpp \
 	asio/consign.hpp \
diff --git a/asio/include/asio.hpp b/asio/include/asio.hpp
index 0411246cf1..67018a575c 100644
--- a/asio/include/asio.hpp
+++ b/asio/include/asio.hpp
@@ -68,6 +68,7 @@
 #include "asio/co_spawn.hpp"
 #include "asio/completion_condition.hpp"
 #include "asio/compose.hpp"
+#include "asio/composed.hpp"
 #include "asio/connect.hpp"
 #include "asio/connect_pipe.hpp"
 #include "asio/consign.hpp"
diff --git a/asio/include/asio/compose.hpp b/asio/include/asio/compose.hpp
index 1fbd33f577..7842c18cb2 100644
--- a/asio/include/asio/compose.hpp
+++ b/asio/include/asio/compose.hpp
@@ -16,215 +16,11 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/composed_work.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/type_traits.hpp"
+#include "asio/composed.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
-namespace detail {
-
-template <typename Impl, typename Work, typename Handler, typename Signature>
-class composed_op;
-
-template <typename Impl, typename Work, typename Handler,
-    typename R, typename... Args>
-class composed_op<Impl, Work, Handler, R(Args...)>
-  : public base_from_cancellation_state<Handler>
-{
-public:
-  template <typename I, typename W, typename H>
-  composed_op(I&& impl,
-      W&& work,
-      H&& handler)
-    : base_from_cancellation_state<Handler>(
-        handler, enable_terminal_cancellation()),
-      impl_(static_cast<I&&>(impl)),
-      work_(static_cast<W&&>(work)),
-      handler_(static_cast<H&&>(handler)),
-      invocations_(0)
-  {
-  }
-
-  composed_op(composed_op&& other)
-    : base_from_cancellation_state<Handler>(
-        static_cast<base_from_cancellation_state<Handler>&&>(other)),
-      impl_(static_cast<Impl&&>(other.impl_)),
-      work_(static_cast<Work&&>(other.work_)),
-      handler_(static_cast<Handler&&>(other.handler_)),
-      invocations_(other.invocations_)
-  {
-  }
-
-  typedef typename composed_work_guard<
-    typename Work::head_type>::executor_type io_executor_type;
-
-  io_executor_type get_io_executor() const noexcept
-  {
-    return work_.head_.get_executor();
-  }
-
-  typedef associated_executor_t<Handler, io_executor_type> executor_type;
-
-  executor_type get_executor() const noexcept
-  {
-    return (get_associated_executor)(handler_, work_.head_.get_executor());
-  }
-
-  typedef associated_allocator_t<Handler, std::allocator<void>> allocator_type;
-
-  allocator_type get_allocator() const noexcept
-  {
-    return (get_associated_allocator)(handler_, std::allocator<void>());
-  }
-
-  template<typename... T>
-  void operator()(T&&... t)
-  {
-    if (invocations_ < ~0u)
-      ++invocations_;
-    this->get_cancellation_state().slot().clear();
-    impl_(*this, static_cast<T&&>(t)...);
-  }
-
-  void complete(Args... args)
-  {
-    this->work_.reset();
-    static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
-  }
-
-  void reset_cancellation_state()
-  {
-    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_);
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(Filter&& filter)
-  {
-    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
-        static_cast<Filter&&>(filter));
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(InFilter&& in_filter,
-      OutFilter&& out_filter)
-  {
-    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
-        static_cast<InFilter&&>(in_filter),
-        static_cast<OutFilter&&>(out_filter));
-  }
-
-  cancellation_type_t cancelled() const noexcept
-  {
-    return base_from_cancellation_state<Handler>::cancelled();
-  }
-
-//private:
-  Impl impl_;
-  Work work_;
-  Handler handler_;
-  unsigned invocations_;
-};
-
-template <typename Impl, typename Work, typename Handler, typename Signature>
-inline bool asio_handler_is_continuation(
-    composed_op<Impl, Work, Handler, Signature>* this_handler)
-{
-  return this_handler->invocations_ > 1 ? true
-    : asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-}
-
-template <typename Signature, typename Executors>
-class initiate_composed_op
-{
-public:
-  typedef typename composed_io_executors<Executors>::head_type executor_type;
-
-  template <typename T>
-  explicit initiate_composed_op(int, T&& executors)
-    : executors_(static_cast<T&&>(executors))
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executors_.head_;
-  }
-
-  template <typename Handler, typename Impl>
-  void operator()(Handler&& handler, Impl&& impl) const
-  {
-    composed_op<decay_t<Impl>, composed_work<Executors>,
-      decay_t<Handler>, Signature>(
-        static_cast<Impl&&>(impl),
-        composed_work<Executors>(executors_),
-        static_cast<Handler&&>(handler))();
-  }
-
-private:
-  composed_io_executors<Executors> executors_;
-};
-
-template <typename Signature>
-class initiate_composed_op<Signature, void()>
-{
-public:
-  template <typename T>
-  explicit initiate_composed_op(int, T&&)
-  {
-  }
-
-  template <typename Handler, typename Impl>
-  void operator()(Handler&& handler, Impl&& impl) const
-  {
-    composed_op<decay_t<Impl>, composed_work<void()>,
-      decay_t<Handler>, Signature>(
-        static_cast<Impl&&>(impl),
-        composed_work<void()>(composed_io_executors<void()>()),
-        static_cast<Handler&&>(handler))();
-  }
-};
-
-template <typename Signature, typename Executors>
-inline initiate_composed_op<Signature, Executors> make_initiate_composed_op(
-    composed_io_executors<Executors>&& executors)
-{
-  return initiate_composed_op<Signature, Executors>(0,
-      static_cast<composed_io_executors<Executors>&&>(executors));
-}
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename Impl, typename Work, typename Handler,
-    typename Signature, typename DefaultCandidate>
-struct associator<Associator,
-    detail::composed_op<Impl, Work, Handler, Signature>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::composed_op<Impl, Work, Handler, Signature>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::composed_op<Impl, Work, Handler, Signature>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
 
 /// Launch an asynchronous operation with a stateful implementation.
 /**
@@ -294,8 +90,8 @@ struct associator<Associator,
  * template <typename CompletionToken>
  * auto async_echo(tcp::socket& socket,
  *     asio::mutable_buffer buffer,
- *     CompletionToken&& token) ->
- *   decltype(
+ *     CompletionToken&& token)
+ *   -> decltype(
  *     asio::async_compose<CompletionToken,
  *       void(asio::error_code, std::size_t)>(
  *         std::declval<async_echo_implementation>(),
@@ -310,25 +106,19 @@ struct associator<Associator,
  */
 template <typename CompletionToken, typename Signature,
     typename Implementation, typename... IoObjectsOrExecutors>
-auto async_compose(Implementation&& implementation,
+inline auto async_compose(Implementation&& implementation,
     type_identity_t<CompletionToken>& token,
     IoObjectsOrExecutors&&... io_objects_or_executors)
   -> decltype(
     async_initiate<CompletionToken, Signature>(
-      detail::make_initiate_composed_op<Signature>(
-        detail::make_composed_io_executors(
-          detail::get_composed_io_executor(
-            static_cast<IoObjectsOrExecutors&&>(
-              io_objects_or_executors))...)),
-      token, static_cast<Implementation&&>(implementation)))
+      composed<Signature>(static_cast<Implementation&&>(implementation),
+        static_cast<IoObjectsOrExecutors&&>(io_objects_or_executors)...),
+      token))
 {
   return async_initiate<CompletionToken, Signature>(
-      detail::make_initiate_composed_op<Signature>(
-        detail::make_composed_io_executors(
-          detail::get_composed_io_executor(
-            static_cast<IoObjectsOrExecutors&&>(
-              io_objects_or_executors))...)),
-      token, static_cast<Implementation&&>(implementation));
+      composed<Signature>(static_cast<Implementation&&>(implementation),
+        static_cast<IoObjectsOrExecutors&&>(io_objects_or_executors)...),
+      token);
 }
 
 } // namespace asio
diff --git a/asio/include/asio/composed.hpp b/asio/include/asio/composed.hpp
new file mode 100644
index 0000000000..d5d546fa18
--- /dev/null
+++ b/asio/include/asio/composed.hpp
@@ -0,0 +1,413 @@
+//
+// composed.hpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_COMPOSED_HPP
+#define ASIO_COMPOSED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/async_result.hpp"
+#include "asio/detail/base_from_cancellation_state.hpp"
+#include "asio/detail/composed_work.hpp"
+#include "asio/detail/handler_cont_helpers.hpp"
+#include "asio/detail/type_traits.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Impl, typename Work,
+    typename Handler, typename... Signatures>
+class composed_op;
+
+template <typename Impl, typename Work, typename Handler>
+class composed_op<Impl, Work, Handler>
+  : public base_from_cancellation_state<Handler>
+{
+public:
+  template <typename I, typename W, typename H>
+  composed_op(I&& impl,
+      W&& work,
+      H&& handler)
+    : base_from_cancellation_state<Handler>(
+        handler, enable_terminal_cancellation()),
+      impl_(static_cast<I&&>(impl)),
+      work_(static_cast<W&&>(work)),
+      handler_(static_cast<H&&>(handler)),
+      invocations_(0)
+  {
+  }
+
+  composed_op(composed_op&& other)
+    : base_from_cancellation_state<Handler>(
+        static_cast<base_from_cancellation_state<Handler>&&>(other)),
+      impl_(static_cast<Impl&&>(other.impl_)),
+      work_(static_cast<Work&&>(other.work_)),
+      handler_(static_cast<Handler&&>(other.handler_)),
+      invocations_(other.invocations_)
+  {
+  }
+
+  typedef typename composed_work_guard<
+    typename Work::head_type>::executor_type io_executor_type;
+
+  io_executor_type get_io_executor() const noexcept
+  {
+    return work_.head_.get_executor();
+  }
+
+  typedef associated_executor_t<Handler, io_executor_type> executor_type;
+
+  executor_type get_executor() const noexcept
+  {
+    return (get_associated_executor)(handler_, work_.head_.get_executor());
+  }
+
+  typedef associated_allocator_t<Handler, std::allocator<void>> allocator_type;
+
+  allocator_type get_allocator() const noexcept
+  {
+    return (get_associated_allocator)(handler_, std::allocator<void>());
+  }
+
+  template <typename... T>
+  void operator()(T&&... t)
+  {
+    if (invocations_ < ~0u)
+      ++invocations_;
+    this->get_cancellation_state().slot().clear();
+    impl_(*this, static_cast<T&&>(t)...);
+  }
+
+  template <typename... Args>
+  auto complete(Args&&... args)
+    -> decltype(declval<Handler>()(static_cast<Args&&>(args)...))
+  {
+    return static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
+  }
+
+  void reset_cancellation_state()
+  {
+    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_);
+  }
+
+  template <typename Filter>
+  void reset_cancellation_state(Filter&& filter)
+  {
+    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
+        static_cast<Filter&&>(filter));
+  }
+
+  template <typename InFilter, typename OutFilter>
+  void reset_cancellation_state(InFilter&& in_filter,
+      OutFilter&& out_filter)
+  {
+    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
+        static_cast<InFilter&&>(in_filter),
+        static_cast<OutFilter&&>(out_filter));
+  }
+
+  cancellation_type_t cancelled() const noexcept
+  {
+    return base_from_cancellation_state<Handler>::cancelled();
+  }
+
+//private:
+  Impl impl_;
+  Work work_;
+  Handler handler_;
+  unsigned invocations_;
+};
+
+template <typename Impl, typename Work, typename Handler,
+    typename R, typename... Args>
+class composed_op<Impl, Work, Handler, R(Args...)>
+  : public composed_op<Impl, Work, Handler>
+{
+public:
+  using composed_op<Impl, Work, Handler>::composed_op;
+
+  template <typename... T>
+  void operator()(T&&... t)
+  {
+    if (this->invocations_ < ~0u)
+      ++this->invocations_;
+    this->get_cancellation_state().slot().clear();
+    this->impl_(*this, static_cast<T&&>(t)...);
+  }
+
+  void complete(Args... args)
+  {
+    this->work_.reset();
+    static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
+  }
+};
+
+template <typename Impl, typename Work, typename Handler,
+    typename R, typename... Args, typename... Signatures>
+class composed_op<Impl, Work, Handler, R(Args...), Signatures...>
+  : public composed_op<Impl, Work, Handler, Signatures...>
+{
+public:
+  using composed_op<Impl, Work, Handler, Signatures...>::composed_op;
+
+  template <typename... T>
+  void operator()(T&&... t)
+  {
+    if (this->invocations_ < ~0u)
+      ++this->invocations_;
+    this->get_cancellation_state().slot().clear();
+    this->impl_(*this, static_cast<T&&>(t)...);
+  }
+
+  using composed_op<Impl, Work, Handler, Signatures...>::complete;
+
+  void complete(Args... args)
+  {
+    this->work_.reset();
+    static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
+  }
+};
+
+template <typename Impl, typename Work, typename Handler, typename Signature>
+inline bool asio_handler_is_continuation(
+    composed_op<Impl, Work, Handler, Signature>* this_handler)
+{
+  return this_handler->invocations_ > 1 ? true
+    : asio_handler_cont_helpers::is_continuation(
+        this_handler->handler_);
+}
+
+template <typename Implementation, typename Executors, typename... Signatures>
+class initiate_composed
+{
+public:
+  typedef typename composed_io_executors<Executors>::head_type executor_type;
+
+  template <typename I>
+  initiate_composed(I&& impl, composed_io_executors<Executors>&& executors)
+    : implementation_(std::forward<I>(impl)),
+      executors_(std::move(executors))
+  {
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return executors_.head_;
+  }
+
+  template <typename Handler, typename... Args>
+  void operator()(Handler&& handler, Args&&... args) const &
+  {
+    composed_op<decay_t<Implementation>, composed_work<Executors>,
+      decay_t<Handler>, Signatures...>(implementation_,
+        composed_work<Executors>(executors_),
+        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
+  }
+
+  template <typename Handler, typename... Args>
+  void operator()(Handler&& handler, Args&&... args) &&
+  {
+    composed_op<decay_t<Implementation>, composed_work<Executors>,
+      decay_t<Handler>, Signatures...>(
+        static_cast<Implementation&&>(implementation_),
+        composed_work<Executors>(executors_),
+        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
+  }
+
+private:
+  Implementation implementation_;
+  composed_io_executors<Executors> executors_;
+};
+
+template <typename Implementation, typename... Signatures>
+class initiate_composed<Implementation, void(), Signatures...>
+{
+public:
+  template <typename I>
+  initiate_composed(I&& impl, composed_io_executors<void()>&&)
+    : implementation_(std::forward<I>(impl))
+  {
+  }
+
+  template <typename Handler, typename... Args>
+  void operator()(Handler&& handler, Args&&... args) const &
+  {
+    composed_op<decay_t<Implementation>, composed_work<void()>,
+      decay_t<Handler>, Signatures...>(implementation_,
+        composed_work<void()>(composed_io_executors<void()>()),
+        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
+  }
+
+  template <typename Handler, typename... Args>
+  void operator()(Handler&& handler, Args&&... args) &&
+  {
+    composed_op<decay_t<Implementation>, composed_work<void()>,
+      decay_t<Handler>, Signatures...>(
+        static_cast<Implementation&&>(implementation_),
+        composed_work<void()>(composed_io_executors<void()>()),
+        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
+  }
+
+private:
+  Implementation implementation_;
+};
+
+template <typename... Signatures, typename Implementation, typename Executors>
+inline initiate_composed<Implementation, Executors, Signatures...>
+make_initiate_composed(Implementation&& implementation,
+    composed_io_executors<Executors>&& executors)
+{
+  return initiate_composed<decay_t<Implementation>, Executors, Signatures...>(
+      static_cast<Implementation&&>(implementation),
+      static_cast<composed_io_executors<Executors>&&>(executors));
+}
+
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <template <typename, typename> class Associator,
+    typename Impl, typename Work, typename Handler,
+    typename Signature, typename DefaultCandidate>
+struct associator<Associator,
+    detail::composed_op<Impl, Work, Handler, Signature>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
+{
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::composed_op<Impl, Work, Handler, Signature>& h) noexcept
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static auto get(const detail::composed_op<Impl, Work, Handler, Signature>& h,
+      const DefaultCandidate& c) noexcept
+    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Creates an initiation function object that may be used to launch an
+/// asynchronous operation with a stateful implementation.
+/**
+ * The @c composed function simplifies the implementation of composed
+ * asynchronous operations automatically by wrapping a stateful function object
+ * for use as an initiation function object.
+ *
+ * @param implementation A function object that contains the implementation of
+ * the composed asynchronous operation. The first argument to the function
+ * object is a non-const reference to the enclosing intermediate completion
+ * handler. The remaining arguments are any arguments that originate from the
+ * completion handlers of any asynchronous operations performed by the
+ * implementation.
+ *
+ * @param io_objects_or_executors Zero or more I/O objects or I/O executors for
+ * which outstanding work must be maintained.
+ *
+ * @par Per-Operation Cancellation
+ * By default, terminal per-operation cancellation is enabled for composed
+ * operations that are implemented using @c composed. To disable cancellation
+ * for the composed operation, or to alter its supported cancellation types,
+ * call the @c self object's @c reset_cancellation_state function.
+ *
+ * @par Example:
+ *
+ * @code struct async_echo_implementation
+ * {
+ *   tcp::socket& socket_;
+ *   asio::mutable_buffer buffer_;
+ *   enum { starting, reading, writing } state_;
+ *
+ *   template <typename Self>
+ *   void operator()(Self& self,
+ *       asio::error_code error,
+ *       std::size_t n)
+ *   {
+ *     switch (state_)
+ *     {
+ *     case starting:
+ *       state_ = reading;
+ *       socket_.async_read_some(
+ *           buffer_, std::move(self));
+ *       break;
+ *     case reading:
+ *       if (error)
+ *       {
+ *         self.complete(error, 0);
+ *       }
+ *       else
+ *       {
+ *         state_ = writing;
+ *         asio::async_write(socket_, buffer_,
+ *             asio::transfer_exactly(n),
+ *             std::move(self));
+ *       }
+ *       break;
+ *     case writing:
+ *       self.complete(error, n);
+ *       break;
+ *     }
+ *   }
+ * };
+ *
+ * template <typename CompletionToken>
+ * auto async_echo(tcp::socket& socket,
+ *     asio::mutable_buffer buffer,
+ *     CompletionToken&& token)
+ *   -> decltype(
+ *     asio::async_initiate<CompletionToken,
+ *       void(asio::error_code, std::size_t)>(
+ *         asio::composed(
+ *           async_echo_implementation{socket, buffer,
+ *             async_echo_implementation::starting}, socket),
+ *         token))
+ * {
+ *   return asio::async_initiate<CompletionToken,
+ *     void(asio::error_code, std::size_t)>(
+ *       asio::composed(
+ *         async_echo_implementation{socket, buffer,
+ *           async_echo_implementation::starting}, socket),
+ *       token, asio::error_code{}, 0);
+ * } @endcode
+ */
+template <ASIO_COMPLETION_SIGNATURE... Signatures,
+    typename Implementation, typename... IoObjectsOrExecutors>
+inline auto composed(Implementation&& implementation,
+    IoObjectsOrExecutors&&... io_objects_or_executors)
+  -> decltype(
+    detail::make_initiate_composed<Signatures...>(
+      static_cast<Implementation&&>(implementation),
+      detail::make_composed_io_executors(
+        detail::get_composed_io_executor(
+          static_cast<IoObjectsOrExecutors&&>(
+            io_objects_or_executors))...)))
+{
+  return detail::make_initiate_composed<Signatures...>(
+      static_cast<Implementation&&>(implementation),
+      detail::make_composed_io_executors(
+        detail::get_composed_io_executor(
+          static_cast<IoObjectsOrExecutors&&>(
+            io_objects_or_executors))...));
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_COMPOSE_HPP
diff --git a/asio/src/Makefile.mgw b/asio/src/Makefile.mgw
index 1b3a276a38..ad418fde00 100644
--- a/asio/src/Makefile.mgw
+++ b/asio/src/Makefile.mgw
@@ -69,6 +69,7 @@ UNIT_TEST_EXES = \
 	tests/unit/co_spawn.exe \
 	tests/unit/completion_condition.exe \
 	tests/unit/compose.exe \
+	tests/unit/composed.exe \
 	tests/unit/connect.exe \
 	tests/unit/coroutine.exe \
 	tests/unit/deadline_timer.exe \
diff --git a/asio/src/Makefile.msc b/asio/src/Makefile.msc
index f88467be52..590895bc3d 100644
--- a/asio/src/Makefile.msc
+++ b/asio/src/Makefile.msc
@@ -160,6 +160,7 @@ UNIT_TEST_EXES = \
 	tests\unit\co_spawn.exe \
 	tests\unit\completion_condition.exe \
 	tests\unit\compose.exe \
+	tests\unit\composed.exe \
 	tests\unit\connect.exe \
 	tests\unit\connect_pipe.exe \
 	tests\unit\coroutine.exe \
diff --git a/asio/src/tests/Makefile.am b/asio/src/tests/Makefile.am
index c13a65b57c..4c5cee09fb 100644
--- a/asio/src/tests/Makefile.am
+++ b/asio/src/tests/Makefile.am
@@ -59,6 +59,7 @@ check_PROGRAMS = \
 	unit/co_spawn \
 	unit/completion_condition \
 	unit/compose \
+	unit/composed \
 	unit/connect \
 	unit/connect_pipe \
 	unit/consign \
@@ -278,6 +279,7 @@ TESTS = \
 	unit/co_spawn \
 	unit/completion_condition \
 	unit/compose \
+	unit/composed \
 	unit/connect \
 	unit/connect_pipe \
 	unit/consign \
@@ -495,6 +497,7 @@ unit_co_composed_SOURCES = unit/co_composed.cpp
 unit_co_spawn_SOURCES = unit/co_spawn.cpp
 unit_completion_condition_SOURCES = unit/completion_condition.cpp
 unit_compose_SOURCES = unit/compose.cpp
+unit_composed_SOURCES = unit/composed.cpp
 unit_connect_SOURCES = unit/connect.cpp
 unit_connect_pipe_SOURCES = unit/connect_pipe.cpp
 unit_consign_SOURCES = unit/consign.cpp
diff --git a/asio/src/tests/unit/.gitignore b/asio/src/tests/unit/.gitignore
index d19534bcdc..bcdc1a4ff3 100644
--- a/asio/src/tests/unit/.gitignore
+++ b/asio/src/tests/unit/.gitignore
@@ -54,6 +54,7 @@ co_composed
 co_spawn
 completion_condition
 compose
+composed
 connect
 connect_pipe
 consign
diff --git a/asio/src/tests/unit/composed.cpp b/asio/src/tests/unit/composed.cpp
new file mode 100644
index 0000000000..d8bfb2774b
--- /dev/null
+++ b/asio/src/tests/unit/composed.cpp
@@ -0,0 +1,530 @@
+//
+// composed.cpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include "asio/composed.hpp"
+
+#include <functional>
+#include "asio/bind_cancellation_slot.hpp"
+#include "asio/cancellation_signal.hpp"
+#include "asio/io_context.hpp"
+#include "asio/post.hpp"
+#include "asio/system_timer.hpp"
+#include "unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+class impl_0_completion_args
+{
+public:
+  explicit impl_0_completion_args(asio::io_context& ioc)
+    : ioc_(ioc),
+      state_(starting)
+  {
+  }
+
+  template <typename Self>
+  void operator()(Self& self)
+  {
+    switch (state_)
+    {
+    case starting:
+      state_ = posting;
+      asio::post(ioc_, static_cast<Self&&>(self));
+      break;
+    case posting:
+      self.complete();
+      break;
+    default:
+      break;
+    }
+  }
+
+private:
+  asio::io_context& ioc_;
+  enum { starting, posting } state_;
+};
+
+template <typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void())
+async_0_completion_args(asio::io_context& ioc,
+    CompletionToken&& token)
+{
+  return asio::async_initiate<CompletionToken, void()>(
+      asio::composed(impl_0_completion_args(ioc)), token);
+}
+
+void compose_0_args_handler(int* count)
+{
+  ++(*count);
+}
+
+struct compose_0_args_lvalue_handler
+{
+  int* count_;
+
+  void operator()()
+  {
+    ++(*count_);
+  }
+};
+
+void compose_0_completion_args_test()
+{
+  namespace bindns = std;
+
+  asio::io_context ioc;
+  int count = 0;
+
+  async_0_completion_args(ioc, bindns::bind(&compose_0_args_handler, &count));
+
+  // No handlers can be called until run() is called.
+  ASIO_CHECK(!ioc.stopped());
+  ASIO_CHECK(count == 0);
+
+  ioc.run();
+
+  // The run() call will not return until all work has finished.
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+
+  ioc.restart();
+  count = 0;
+
+  compose_0_args_lvalue_handler lvalue_handler = { &count };
+  async_0_completion_args(ioc, lvalue_handler);
+
+  // No handlers can be called until run() is called.
+  ASIO_CHECK(!ioc.stopped());
+  ASIO_CHECK(count == 0);
+
+  ioc.run();
+
+  // The run() call will not return until all work has finished.
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+}
+
+//------------------------------------------------------------------------------
+
+class impl_1_completion_arg
+{
+public:
+  explicit impl_1_completion_arg(asio::io_context& ioc)
+    : ioc_(ioc),
+      state_(starting)
+  {
+  }
+
+  template <typename Self>
+  void operator()(Self& self)
+  {
+    switch (state_)
+    {
+    case starting:
+      state_ = posting;
+      asio::post(ioc_, static_cast<Self&&>(self));
+      break;
+    case posting:
+      self.complete(42);
+      break;
+    default:
+      break;
+    }
+  }
+
+private:
+  asio::io_context& ioc_;
+  enum { starting, posting } state_;
+};
+
+template <typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void(int))
+async_1_completion_arg(asio::io_context& ioc,
+    CompletionToken&& token)
+{
+  return asio::async_initiate<CompletionToken, void(int)>(
+      asio::composed(impl_1_completion_arg(ioc)), token);
+}
+
+void compose_1_arg_handler(int* count, int* result_out, int result)
+{
+  ++(*count);
+  *result_out = result;
+}
+
+struct compose_1_arg_lvalue_handler
+{
+  int* count_;
+  int* result_out_;
+
+  void operator()(int result)
+  {
+    ++(*count_);
+    *result_out_ = result;
+  }
+};
+
+void compose_1_completion_arg_test()
+{
+  namespace bindns = std;
+  using bindns::placeholders::_1;
+
+  asio::io_context ioc;
+  int count = 0;
+  int result = 0;
+
+  async_1_completion_arg(ioc,
+      bindns::bind(&compose_1_arg_handler, &count, &result, _1));
+
+  // No handlers can be called until run() is called.
+  ASIO_CHECK(!ioc.stopped());
+  ASIO_CHECK(count == 0);
+  ASIO_CHECK(result == 0);
+
+  ioc.run();
+
+  // The run() call will not return until all work has finished.
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == 42);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  compose_1_arg_lvalue_handler lvalue_handler = { &count, &result };
+  async_1_completion_arg(ioc, lvalue_handler);
+
+  // No handlers can be called until run() is called.
+  ASIO_CHECK(!ioc.stopped());
+  ASIO_CHECK(count == 0);
+  ASIO_CHECK(result == 0);
+
+  ioc.run();
+
+  // The run() call will not return until all work has finished.
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == 42);
+}
+
+//------------------------------------------------------------------------------
+
+typedef asio::enable_terminal_cancellation default_filter;
+
+template <typename CancellationFilter>
+class impl_cancellable
+{
+public:
+  explicit impl_cancellable(CancellationFilter cancellation_filter,
+      asio::system_timer& timer)
+    : cancellation_filter_(cancellation_filter),
+      timer_(timer),
+      state_(starting)
+  {
+  }
+
+  template <typename Self>
+  void operator()(Self& self,
+      const asio::error_code& ec = asio::error_code())
+  {
+    switch (state_)
+    {
+    case starting:
+      if (!asio::is_same<CancellationFilter, default_filter>::value)
+        self.reset_cancellation_state(cancellation_filter_);
+      state_ = waiting;
+      timer_.expires_after(asio::chrono::milliseconds(100));
+      timer_.async_wait(static_cast<Self&&>(self));
+      break;
+    case waiting:
+      self.complete(!ec);
+      break;
+    default:
+      break;
+    }
+  }
+
+private:
+  CancellationFilter cancellation_filter_;
+  asio::system_timer& timer_;
+  enum { starting, waiting } state_;
+};
+
+template <typename CancellationFilter, typename CompletionToken>
+ASIO_INITFN_RESULT_TYPE(CompletionToken, void(bool))
+async_cancellable(CancellationFilter cancellation_filter,
+    asio::system_timer& timer,
+    CompletionToken&& token)
+{
+  return asio::async_initiate<CompletionToken, void(bool)>(
+      asio::composed<void(bool)>(
+        impl_cancellable<CancellationFilter>(cancellation_filter, timer)),
+      token);
+}
+
+void compose_partial_cancellation_handler(
+    int* count, bool* result_out, bool result)
+{
+  ++(*count);
+  *result_out = result;
+}
+
+void compose_default_cancellation_test()
+{
+  namespace bindns = std;
+  using bindns::placeholders::_1;
+
+  asio::io_context ioc;
+  asio::system_timer timer(ioc);
+  asio::cancellation_signal signal;
+  int count = 0;
+  bool result = false;
+
+  async_cancellable(default_filter(), timer,
+      bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1));
+
+  ioc.run();
+
+  // No cancellation, operation completes successfully.
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == true);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(default_filter(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Total cancellation unsupported. Operation completes successfully.
+  signal.emit(asio::cancellation_type::total);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == true);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(default_filter(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Partial cancellation unsupported. Operation completes successfully.
+  signal.emit(asio::cancellation_type::partial);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == true);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(default_filter(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Terminal cancellation works. Operation completes with failure.
+  signal.emit(asio::cancellation_type::terminal);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == false);
+}
+
+void compose_partial_cancellation_test()
+{
+  namespace bindns = std;
+  using bindns::placeholders::_1;
+
+  asio::io_context ioc;
+  asio::system_timer timer(ioc);
+  asio::cancellation_signal signal;
+  int count = 0;
+  bool result = false;
+
+  async_cancellable(asio::enable_partial_cancellation(), timer,
+      bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1));
+
+  ioc.run();
+
+  // No cancellation, operation completes successfully.
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == true);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(asio::enable_partial_cancellation(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Total cancellation unsupported. Operation completes successfully.
+  signal.emit(asio::cancellation_type::total);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == true);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(asio::enable_partial_cancellation(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Partial cancellation works. Operation completes with failure.
+  signal.emit(asio::cancellation_type::partial);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == false);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(asio::enable_partial_cancellation(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Terminal cancellation works. Operation completes with failure.
+  signal.emit(asio::cancellation_type::terminal);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == false);
+}
+
+void compose_total_cancellation_test()
+{
+  namespace bindns = std;
+  using bindns::placeholders::_1;
+
+  asio::io_context ioc;
+  asio::system_timer timer(ioc);
+  asio::cancellation_signal signal;
+  int count = 0;
+  bool result = false;
+
+  async_cancellable(asio::enable_total_cancellation(), timer,
+      bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1));
+
+  ioc.run();
+
+  // No cancellation, operation completes successfully.
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == true);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(asio::enable_total_cancellation(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Total cancellation works. Operation completes with failure.
+  signal.emit(asio::cancellation_type::total);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == false);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(asio::enable_total_cancellation(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Partial cancellation works. Operation completes with failure.
+  signal.emit(asio::cancellation_type::partial);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == false);
+
+  ioc.restart();
+  count = 0;
+  result = 0;
+
+  async_cancellable(asio::enable_total_cancellation(), timer,
+      asio::bind_cancellation_slot(signal.slot(),
+        bindns::bind(&compose_partial_cancellation_handler,
+        &count, &result, _1)));
+
+  // Terminal cancellation works. Operation completes with failure.
+  signal.emit(asio::cancellation_type::terminal);
+
+  ioc.run();
+
+  ASIO_CHECK(ioc.stopped());
+  ASIO_CHECK(count == 1);
+  ASIO_CHECK(result == false);
+}
+
+//------------------------------------------------------------------------------
+
+ASIO_TEST_SUITE
+(
+  "compose",
+  ASIO_TEST_CASE(compose_0_completion_args_test)
+  ASIO_TEST_CASE(compose_1_completion_arg_test)
+  ASIO_TEST_CASE(compose_default_cancellation_test)
+  ASIO_TEST_CASE(compose_partial_cancellation_test)
+  ASIO_TEST_CASE(compose_total_cancellation_test)
+)