diff --git a/CMakeLists.txt b/CMakeLists.txt
index 692276af..807c993b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -40,6 +40,7 @@ option(
 include(GNUInstallDirs)
 set(INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
 
+if(FALSE)
 if(PROJECT_IS_TOP_LEVEL AND NOT BEMAN_EXECUTION_ENABLE_INSTALL OR CMAKE_SKIP_INSTALL_RULES)
   set(CMAKE_SKIP_INSTALL_RULES ON)
 
@@ -90,6 +91,7 @@ if(PROJECT_IS_TOP_LEVEL AND NOT BEMAN_EXECUTION_ENABLE_INSTALL OR CMAKE_SKIP_INS
     # LINKER "lld"
   )
 endif()
+endif()
 
 add_subdirectory(src/beman/execution)
 
diff --git a/include/beman/execution/detail/as_tuple.hpp b/include/beman/execution/detail/as_tuple.hpp
new file mode 100644
index 00000000..1b9726c0
--- /dev/null
+++ b/include/beman/execution/detail/as_tuple.hpp
@@ -0,0 +1,25 @@
+// include/beman/execution/detail/as_tuple.hpp                        -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_AS_TUPLE
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_AS_TUPLE
+
+#include <beman/execution/detail/decayed_tuple.hpp>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+template <typename T>
+struct as_tuple;
+template <typename Rc, typename... A>
+struct as_tuple<Rc(A...)> {
+    using type = ::beman::execution::detail::decayed_tuple<Rc, A...>;
+};
+
+template <typename T>
+using as_tuple_t = typename ::beman::execution::detail::as_tuple<T>::type;
+} // namespace beman::execution::detail
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/associate.hpp b/include/beman/execution/detail/associate.hpp
new file mode 100644
index 00000000..f89adf6d
--- /dev/null
+++ b/include/beman/execution/detail/associate.hpp
@@ -0,0 +1,161 @@
+// include/beman/execution/detail/associate.hpp                       -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_ASSOCIATE
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_ASSOCIATE
+
+#include <beman/execution/detail/scope_token.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/connect.hpp>
+#include <beman/execution/detail/transform_sender.hpp>
+#include <beman/execution/detail/get_domain_early.hpp>
+#include <beman/execution/detail/make_sender.hpp>
+#include <beman/execution/detail/default_impls.hpp>
+#include <beman/execution/detail/impls_for.hpp>
+#include <type_traits>
+#include <optional>
+#include <utility>
+#include <iostream> //-dk:TODO remove
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+template <::beman::execution::scope_token Token, ::beman::execution::sender Sender>
+struct associate_data {
+    using wrap_sender = ::std::remove_cvref_t<decltype(::std::declval<Token&>().wrap(::std::declval<Sender>()))>;
+
+    explicit associate_data(Token t, Sender&& s) : token(t), sender(this->token.wrap(::std::forward<Sender>(s))) {
+        if (!token.try_associate()) {
+            this->sender.reset();
+        }
+    }
+    associate_data(const associate_data& other) noexcept(::std::is_nothrow_copy_constructible_v<wrap_sender> &&
+                                                         noexcept(token.try_associate()))
+        : token(other.token), sender() {
+        if (other.sender && this->token.try_associate()) {
+            try {
+                this->sender.emplace(*other.sender);
+            } catch (...) {
+                this->token.disassociate();
+            }
+        }
+    }
+    associate_data(associate_data&& other) noexcept(::std::is_nothrow_move_constructible_v<wrap_sender>)
+        : token(other.token), sender(::std::move(other.sender)) {
+        other.sender.reset();
+    }
+    auto operator=(const associate_data&) -> associate_data& = delete;
+    auto operator=(associate_data&&) -> associate_data&      = delete;
+    ~associate_data() {
+        if (this->sender) {
+            this->sender.reset();
+            this->token.disassociate();
+        }
+    }
+
+    auto release() -> ::std::optional<::std::pair<Token, wrap_sender>> {
+        return this->sender ? (std::unique_ptr<std::optional<wrap_sender>, decltype([](auto* opt) { opt->reset(); })>(
+                                   &this->sender),
+                               ::std::optional{::std::pair{::std::move(this->token), ::std::move(*this->sender)}})
+                            : ::std::optional<::std::pair<Token, wrap_sender>>{};
+    }
+
+    Token                        token;
+    ::std::optional<wrap_sender> sender;
+};
+template <::beman::execution::scope_token Token, ::beman::execution::sender Sender>
+associate_data(Token, Sender&&) -> associate_data<Token, Sender>;
+
+struct associate_t {
+    template <::beman::execution::sender Sender, ::beman::execution::scope_token Token>
+    auto operator()(Sender&& sender, Token&& token) const {
+        auto domain(::beman::execution::detail::get_domain_early(sender));
+        return ::beman::execution::transform_sender(
+            domain,
+            ::beman::execution::detail::make_sender(
+                *this,
+                ::beman::execution::detail::associate_data(::std::forward<Token>(token),
+                                                           ::std::forward<Sender>(sender))));
+    }
+};
+
+template <>
+struct impls_for<associate_t> : ::beman::execution::detail::default_impls {
+    template <typename, typename>
+    struct get_noexcept : ::std::false_type {};
+    template <typename Tag, typename Data, typename Receiver>
+    struct get_noexcept<::beman::execution::detail::basic_sender<Tag, Data>, Receiver>
+        : ::std::bool_constant<
+              ::std::is_nothrow_move_constructible_v<typename ::std::remove_cvref_t<Data>::wrap_sender>&& ::beman::
+                  execution::detail::nothrow_callable<::beman::execution::connect_t,
+                                                      typename ::std::remove_cvref_t<Data>::wrap_sender,
+                                                      Receiver>> {};
+
+    static constexpr auto get_state =
+        []<typename Sender, typename Receiver>(Sender&& sender, Receiver& receiver) noexcept(
+            ::std::is_nothrow_constructible_v<::std::remove_cvref_t<Sender>, Sender>&&
+                get_noexcept<::std::remove_cvref_t<Sender>, Receiver>::value) {
+            auto [_, data] = ::std::forward<Sender>(sender);
+            auto dataParts{data.release()};
+
+            using scope_token = decltype(dataParts->first);
+            using wrap_sender = decltype(dataParts->second);
+            using op_t        = decltype(::beman::execution::connect(::std::move(dataParts->second),
+                                                              ::std::forward<Receiver>(receiver)));
+
+            struct op_state {
+                using sop_t        = op_t;
+                using sscope_token = scope_token;
+                bool associated{false};
+                union {
+                    Receiver* rcvr;
+                    struct {
+                        sscope_token tok;
+                        sop_t        op;
+                    } assoc;
+                };
+                explicit op_state(Receiver& r) noexcept : rcvr(::std::addressof(r)) {}
+                explicit op_state(sscope_token tk, wrap_sender&& sndr, Receiver& r) try
+                    : associated(true), assoc(tk, ::beman::execution::connect(::std::move(sndr), ::std::move(r))) {
+                } catch (...) {
+                    tk.disassociate();
+                    throw;
+                }
+                op_state(op_state&&) = delete;
+                ~op_state() {
+                    if (this->associated) {
+                        this->assoc.op.~sop_t();
+                        this->assoc.tok.disassociate();
+                        this->assoc.tok.~sscope_token();
+                    }
+                }
+                auto run() noexcept -> void {
+                    if (this->associated) {
+                        ::beman::execution::start(this->assoc.op);
+                    } else {
+                        ::beman::execution::set_stopped(::std::move(*this->rcvr));
+                    }
+                }
+            };
+            return dataParts ? op_state(::std::move(dataParts->first), ::std::move(dataParts->second), receiver)
+                             : op_state(receiver);
+        };
+    static constexpr auto start = [](auto& state, auto&&) noexcept -> void { state.run(); };
+};
+
+template <typename Data, typename Env>
+struct completion_signatures_for_impl<
+    ::beman::execution::detail::basic_sender<::beman::execution::detail::associate_t, Data>,
+    Env> {
+    using type = ::beman::execution::completion_signatures<::beman::execution::set_value_t()>;
+};
+} // namespace beman::execution::detail
+
+namespace beman::execution {
+using associate_t = ::beman::execution::detail::associate_t;
+inline constexpr associate_t associate{};
+} // namespace beman::execution
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/counting_scope.hpp b/include/beman/execution/detail/counting_scope.hpp
new file mode 100644
index 00000000..46370e7f
--- /dev/null
+++ b/include/beman/execution/detail/counting_scope.hpp
@@ -0,0 +1,60 @@
+// include/beman/execution/detail/counting_scope.hpp                  -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_COUNTING_SCOPE
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_COUNTING_SCOPE
+
+#include <beman/execution/detail/counting_scope_base.hpp>
+#include <beman/execution/detail/counting_scope_join.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/inplace_stop_source.hpp>
+#include <beman/execution/detail/stop_when.hpp>
+#include <utility>
+#include <cstdlib>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution {
+class counting_scope;
+}
+
+// ----------------------------------------------------------------------------
+
+class beman::execution::counting_scope : public ::beman::execution::detail::counting_scope_base {
+  public:
+    class token;
+
+    auto join() noexcept -> ::beman::execution::sender auto {
+        return ::beman::execution::detail::counting_scope_join(this);
+    }
+    auto get_token() noexcept -> token;
+    auto request_stop() noexcept -> void { this->stop_source.request_stop(); }
+
+  private:
+    ::beman::execution::inplace_stop_source stop_source{};
+};
+
+// ----------------------------------------------------------------------------
+
+class beman::execution::counting_scope::token : public ::beman::execution::detail::counting_scope_base::token {
+  public:
+    template <::beman::execution::sender Sender>
+    auto wrap(Sender&& sender) const noexcept -> ::beman::execution::sender auto {
+        return ::beman::execution::detail::stop_when(
+            ::std::forward<Sender>(sender),
+            static_cast<::beman::execution::counting_scope*>(this->scope)->stop_source.get_token());
+    }
+
+  private:
+    friend class beman::execution::counting_scope;
+    explicit token(::beman::execution::counting_scope* s)
+        : ::beman::execution::detail::counting_scope_base::token(s) {}
+};
+
+// ----------------------------------------------------------------------------
+
+inline auto beman::execution::counting_scope::get_token() noexcept -> beman::execution::counting_scope::token {
+    return beman::execution::counting_scope::token(this);
+}
+
+#endif
diff --git a/include/beman/execution/detail/counting_scope_base.hpp b/include/beman/execution/detail/counting_scope_base.hpp
new file mode 100644
index 00000000..56ca4f5e
--- /dev/null
+++ b/include/beman/execution/detail/counting_scope_base.hpp
@@ -0,0 +1,166 @@
+// include/beman/execution/detail/counting_scope_base.hpp             -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_COUNTING_SCOPE_BASE
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_COUNTING_SCOPE_BASE
+
+#include <beman/execution/detail/immovable.hpp>
+#include <cstddef>
+#include <exception>
+#include <mutex>
+#include <utility>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+struct counting_scope_base;
+}
+
+// ----------------------------------------------------------------------------
+
+class beman::execution::detail::counting_scope_base : ::beman::execution::detail::immovable {
+  public:
+    counting_scope_base()                      = default;
+    counting_scope_base(counting_scope_base&&) = delete;
+    ~counting_scope_base();
+
+    static constexpr ::std::size_t max_associations{8194u};
+
+    auto close() noexcept -> void;
+
+    struct node {
+        virtual auto complete() noexcept -> void        = 0;
+        virtual auto complete_inline() noexcept -> void = 0;
+        node*        next{};
+    };
+    auto start_node(node*) -> void;
+
+  protected:
+    class token {
+      public:
+        auto try_associate() const noexcept -> bool { return this->scope->try_associate(); }
+        auto disassociate() const noexcept -> void { this->scope->disassociate(); }
+
+      protected:
+        explicit token(::beman::execution::detail::counting_scope_base* s) : scope(s) {}
+        ::beman::execution::detail::counting_scope_base* scope;
+    };
+
+  private:
+    enum class state_t : unsigned char {
+        unused,
+        open,
+        open_and_joining,
+        closed,
+        closed_and_joining,
+        unused_and_closed,
+        joined
+    };
+
+    auto try_associate() noexcept -> bool;
+    auto disassociate() noexcept -> void;
+    auto complete() noexcept -> void;
+    auto add_node(node* n, ::std::lock_guard<::std::mutex>&) noexcept -> void;
+
+    ::std::mutex mutex;
+    //-dk:TODO fuse state and count and use atomic accesses
+    ::std::size_t count{};
+    state_t       state{state_t::unused};
+    node*         head{};
+};
+
+// ----------------------------------------------------------------------------
+
+beman::execution::detail::counting_scope_base::~counting_scope_base() {
+    ::std::lock_guard kerberos(this->mutex);
+    switch (this->state) {
+    default:
+        ::std::terminate();
+    case state_t::unused:
+    case state_t::unused_and_closed:
+    case state_t::joined:
+        break;
+    }
+}
+
+auto beman::execution::detail::counting_scope_base::close() noexcept -> void {
+    switch (this->state) {
+    default:
+        break;
+    case state_t::unused:
+        this->state = state_t::unused_and_closed;
+        break;
+    case state_t::open:
+        this->state = state_t::closed;
+        break;
+    case state_t::open_and_joining:
+        this->state = state_t::closed_and_joining;
+        break;
+    }
+}
+
+auto beman::execution::detail::counting_scope_base::add_node(node* n, ::std::lock_guard<::std::mutex>&) noexcept
+    -> void {
+    n->next = std::exchange(this->head, n);
+}
+
+auto beman::execution::detail::counting_scope_base::try_associate() noexcept -> bool {
+    ::std::lock_guard lock(this->mutex);
+    switch (this->state) {
+    default:
+        return false;
+    case state_t::unused:
+        this->state = state_t::open; // fall-through!
+        [[fallthrough]];
+    case state_t::open:
+    case state_t::open_and_joining:
+        ++this->count;
+        return true;
+    }
+}
+auto beman::execution::detail::counting_scope_base::disassociate() noexcept -> void {
+    {
+        ::std::lock_guard lock(this->mutex);
+        if (0u < --this->count)
+            return;
+        this->state = state_t::joined;
+    }
+    this->complete();
+}
+
+auto beman::execution::detail::counting_scope_base::complete() noexcept -> void {
+    node* current{[this] {
+        ::std::lock_guard lock(this->mutex);
+        return ::std::exchange(this->head, nullptr);
+    }()};
+    while (current) {
+        ::std::exchange(current, current->next)->complete();
+    }
+}
+
+auto beman::execution::detail::counting_scope_base::start_node(node* n) -> void {
+    ::std::lock_guard kerberos(this->mutex);
+    switch (this->state) {
+    case ::beman::execution::detail::counting_scope_base::state_t::unused:
+    case ::beman::execution::detail::counting_scope_base::state_t::unused_and_closed:
+    case ::beman::execution::detail::counting_scope_base::state_t::joined:
+        this->state = ::beman::execution::detail::counting_scope_base::state_t::joined;
+        n->complete_inline();
+        return;
+    case ::beman::execution::detail::counting_scope_base::state_t::open:
+        this->state = ::beman::execution::detail::counting_scope_base::state_t::open_and_joining;
+        break;
+    case ::beman::execution::detail::counting_scope_base::state_t::open_and_joining:
+        break;
+    case ::beman::execution::detail::counting_scope_base::state_t::closed:
+        this->state = ::beman::execution::detail::counting_scope_base::state_t::closed_and_joining;
+        break;
+    case ::beman::execution::detail::counting_scope_base::state_t::closed_and_joining:
+        break;
+    }
+    this->add_node(n, kerberos);
+}
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/counting_scope_join.hpp b/include/beman/execution/detail/counting_scope_join.hpp
new file mode 100644
index 00000000..0673242c
--- /dev/null
+++ b/include/beman/execution/detail/counting_scope_join.hpp
@@ -0,0 +1,87 @@
+// include/beman/execution/detail/counting_scope_join.hpp             -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_COUNTING_SCOPE_JOIN
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_COUNTING_SCOPE_JOIN
+
+#include <beman/execution/detail/basic_sender.hpp>
+#include <beman/execution/detail/completion_signatures.hpp>
+#include <beman/execution/detail/connect.hpp>
+#include <beman/execution/detail/counting_scope_base.hpp>
+#include <beman/execution/detail/default_impls.hpp>
+#include <beman/execution/detail/get_env.hpp>
+#include <beman/execution/detail/get_scheduler.hpp>
+#include <beman/execution/detail/impls_for.hpp>
+#include <beman/execution/detail/make_sender.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/schedule.hpp>
+#include <beman/execution/detail/set_value.hpp>
+#include <beman/execution/detail/start.hpp>
+
+#include <type_traits>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+struct counting_scope_join_t {
+    template <::beman::execution::receiver>
+    struct state;
+
+    auto operator()(::beman::execution::detail::counting_scope_base* ptr) const {
+        return ::beman::execution::detail::make_sender(*this, ptr);
+    }
+};
+inline constexpr counting_scope_join_t counting_scope_join{};
+
+template <typename Env>
+struct completion_signatures_for_impl<
+    ::beman::execution::detail::basic_sender<::beman::execution::detail::counting_scope_join_t,
+                                             ::beman::execution::detail::counting_scope_base*>,
+    Env> {
+    using type = ::beman::execution::completion_signatures<::beman::execution::set_value_t()>;
+};
+
+} // namespace beman::execution::detail
+
+// ----------------------------------------------------------------------------
+
+template <::beman::execution::receiver Receiver>
+struct beman::execution::detail::counting_scope_join_t::state : ::beman::execution::detail::counting_scope_base::node {
+    using op_t = decltype(::beman::execution::connect(::beman::execution::schedule(::beman::execution::get_scheduler(
+                                                          ::beman::execution::get_env(::std::declval<Receiver&>()))),
+                                                      ::std::declval<Receiver&>()));
+
+    ::beman::execution::detail::counting_scope_base* scope;
+    explicit state(::beman::execution::detail::counting_scope_base* s, Receiver& r)
+        : scope(s),
+          receiver(r),
+          op(::beman::execution::connect(::beman::execution::schedule(::beman::execution::get_scheduler(
+                                             ::beman::execution::get_env(this->receiver))),
+                                         this->receiver)) {}
+    virtual ~state() = default;
+
+    auto complete() noexcept -> void override { ::beman::execution::start(this->op); }
+    auto complete_inline() noexcept -> void override { ::beman::execution::set_value(::std::move(this->receiver)); }
+
+    auto start() noexcept -> void { this->scope->start_node(this); }
+
+    ::std::remove_cvref_t<Receiver>& receiver;
+    op_t                             op;
+};
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+template <>
+struct impls_for<::beman::execution::detail::counting_scope_join_t> : ::beman::execution::detail::default_impls {
+    static constexpr auto get_state = []<typename Receiver>(auto&& sender, Receiver& receiver) noexcept(false) {
+        auto [_, self] = sender;
+        return ::beman::execution::detail::counting_scope_join_t::state<Receiver>(self, receiver);
+    };
+    static constexpr auto start = [](auto& s, auto&) noexcept { s.start(); };
+};
+} // namespace beman::execution::detail
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/meta_contain_same.hpp b/include/beman/execution/detail/meta_contain_same.hpp
new file mode 100644
index 00000000..c5874e8d
--- /dev/null
+++ b/include/beman/execution/detail/meta_contain_same.hpp
@@ -0,0 +1,27 @@
+// include/beman/execution/detail/meta_contain_same.hpp               -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_META_CONTAIN_SAME
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_META_CONTAIN_SAME
+
+#include <beman/execution/detail/meta_contains.hpp>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail::meta {
+template <typename, typename>
+struct contain_same_t;
+template <template <typename...> class L0, typename... M0, template <typename...> class L1, typename... M1>
+struct contain_same_t<L0<M0...>, L1<M1...>> {
+    static constexpr bool value =
+        ((sizeof...(M0) == sizeof...(M1)) && ... && ::beman::execution::detail::meta::contains<M0, M1...>);
+};
+
+template <typename S0, typename S1>
+inline constexpr bool contain_same = contain_same_t<S0, S1>::value;
+
+} // namespace beman::execution::detail::meta
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/prop.hpp b/include/beman/execution/detail/prop.hpp
new file mode 100644
index 00000000..1b2cdf23
--- /dev/null
+++ b/include/beman/execution/detail/prop.hpp
@@ -0,0 +1,33 @@
+// include/beman/execution/detail/prop.hpp                            -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_PROP
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_PROP
+
+#include <type_traits>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution {
+template <typename Query, typename Value>
+struct prop {
+    [[no_unique_address]] Query query_{};
+    Value                       value_;
+
+    template <typename Q, typename V>
+    prop(Q q, V&& v) : query_(q), value_(v) {}
+    prop(prop&&)                = default;
+    prop(const prop&)           = default;
+    auto operator=(prop&&)      = delete;
+    auto operator=(const prop&) = delete;
+
+    constexpr auto query(Query) const noexcept -> Value { return this->value_; }
+};
+
+template <typename Query, typename Value>
+prop(Query, Value) -> prop<Query, ::std::unwrap_reference_t<Value>>;
+} // namespace beman::execution
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/scope_token.hpp b/include/beman/execution/detail/scope_token.hpp
new file mode 100644
index 00000000..edb98279
--- /dev/null
+++ b/include/beman/execution/detail/scope_token.hpp
@@ -0,0 +1,42 @@
+// include/beman/execution/detail/scope_token.hpp                     -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_SCOPE_TOKEN
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_SCOPE_TOKEN
+
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/sender_in.hpp>
+#include <beman/execution/detail/get_completion_signatures.hpp>
+#include <concepts>
+#include <type_traits>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+struct token_test_env {};
+
+struct token_test_sender {
+    using sender_concept = ::beman::execution::sender_t;
+    auto get_completion_signatures(::beman::execution::detail::token_test_env) const noexcept {
+        return ::beman::execution::completion_signatures<>{};
+    }
+};
+static_assert(::beman::execution::sender<::beman::execution::detail::token_test_sender>);
+static_assert(::beman::execution::sender_in<::beman::execution::detail::token_test_sender,
+                                            ::beman::execution::detail::token_test_env>);
+} // namespace beman::execution::detail
+
+namespace beman::execution {
+template <typename Token>
+concept scope_token = ::std::copyable<Token> && requires(Token token) {
+    { token.try_associate() } -> ::std::same_as<bool>;
+    { token.disassociate() } noexcept;
+    {
+        token.wrap(::std::declval<::beman::execution::detail::token_test_sender>())
+    } -> ::beman::execution::sender_in<::beman::execution::detail::token_test_env>;
+};
+} // namespace beman::execution
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/simple_counting_scope.hpp b/include/beman/execution/detail/simple_counting_scope.hpp
index dc84e91e..84b3c187 100644
--- a/include/beman/execution/detail/simple_counting_scope.hpp
+++ b/include/beman/execution/detail/simple_counting_scope.hpp
@@ -4,11 +4,9 @@
 #ifndef INCLUDED_BEMAN_EXECUTION_DETAIL_SIMPLE_COUNTING_SCOPE
 #define INCLUDED_BEMAN_EXECUTION_DETAIL_SIMPLE_COUNTING_SCOPE
 
+#include <beman/execution/detail/counting_scope_base.hpp>
+#include <beman/execution/detail/counting_scope_join.hpp>
 #include <beman/execution/detail/sender.hpp>
-#include <beman/execution/detail/notify.hpp>
-#include <beman/execution/detail/immovable.hpp>
-#include <atomic>
-#include <mutex>
 #include <utility>
 #include <cstdlib>
 
@@ -20,126 +18,29 @@ class simple_counting_scope;
 
 // ----------------------------------------------------------------------------
 
-class beman::execution::simple_counting_scope : ::beman::execution::detail::immovable {
+class beman::execution::simple_counting_scope : public ::beman::execution::detail::counting_scope_base {
   public:
     class token;
-    class assoc;
 
     auto get_token() noexcept -> token;
-    auto close() noexcept -> void {
-        switch (this->state) {
-        default:
-            break;
-        case state_t::unused:
-            this->state = state_t::unused_and_closed;
-            break;
-        case state_t::open:
-            this->state = state_t::closed;
-            break;
-        case state_t::open_and_joining:
-            this->state = state_t::closed_and_joining;
-            break;
-        }
+    auto join() noexcept -> ::beman::execution::sender auto {
+        return ::beman::execution::detail::counting_scope_join(this);
     }
-    auto join() noexcept {
-        bool complete{false};
-        {
-            ::std::lock_guard kerberos(this->mutex);
-            if (0u == this->count) {
-                this->state = state_t::joined;
-                complete    = true;
-            }
-        }
-        if (complete) {
-            n.complete();
-        }
-        return ::beman::execution::detail::notify(this->n);
-    }
-
-  private:
-    enum class state_t : unsigned char {
-        unused,
-        open,
-        open_and_joining,
-        closed,
-        closed_and_joining,
-        unused_and_closed,
-        joined
-    };
-    friend class assoc;
-    auto try_associate() noexcept -> simple_counting_scope* {
-        ::std::lock_guard lock(this->mutex);
-        switch (this->state) {
-        default:
-            return nullptr;
-        case state_t::unused:
-            this->state = state_t::open; // fall-through!
-            [[fallthrough]];
-        case state_t::open:
-        case state_t::open_and_joining:
-            ++this->count;
-            return this;
-        }
-    }
-    auto disassociate() noexcept -> void {
-        {
-            ::std::lock_guard lock(this->mutex);
-            if (0u < --this->count)
-                return;
-            this->state = state_t::joined;
-        }
-        n.complete();
-    }
-    ::std::mutex                         mutex;
-    ::std::size_t                        count{};
-    state_t                              state{state_t::unused};
-    ::beman::execution::detail::notifier n;
-};
-
-// ----------------------------------------------------------------------------
-
-// NOLINTBEGIN(misc-unconventional-assign-operator,hicpp-special-member-functions)
-class beman::execution::simple_counting_scope::assoc {
-  public:
-    assoc() = default;
-    assoc(const assoc& other) noexcept : assoc(other.scope) {}
-    assoc(assoc&& other) noexcept : scope(::std::exchange(other.scope, nullptr)) {}
-    ~assoc() {
-        if (this->scope)
-            this->scope->disassociate();
-    }
-
-    auto operator=(assoc other) noexcept -> assoc& {
-        ::std::swap(this->scope, other.scope);
-        return *this;
-    }
-
-    explicit operator bool() const noexcept { return this->scope != nullptr; }
-
-  private:
-    friend class beman::execution::simple_counting_scope::token;
-    explicit assoc(beman::execution::simple_counting_scope* scp) : scope(scp ? scp->try_associate() : nullptr) {}
-    beman::execution::simple_counting_scope* scope{};
 };
-// NOLINTEND(misc-unconventional-assign-operator,hicpp-special-member-functions)
 
 // ----------------------------------------------------------------------------
 
-class beman::execution::simple_counting_scope::token {
+class beman::execution::simple_counting_scope::token : public ::beman::execution::detail::counting_scope_base::token {
   public:
     template <::beman::execution::sender Sender>
     auto wrap(Sender&& sender) const noexcept -> Sender&& {
         return ::std::forward<Sender>(sender);
     }
 
-    auto try_associate() const -> beman::execution::simple_counting_scope::assoc {
-        return beman::execution::simple_counting_scope::assoc(this->scope);
-    }
-
   private:
     friend class beman::execution::simple_counting_scope;
-    explicit token(beman::execution::simple_counting_scope* scp) noexcept : scope(scp) {}
-    beman::execution::simple_counting_scope* scope;
+    explicit token(::beman::execution::detail::counting_scope_base* s)
+        : ::beman::execution::detail::counting_scope_base::token(s) {}
 };
 
 // ----------------------------------------------------------------------------
diff --git a/include/beman/execution/detail/spawn.hpp b/include/beman/execution/detail/spawn.hpp
new file mode 100644
index 00000000..f45441a8
--- /dev/null
+++ b/include/beman/execution/detail/spawn.hpp
@@ -0,0 +1,93 @@
+// include/beman/execution/detail/spawn.hpp                           -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_SPAWN
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_SPAWN
+
+#include <beman/execution/detail/spawn_get_allocator.hpp>
+#include <beman/execution/detail/scope_token.hpp>
+#include <beman/execution/detail/empty_env.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/connect_result_t.hpp>
+#include <beman/execution/detail/connect.hpp>
+#include <beman/execution/detail/start.hpp>
+#include <beman/execution/detail/write_env.hpp>
+#include <memory>
+#include <utility>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+struct spawn_t {
+    struct state_base {
+        virtual ~state_base()                    = default;
+        virtual auto complete() noexcept -> void = 0;
+    };
+
+    struct receiver {
+        using receiver_concept = ::beman::execution::receiver_t;
+        state_base* state{};
+
+        auto set_value() && noexcept -> void { this->state->complete(); }
+        auto set_stopped() && noexcept -> void { this->state->complete(); }
+    };
+
+    template <typename Alloc, ::beman::execution::scope_token Tok, ::beman::execution::sender Sndr>
+    struct state : state_base {
+        using op_t     = ::beman::execution::connect_result_t<Sndr, receiver>;
+        using alloc_t  = typename ::std::allocator_traits<Alloc>::template rebind_alloc<state>;
+        using traits_t = ::std::allocator_traits<alloc_t>;
+
+        state(Alloc a, Sndr&& sndr, Tok tok)
+            : alloc(a), op(::beman::execution::connect(::std::forward<Sndr>(sndr), receiver{this})), token(tok) {
+            if (this->token.try_associate()) {
+                ::beman::execution::start(this->op);
+            } else {
+                this->destroy();
+            }
+        }
+        auto complete() noexcept -> void override {
+            Tok tok(this->token);
+            this->destroy();
+            tok.disassociate();
+        }
+        auto destroy() noexcept -> void {
+            alloc_t all(this->alloc);
+            traits_t::destroy(all, this);
+            traits_t::deallocate(all, this, 1);
+        }
+
+        alloc_t alloc;
+        op_t    op;
+        Tok     token;
+    };
+
+    template <::beman::execution::sender Sender, ::beman::execution::scope_token Token, typename Env>
+    auto operator()(Sender&& sender, Token&& tok, Env&& env) const {
+        auto new_sender{tok.wrap(::std::forward<Sender>(sender))};
+        auto [all, senv] = ::beman::execution::detail::spawn_get_allocator(new_sender, env);
+
+        using sender_t = decltype(::beman::execution::write_env(::std::move(new_sender), senv));
+        using state_t  = state<decltype(all), Token, sender_t>;
+        using alloc_t  = typename ::std::allocator_traits<decltype(all)>::template rebind_alloc<state_t>;
+        using traits_t = ::std::allocator_traits<alloc_t>;
+        alloc_t  alloc(all);
+        state_t* op{traits_t::allocate(alloc, 1u)};
+        traits_t::construct(alloc, op, all, ::beman::execution::write_env(::std::move(new_sender), senv), tok);
+    }
+    template <::beman::execution::sender Sender, ::beman::execution::scope_token Token>
+    auto operator()(Sender&& sender, Token&& token) const {
+        return (*this)(::std::forward<Sender>(sender), ::std::forward<Token>(token), ::beman::execution::empty_env{});
+    }
+};
+} // namespace beman::execution::detail
+
+namespace beman::execution {
+using spawn_t = ::beman::execution::detail::spawn_t;
+inline constexpr spawn_t spawn{};
+} // namespace beman::execution
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/spawn_future.hpp b/include/beman/execution/detail/spawn_future.hpp
new file mode 100644
index 00000000..e282aa57
--- /dev/null
+++ b/include/beman/execution/detail/spawn_future.hpp
@@ -0,0 +1,271 @@
+// include/beman/execution/detail/spawn_future.hpp                    -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_SPAWN_FUTURE
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_SPAWN_FUTURE
+
+#include <beman/execution/detail/spawn_get_allocator.hpp>
+#include <beman/execution/detail/as_tuple.hpp>
+#include <beman/execution/detail/scope_token.hpp>
+#include <beman/execution/detail/completion_signatures_of_t.hpp>
+#include <beman/execution/detail/connect_result_t.hpp>
+#include <beman/execution/detail/default_impls.hpp>
+#include <beman/execution/detail/empty_env.hpp>
+#include <beman/execution/detail/get_allocator.hpp>
+#include <beman/execution/detail/get_env.hpp>
+#include <beman/execution/detail/impls_for.hpp>
+#include <beman/execution/detail/inplace_stop_source.hpp>
+#include <beman/execution/detail/join_env.hpp>
+#include <beman/execution/detail/make_sender.hpp>
+#include <beman/execution/detail/meta_unique.hpp>
+#include <beman/execution/detail/meta_combine.hpp>
+#include <beman/execution/detail/prop.hpp>
+#include <beman/execution/detail/queryable.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/set_error.hpp>
+#include <beman/execution/detail/set_stopped.hpp>
+#include <beman/execution/detail/set_value.hpp>
+#include <beman/execution/detail/stop_when.hpp>
+#include <beman/execution/detail/start.hpp>
+#include <beman/execution/detail/write_env.hpp>
+
+#include <exception>
+#include <memory>
+#include <mutex>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+template <typename>
+struct non_throwing_args_copy;
+template <typename Rc, typename... A>
+struct non_throwing_args_copy<Rc(A...)> {
+    static constexpr bool value = (true && ... && ::std::is_nothrow_constructible_v<::std::decay_t<A>, A>);
+};
+template <typename S>
+inline constexpr bool non_throwing_args_copy_v{non_throwing_args_copy<S>::value};
+
+template <typename Completions>
+struct spawn_future_state_base;
+template <typename... Sigs>
+struct spawn_future_state_base<::beman::execution::completion_signatures<Sigs...>> {
+    static constexpr bool has_non_throwing_args_copy = (true && ... && non_throwing_args_copy_v<Sigs>);
+    using result_t                                   = ::beman::execution::detail::meta::unique<
+                                          ::std::conditional_t<has_non_throwing_args_copy,
+                                                               ::std::variant<::std::monostate, ::beman::execution::detail::as_tuple_t<Sigs>...>,
+                                                               ::std::variant<::std::monostate,
+                                                                              ::std::tuple<::beman::execution::set_error_t, ::std::exception_ptr>,
+                                                                              ::beman::execution::detail::as_tuple_t<Sigs>...>>>;
+
+    result_t result{};
+    virtual ~spawn_future_state_base()       = default;
+    virtual auto complete() noexcept -> void = 0;
+};
+
+template <typename Completions>
+struct spawn_future_receiver {
+    using receiver_concept = ::beman::execution::receiver_t;
+    using state_t          = ::beman::execution::detail::spawn_future_state_base<Completions>;
+
+    state_t* state{};
+
+    template <typename... A>
+    auto set_value(A&&... a) && noexcept -> void {
+        this->set_complete<::beman::execution::set_value_t>(::std::forward<A>(a)...);
+    }
+    template <typename E>
+    auto set_error(E&& e) && noexcept -> void {
+        this->set_complete<::beman::execution::set_error_t>(::std::forward<E>(e));
+    }
+    auto set_stopped() && noexcept -> void { this->set_complete<::beman::execution::set_stopped_t>(); }
+
+    template <typename Tag, typename... T>
+    auto set_complete(T&&... t) noexcept {
+        try {
+            this->state->result.template emplace<::beman::execution::detail::decayed_tuple<Tag, T...>>(
+                Tag(), ::std::forward<T>(t)...);
+        } catch (...) {
+            if constexpr (!state_t::has_non_throwing_args_copy) {
+                this->state->result
+                    .template emplace<::std::tuple<::beman::execution::set_error_t, ::std::exception_ptr>>(
+                        ::beman::execution::set_error_t{}, ::std::current_exception());
+            }
+        }
+        this->state->complete();
+    }
+};
+
+template <::beman::execution::sender Sndr, typename Env>
+using future_spawned_sender = decltype(::beman::execution::write_env(
+    ::beman::execution::detail::stop_when(::std::declval<Sndr>(),
+                                          ::std::declval<::beman::execution::inplace_stop_token>()),
+    ::std::declval<Env>()));
+
+template <::beman::execution::sender Sndr, typename Env>
+using spawn_future_sigs = ::beman::execution::detail::meta::unique<::beman::execution::detail::meta::prepend<
+    ::beman::execution::set_stopped_t(),
+    ::beman::execution::completion_signatures_of_t<::beman::execution::detail::future_spawned_sender<Sndr, Env>>>>;
+
+template <typename Allocator, ::beman::execution::scope_token Token, ::beman::execution::sender Sndr, typename Env>
+struct spawn_future_state
+    : ::beman::execution::detail::spawn_future_state_base<::beman::execution::detail::spawn_future_sigs<Sndr, Env>> {
+    using alloc_t          = typename ::std::allocator_traits<Allocator>::template rebind_alloc<spawn_future_state>;
+    using traits_t         = ::std::allocator_traits<alloc_t>;
+    using spawned_sender_t = ::beman::execution::detail::future_spawned_sender<Sndr, Env>;
+    using sigs_t           = ::beman::execution::detail::spawn_future_sigs<Sndr, Env>;
+    using receiver_t       = ::beman::execution::detail::spawn_future_receiver<sigs_t>;
+    static_assert(::beman::execution::sender<spawned_sender_t>);
+    static_assert(::beman::execution::receiver<receiver_t>);
+    using op_t = ::beman::execution::connect_result_t<spawned_sender_t, receiver_t>;
+
+    template <::beman::execution::sender S>
+    spawn_future_state(auto a, S&& s, Token tok, Env env)
+        : alloc(::std::move(a)),
+          op(::beman::execution::write_env(
+                 ::beman::execution::detail::stop_when(::std::forward<S>(s), source.get_token()), env),
+             receiver_t(this)),
+          token(::std::move(tok)),
+          associated(token.try_associate()) {
+        if (this->associated) {
+            ::beman::execution::start(this->op);
+        } else {
+            ::beman::execution::set_stopped(receiver_t(this));
+        }
+    }
+    auto complete() noexcept -> void override {
+        {
+            ::std::lock_guard cerberos(this->gate);
+            if (this->fun == nullptr) {
+                this->receiver = this;
+                return;
+            }
+        }
+        this->fun(this->receiver, *this);
+    }
+    auto abandon() noexcept -> void {
+        bool ready{[&] {
+            ::std::lock_guard cerberos(this->gate);
+            if (this->receiver == nullptr) {
+                this->receiver = this;
+                this->fun      = [](void*, spawn_future_state& state) noexcept { state.destroy(); };
+                return false;
+            }
+            return true;
+        }()};
+        if (ready) {
+            this->destroy();
+        } else {
+            this->source.request_stop();
+        }
+    }
+    template <::beman::execution::receiver Rcvr>
+    static auto complete_receiver(Rcvr& rcvr, typename spawn_future_state::result_t& res) noexcept {
+        std::visit(
+            [&rcvr]<typename Tuplish>(Tuplish&& tuplish) noexcept {
+                if constexpr (!::std::same_as<::std::remove_cvref_t<decltype(tuplish)>, ::std::monostate>) {
+                    ::std::apply(
+                        [&rcvr]<typename... Args>(auto cpo, Args&&... args) {
+                            cpo(::std::move(rcvr), ::std::forward<Args>(args)...);
+                        },
+                        ::std::forward<Tuplish>(tuplish));
+                }
+            },
+            ::std::move(res));
+    }
+    template <::beman::execution::receiver Rcvr>
+    auto consume(Rcvr& rcvr) noexcept -> void {
+        {
+            ::std::lock_guard cerberos(this->gate);
+            if (this->receiver == nullptr) {
+                this->receiver = &rcvr;
+                this->fun      = [](void* ptr, spawn_future_state& state) noexcept {
+                    spawn_future_state::complete_receiver(*static_cast<Rcvr*>(ptr), state.result);
+                };
+                return;
+            }
+        }
+        spawn_future_state::complete_receiver(rcvr, this->result);
+    }
+    auto destroy() noexcept -> void {
+        Token tok{this->token};
+        bool  assoc{this->associated};
+        {
+            alloc_t a{this->alloc};
+            traits_t::destroy(a, this);
+            traits_t::deallocate(a, this, 1u);
+        }
+        if (assoc) {
+            tok.disassociate();
+        }
+    }
+
+    ::std::mutex                            gate{};
+    alloc_t                                 alloc;
+    ::beman::execution::inplace_stop_source source{};
+    op_t                                    op;
+    Token                                   token;
+    bool                                    associated{false};
+    void*                                   receiver{};
+    auto (*fun)(void*, spawn_future_state&) noexcept -> void = nullptr;
+};
+
+class spawn_future_t {
+  public:
+    template <::beman::execution::sender Sndr, ::beman::execution::scope_token Tok, typename Ev>
+        requires ::beman::execution::detail::queryable<::std::remove_cvref_t<Ev>>
+    auto operator()(Sndr&& sndr, Tok&& tok, Ev&& ev) const {
+        auto make{[&]() -> decltype(auto) { //-dk:TODO why decltype(auto) instead of auto?
+            return tok.wrap(::std::forward<Sndr>(sndr));
+        }};
+        using sndr_t = decltype(make());
+        static_assert(::beman::execution::sender<Sndr>);
+
+        auto [alloc, senv] = spawn_get_allocator(sndr, ev);
+        using state_t = ::beman::execution::detail::spawn_future_state<decltype(alloc), Tok, sndr_t, decltype(senv)>;
+        using state_alloc_t  = typename ::std::allocator_traits<decltype(alloc)>::template rebind_alloc<state_t>;
+        using state_traits_t = ::std::allocator_traits<state_alloc_t>;
+        state_alloc_t state_alloc(alloc);
+        state_t*      op{state_traits_t::allocate(state_alloc, 1u)};
+        try {
+            state_traits_t::construct(state_alloc, op, alloc, make(), tok, senv);
+        } catch (...) {
+            state_traits_t::deallocate(state_alloc, op, 1u);
+            throw;
+        }
+
+        using deleter = decltype([](state_t* p) noexcept { p->abandon(); });
+        return ::beman::execution::detail::make_sender(*this, ::std::unique_ptr<state_t, deleter>{op});
+    }
+    template <::beman::execution::sender Sndr, ::beman::execution::scope_token Tok>
+    auto operator()(Sndr&& sndr, Tok&& tok) const {
+        return (*this)(::std::forward<Sndr>(sndr), ::std::forward<Tok>(tok), ::beman::execution::empty_env{});
+    }
+};
+
+template <typename State, typename Deleter, typename Env>
+struct completion_signatures_for_impl<
+    ::beman::execution::detail::basic_sender<::beman::execution::detail::spawn_future_t,
+                                             ::std::unique_ptr<State, Deleter>>,
+    Env> {
+    using type = typename State::sigs_t;
+};
+
+template <>
+struct impls_for<spawn_future_t> : ::beman::execution::detail::default_impls {
+    static constexpr auto start{[](auto& state, auto& rcvr) noexcept -> void { state->consume(rcvr); }};
+};
+} // namespace beman::execution::detail
+
+namespace beman::execution {
+using spawn_future_t = ::beman::execution::detail::spawn_future_t;
+inline constexpr spawn_future_t spawn_future{};
+} // namespace beman::execution
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/spawn_get_allocator.hpp b/include/beman/execution/detail/spawn_get_allocator.hpp
new file mode 100644
index 00000000..1056a513
--- /dev/null
+++ b/include/beman/execution/detail/spawn_get_allocator.hpp
@@ -0,0 +1,36 @@
+// include/beman/execution/detail/spawn_get_allocator.hpp             -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_SPAWN_GET_ALLOCATOR
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_SPAWN_GET_ALLOCATOR
+
+#include <beman/execution/detail/get_allocator.hpp>
+#include <beman/execution/detail/get_env.hpp>
+#include <beman/execution/detail/join_env.hpp>
+#include <beman/execution/detail/prop.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <memory>
+#include <utility>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+template <::beman::execution::sender Sndr, typename Ev>
+auto spawn_get_allocator(const Sndr& sndr, const Ev& ev) {
+    if constexpr (requires { ::beman::execution::get_allocator(ev); }) {
+        return ::std::pair(::beman::execution::get_allocator(ev), ev);
+    } else if constexpr (requires { ::beman::execution::get_allocator(::beman::execution::get_env(sndr)); }) {
+        auto alloc{::beman::execution::get_allocator(::beman::execution::get_env(sndr))};
+        return ::std::pair(alloc,
+                           ::beman::execution::detail::join_env(
+                               ::beman::execution::prop(::beman::execution::get_allocator, alloc), ev));
+    } else {
+        return ::std::pair(::std::allocator<void>{}, ev);
+    }
+}
+
+} // namespace beman::execution::detail
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/stop_when.hpp b/include/beman/execution/detail/stop_when.hpp
new file mode 100644
index 00000000..0ec7937d
--- /dev/null
+++ b/include/beman/execution/detail/stop_when.hpp
@@ -0,0 +1,133 @@
+// include/beman/execution/detail/stop_when.hpp                       -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_STOP_WHEN
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_STOP_WHEN
+
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/stoppable_token.hpp>
+#include <beman/execution/detail/unstoppable_token.hpp>
+#include <beman/execution/detail/inplace_stop_source.hpp>
+#include <beman/execution/detail/operation_state.hpp>
+#include <beman/execution/detail/get_stop_token.hpp>
+#include <beman/execution/detail/get_env.hpp>
+#include <beman/execution/detail/start.hpp>
+#include <beman/execution/detail/set_value.hpp>
+#include <beman/execution/detail/set_error.hpp>
+#include <beman/execution/detail/set_stopped.hpp>
+#include <beman/execution/detail/get_completion_signatures.hpp>
+#include <beman/execution/detail/connect.hpp>
+#include <beman/execution/detail/stop_callback_for_t.hpp>
+#include <type_traits>
+#include <optional>
+#include <utility>
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+inline constexpr struct stop_when_t {
+
+    template <::beman::execution::sender Sndr, ::beman::execution::stoppable_token Tok>
+    struct sender {
+        using sender_concept = ::beman::execution::sender_t;
+
+        std::remove_cvref_t<Sndr> sndr;
+        std::remove_cvref_t<Tok>  tok;
+
+        template <::beman::execution::receiver Rcvr>
+        struct state {
+            using operation_state_concept = ::beman::execution::operation_state_t;
+            using rcvr_t                  = ::std::remove_cvref_t<Rcvr>;
+            using token1_t                = ::std::remove_cvref_t<Tok>;
+            using token2_t =
+                decltype(::beman::execution::get_stop_token(::beman::execution::get_env(::std::declval<rcvr_t>())));
+
+            struct cb_t {
+                ::beman::execution::inplace_stop_source& source;
+                auto                                     operator()() const noexcept { this->source.request_stop(); }
+            };
+            struct base_state {
+                rcvr_t                                  rcvr;
+                ::beman::execution::inplace_stop_source source{};
+            };
+            struct env {
+                base_state* st;
+                auto        query(const ::beman::execution::get_stop_token_t&) const noexcept {
+                    return this->st->source.get_token();
+                }
+                template <typename Q, typename... A>
+                    requires requires(const Q& q, A&&... a, const rcvr_t& r) {
+                        q(::beman::execution::get_env(r), ::std::forward<A>(a)...);
+                    }
+                auto query(const Q& q, A&&... a) const noexcept {
+                    return q(::beman::execution::get_env(this->st->rcvr), ::std::forward<A>(a)...);
+                }
+            };
+
+            struct receiver {
+                using receiver_concept = ::beman::execution::receiver_t;
+                base_state* st;
+
+                auto get_env() const noexcept -> env { return env{this->st}; }
+                template <typename... A>
+                auto set_value(A&&... a) const noexcept -> void {
+                    ::beman::execution::set_value(::std::move(this->st->rcvr), ::std::forward<A>(a)...);
+                }
+                template <typename E>
+                auto set_error(E&& e) const noexcept -> void {
+                    ::beman::execution::set_error(::std::move(this->st->rcvr), ::std::forward<E>(e));
+                }
+                auto set_stopped() const noexcept -> void {
+                    ::beman::execution::set_stopped(::std::move(this->st->rcvr));
+                }
+            };
+            using inner_state_t =
+                decltype(::beman::execution::connect(::std::declval<Sndr>(), ::std::declval<receiver>()));
+
+            token1_t                                                               tok;
+            base_state                                                             base;
+            std::optional<::beman::execution::stop_callback_for_t<token1_t, cb_t>> cb1;
+            std::optional<::beman::execution::stop_callback_for_t<token2_t, cb_t>> cb2;
+            inner_state_t                                                          inner_state;
+
+            template <::beman::execution::sender          S,
+                      ::beman::execution::stoppable_token T,
+                      ::beman::execution::receiver        R>
+            state(S&& s, T&& t, R&& r)
+                : tok(::std::forward<T>(t)),
+                  base{::std::forward<R>(r)},
+                  inner_state(::beman::execution::connect(::std::forward<S>(s), receiver(&this->base))) {}
+
+            auto start() & noexcept {
+                this->cb1.emplace(this->tok, cb_t(this->base.source));
+                this->cb2.emplace(::beman::execution::get_stop_token(::beman::execution::get_env(this->base.rcvr)),
+                                  cb_t(this->base.source));
+                ::beman::execution::start(this->inner_state);
+            }
+        };
+
+        template <typename E>
+        auto get_completion_signatures(const E& e) const noexcept {
+            return ::beman::execution::get_completion_signatures(this->sndr, e);
+        }
+        template <::beman::execution::receiver Rcvr>
+        auto connect(Rcvr&& rcvr) && -> state<Rcvr> {
+            return state<Rcvr>{std::move(this->sndr), ::std::move(this->tok), ::std::forward<Rcvr>(rcvr)};
+        }
+    };
+
+    template <::beman::execution::sender Sndr, ::beman::execution::stoppable_token Tok>
+    auto operator()(Sndr&& sndr, Tok&& tok) const noexcept {
+        if constexpr (::beman::execution::unstoppable_token<Tok>) {
+            return ::std::forward<Sndr>(sndr);
+        } else {
+            return sender<Sndr, Tok>(::std::forward<Sndr>(sndr), ::std::forward<Tok>(tok));
+        }
+    }
+} stop_when{};
+} // namespace beman::execution::detail
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/include/beman/execution/detail/write_env.hpp b/include/beman/execution/detail/write_env.hpp
index fe670eef..6da548a4 100644
--- a/include/beman/execution/detail/write_env.hpp
+++ b/include/beman/execution/detail/write_env.hpp
@@ -45,6 +45,11 @@ struct impls_for<write_env_t> : ::beman::execution::detail::default_impls {
 inline constexpr write_env_t write_env{};
 } // namespace beman::execution::detail
 
+namespace beman::execution {
+using write_env_t = ::beman::execution::detail::write_env_t;
+inline constexpr write_env_t write_env{};
+} // namespace beman::execution
+
 // ----------------------------------------------------------------------------
 
 #endif
diff --git a/include/beman/execution/execution.hpp b/include/beman/execution/execution.hpp
index 5a203e14..b87c5ae0 100644
--- a/include/beman/execution/execution.hpp
+++ b/include/beman/execution/execution.hpp
@@ -43,6 +43,7 @@
 #include <beman/execution/detail/just.hpp>
 #include <beman/execution/detail/let.hpp>
 #include <beman/execution/detail/on.hpp>
+#include <beman/execution/detail/prop.hpp>
 #include <beman/execution/detail/read_env.hpp>
 #include <beman/execution/detail/schedule_from.hpp>
 #include <beman/execution/detail/starts_on.hpp>
diff --git a/src/beman/execution/CMakeLists.txt b/src/beman/execution/CMakeLists.txt
index ea6aecae..1b89b44f 100644
--- a/src/beman/execution/CMakeLists.txt
+++ b/src/beman/execution/CMakeLists.txt
@@ -6,10 +6,12 @@
 add_library(${TARGET_NAME} STATIC)
 add_library(${TARGET_ALIAS} ALIAS ${TARGET_NAME})
 
+if(FALSE)
 if(NOT BEMAN_EXECUTION_ENABLE_INSTALL OR CMAKE_SKIP_INSTALL_RULES)
   target_link_libraries(${TARGET_NAME} PUBLIC $<BUILD_INTERFACE:${TARGET_NAME}_project_options>)
   target_link_libraries(${TARGET_NAME} PUBLIC $<BUILD_INTERFACE:${TARGET_NAME}_project_warnings>)
 endif()
+endif()
 
 include(CMakePrintHelpers)
 cmake_print_variables(TARGET_ALIAS TARGET_NAME TARGET_PREFIX PROJECT_SOURCE_DIR)
@@ -27,6 +29,8 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/execution.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/functional.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/stop_token.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution26/execution.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution26/stop_token.hpp
   PUBLIC FILE_SET
          ${TARGET_NAME}_detail_headers
          TYPE
@@ -39,6 +43,8 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/apply_sender.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/as_awaitable.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/as_except_ptr.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/as_tuple.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/associate.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/atomic_intrusive_stack.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/await_result_type.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/await_suspend_result.hpp
@@ -47,6 +53,7 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/basic_receiver.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/basic_sender.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/basic_state.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/bulk.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/call_result_t.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/callable.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/check_type_alias_exist.hpp
@@ -65,6 +72,9 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/connect_awaitable.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/connect_result_t.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/continues_on.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/counting_scope.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/counting_scope_base.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/counting_scope_join.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/decayed_same_as.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/decayed_tuple.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/decayed_type_list.hpp
@@ -111,6 +121,7 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/make_sender.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/matching_sig.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/meta_combine.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/meta_contain_same.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/meta_contains.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/meta_filter.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/meta_prepend.hpp
@@ -128,6 +139,7 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/operation_state.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/operation_state_task.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/product_type.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/prop.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/query_with_default.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/queryable.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/read_env.hpp
@@ -141,6 +153,7 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/schedule_result_t.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/scheduler.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/scheduler_t.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/scope_token.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/sender.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/sender_adaptor.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/sender_adaptor_closure.hpp
@@ -156,6 +169,9 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/simple_counting_scope.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/single_sender.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/single_sender_value_type.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/spawn.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/spawn_future.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/spawn_get_allocator.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/split.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/start.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/starts_on.hpp
@@ -163,6 +179,7 @@ target_sources(
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/stop_callback_for_t.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/stop_source.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/stop_token_of_t.hpp
+         ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/stop_when.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/stoppable_source.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/stoppable_token.hpp
          ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/suppress_pop.hpp
diff --git a/tests/beman/execution/CMakeLists.txt b/tests/beman/execution/CMakeLists.txt
index d66fbf45..8675d73b 100644
--- a/tests/beman/execution/CMakeLists.txt
+++ b/tests/beman/execution/CMakeLists.txt
@@ -8,13 +8,24 @@ if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
   message(FATAL_ERROR "In-source builds are not allowed!")
 endif()
 
+list(
+  APPEND
+  todo
+  exec-associate.test
+)
 list(
   APPEND
   execution_tests
+  exec-scope-counting.test
+  exec-spawn.test
+  exec-stop-when.test
+  exec-prop.test
+  exec-scope-simple-counting.test
+  exec-spawn-future.test
+  exec-scope-concepts.test
   issue-144.test
   exec-on.test
   notify.test
-  exec-scounting.test
   exec-awaitable.test
   allocator-requirements-general.test
   exec-connect.test
@@ -132,9 +143,10 @@ foreach(test ${execution_tests})
   add_test(NAME ${TEST_EXE} COMMAND $<TARGET_FILE:${TEST_EXE}>)
 endforeach()
 
-if(NOT PROJECT_IS_TOP_LEVEL AND BEMAN_EXECUTION_ENABLE_TESTING)
-  # test if the targets are findable from the build directory
-  # cmake-format: off
+if(FALSE)
+  if(NOT PROJECT_IS_TOP_LEVEL AND BEMAN_EXECUTION_ENABLE_TESTING)
+    # test if the targets are findable from the build directory
+    # cmake-format: off
   add_test(NAME find-package-test
     COMMAND ${CMAKE_CTEST_COMMAND}
       # --verbose
@@ -153,4 +165,5 @@ if(NOT PROJECT_IS_TOP_LEVEL AND BEMAN_EXECUTION_ENABLE_TESTING)
           # TODO(CK): Needed too? "--config $<CONFIG>"
   )
   # cmake-format: on
+  endif()
 endif()
diff --git a/tests/beman/execution/exec-associate.test.cpp b/tests/beman/execution/exec-associate.test.cpp
new file mode 100644
index 00000000..9ec7de2a
--- /dev/null
+++ b/tests/beman/execution/exec-associate.test.cpp
@@ -0,0 +1,151 @@
+// tests/beman/execution/exec-associate.test.cpp                      -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/associate.hpp>
+#include <beman/execution/detail/connect.hpp>
+#include <beman/execution/detail/get_completion_signatures.hpp>
+#include <beman/execution/detail/scope_token.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/sync_wait.hpp>
+#include <test/execution.hpp>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+// ----------------------------------------------------------------------------
+
+namespace {
+struct sender {
+    struct state {
+        using operation_state_concept = test_std::operation_state_t;
+        auto start() & noexcept {}
+    };
+    using sender_concept = test_std::sender_t;
+    auto connect(auto&&) { return state(); }
+};
+static_assert(test_std::sender<sender>);
+
+template <test_std::sender Sender>
+struct wrap_sender {
+    using sender_concept = test_std::sender_t;
+    std::remove_cvref_t<Sender> sender;
+    wrap_sender(Sender&& s) : sender(std::forward<Sender>(s)) {}
+
+    template <typename Env>
+    auto get_completion_signatures(const Env& env) const noexcept {
+        return test_std::get_completion_signatures(this->sender, env);
+    }
+    template <test_std::receiver Receiver>
+    auto connect(Receiver&& receiver) && {
+        return test_std::connect(std::move(this->sender), std::forward<Receiver>(receiver));
+    }
+    template <test_std::receiver Receiver>
+    auto connect(Receiver&& receiver) const& {
+        return test_std::connect(this->sender, std::forward<Receiver>(receiver));
+    }
+};
+template <test_std::sender Sender>
+wrap_sender(Sender&& sender) -> wrap_sender<Sender>;
+
+static_assert(test_std::sender<wrap_sender<sender>>);
+
+template <bool Noexcept>
+struct token {
+    bool         value{};
+    std::size_t* count{};
+    auto         try_associate() noexcept(Noexcept) -> bool {
+        if (this->value && this->count) {
+            ++*this->count;
+        }
+        return this->value;
+    }
+    auto disassociate() noexcept -> void {
+        if (this->count) {
+            --*this->count;
+        }
+    }
+    template <test_std::sender Sender>
+    auto wrap(Sender&& sender) noexcept {
+        return wrap_sender(std::forward<Sender>(sender));
+    }
+};
+static_assert(test_std::scope_token<token<true>>);
+static_assert(test_std::scope_token<token<false>>);
+
+struct dtor_sender {
+    std::size_t* count{};
+    using sender_concept = test_std::sender_t;
+
+    explicit dtor_sender(std::size_t* c) : count(c) {}
+    dtor_sender(dtor_sender&& other) : count(std::exchange(other.count, nullptr)) {}
+    ~dtor_sender() { ASSERT(count == nullptr || *count == 1u); }
+};
+static_assert(test_std::sender<dtor_sender>);
+
+auto test_associate_data() {
+    using data_t = test_detail::associate_data<token<true>, sender>;
+    static_assert(std::same_as<wrap_sender<sender>, data_t::wrap_sender>);
+
+    {
+        test_detail::associate_data data(token<true>{true}, sender{});
+        static_assert(std::same_as<data_t, decltype(data)>);
+        ASSERT(data.sender);
+        test_detail::associate_data move(std::move(data));
+        ASSERT(!data.sender.has_value());
+        ASSERT(move.sender);
+    }
+    {
+        test_detail::associate_data data(token<true>{false}, sender{});
+        static_assert(std::same_as<data_t, decltype(data)>);
+        ASSERT(!data.sender);
+    }
+    {
+        std::size_t count{};
+        ASSERT(count == 0u);
+        {
+            test_detail::associate_data data(token<true>{true, &count}, dtor_sender{&count});
+            ASSERT(count == 1u);
+        }
+        ASSERT(count == 0u);
+    }
+    {
+        std::size_t count{};
+        ASSERT(count == 0u);
+        {
+            test_detail::associate_data data(token<true>{true, &count}, sender{});
+            ASSERT(count == 1u);
+            ASSERT(data.sender);
+            auto p{data.release()};
+            ASSERT(count == 1u);
+            ASSERT(!data.sender);
+        }
+        ASSERT(count == 1u);
+    }
+}
+
+struct receiver {
+    using receiver_concept = test_std::receiver_t;
+
+    auto set_value(auto&&...) && noexcept {}
+    auto set_error(auto&&) && noexcept {}
+    auto set_stopped() && noexcept {}
+};
+static_assert(test_std::receiver<receiver>);
+
+template <test_std::sender Sender, test_std::scope_token Token>
+auto test_associate(Sender&& sender, Token&& token) -> void {
+    [[maybe_unused]] auto sndr = test_std::associate(std::forward<Sender>(sender), std::forward<Token>(token));
+    static_assert(test_std::sender<decltype(sndr)>);
+    test_std::sync_wait(std::move(sndr));
+}
+
+} // namespace
+
+TEST(exec_associate) {
+    static_assert(std::same_as<const test_std::associate_t, decltype(test_std::associate)>);
+
+    test_associate_data();
+
+    test_associate(sender{}, token<true>{});
+}
diff --git a/tests/beman/execution/exec-prop.test.cpp b/tests/beman/execution/exec-prop.test.cpp
new file mode 100644
index 00000000..7adbbff3
--- /dev/null
+++ b/tests/beman/execution/exec-prop.test.cpp
@@ -0,0 +1,40 @@
+// tests/beman/execution/exec-prop.test.cpp                           -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/prop.hpp>
+#include <beman/execution/detail/forwarding_query.hpp>
+#include <type_traits>
+#include <concepts>
+#include <test/execution.hpp>
+
+// ----------------------------------------------------------------------------
+
+namespace {
+constexpr struct test_query_t {
+    template <typename Env>
+        requires requires(const test_query_t& self, const Env& e) { e.query(self); }
+    decltype(auto) operator()(const Env& e) const noexcept(noexcept(e.query(*this))) {
+        return e.query(*this);
+    }
+    constexpr auto query(const test_std::forwarding_query_t&) const noexcept -> bool { return true; }
+} test_query{};
+
+struct env {
+    auto query(const test_query_t&) const noexcept { return 42; }
+};
+
+template <typename Env, typename Value>
+auto test_prop(Env&& env, Value&& value) {
+    static_assert(requires {
+        { test_query(env) } noexcept;
+    });
+    ASSERT(test_query(env) == value);
+}
+} // namespace
+
+TEST(exec_prop) {
+    test_prop(env{}, 42);
+    test_prop(test_std::prop(test_query, 42), 42);
+    [[maybe_unused]] auto p{test_std::prop(test_query, 2.5)};
+    static_assert(not std::is_assignable_v<decltype(p), decltype(p)>);
+}
diff --git a/tests/beman/execution/exec-scope-concepts.test.cpp b/tests/beman/execution/exec-scope-concepts.test.cpp
new file mode 100644
index 00000000..1c500b50
--- /dev/null
+++ b/tests/beman/execution/exec-scope-concepts.test.cpp
@@ -0,0 +1,66 @@
+// tests/beman/execution/exec-scope-concepts.test.cpp                 -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/scope_token.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/sender_in.hpp>
+#include <beman/execution/detail/completion_signatures.hpp>
+#include <beman/execution/detail/set_value.hpp>
+#include <test/execution.hpp>
+#include <concepts>
+#include <utility>
+
+// ----------------------------------------------------------------------------
+
+namespace {
+struct sender {
+    using sender_concept = test_std::sender_t;
+};
+static_assert(test_std::sender<sender>);
+
+struct copyable {};
+static_assert(std::copyable<copyable>);
+struct non_copyable {
+    non_copyable()                    = default;
+    non_copyable(const non_copyable&) = delete;
+};
+static_assert(not std::copyable<non_copyable>);
+
+struct empty {};
+
+template <test_std::sender S>
+struct wrap {
+    using sender_concept = test_std::sender_t;
+    std::remove_cvref_t<S> sndr;
+    template <typename E>
+    auto get_completion_signatures(const E& e) const noexcept {
+        return test_std::get_completion_signatures(sndr, e);
+    }
+};
+static_assert(test_std::sender<wrap<sender>>);
+
+template <test_std::sender>
+struct bad {
+    using sender_concept = test_std::sender_t;
+};
+
+template <typename Mem, typename Bool, bool Noexcept, template <test_std::sender> class Wrap>
+struct token {
+    Mem  mem{};
+    auto try_associate() -> Bool { return {}; }
+    auto disassociate() noexcept(Noexcept) -> void {}
+    template <test_std::sender Sender>
+    auto wrap(Sender&& sndr) -> Wrap<Sender> {
+        return Wrap<Sender>(std::forward<Sender>(sndr));
+    }
+};
+} // namespace
+
+TEST(exec_scope_concepts) {
+    static_assert(test_std::scope_token<token<copyable, bool, true, wrap>>);
+    static_assert(not test_std::scope_token<token<non_copyable, bool, true, wrap>>);
+    static_assert(not test_std::scope_token<token<copyable, int, true, wrap>>);
+    static_assert(not test_std::scope_token<token<copyable, bool, false, wrap>>);
+    static_assert(not test_std::scope_token<token<copyable, bool, true, bad>>);
+    static_assert(not test_std::scope_token<empty>);
+}
diff --git a/tests/beman/execution/exec-scope-counting.test.cpp b/tests/beman/execution/exec-scope-counting.test.cpp
new file mode 100644
index 00000000..6e685134
--- /dev/null
+++ b/tests/beman/execution/exec-scope-counting.test.cpp
@@ -0,0 +1,146 @@
+// tests/beman/execution/exec-scope-counting.test.cpp                 -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/counting_scope.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/just.hpp>
+#include <beman/execution/detail/sync_wait.hpp>
+#include <test/execution.hpp>
+#include <test/inline_scheduler.hpp>
+#include <concepts>
+#include <type_traits>
+
+// ----------------------------------------------------------------------------
+
+namespace {
+
+auto general() -> void {
+    using scope = test_std::counting_scope;
+    using token = scope::token;
+
+    // static_assert(requires(token const& tok){ { tok.wrap(test_std::just(10)) } noexcept; });
+    static_assert(requires(const token& tok) {
+        { tok.try_associate() } noexcept -> std::same_as<bool>;
+    });
+    static_assert(requires(const token& tok) { tok.try_associate(); });
+    static_assert(requires(const token& tok) {
+        { tok.disassociate() } noexcept;
+    });
+
+    static_assert(noexcept(scope{}));
+    static_assert(!std::is_move_constructible_v<scope>);
+    static_assert(!std::is_copy_constructible_v<scope>);
+    static_assert(requires(scope sc) {
+        { sc.get_token() } noexcept -> std::same_as<token>;
+    });
+    static_assert(requires(scope sc) {
+        { sc.close() } noexcept -> std::same_as<void>;
+    });
+    static_assert(requires(scope sc) {
+        { sc.join() } noexcept;
+    });
+}
+
+struct join_receiver {
+    using receiver_concept = test_std::receiver_t;
+
+    struct env {
+        auto query(const test_std::get_scheduler_t&) const noexcept -> test::inline_scheduler { return {}; }
+    };
+
+    bool& called;
+    auto  set_value() && noexcept { this->called = true; }
+    auto  get_env() const noexcept -> env { return {}; }
+};
+
+auto ctor() -> void {
+    {
+        test_std::counting_scope scope;
+    }
+    test::death([] {
+        test_std::counting_scope scope;
+        scope.get_token().try_associate();
+    });
+    test::death([] {
+        test_std::counting_scope scope;
+        scope.get_token().try_associate();
+        bool called{false};
+        auto state(test_std::connect(scope.join(), join_receiver{called}));
+        test_std::start(state);
+    });
+    test::death([] {
+        test_std::counting_scope scope;
+        scope.get_token().try_associate();
+        scope.close();
+    });
+    test::death([] {
+        test_std::counting_scope scope;
+        scope.get_token().try_associate();
+        bool called{false};
+        auto state(test_std::connect(scope.join(), join_receiver{called}));
+        test_std::start(state);
+        scope.close();
+    });
+    {
+        test_std::counting_scope scope;
+        scope.close();
+    }
+    {
+        test_std::counting_scope scope;
+        scope.join();
+    }
+}
+
+auto mem() -> void {
+    {
+
+        test_std::counting_scope        scope;
+        test_std::counting_scope::token token{scope.get_token()};
+
+        ASSERT(true == token.try_associate());
+        token.disassociate();
+        scope.close();
+        ASSERT(false == token.try_associate());
+
+        test_std::sync_wait(scope.join());
+    }
+    {
+        test_std::counting_scope scope;
+        ASSERT(true == scope.get_token().try_associate());
+        bool called{false};
+        ASSERT(called == false);
+        auto state(test_std::connect(scope.join(), join_receiver(called)));
+        ASSERT(called == false);
+        test_std::start(state);
+        ASSERT(called == false);
+
+        scope.get_token().disassociate();
+        ASSERT(called == true);
+    }
+}
+auto token() -> void {
+    test_std::counting_scope scope;
+    const auto               tok{scope.get_token()};
+    auto                     sndr{tok.wrap(test_std::just(10))};
+
+    ASSERT(true == tok.try_associate());
+    bool called{false};
+    auto state(test_std::connect(scope.join(), join_receiver(called)));
+    test_std::start(state);
+    ASSERT(false == called);
+    scope.close();
+    ASSERT(false == called);
+    ASSERT(false == tok.try_associate());
+    ASSERT(false == called);
+    tok.disassociate();
+    ASSERT(true == called);
+}
+
+} // namespace
+
+TEST(exec_scope_counting) {
+    general();
+    ctor();
+    mem();
+    token();
+}
diff --git a/tests/beman/execution/exec-scope-simple-counting.test.cpp b/tests/beman/execution/exec-scope-simple-counting.test.cpp
new file mode 100644
index 00000000..bd505c8f
--- /dev/null
+++ b/tests/beman/execution/exec-scope-simple-counting.test.cpp
@@ -0,0 +1,147 @@
+// tests/beman/execution/exec-scope-simple-counting.test.cpp          -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/simple_counting_scope.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/just.hpp>
+#include <beman/execution/detail/sync_wait.hpp>
+#include <test/execution.hpp>
+#include <test/inline_scheduler.hpp>
+#include <concepts>
+#include <type_traits>
+
+// ----------------------------------------------------------------------------
+
+namespace {
+
+auto general() -> void {
+    using scope = test_std::simple_counting_scope;
+    using token = scope::token;
+
+    // static_assert(requires(token const& tok){ { tok.wrap(test_std::just(10)) } noexcept; });
+    static_assert(requires(const token& tok) {
+        { tok.try_associate() } noexcept -> std::same_as<bool>;
+    });
+    static_assert(requires(const token& tok) { tok.try_associate(); });
+    static_assert(requires(const token& tok) {
+        { tok.disassociate() } noexcept;
+    });
+
+    static_assert(noexcept(scope{}));
+    static_assert(!std::is_move_constructible_v<scope>);
+    static_assert(!std::is_copy_constructible_v<scope>);
+    static_assert(requires(scope sc) {
+        { sc.get_token() } noexcept -> std::same_as<token>;
+    });
+    static_assert(requires(scope sc) {
+        { sc.close() } noexcept -> std::same_as<void>;
+    });
+    static_assert(requires(scope sc) {
+        { sc.join() } noexcept;
+    });
+}
+
+struct join_receiver {
+    using receiver_concept = test_std::receiver_t;
+
+    struct env {
+        auto query(const test_std::get_scheduler_t&) const noexcept -> test::inline_scheduler { return {}; }
+    };
+
+    bool& called;
+    auto  set_value() && noexcept { this->called = true; }
+    auto  get_env() const noexcept -> env { return {}; }
+};
+
+auto ctor() -> void {
+    {
+        test_std::simple_counting_scope scope;
+    }
+    test::death([] {
+        test_std::simple_counting_scope scope;
+        scope.get_token().try_associate();
+    });
+    test::death([] {
+        test_std::simple_counting_scope scope;
+        scope.get_token().try_associate();
+        bool called{false};
+        auto state(test_std::connect(scope.join(), join_receiver{called}));
+        test_std::start(state);
+    });
+    test::death([] {
+        test_std::simple_counting_scope scope;
+        scope.get_token().try_associate();
+        scope.close();
+    });
+    test::death([] {
+        test_std::simple_counting_scope scope;
+        scope.get_token().try_associate();
+        bool called{false};
+        auto state(test_std::connect(scope.join(), join_receiver{called}));
+        test_std::start(state);
+        scope.close();
+    });
+    {
+        test_std::simple_counting_scope scope;
+        scope.close();
+    }
+    {
+        test_std::simple_counting_scope scope;
+        scope.join();
+    }
+}
+
+auto mem() -> void {
+    {
+
+        test_std::simple_counting_scope        scope;
+        test_std::simple_counting_scope::token token{scope.get_token()};
+
+        ASSERT(true == token.try_associate());
+        token.disassociate();
+        scope.close();
+        ASSERT(false == token.try_associate());
+
+        test_std::sync_wait(scope.join());
+    }
+    {
+        test_std::simple_counting_scope scope;
+        ASSERT(true == scope.get_token().try_associate());
+        bool called{false};
+        ASSERT(called == false);
+        auto state(test_std::connect(scope.join(), join_receiver(called)));
+        ASSERT(called == false);
+        test_std::start(state);
+        ASSERT(called == false);
+
+        scope.get_token().disassociate();
+        ASSERT(called == true);
+    }
+}
+auto token() -> void {
+    test_std::simple_counting_scope scope;
+    const auto                      tok{scope.get_token()};
+    auto                            sndr{tok.wrap(test_std::just(10))};
+    static_assert(std::same_as<decltype(sndr), decltype(test_std::just(10))>);
+
+    ASSERT(true == tok.try_associate());
+    bool called{false};
+    auto state(test_std::connect(scope.join(), join_receiver(called)));
+    test_std::start(state);
+    ASSERT(false == called);
+    scope.close();
+    ASSERT(false == called);
+    ASSERT(false == tok.try_associate());
+    ASSERT(false == called);
+    tok.disassociate();
+    ASSERT(true == called);
+}
+
+} // namespace
+
+TEST(exec_scope_simple_counting) {
+    general();
+    ctor();
+    mem();
+    token();
+}
diff --git a/tests/beman/execution/exec-scounting.test.cpp b/tests/beman/execution/exec-scounting.test.cpp
deleted file mode 100644
index c3bb3682..00000000
--- a/tests/beman/execution/exec-scounting.test.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-// src/beman/execution/tests/exec-scounting-ctor.test.cpp           -*-C++-*-
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include <beman/execution/detail/simple_counting_scope.hpp>
-#include <beman/execution/execution.hpp>
-#include <test/execution.hpp>
-#include <concepts>
-#include <optional>
-
-// ----------------------------------------------------------------------------
-
-namespace {
-struct receiver {
-    using receiver_concept = test_std::receiver_t;
-    bool& flag;
-    auto  set_value() && noexcept -> void { this->flag = true; }
-};
-
-auto test_scounting_ctor() -> void {
-    static_assert(std::default_initializable<test_std::simple_counting_scope>);
-    static_assert(noexcept(test_std::simple_counting_scope{}));
-    static_assert(std::destructible<test_std::simple_counting_scope>);
-    static_assert(not std::copy_constructible<test_std::simple_counting_scope>);
-    static_assert(not std::move_constructible<test_std::simple_counting_scope>);
-    static_assert(not std::assignable_from<test_std::simple_counting_scope&, test_std::simple_counting_scope>);
-    static_assert(not std::assignable_from<test_std::simple_counting_scope&, const test_std::simple_counting_scope>);
-
-    // a scope is created unused and can be destroyed:
-    {
-        test_std::simple_counting_scope scope{};
-        test::use(scope);
-    }
-    // a scope can be used and closed and can be destroyed:
-    {
-        test_std::simple_counting_scope scope{};
-        scope.close();
-    }
-    // a scope can be joined and destroyed:
-    {
-        test_std::simple_counting_scope scope{};
-        test_std::sync_wait(scope.join());
-    }
-    // a scope can be closed, joined, and destroyed:
-    {
-        test_std::simple_counting_scope scope{};
-        scope.close();
-        test_std::sync_wait(scope.join());
-    }
-    // a scope with an outstanding token can be destroyed:
-    {
-        std::optional<test_std::simple_counting_scope> scope_opt;
-        scope_opt.emplace();
-        auto token{scope_opt->get_token()};
-        scope_opt.reset();
-        test::use(token);
-    }
-}
-
-auto test_scounting_assoc_ctor() -> void {
-    static_assert(noexcept(test_std::simple_counting_scope::assoc{}));
-    ASSERT(test_std::simple_counting_scope::assoc{} ? false : true);
-}
-
-auto test_scounting_associate() -> void {
-    test_std::simple_counting_scope scope;
-    std::optional                   assoc(scope.get_token().try_associate());
-    ASSERT(*assoc ? true : false);
-    ASSERT(scope.get_token().try_associate() ? true : false);
-    std::optional assoc2(scope.get_token().try_associate());
-    scope.close();
-    ASSERT(scope.get_token().try_associate() ? false : true);
-
-    bool flag{};
-    auto op{test_std::connect(scope.join(), receiver{flag})};
-    ASSERT(flag == false);
-    test_std::start(op);
-
-    ASSERT(flag == false);
-    assoc.reset();
-
-    std::optional assoc3{test_std::simple_counting_scope::assoc()};
-    *assoc3 = ::std::move(*assoc2);
-
-    ASSERT(flag == false);
-    assoc2.reset();
-
-    ASSERT(flag == false);
-    assoc3.reset();
-    ASSERT(flag == true);
-}
-} // namespace
-
-// ----------------------------------------------------------------------------
-
-TEST(exec_scounting_ctor) {
-    test_scounting_ctor();
-    test_scounting_assoc_ctor();
-    test_scounting_associate();
-}
diff --git a/tests/beman/execution/exec-spawn-future.test.cpp b/tests/beman/execution/exec-spawn-future.test.cpp
new file mode 100644
index 00000000..de6a80a4
--- /dev/null
+++ b/tests/beman/execution/exec-spawn-future.test.cpp
@@ -0,0 +1,430 @@
+// tests/beman/execution/exec-spawn-future.test.cpp                   -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/spawn_future.hpp>
+#include <beman/execution/detail/spawn_get_allocator.hpp>
+#include <beman/execution/detail/queryable.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/scope_token.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/simple_allocator.hpp>
+#include <beman/execution/detail/get_allocator.hpp>
+#include <beman/execution/detail/get_stop_token.hpp>
+#include <beman/execution/detail/join_env.hpp>
+#include <beman/execution/detail/inplace_stop_source.hpp>
+#include <beman/execution/detail/just.hpp>
+#include <beman/execution/detail/then.hpp>
+#include <beman/execution/detail/get_completion_signatures.hpp>
+#include <beman/execution/detail/meta_contain_same.hpp>
+#include <test/execution.hpp>
+#include <concepts>
+
+// ----------------------------------------------------------------------------
+
+namespace {
+struct non_env {
+    ~non_env() = delete;
+};
+static_assert(not test_detail::queryable<non_env>);
+
+struct env {
+    int  value{};
+    auto operator==(const env&) const -> bool = default;
+};
+static_assert(test_detail::queryable<env>);
+
+struct non_sender {};
+static_assert(not test_std::sender<non_sender>);
+
+template <typename... T>
+struct sender {
+    using sender_concept        = test_std::sender_t;
+    using completion_signatures = test_std::completion_signatures<test_std::set_value_t(T...)>;
+
+    struct state_base {
+        virtual ~state_base()               = default;
+        virtual auto complete(T...) -> void = 0;
+    };
+    template <test_std::receiver Rcvr>
+    struct state : state_base {
+        using operation_state_concept = test_std::operation_state_t;
+        std::remove_cvref_t<Rcvr> rcvr;
+        state_base**              handle{};
+        auto complete(T... a) -> void override { test_std::set_value(std::move(this->rcvr), a...); }
+        state(auto&& r, state_base** h) : rcvr(std::forward<decltype(r)>(r)), handle(h) {}
+        auto start() & noexcept { *this->handle = this; }
+    };
+    state_base** handle{nullptr};
+    template <test_std::receiver Rcvr>
+    auto connect(Rcvr&& rcvr) -> state<Rcvr> {
+        return state<Rcvr>(std::forward<Rcvr>(rcvr), this->handle);
+    }
+};
+static_assert(test_std::sender<sender<>>);
+static_assert(test_std::sender<sender<int>>);
+static_assert(test_std::sender<sender<int, bool>>);
+
+template <bool Noexcept>
+struct token {
+    std::size_t* count{nullptr};
+    auto         try_associate() -> bool { return this->count && bool(++*this->count); }
+    auto         disassociate() noexcept(Noexcept) -> void { --*this->count; }
+    template <test_std::sender Sender>
+    auto wrap(Sender&& sender) -> Sender {
+        return std::forward<Sender>(sender);
+    }
+};
+static_assert(test_std::scope_token<token<true>>);
+static_assert(not test_std::scope_token<token<false>>);
+
+struct exception {
+    int value;
+};
+struct throws {
+    throws() = default;
+    throws(throws&&) noexcept(false) { throw exception{42}; }
+};
+static_assert(!std::is_nothrow_constructible_v<std::decay_t<throws>, throws>);
+
+template <bool Expect, typename Env = ::env, typename Sender, typename Token>
+auto test_spawn_future_interface(Sender&& sndr, Token&& tok) -> void {
+    if constexpr (!std::same_as<std::remove_cvref_t<Env>, non_env>) {
+        static_assert(Expect ==
+                      requires { test_std::spawn_future(std::forward<Sender>(sndr), std::forward<Token>(tok)); });
+    }
+    static_assert(Expect == requires(const Env& e) {
+        test_std::spawn_future(std::forward<Sender>(sndr), std::forward<Token>(tok), e);
+    });
+}
+
+template <typename Completions>
+struct state_base : test_detail::spawn_future_state_base<Completions> {
+    bool called{false};
+    auto complete() noexcept -> void override { this->called = true; }
+};
+auto test_state_base() {
+    static_assert(
+        noexcept(std::declval<test_detail::spawn_future_state_base<test_std::completion_signatures<>>&>().complete()));
+    using state0_t = state_base<test_std::completion_signatures<>>;
+    [[maybe_unused]] state0_t b0;
+    static_assert(std::same_as<std::variant<std::monostate>, state0_t::result_t>);
+    static_assert(std::same_as<state0_t::result_t, decltype(b0.result)>);
+
+    using state1_t = state_base<test_std::completion_signatures<test_std::set_value_t(int)>>;
+    [[maybe_unused]] state1_t b1;
+    static_assert(
+        std::same_as<std::variant<std::monostate, std::tuple<test_std::set_value_t, int>>, state1_t::result_t>);
+    static_assert(std::same_as<state1_t::result_t, decltype(b1.result)>);
+
+    using state2_t = state_base<test_std::completion_signatures<test_std::set_value_t(throws)>>;
+    [[maybe_unused]] state2_t b2;
+    static_assert(std::same_as<std::variant<std::monostate,
+                                            std::tuple<test_std::set_error_t, std::exception_ptr>,
+                                            std::tuple<test_std::set_value_t, throws>>,
+                               typename state2_t::result_t>);
+    static_assert(std::same_as<state2_t::result_t, decltype(b2.result)>);
+
+    using state3_t = state_base<
+        test_std::completion_signatures<test_std::set_value_t(throws), test_std::set_error_t(std::exception_ptr)>>;
+    [[maybe_unused]] state3_t b3;
+    static_assert(std::same_as<std::variant<std::monostate,
+                                            std::tuple<test_std::set_error_t, std::exception_ptr>,
+                                            std::tuple<test_std::set_value_t, throws>>,
+                               typename state3_t::result_t>);
+    static_assert(std::same_as<state3_t::result_t, decltype(b3.result)>);
+
+    using state4_t = state_base<
+        test_std::completion_signatures<test_std::set_value_t(throws), test_std::set_value_t(const throws&)>>;
+    [[maybe_unused]] state4_t b4;
+    static_assert(std::same_as<std::variant<std::monostate,
+                                            std::tuple<test_std::set_error_t, std::exception_ptr>,
+                                            std::tuple<test_std::set_value_t, throws>>,
+                               typename state4_t::result_t>);
+    static_assert(std::same_as<state4_t::result_t, decltype(b4.result)>);
+
+    using state5_t = state_base<test_std::completion_signatures<test_std::set_stopped_t()>>;
+    [[maybe_unused]] state5_t b5;
+    static_assert(
+        std::same_as<std::variant<std::monostate, std::tuple<test_std::set_stopped_t>>, typename state5_t::result_t>);
+    static_assert(std::same_as<state5_t::result_t, decltype(b5.result)>);
+}
+
+auto test_receiver() {
+    {
+        using c_t = test_std::completion_signatures<test_std::set_stopped_t()>;
+        state_base<c_t> state{};
+        ASSERT(state.called == false);
+        ASSERT(std::holds_alternative<std::monostate>(state.result));
+        static_assert(test_std::receiver<test_detail::spawn_future_receiver<c_t>>);
+        [[maybe_unused]] test_detail::spawn_future_receiver<c_t> r0{&state};
+        [](auto&& r) { static_assert(not requires { r.set_stopped(); }); }(r0);
+        static_assert(noexcept(std::move(r0).set_stopped()));
+        std::move(r0).set_stopped();
+        ASSERT(state.called == true);
+        ASSERT((std::holds_alternative<std::tuple<test_std::set_stopped_t>>(state.result)));
+    }
+
+    {
+        using c_t = test_std::completion_signatures<test_std::set_error_t(int)>;
+        state_base<c_t> state{};
+        ASSERT(state.called == false);
+        ASSERT(std::holds_alternative<std::monostate>(state.result));
+        static_assert(test_std::receiver<test_detail::spawn_future_receiver<c_t>>);
+        [[maybe_unused]] test_detail::spawn_future_receiver<c_t> r0{&state};
+        [](auto&& r) { static_assert(not requires { r.set_error(17); }); }(r0);
+        static_assert(noexcept(std::move(r0).set_error(17)));
+        std::move(r0).set_error(17);
+        ASSERT(state.called == true);
+        ASSERT((std::holds_alternative<std::tuple<test_std::set_error_t, int>>(state.result)));
+        ASSERT((std::get<1>(std::get<std::tuple<test_std::set_error_t, int>>(state.result)) == 17));
+    }
+
+    {
+        using c_t = test_std::completion_signatures<test_std::set_value_t(int, bool, char)>;
+        state_base<c_t> state{};
+        ASSERT(state.called == false);
+        ASSERT(std::holds_alternative<std::monostate>(state.result));
+        static_assert(test_std::receiver<test_detail::spawn_future_receiver<c_t>>);
+        [[maybe_unused]] test_detail::spawn_future_receiver<c_t> r0{&state};
+        [](auto&& r) { static_assert(not requires { r.set_value(17, true, 'x'); }); }(r0);
+        static_assert(noexcept(std::move(r0).set_value(17, true, 'x')));
+        std::move(r0).set_value(17, true, 'x');
+        ASSERT(state.called == true);
+        ASSERT((std::holds_alternative<std::tuple<test_std::set_value_t, int, bool, char>>(state.result)));
+        ASSERT((std::get<1>(std::get<std::tuple<test_std::set_value_t, int, bool, char>>(state.result)) == 17));
+        ASSERT((std::get<2>(std::get<std::tuple<test_std::set_value_t, int, bool, char>>(state.result)) == true));
+        ASSERT((std::get<3>(std::get<std::tuple<test_std::set_value_t, int, bool, char>>(state.result)) == 'x'));
+    }
+
+    {
+        using c_t = test_std::completion_signatures<test_std::set_value_t(int, throws, char)>;
+        state_base<c_t> state{};
+        ASSERT(state.called == false);
+        ASSERT(std::holds_alternative<std::monostate>(state.result));
+        static_assert(test_std::receiver<test_detail::spawn_future_receiver<c_t>>);
+        [[maybe_unused]] test_detail::spawn_future_receiver<c_t> r0{&state};
+        [](auto&& r) { static_assert(not requires { r.set_value(17, throws(), 'x'); }); }(r0);
+        static_assert(noexcept(std::move(r0).set_value(17, throws(), 'x')));
+        std::move(r0).set_value(17, throws(), 'x');
+        ASSERT(state.called == true);
+        ASSERT((std::holds_alternative<std::tuple<test_std::set_error_t, std::exception_ptr>>(state.result)));
+        try {
+            std::rethrow_exception(
+                std::get<1>(std::get<std::tuple<test_std::set_error_t, std::exception_ptr>>(state.result)));
+            ASSERT(nullptr == "not reached");
+        } catch (const exception& ex) {
+            ASSERT(ex.value == 42);
+        } catch (...) {
+            ASSERT(nullptr == "not reached");
+        }
+    }
+}
+
+struct allocator {
+    using value_type = int;
+    int value{};
+
+    auto allocate(std::size_t n) -> int* { return new int[n]; }
+    auto deallocate(int* p, std::size_t) -> void { delete[] p; }
+
+    auto operator==(const allocator&) const -> bool = default;
+};
+static_assert(test_detail::simple_allocator<allocator>);
+
+struct alloc_env {
+    int  value{};
+    auto operator==(const alloc_env&) const -> bool = default;
+
+    auto query(const test_std::get_allocator_t&) const noexcept -> allocator { return allocator{this->value}; }
+};
+
+struct alloc_sender {
+    using sender_concept = test_std::sender_t;
+    int value{};
+
+    auto get_env() const noexcept -> alloc_env { return alloc_env{this->value}; }
+};
+static_assert(test_std::sender<alloc_sender>);
+
+auto test_get_allocator() {
+    {
+        alloc_env ae{87};
+        auto [alloc, ev] = test_detail::spawn_get_allocator(sender<>{}, ae);
+        static_assert(std::same_as<decltype(alloc), allocator>);
+        ASSERT(alloc == allocator{87});
+        static_assert(std::same_as<decltype(ev), alloc_env>);
+        ASSERT(ev == alloc_env{87});
+    }
+    {
+        auto [alloc, ev] = test_detail::spawn_get_allocator(alloc_sender{53}, env{42});
+        static_assert(std::same_as<decltype(alloc), allocator>);
+        ASSERT(alloc == allocator{53});
+        ASSERT(test_std::get_allocator(ev) == allocator{53});
+    }
+    {
+        test_std::inplace_stop_source source;
+        auto [alloc, ev] = test_detail::spawn_get_allocator(
+            alloc_sender{53}, test_std::prop(test_std::get_stop_token, source.get_token()));
+        static_assert(std::same_as<decltype(alloc), allocator>);
+        ASSERT(alloc == allocator{53});
+        ASSERT(test_std::get_allocator(ev) == allocator{53});
+        ASSERT(test_std::get_stop_token(ev) == source.get_token());
+    }
+    {
+        test_std::inplace_stop_source source;
+        auto [alloc, ev] = test_detail::spawn_get_allocator(
+            alloc_sender{53},
+            test_detail::join_env(test_std::prop(test_std::get_allocator, allocator(101)),
+                                  test_std::prop(test_std::get_stop_token, source.get_token())));
+        static_assert(std::same_as<decltype(alloc), allocator>);
+        ASSERT(alloc == allocator{101});
+        ASSERT(test_std::get_allocator(ev) == allocator{101});
+        ASSERT(test_std::get_stop_token(ev) == source.get_token());
+    }
+    {
+        auto [alloc, ev] = test_detail::spawn_get_allocator(sender<>{}, env{42});
+        static_assert(std::same_as<decltype(alloc), std::allocator<void>>);
+        static_assert(std::same_as<decltype(ev), env>);
+        ASSERT(ev == env{42});
+    }
+}
+
+struct rcvr {
+    using receiver_concept = test_std::receiver_t;
+
+    auto set_value(auto&&...) && noexcept -> void {}
+    auto set_error(auto&&) && noexcept -> void {}
+    auto set_stopped() && noexcept -> void {}
+};
+static_assert(test_std::receiver<rcvr>);
+
+auto test_spawn_future() {
+    {
+        std::size_t              count{};
+        sender<int>::state_base* handle{};
+        int                      result{};
+        ASSERT(count == 0u);
+        ASSERT(handle == nullptr);
+        ASSERT(result == 0);
+
+        auto sndr{test_std::spawn_future(
+            sender<int>{&handle} | test_std::then([](int v) { return v; }), token<true>{&count}, env{})};
+        ASSERT(count == 1u);
+        ASSERT(handle != nullptr);
+        ASSERT(result == 0);
+
+        {
+            auto state(test_std::connect(std::move(sndr) | test_std::then([&result](int v) { result = v; }), rcvr{}));
+            ASSERT(result == 0);
+
+            test_std::start(state);
+            ASSERT(count == 1u);
+            ASSERT(result == 0);
+
+            handle->complete(42);
+            ASSERT(result == 42);
+            ASSERT(count == 1u);
+        }
+        ASSERT(count == 0u);
+    }
+    {
+        std::size_t              count{};
+        sender<int>::state_base* handle{};
+        int                      result{};
+        ASSERT(count == 0u);
+        ASSERT(handle == nullptr);
+        ASSERT(result == 0);
+
+        auto sndr{test_std::spawn_future(
+            sender<int>{&handle} | test_std::then([](int v) { return v; }), token<true>{&count}, env{})};
+        ASSERT(count == 1u);
+        ASSERT(handle != nullptr);
+        ASSERT(result == 0);
+
+        {
+            auto state(test_std::connect(std::move(sndr) | test_std::then([&result](int v) { result = v; }), rcvr{}));
+            ASSERT(result == 0);
+
+            handle->complete(42);
+            ASSERT(result == 0);
+
+            test_std::start(state);
+
+            ASSERT(result == 42);
+            ASSERT(count == 1u);
+        }
+        ASSERT(count == 0u);
+    }
+    {
+        std::size_t              count{};
+        sender<int>::state_base* handle{};
+        int                      result{};
+        ASSERT(count == 0u);
+        ASSERT(handle == nullptr);
+        ASSERT(result == 0);
+
+        {
+            auto sndr{test_std::spawn_future(
+                sender<int>{&handle} | test_std::then([](int v) { return v; }), token<true>{&count}, env{})};
+            ASSERT(count == 1u);
+            ASSERT(handle != nullptr);
+            ASSERT(result == 0);
+        }
+        ASSERT(count == 1u);
+        handle->complete(17);
+        ASSERT(count == 0u);
+        ASSERT(result == 0);
+    }
+    {
+        std::size_t              count{};
+        sender<int>::state_base* handle{};
+        int                      result{};
+        ASSERT(count == 0u);
+        ASSERT(handle == nullptr);
+        ASSERT(result == 0);
+
+        {
+            auto sndr{test_std::spawn_future(
+                sender<int>{&handle} | test_std::then([](int v) { return v; }), token<true>{&count}, env{})};
+            ASSERT(count == 1u);
+            ASSERT(handle != nullptr);
+            ASSERT(result == 0);
+#if 0
+            using type = typename beman::execution::detail::completion_signatures_for_impl<decltype(sndr), test_std::empty_env>::type;
+            static_assert(std::same_as<test_std::completion_signatures<test_std::set_stopped_t(), test_std::set_value_t(int), test_std::set_error_t(std::exception_ptr)>, type>);
+            static_assert(std::same_as<
+                test_std::completion_signatures<test_std::set_stopped_t(), test_std::set_value_t(int), test_std::set_error_t(std::exception_ptr)>,
+                decltype(test_std::get_completion_signatures(sndr, test_std::empty_env{}))
+            >);
+#endif
+            using exp_type  = test_std::completion_signatures<test_std::set_stopped_t(),
+                                                              test_std::set_value_t(int),
+                                                              test_std::set_error_t(std::exception_ptr)>;
+            using comp_type = decltype(test_std::get_completion_signatures(std::move(sndr), test_std::empty_env{}));
+            static_assert(test_detail::meta::contain_same<exp_type, comp_type>);
+
+            handle->complete(17);
+            ASSERT(result == 0);
+        }
+        ASSERT(count == 0u);
+        ASSERT(result == 0);
+    }
+}
+
+} // namespace
+
+TEST(exec_spawn_future) {
+    static_assert(std::same_as<const test_std::spawn_future_t, decltype(test_std::spawn_future)>);
+    test_spawn_future_interface<true>(sender{}, token<true>{});
+    test_spawn_future_interface<false>(non_sender{}, token<true>{});
+    test_spawn_future_interface<false>(sender{}, token<false>{});
+
+    test_spawn_future_interface<false, non_env>(sender{}, token<true>{});
+
+    test_state_base();
+    test_receiver();
+
+    test_get_allocator();
+
+    test_spawn_future();
+}
diff --git a/tests/beman/execution/exec-spawn.test.cpp b/tests/beman/execution/exec-spawn.test.cpp
new file mode 100644
index 00000000..14f2cce2
--- /dev/null
+++ b/tests/beman/execution/exec-spawn.test.cpp
@@ -0,0 +1,168 @@
+// tests/beman/execution/exec-spawn.test.cpp                          -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/spawn.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/scope_token.hpp>
+#include <beman/execution/detail/set_value.hpp>
+#include <beman/execution/detail/set_stopped.hpp>
+#include <test/execution.hpp>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+// ----------------------------------------------------------------------------
+
+namespace {
+struct env {};
+
+template <bool B>
+struct sender {
+    using sender_concept        = std::conditional_t<B, test_std::sender_t, void>;
+    using completion_signatures = test_std::completion_signatures<test_std::set_value_t()>;
+
+    struct base {
+        virtual ~base()                 = default;
+        virtual auto complete() -> void = 0;
+    };
+
+    template <test_std::receiver Rcvr>
+    struct state : base {
+        std::remove_cvref_t<Rcvr> rcvr;
+        base*&                    handle;
+
+        using operation_state_concept = test_std::operation_state_t;
+        state(auto&& r, base*& h) : rcvr(std::forward<decltype(r)>(r)), handle(h) {}
+        auto start() & noexcept { this->handle = this; }
+        auto complete() -> void override { test_std::set_value(std::move(this->rcvr)); }
+    };
+
+    base** handle{};
+    template <test_std::receiver Rcvr>
+    auto connect(Rcvr&& rcvr) -> state<Rcvr> {
+        return state<Rcvr>{std::forward<Rcvr>(rcvr), *this->handle};
+    }
+};
+static_assert(test_std::sender<sender<true>>);
+static_assert(!test_std::sender<sender<false>>);
+
+template <bool B>
+struct token {
+    bool* associated{};
+    bool* disassociated{};
+    bool  can_associate{true};
+    auto  try_associate() noexcept(B) -> bool { return this->can_associate && (*this->associated = true); }
+    auto  disassociate() noexcept(B) { *this->disassociated = true; }
+    template <test_std::sender Sndr>
+    auto wrap(Sndr&& sndr) {
+        return std::forward<Sndr>(sndr);
+    }
+};
+static_assert(test_std::scope_token<token<true>>);
+static_assert(!test_std::scope_token<token<false>>);
+
+template <bool Expect, typename Sndr, typename Tok, typename Ev>
+auto test_overload(Sndr&& sndr, Tok&& tok, Ev ev) -> void {
+    static_assert(Expect == requires { test_std::spawn(::std::forward<Sndr>(sndr), ::std::forward<Tok>(tok)); });
+    static_assert(Expect == requires {
+        test_std::spawn(::std::forward<Sndr>(sndr), ::std::forward<Tok>(tok), ::std::forward<Ev>(ev));
+    });
+}
+
+struct test_state : test_detail::spawn_t::state_base {
+    bool& value;
+    test_state(bool& v) : value(v) {}
+    auto complete() noexcept -> void override { value = true; }
+};
+
+auto test_spawn_state_base() -> void {
+    bool       called{false};
+    test_state state(called);
+    ASSERT(called == false);
+    test_detail::spawn_t::state_base& base{state};
+    ASSERT(called == false);
+    base.complete();
+    ASSERT(called == true);
+}
+
+template <bool Expect, typename Rcvr>
+auto test_spawn_receiver() -> void {
+    static_assert(test_std::receiver<Rcvr>);
+    static_assert(Expect == requires(Rcvr rcvr) { test_std::set_value(std::move(rcvr)); });
+    static_assert(Expect != requires(Rcvr rcvr) { test_std::set_value(rcvr); });
+    static_assert(Expect == requires(Rcvr rcvr) { test_std::set_stopped(std::move(rcvr)); });
+    static_assert(Expect != requires(Rcvr rcvr) { test_std::set_stopped(rcvr); });
+
+    {
+        bool       called{false};
+        test_state state(called);
+        Rcvr       rcvr{&state};
+        ASSERT(called == false);
+        test_std::set_value(std::move(rcvr));
+        ASSERT(called == true);
+    }
+    {
+        bool       called{false};
+        test_state state(called);
+        Rcvr       rcvr{&state};
+        ASSERT(called == false);
+        test_std::set_stopped(std::move(rcvr));
+        ASSERT(called == true);
+    }
+}
+
+template <typename Alloc, test_std::scope_token Tok, test_std::sender Sndr>
+auto test_spawn_state(Alloc&& alloc, Tok&& tok, Sndr&& sndr) -> void {
+    static_assert(requires(test_detail::spawn_t::state<Alloc, Tok, Sndr> state) {
+        static_cast<test_detail::spawn_t::state_base&>(state);
+        test_detail::spawn_t::state<Alloc, Tok, Sndr>(alloc, std::forward<Sndr>(sndr), std::forward<Tok>(tok));
+    });
+}
+
+auto test_spawn() {
+    {
+        sender<true>::base* handle{nullptr};
+        bool                associated(false);
+        bool                disassociated(false);
+        ASSERT(handle == nullptr);
+        ASSERT(associated == false);
+        ASSERT(disassociated == false);
+        test_std::spawn(sender<true>{&handle}, token<true>{&associated, &disassociated});
+        ASSERT(handle != nullptr);
+        ASSERT(associated == true);
+        ASSERT(disassociated == false);
+        handle->complete();
+        ASSERT(handle != nullptr);
+        ASSERT(associated == true);
+        ASSERT(disassociated == true);
+    }
+    {
+        sender<true>::base* handle{nullptr};
+        bool                associated(false);
+        bool                disassociated(false);
+        ASSERT(handle == nullptr);
+        ASSERT(associated == false);
+        ASSERT(disassociated == false);
+        test_std::spawn(sender<true>{&handle}, token<true>{&associated, &disassociated, false});
+        ASSERT(handle == nullptr);
+        ASSERT(associated == false);
+        ASSERT(disassociated == false);
+    }
+}
+
+} // namespace
+
+TEST(exec_spawn_future) {
+    static_assert(std::same_as<decltype(test_std::spawn), const test_std::spawn_t>);
+    test_overload<true>(sender<true>{}, token<true>{}, env{});
+    test_overload<false>(sender<false>{}, token<true>{}, env{});
+    test_overload<false>(sender<true>{}, token<false>{}, env{});
+
+    test_spawn_state_base();
+    test_spawn_receiver<true, test_std::spawn_t::receiver>();
+    test_spawn_state(std::allocator<void>{}, token<true>{}, sender<true>{});
+
+    test_spawn();
+}
diff --git a/tests/beman/execution/exec-stop-when.test.cpp b/tests/beman/execution/exec-stop-when.test.cpp
new file mode 100644
index 00000000..52690c05
--- /dev/null
+++ b/tests/beman/execution/exec-stop-when.test.cpp
@@ -0,0 +1,147 @@
+// tests/beman/execution/exec-stop-when.test.cpp                      -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/stop_when.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/completion_signatures.hpp>
+#include <beman/execution/detail/set_value.hpp>
+#include <beman/execution/detail/set_stopped.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/operation_state.hpp>
+#include <beman/execution/detail/inplace_stop_source.hpp>
+#include <beman/execution/detail/get_stop_token.hpp>
+#include <beman/execution/detail/get_env.hpp>
+#include <beman/execution/detail/connect.hpp>
+#include <beman/execution/detail/start.hpp>
+#include <beman/execution/detail/stop_callback_for_t.hpp>
+#include <beman/execution/detail/never_stop_token.hpp>
+#include <beman/execution/detail/just.hpp>
+#include <beman/execution/detail/sync_wait.hpp>
+#include <test/execution.hpp>
+#include <concepts>
+#include <optional>
+#include <type_traits>
+#include <utility>
+
+// ----------------------------------------------------------------------------
+
+namespace {
+struct sender {
+    using sender_concept        = test_std::sender_t;
+    using completion_signatures = test_std::completion_signatures<test_std::set_value_t(), test_std::set_stopped_t()>;
+
+    template <test_std::receiver Rcvr>
+    struct state {
+        using operation_state_concept = test_std::operation_state_t;
+        using rcvr_t                  = std::remove_cvref_t<Rcvr>;
+        using token_t = decltype(test_std::get_stop_token(test_std::get_env(std::declval<const rcvr_t>())));
+
+        struct cb_t {
+            rcvr_t& rcvr;
+            auto    operator()() noexcept { test_std::set_stopped(std::move(this->rcvr)); }
+        };
+        using stop_cb_t = test_std::stop_callback_for_t<token_t, cb_t>;
+
+        rcvr_t                   rcvr;
+        std::optional<stop_cb_t> stop_cb;
+
+        template <test_std::receiver R>
+        state(R&& r) : rcvr(r) {}
+
+        auto start() & noexcept {
+            this->stop_cb.emplace(test_std::get_stop_token(test_std::get_env(this->rcvr)), cb_t{this->rcvr});
+        }
+    };
+
+    template <test_std::receiver Rcvr>
+    auto connect(Rcvr&& rcvr) -> state<Rcvr> {
+        return state<Rcvr>(std::forward<Rcvr>(rcvr));
+    }
+};
+static_assert(test_std::sender<sender>);
+
+struct env {
+    test_std::inplace_stop_token token;
+    auto                         query(const test_std::get_stop_token_t&) const noexcept { return this->token; }
+};
+enum class completion : char { none, value, stopped };
+
+struct receiver {
+    using receiver_concept = test_std::receiver_t;
+
+    test_std::inplace_stop_token token;
+    completion&                  comp;
+
+    auto set_value() && noexcept { this->comp = completion::value; }
+    auto set_stopped() && noexcept { this->comp = completion::stopped; }
+
+    auto get_env() const noexcept { return env{this->token}; }
+};
+static_assert(test_std::receiver<receiver>);
+} // namespace
+
+TEST(exec_stop_when) {
+    static_assert(std::same_as<const test_detail::stop_when_t, decltype(test_detail::stop_when)>);
+    static_assert(requires(const env& e) {
+        { test_std::get_stop_token(e) } -> std::same_as<test_std::inplace_stop_token>;
+    });
+    static_assert(requires(const receiver& r) {
+        { test_std::get_stop_token(test_std::get_env(r)) } -> std::same_as<test_std::inplace_stop_token>;
+    });
+
+    {
+        test_std::inplace_stop_source source;
+        completion                    comp{completion::none};
+        auto                          state{test_std::connect(sender{}, receiver{source.get_token(), comp})};
+        ASSERT(comp == completion::none);
+        test_std::start(state);
+        ASSERT(comp == completion::none);
+
+        source.request_stop();
+        ASSERT(comp == completion::stopped);
+    }
+    {
+        auto sndr{test_detail::stop_when(sender{}, test_std::never_stop_token{})};
+        static_assert(std::same_as<sender, decltype(sndr)>);
+    }
+    {
+        test_std::inplace_stop_source source;
+        completion                    comp{completion::none};
+        auto state{test_std::connect(test_detail::stop_when(sender{}, test_std::never_stop_token{}),
+                                     receiver{source.get_token(), comp})};
+        ASSERT(comp == completion::none);
+        test_std::start(state);
+        ASSERT(comp == completion::none);
+
+        source.request_stop();
+        ASSERT(comp == completion::stopped);
+    }
+    {
+        test_std::inplace_stop_source source1;
+        test_std::inplace_stop_source source2;
+        completion                    comp{completion::none};
+        auto                          state{test_std::connect(test_detail::stop_when(sender{}, source1.get_token()),
+                                     receiver{source2.get_token(), comp})};
+        ASSERT(comp == completion::none);
+        test_std::start(state);
+        ASSERT(comp == completion::none);
+
+        source1.request_stop();
+        ASSERT(comp == completion::stopped);
+    }
+    {
+        test_std::inplace_stop_source source1;
+        test_std::inplace_stop_source source2;
+        completion                    comp{completion::none};
+        auto                          state{test_std::connect(test_detail::stop_when(sender{}, source1.get_token()),
+                                     receiver{source2.get_token(), comp})};
+        ASSERT(comp == completion::none);
+        test_std::start(state);
+        ASSERT(comp == completion::none);
+
+        source2.request_stop();
+        ASSERT(comp == completion::stopped);
+    }
+    test_std::inplace_stop_source source;
+    test_std::sync_wait(test_detail::stop_when(test_std::just(), source.get_token()));
+}
diff --git a/tests/beman/execution/include/test/execution.hpp b/tests/beman/execution/include/test/execution.hpp
index 13ac3469..f030b621 100644
--- a/tests/beman/execution/include/test/execution.hpp
+++ b/tests/beman/execution/include/test/execution.hpp
@@ -7,6 +7,13 @@
 #include <beman/execution/stop_token.hpp>
 #include <concepts>
 #include <cstddef>
+#ifndef _MSC_VER
+#include <cstdlib>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <iostream>
+#endif
+#include <source_location>
 
 #undef NDEBUG
 #include <cassert>
@@ -21,6 +28,16 @@ namespace test_std    = ::beman::execution;
 namespace test_detail = ::beman::execution::detail;
 
 namespace test {
+#if 201907L <= __cpp_lib_source_location
+using source_location = ::std::source_location;
+#else
+struct source_location {
+    static auto current() -> source_location { return {}; }
+    auto        file_name() const -> const char* { return "<unknown:no std::source_location>"; }
+    auto        line() const -> const char* { return "<unknown:no std::source_location>"; }
+};
+#endif
+
 inline bool unreachable_helper() { return false; }
 
 template <typename>
@@ -41,6 +58,28 @@ struct throws {
     auto operator=(const throws&) noexcept(false) -> throws& = default;
 };
 
+inline auto death([[maybe_unused]] auto                   fun,
+                  [[maybe_unused]] ::std::source_location location = test::source_location::current()) noexcept
+    -> void {
+#ifndef _MSC_VER
+    switch (::pid_t rc = ::fork()) {
+    default: {
+        int stat{};
+        ASSERT(rc == ::wait(&stat));
+        if (stat == EXIT_SUCCESS) {
+            ::std::cerr << "failed death test at " << "file=" << location.file_name() << ":" << location.line() << "\n"
+                        << std::flush;
+            ASSERT(stat != EXIT_SUCCESS);
+        }
+    } break;
+    case 0: {
+        ::close(2);
+        fun();
+        ::std::exit(EXIT_SUCCESS);
+    } break;
+    }
+#endif
+}
 } // namespace test
 
 #endif // INCLUDED_TEST_EXECUTION
diff --git a/tests/beman/execution/include/test/inline_scheduler.hpp b/tests/beman/execution/include/test/inline_scheduler.hpp
new file mode 100644
index 00000000..694864fd
--- /dev/null
+++ b/tests/beman/execution/include/test/inline_scheduler.hpp
@@ -0,0 +1,54 @@
+// tests/beman/execution/include/test/inline_scheduler.hpp            -*-C++-*-
+// ----------------------------------------------------------------------------
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// ----------------------------------------------------------------------------
+
+#ifndef INCLUDED_TESTS_BEMAN_EXECUTION_INCLUDE_TEST_INLINE_SCHEDULER
+#define INCLUDED_TESTS_BEMAN_EXECUTION_INCLUDE_TEST_INLINE_SCHEDULER
+
+#include <beman/execution/detail/get_completion_scheduler.hpp>
+#include <beman/execution/detail/get_env.hpp>
+#include <beman/execution/detail/sender.hpp>
+#include <beman/execution/detail/receiver.hpp>
+#include <beman/execution/detail/set_value.hpp>
+#include <beman/execution/detail/operation_state.hpp>
+#include <beman/execution/detail/scheduler.hpp>
+#include <beman/execution/detail/completion_signatures.hpp>
+#include <test/execution.hpp>
+
+// ----------------------------------------------------------------------------
+
+namespace test {
+struct inline_scheduler {
+    struct env {
+        inline_scheduler query(const test_std::get_completion_scheduler_t<test_std::set_value_t>&) const noexcept {
+            return {};
+        }
+    };
+    template <test_std::receiver Receiver>
+    struct state {
+        using operation_state_concept = test_std::operation_state_t;
+        std::remove_cvref_t<Receiver> receiver;
+        void                          start() & noexcept { ::beman::execution::set_value(std::move(receiver)); }
+    };
+    struct sender {
+        using sender_concept        = test_std::sender_t;
+        using completion_signatures = test_std::completion_signatures<::beman::execution::set_value_t()>;
+
+        env get_env() const noexcept { return {}; }
+        template <test_std::receiver Receiver>
+        state<Receiver> connect(Receiver&& receiver) {
+            return {std::forward<Receiver>(receiver)};
+        }
+    };
+    static_assert(test_std::sender<sender>);
+
+    using scheduler_concept = test_std::scheduler_t;
+    constexpr sender schedule() noexcept { return {}; }
+    bool             operator==(const inline_scheduler&) const = default;
+};
+} // namespace test
+
+// ----------------------------------------------------------------------------
+
+#endif