diff --git a/CMakeLists.txt b/CMakeLists.txt
index 117c863..38f8e5b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -73,7 +73,6 @@ endif ()
 add_custom_target(buildSingleHeader
     COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/buildSingleHeader.cmake
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-add_dependencies(pushmi buildSingleHeader)
 
 install(
     DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
diff --git a/Readme.md b/Readme.md
index 707c095..d82a2b0 100644
--- a/Readme.md
+++ b/Readme.md
@@ -157,121 +157,121 @@ auto s0 = single<int>{single{}};
 auto s1 = single<int, std::exception_ptr>{single{}};
 ```
 
-## `deferred`
+## `sender`
 
-The `deferred` type in the library provides simple ways to construct new implementations of the NoneSender concept.
+The `sender` type in the library provides simple ways to construct new implementations of the NoneSender concept.
 
 construct a producer of nothing, aka `never()`
 
 ```cpp
-deferred<> d;
+sender<> d;
 ```
 
 construct new type using one or more lambdas, or with designated initializers, use multiple lambdas to build overload sets
 
 ```cpp
-auto d0 = deferred{on_submit{[](auto out){}}};
-auto d1 = deferred{[](auto out){}};
-auto d2 = deferred{on_submit{[](none<> out){}, [](auto out){}}};
+auto d0 = sender{on_submit{[](auto out){}}};
+auto d1 = sender{[](auto out){}};
+auto d2 = sender{on_submit{[](none<> out){}, [](auto out){}}};
 
 ```
 
-construct a new type with shared state across the lambdas. very useful for building a filter on top of an existing deferred. The state must be a NoneSender, but can be a super-set with additional state for this filter.
+construct a new type with shared state across the lambdas. very useful for building a filter on top of an existing sender. The state must be a NoneSender, but can be a super-set with additional state for this filter.
 
 ```cpp
-auto d0 = deferred{deferred{}};
+auto d0 = sender{sender{}};
 
-auto d1 = deferred{deferred{}, on_submit{
-    [](deferred<>& in, auto out){in | submit(out);}}};
+auto d1 = sender{sender{}, on_submit{
+    [](sender<>& in, auto out){in | submit(out);}}};
 
-auto d2 = deferred{deferred{},
-    [](deferred<>& in, auto out){in | submit(out);}};
+auto d2 = sender{sender{},
+    [](sender<>& in, auto out){in | submit(out);}};
 
 ```
 
 construct a type-erased type for a particular E (which could be a std::variant of supported types). I have a plan to provide operators to collapse values and errors to variant or tuple and then expand from variant or tuple back to their constituent values/errors.
 
 ```cpp
-auto d0 = deferred<>{deferred{}};
-auto d1 = deferred<std::exception_ptr>{deferred{}};
+auto d0 = sender<>{sender{}};
+auto d1 = sender<std::exception_ptr>{sender{}};
 ```
 
-## `single_deferred`
+## `single_sender`
 
-The `single_deferred` type in the library provides simple ways to construct new implementations of the SingleSender concept.
+The `single_sender` type in the library provides simple ways to construct new implementations of the SingleSender concept.
 
 construct a producer of nothing, aka `never()`
 
 ```cpp
-single_deferred<> sd;
+single_sender<> sd;
 ```
 
 construct new type using one or more lambdas, or with designated initializers, use multiple lambdas to build overload sets
 
 ```cpp
-auto sd0 = single_deferred{on_submit{[](auto out){}}};
-auto sd1 = single_deferred{[](auto out){}};
-auto sd2 = single_deferred{on_submit{[](single<> out){}, [](auto out){}}};
+auto sd0 = single_sender{on_submit{[](auto out){}}};
+auto sd1 = single_sender{[](auto out){}};
+auto sd2 = single_sender{on_submit{[](single<> out){}, [](auto out){}}};
 
 ```
 
-construct a new type with shared state across the lambdas. very useful for building a filter on top of an existing single_deferred. The state must be a SingleSender, but can be a super-set with additional state for this filter.
+construct a new type with shared state across the lambdas. very useful for building a filter on top of an existing single_sender. The state must be a SingleSender, but can be a super-set with additional state for this filter.
 
 ```cpp
-auto sd0 = single_deferred{single_deferred{}};
+auto sd0 = single_sender{single_sender{}};
 
-auto sd1 = single_deferred{single_deferred{}, on_submit{
-    [](single_deferred<>& in, auto out){in | submit(out);}}};
+auto sd1 = single_sender{single_sender{}, on_submit{
+    [](single_sender<>& in, auto out){in | submit(out);}}};
 
-auto sd2 = single_deferred{single_deferred{},
-    [](single_deferred<>& in, auto out){in | submit(out);}};
+auto sd2 = single_sender{single_sender{},
+    [](single_sender<>& in, auto out){in | submit(out);}};
 
 ```
 
 construct a type-erased type for a particular T & E (which could be a std::variant of supported types). I have a plan to provide operators to collapse values and errors to variant or tuple and then expand from variant or tuple back to their constituent values/errors.
 
 ```cpp
-auto sd0 = single_deferred<int>{single_deferred{}};
-auto sd1 = single_deferred<int, std::exception_ptr>{single_deferred{}};
+auto sd0 = single_sender<int>{single_sender{}};
+auto sd1 = single_sender<int, std::exception_ptr>{single_sender{}};
 ```
 
-## `time_single_deferred`
+## `time_single_sender`
 
-The `time_single_deferred` type in the library provides simple ways to construct new implementations of the TimeSingleSender concept.
+The `time_single_sender` type in the library provides simple ways to construct new implementations of the TimeSingleSender concept.
 
 construct a producer of nothing, aka `never()`
 
 ```cpp
-time_single_deferred<> tsd;
+time_single_sender<> tsd;
 ```
 
 construct new type using one or more lambdas, or with designated initializers, use multiple lambdas to build overload sets
 
 ```cpp
-auto tsd0 = time_single_deferred{on_submit{[](auto at, auto out){}}};
-auto tsd1 = time_single_deferred{[](auto at, auto out){}};
-auto tsd2 = time_single_deferred{on_submit{[](auto at, single<> out){}, [](auto at, auto out){}}};
+auto tsd0 = time_single_sender{on_submit{[](auto at, auto out){}}};
+auto tsd1 = time_single_sender{[](auto at, auto out){}};
+auto tsd2 = time_single_sender{on_submit{[](auto at, single<> out){}, [](auto at, auto out){}}};
 
 ```
 
-construct a new type with shared state across the lambdas. very useful for building a filter on top of an existing time_single_deferred. The state must be a SingleSender, but can be a super-set with additional state for this filter.
+construct a new type with shared state across the lambdas. very useful for building a filter on top of an existing time_single_sender. The state must be a SingleSender, but can be a super-set with additional state for this filter.
 
 ```cpp
-auto tsd0 = time_single_deferred{single_deferred{}};
+auto tsd0 = time_single_sender{single_sender{}};
 
-auto tsd1 = time_single_deferred{single_deferred{}, on_submit{
-    [](time_single_deferred<>& in, auto at, auto out){in | submit(at, out);}}};
+auto tsd1 = time_single_sender{single_sender{}, on_submit{
+    [](time_single_sender<>& in, auto at, auto out){in | submit(at, out);}}};
 
-auto tsd2 = time_single_deferred{single_deferred{},
-    [](time_single_deferred<>& in, auto at, auto out){in | submit(at, out);}};
+auto tsd2 = time_single_sender{single_sender{},
+    [](time_single_sender<>& in, auto at, auto out){in | submit(at, out);}};
 
 ```
 
 construct a type-erased type for a particular T & E (which could be a std::variant of supported types). I have a plan to provide operators to collapse values and errors to variant or tuple and then expand from variant or tuple back to their constituent values/errors.
 
 ```cpp
-auto tsd0 = time_single_deferred<int>{time_single_deferred{}};
-auto tsd1 = time_single_deferred<int, std::exception_ptr>{time_single_deferred{}};
+auto tsd0 = time_single_sender<int>{time_single_sender{}};
+auto tsd1 = time_single_sender<int, std::exception_ptr>{time_single_sender{}};
 ```
 
 ## put it all together with some algorithms
diff --git a/TARGETS b/TARGETS
index 1669ad2..3cb22b8 100644
--- a/TARGETS
+++ b/TARGETS
@@ -7,11 +7,11 @@ cpp_library(
         "include/executor.h",
         "include/extension_points.h",
         "include/flowsingle.h",
-        "include/flowsingledeferred.h",
+        "include/flowsinglesender.h",
         "include/none.h",
         "include/piping.h",
         "include/single.h",
-        "include/singledeferred.h",
+        "include/singlesender.h",
         "include/traits.h",
         "include/trampoline.h",
     ],
diff --git a/benchmarks/PushmiBenchmarks.cpp b/benchmarks/PushmiBenchmarks.cpp
index 996ca50..7a171c9 100644
--- a/benchmarks/PushmiBenchmarks.cpp
+++ b/benchmarks/PushmiBenchmarks.cpp
@@ -11,7 +11,7 @@
 
 #include "pushmi/none.h"
 #include "pushmi/flow_single.h"
-#include "pushmi/flow_single_deferred.h"
+#include "pushmi/flow_single_sender.h"
 #include "pushmi/entangle.h"
 
 #include "pool.h"
diff --git a/buildSingleHeader.cmake b/buildSingleHeader.cmake
index a1263ea..3d9d811 100644
--- a/buildSingleHeader.cmake
+++ b/buildSingleHeader.cmake
@@ -34,20 +34,21 @@ set(header_files
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/boosters.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/piping.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/none.h"
-    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/deferred.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/sender.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/single.h"
-    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/single_deferred.h"
-    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/time_single_deferred.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/single_sender.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/time_single_sender.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/executor.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/flow_single.h"
-    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/flow_single_deferred.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/flow_single_sender.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/many.h"
-    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/many_deferred.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/many_sender.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/trampoline.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/new_thread.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/o/extension_operators.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/o/submit.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/subject.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/o/async.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/o/empty.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/o/from.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/pushmi/o/just.h"
diff --git a/examples/include/bulk.h b/examples/include/bulk.h
index 1cc7c18..d13bd6b 100644
--- a/examples/include/bulk.h
+++ b/examples/include/bulk.h
@@ -5,7 +5,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-#include <pushmi/single_deferred.h>
+#include <pushmi/single_sender.h>
 
 namespace pushmi {
 
@@ -21,7 +21,7 @@ PUSHMI_INLINE_VAR constexpr struct bulk_fn {
       IF&& initFunc,
       RS&& selector) const {
     return [func, sb, se, driver, initFunc, selector](auto in){
-      return make_single_deferred(
+      return make_single_sender(
         [in, func, sb, se, driver, initFunc, selector](auto out) mutable {
           submit(in, make_single(std::move(out),
               [func, sb, se, driver, initFunc, selector](auto& out, auto input) {
diff --git a/examples/include/no_fail.h b/examples/include/no_fail.h
index 2b0df49..ba0100a 100644
--- a/examples/include/no_fail.h
+++ b/examples/include/no_fail.h
@@ -4,7 +4,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-#include <pushmi/single_deferred.h>
+#include <pushmi/single_sender.h>
 #include <pushmi/o/submit.h>
 
 namespace pushmi {
@@ -33,7 +33,7 @@ struct no_fail_fn {
     PUSHMI_TEMPLATE(class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(out_impl<In>{})
       );
diff --git a/examples/include/pool.h b/examples/include/pool.h
index adcd0ad..947eba0 100644
--- a/examples/include/pool.h
+++ b/examples/include/pool.h
@@ -45,7 +45,7 @@ class pool {
 
   inline auto executor() {
     auto exec = execution::require(p.executor(), execution::never_blocking, execution::oneway);
-    return MAKE(time_single_deferred)(__pool_submit<decltype(exec)>{exec});
+    return MAKE(time_single_sender)(__pool_submit<decltype(exec)>{exec});
   }
 
   inline void stop() {p.stop();}
diff --git a/examples/set_done/set_done_2.cpp b/examples/set_done/set_done_2.cpp
index 2fb86ec..e3cd434 100644
--- a/examples/set_done/set_done_2.cpp
+++ b/examples/set_done/set_done_2.cpp
@@ -14,7 +14,7 @@ using namespace pushmi::aliases;
 const bool setting_exists = false;
 
 auto get_setting() {
-  return mi::make_single_deferred(
+  return mi::make_single_sender(
     [](auto out){
       if(setting_exists) {
         op::just(42) | op::submit(out);
@@ -31,7 +31,7 @@ auto println = [](auto v){std::cout << v << std::endl;};
 template<class T, class E = std::exception_ptr>
 auto concat =
   [](auto in){
-    return mi::make_single_deferred(
+    return mi::make_single_sender(
       [in](auto out) mutable {
         ::pushmi::submit(in, mi::make_single(out,
         [](auto out, auto v){
@@ -54,9 +54,9 @@ int main()
     op::just(42) |
       op::transform([](int i) {
         if (i < 42) {
-          return mi::any_single_deferred<std::string>{op::empty<std::string>()};
+          return mi::any_single_sender<std::string>{op::empty<std::string>()};
         }
-        return mi::any_single_deferred<std::string>{op::just(std::to_string(i))};
+        return mi::any_single_sender<std::string>{op::just(std::to_string(i))};
       }) |
       concat<std::string> |
       op::submit(println);
diff --git a/examples/set_error/set_error_2.cpp b/examples/set_error/set_error_2.cpp
index 2bfa540..e078b99 100644
--- a/examples/set_error/set_error_2.cpp
+++ b/examples/set_error/set_error_2.cpp
@@ -16,7 +16,7 @@ using namespace pushmi::aliases;
 template<class T, class E = std::exception_ptr>
 auto concat =
   [](auto in){
-    return mi::make_single_deferred(
+    return mi::make_single_sender(
       [in](auto out) mutable {
         ::pushmi::submit(in, mi::make_single(out,
         [](auto out, auto v){
@@ -63,7 +63,7 @@ int main()
 
   op::just(42) |
     op::transform([](auto v) {
-      using r_t = mi::any_single_deferred<int>;
+      using r_t = mi::any_single_sender<int>;
       if (v < 40) {
         return r_t{op::error<int>(std::exception_ptr{})};
       } else {
diff --git a/examples/then_execute/then_execute_2.cpp b/examples/then_execute/then_execute_2.cpp
index 94ce6c2..67da81c 100644
--- a/examples/then_execute/then_execute_2.cpp
+++ b/examples/then_execute/then_execute_2.cpp
@@ -13,8 +13,8 @@
 
 #include <pool.h>
 
-#include <pushmi/deferred.h>
-#include <pushmi/single_deferred.h>
+#include <pushmi/sender.h>
+#include <pushmi/single_sender.h>
 #include <pushmi/o/just.h>
 #include <pushmi/o/via.h>
 #include <pushmi/o/transform.h>
diff --git a/examples/twoway_execute/twoway_execute_2.cpp b/examples/twoway_execute/twoway_execute_2.cpp
index f1d019c..d4ee172 100644
--- a/examples/twoway_execute/twoway_execute_2.cpp
+++ b/examples/twoway_execute/twoway_execute_2.cpp
@@ -12,8 +12,8 @@
 
 #include <pool.h>
 
-#include <pushmi/deferred.h>
-#include <pushmi/single_deferred.h>
+#include <pushmi/sender.h>
+#include <pushmi/single_sender.h>
 #include <pushmi/o/transform.h>
 
 using namespace pushmi::aliases;
diff --git a/include/pushmi.h b/include/pushmi.h
index 98a652f..d6c6c99 100644
--- a/include/pushmi.h
+++ b/include/pushmi.h
@@ -1150,7 +1150,7 @@ template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
 class none;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class deferred;
+class sender;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
 class single;
@@ -1159,19 +1159,19 @@ template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
 class many;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class single_deferred;
+class single_sender;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class many_deferred;
+class many_sender;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class time_single_deferred;
+class time_single_sender;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
 class flow_single;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class flow_single_deferred;
+class flow_single_sender;
 
 template<
   class E = std::exception_ptr,
@@ -2370,19 +2370,19 @@ template<>
 struct construct_deduced<flow_single>;
 
 template<>
-struct construct_deduced<deferred>;
+struct construct_deduced<sender>;
 
 template<>
-struct construct_deduced<single_deferred>;
+struct construct_deduced<single_sender>;
 
 template<>
-struct construct_deduced<many_deferred>;
+struct construct_deduced<many_sender>;
 
 template<>
-struct construct_deduced<flow_single_deferred>;
+struct construct_deduced<flow_single_sender>;
 
 template<>
-struct construct_deduced<time_single_deferred>;
+struct construct_deduced<time_single_sender>;
 
 template <template <class...> class T, class... AN>
 using deduced_type_t = pushmi::invoke_result_t<construct_deduced<T>, AN...>;
@@ -2982,11 +2982,11 @@ std::future<void> future_from(Out out) {
 
 namespace pushmi {
 namespace detail {
-struct erase_deferred_t {};
+struct erase_sender_t {};
 } // namespace detail
 
 template <class E>
-class deferred<detail::erase_deferred_t, E> {
+class sender<detail::erase_sender_t, E> {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(std::promise<void>)]; // can hold a void promise in-situ
@@ -3005,7 +3005,7 @@ class deferred<detail::erase_deferred_t, E> {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  deferred(Wrapped obj, std::false_type) : deferred() {
+  sender(Wrapped obj, std::false_type) : sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -3021,7 +3021,7 @@ class deferred<detail::erase_deferred_t, E> {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  deferred(Wrapped obj, std::true_type) noexcept : deferred() {
+  sender(Wrapped obj, std::true_type) noexcept : sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -3040,25 +3040,25 @@ class deferred<detail::erase_deferred_t, E> {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, sender>::value, U>;
  public:
   using properties = property_set<is_sender<>, is_none<>>;
 
-  deferred() = default;
-  deferred(deferred&& that) noexcept : deferred() {
+  sender() = default;
+  sender(sender&& that) noexcept : sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
   PUSHMI_TEMPLATE(class Wrapped)
     (requires SenderTo<wrapped_t<Wrapped>, any_none<E>, is_none<>>)
-  explicit deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-    : deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
-  ~deferred() {
+  explicit sender(Wrapped obj) noexcept(insitu<Wrapped>())
+    : sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
+  ~sender() {
     vptr_->op_(data_, nullptr);
   }
-  deferred& operator=(deferred&& that) noexcept {
-    this->~deferred();
-    new ((void*)this) deferred(std::move(that));
+  sender& operator=(sender&& that) noexcept {
+    this->~sender();
+    new ((void*)this) sender(std::move(that));
     return *this;
   }
   void submit(any_none<E> out) {
@@ -3068,18 +3068,18 @@ class deferred<detail::erase_deferred_t, E> {
 
 // Class static definitions:
 template <class E>
-constexpr typename deferred<detail::erase_deferred_t, E>::vtable const
-    deferred<detail::erase_deferred_t, E>::noop_;
+constexpr typename sender<detail::erase_sender_t, E>::vtable const
+    sender<detail::erase_sender_t, E>::noop_;
 
 template <class SF>
-class deferred<SF> {
+class sender<SF> {
   SF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_none<>>;
 
-  constexpr deferred() = default;
-  constexpr explicit deferred(SF sf) : sf_(std::move(sf)) {}
+  constexpr sender() = default;
+  constexpr explicit sender(SF sf) : sf_(std::move(sf)) {}
   PUSHMI_TEMPLATE(class Out)
     (requires Receiver<Out, is_none<>> && Invocable<SF&, Out>)
   void submit(Out out) {
@@ -3088,7 +3088,7 @@ class deferred<SF> {
 };
 
 template <PUSHMI_TYPE_CONSTRAINT(Sender<is_none<>>) Data, class DSF>
-class deferred<Data, DSF> {
+class sender<Data, DSF> {
   Data data_;
   DSF sf_;
   static_assert(Sender<Data, is_none<>>, "The Data template parameter "
@@ -3097,10 +3097,10 @@ class deferred<Data, DSF> {
  public:
   using properties = property_set<is_sender<>, is_none<>>;
 
-  constexpr deferred() = default;
-  constexpr explicit deferred(Data data)
+  constexpr sender() = default;
+  constexpr explicit sender(Data data)
       : data_(std::move(data)) {}
-  constexpr deferred(Data data, DSF sf)
+  constexpr sender(Data data, DSF sf)
       : data_(std::move(data)), sf_(std::move(sf)) {}
 
   PUSHMI_TEMPLATE(class Out)
@@ -3111,60 +3111,60 @@ class deferred<Data, DSF> {
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_deferred
-PUSHMI_INLINE_VAR constexpr struct make_deferred_fn {
+// make_sender
+PUSHMI_INLINE_VAR constexpr struct make_sender_fn {
   inline auto operator()() const {
-    return deferred<ignoreSF>{};
+    return sender<ignoreSF>{};
   }
   template <class SF>
   auto operator()(SF sf) const {
-    return deferred<SF>{std::move(sf)};
+    return sender<SF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE(class Wrapped)
     (requires Sender<Wrapped, is_none<>>)
   auto operator()(Wrapped w) const {
-    return deferred<detail::erase_deferred_t, std::exception_ptr>{std::move(w)};
+    return sender<detail::erase_sender_t, std::exception_ptr>{std::move(w)};
   }
   PUSHMI_TEMPLATE(class Data, class DSF)
     (requires Sender<Data, is_none<>>)
   auto operator()(Data data, DSF sf) const {
-    return deferred<Data, DSF>{std::move(data), std::move(sf)};
+    return sender<Data, DSF>{std::move(data), std::move(sf)};
   }
-} const make_deferred {};
+} const make_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-deferred() -> deferred<ignoreSF>;
+sender() -> sender<ignoreSF>;
 
 template <class SF>
-deferred(SF) -> deferred<SF>;
+sender(SF) -> sender<SF>;
 
 PUSHMI_TEMPLATE(class Wrapped)
   (requires Sender<Wrapped, is_none<>>)
-deferred(Wrapped) ->
-    deferred<detail::erase_deferred_t, std::exception_ptr>;
+sender(Wrapped) ->
+    sender<detail::erase_sender_t, std::exception_ptr>;
 
 PUSHMI_TEMPLATE(class Data, class DSF)
   (requires Sender<Data, is_none<>>)
-deferred(Data, DSF) -> deferred<Data, DSF>;
+sender(Data, DSF) -> sender<Data, DSF>;
 #endif
 
 template <class E = std::exception_ptr>
-using any_deferred = deferred<detail::erase_deferred_t, E>;
+using any_sender = sender<detail::erase_sender_t, E>;
 
 template<>
-struct construct_deduced<deferred> : make_deferred_fn {};
+struct construct_deduced<sender> : make_sender_fn {};
 
 // template <SenderTo<any_none<std::exception_ptr>, is_none<>> Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return deferred<detail::erase_deferred_t, std::exception_ptr>{std::move(w)};
+//   return sender<detail::erase_sender_t, std::exception_ptr>{std::move(w)};
 // }
 //
 // template <class E, SenderTo<any_none<E>, is_none<>> Wrapped>
 //   requires Same<is_none<>, properties_t<Wrapped>>
 // auto erase_cast(Wrapped w) {
-//   return deferred<detail::erase_deferred_t, E>{std::move(w)};
+//   return sender<detail::erase_sender_t, E>{std::move(w)};
 // }
 
 } // namespace pushmi
@@ -3609,7 +3609,7 @@ std::future<T> future_from(Out singleSender) {
 namespace pushmi {
 
 template <class V, class E = std::exception_ptr>
-class any_single_deferred {
+class any_single_sender {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(V)]; // can hold a V in-situ
@@ -3628,7 +3628,7 @@ class any_single_deferred {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  any_single_deferred(Wrapped obj, std::false_type) : any_single_deferred() {
+  any_single_sender(Wrapped obj, std::false_type) : any_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -3644,8 +3644,8 @@ class any_single_deferred {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  any_single_deferred(Wrapped obj, std::true_type) noexcept
-      : any_single_deferred() {
+  any_single_sender(Wrapped obj, std::true_type) noexcept
+      : any_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -3664,27 +3664,27 @@ class any_single_deferred {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, any_single_deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, any_single_sender>::value, U>;
  public:
   using properties = property_set<is_sender<>, is_single<>>;
 
-  any_single_deferred() = default;
-  any_single_deferred(any_single_deferred&& that) noexcept
-      : any_single_deferred() {
+  any_single_sender() = default;
+  any_single_sender(any_single_sender&& that) noexcept
+      : any_single_sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
 
   PUSHMI_TEMPLATE(class Wrapped)
     (requires SenderTo<wrapped_t<Wrapped>, single<V, E>, is_single<>>)
-  explicit any_single_deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-    : any_single_deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
-  ~any_single_deferred() {
+  explicit any_single_sender(Wrapped obj) noexcept(insitu<Wrapped>())
+    : any_single_sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
+  ~any_single_sender() {
     vptr_->op_(data_, nullptr);
   }
-  any_single_deferred& operator=(any_single_deferred&& that) noexcept {
-    this->~any_single_deferred();
-    new ((void*)this) any_single_deferred(std::move(that));
+  any_single_sender& operator=(any_single_sender&& that) noexcept {
+    this->~any_single_sender();
+    new ((void*)this) any_single_sender(std::move(that));
     return *this;
   }
   void submit(single<V, E> out) {
@@ -3694,18 +3694,18 @@ class any_single_deferred {
 
 // Class static definitions:
 template <class V, class E>
-constexpr typename any_single_deferred<V, E>::vtable const
-  any_single_deferred<V, E>::noop_;
+constexpr typename any_single_sender<V, E>::vtable const
+  any_single_sender<V, E>::noop_;
 
 template <class SF>
-class single_deferred<SF> {
+class single_sender<SF> {
   SF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_single<>>;
 
-  constexpr single_deferred() = default;
-  constexpr explicit single_deferred(SF sf)
+  constexpr single_sender() = default;
+  constexpr explicit single_sender(SF sf)
       : sf_(std::move(sf)) {}
 
   PUSHMI_TEMPLATE(class Out)
@@ -3717,17 +3717,17 @@ class single_deferred<SF> {
 
 namespace detail {
 template <PUSHMI_TYPE_CONSTRAINT(Sender<is_single<>>) Data, class DSF>
-class single_deferred_2 {
+class single_sender_2 {
   Data data_;
   DSF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_single<>>;
 
-  constexpr single_deferred_2() = default;
-  constexpr explicit single_deferred_2(Data data)
+  constexpr single_sender_2() = default;
+  constexpr explicit single_sender_2(Data data)
       : data_(std::move(data)) {}
-  constexpr single_deferred_2(Data data, DSF sf)
+  constexpr single_sender_2(Data data, DSF sf)
       : data_(std::move(data)), sf_(std::move(sf)) {}
   PUSHMI_TEMPLATE(class Out)
     (requires PUSHMI_EXP(lazy::Receiver<Out, is_single<>> PUSHMI_AND
@@ -3738,70 +3738,70 @@ class single_deferred_2 {
 };
 
 template <class A, class B>
-using single_deferred_base =
+using single_sender_base =
   std::conditional_t<
     (bool)Sender<A, is_single<>>,
-    single_deferred_2<A, B>,
-    any_single_deferred<A, B>>;
+    single_sender_2<A, B>,
+    any_single_sender<A, B>>;
 } // namespace detail
 
 template <class A, class B>
-struct single_deferred<A, B>
-  : detail::single_deferred_base<A, B> {
-  constexpr single_deferred() = default;
-  using detail::single_deferred_base<A, B>::single_deferred_base;
+struct single_sender<A, B>
+  : detail::single_sender_base<A, B> {
+  constexpr single_sender() = default;
+  using detail::single_sender_base<A, B>::single_sender_base;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_single_deferred
-PUSHMI_INLINE_VAR constexpr struct make_single_deferred_fn {
+// make_single_sender
+PUSHMI_INLINE_VAR constexpr struct make_single_sender_fn {
   inline auto operator()() const {
-    return single_deferred<ignoreSF>{};
+    return single_sender<ignoreSF>{};
   }
   PUSHMI_TEMPLATE(class SF)
     (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
   auto operator()(SF sf) const {
-    return single_deferred<SF>{std::move(sf)};
+    return single_sender<SF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE(class Data)
     (requires True<> && Sender<Data, is_single<>>)
   auto operator()(Data d) const {
-    return single_deferred<Data, passDSF>{std::move(d)};
+    return single_sender<Data, passDSF>{std::move(d)};
   }
   PUSHMI_TEMPLATE(class Data, class DSF)
     (requires Sender<Data, is_single<>>)
   auto operator()(Data d, DSF sf) const {
-    return single_deferred<Data, DSF>{std::move(d), std::move(sf)};
+    return single_sender<Data, DSF>{std::move(d), std::move(sf)};
   }
-} const make_single_deferred {};
+} const make_single_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-single_deferred() -> single_deferred<ignoreSF>;
+single_sender() -> single_sender<ignoreSF>;
 
 PUSHMI_TEMPLATE(class SF)
   (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
-single_deferred(SF) -> single_deferred<SF>;
+single_sender(SF) -> single_sender<SF>;
 
 PUSHMI_TEMPLATE(class Data)
   (requires True<> && Sender<Data, is_single<>>)
-single_deferred(Data) -> single_deferred<Data, passDSF>;
+single_sender(Data) -> single_sender<Data, passDSF>;
 
 PUSHMI_TEMPLATE(class Data, class DSF)
   (requires Sender<Data, is_single<>>)
-single_deferred(Data, DSF) -> single_deferred<Data, DSF>;
+single_sender(Data, DSF) -> single_sender<Data, DSF>;
 #endif
 
 template<>
-struct construct_deduced<single_deferred> : make_single_deferred_fn {};
+struct construct_deduced<single_sender> : make_single_sender_fn {};
 
 // template <
 //     class V,
 //     class E = std::exception_ptr,
 //     SenderTo<single<V, E>, is_single<>> Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return single_deferred<V, E>{std::move(w)};
+//   return single_sender<V, E>{std::move(w)};
 // }
 
 } // namespace pushmi
@@ -3819,7 +3819,7 @@ template <
     class V,
     class E = std::exception_ptr,
     class TP = std::chrono::system_clock::time_point>
-class any_time_single_deferred {
+class any_time_single_sender {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(std::promise<int>)]; // can hold a V in-situ
@@ -3840,8 +3840,8 @@ class any_time_single_deferred {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  any_time_single_deferred(Wrapped obj, std::false_type)
-    : any_time_single_deferred() {
+  any_time_single_sender(Wrapped obj, std::false_type)
+    : any_time_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -3863,8 +3863,8 @@ class any_time_single_deferred {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  any_time_single_deferred(Wrapped obj, std::true_type) noexcept
-    : any_time_single_deferred() {
+  any_time_single_sender(Wrapped obj, std::true_type) noexcept
+    : any_time_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -3888,28 +3888,28 @@ class any_time_single_deferred {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, any_time_single_deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, any_time_single_sender>::value, U>;
 
  public:
   using properties = property_set<is_time<>, is_single<>>;
 
-  any_time_single_deferred() = default;
-  any_time_single_deferred(any_time_single_deferred&& that) noexcept
-      : any_time_single_deferred() {
+  any_time_single_sender() = default;
+  any_time_single_sender(any_time_single_sender&& that) noexcept
+      : any_time_single_sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
   PUSHMI_TEMPLATE (class Wrapped)
     (requires TimeSenderTo<wrapped_t<Wrapped>, single<V, E>>)
-  explicit any_time_single_deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-  : any_time_single_deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {
+  explicit any_time_single_sender(Wrapped obj) noexcept(insitu<Wrapped>())
+  : any_time_single_sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {
   }
-  ~any_time_single_deferred() {
+  ~any_time_single_sender() {
     vptr_->op_(data_, nullptr);
   }
-  any_time_single_deferred& operator=(any_time_single_deferred&& that) noexcept {
-    this->~any_time_single_deferred();
-    new ((void*)this) any_time_single_deferred(std::move(that));
+  any_time_single_sender& operator=(any_time_single_sender&& that) noexcept {
+    this->~any_time_single_sender();
+    new ((void*)this) any_time_single_sender(std::move(that));
     return *this;
   }
   TP now() {
@@ -3922,24 +3922,24 @@ class any_time_single_deferred {
 
 // Class static definitions:
 template <class V, class E, class TP>
-constexpr typename any_time_single_deferred<V, E, TP>::vtable const
-    any_time_single_deferred<V, E, TP>::noop_;
+constexpr typename any_time_single_sender<V, E, TP>::vtable const
+    any_time_single_sender<V, E, TP>::noop_;
 
 template <class SF, class NF>
 #if __cpp_concepts
   requires Invocable<NF&>
 #endif
-class time_single_deferred<SF, NF> {
+class time_single_sender<SF, NF> {
   SF sf_;
   NF nf_;
 
  public:
   using properties = property_set<is_time<>, is_single<>>;
 
-  constexpr time_single_deferred() = default;
-  constexpr explicit time_single_deferred(SF sf)
+  constexpr time_single_sender() = default;
+  constexpr explicit time_single_sender(SF sf)
       : sf_(std::move(sf)) {}
-  constexpr time_single_deferred(SF sf, NF nf)
+  constexpr time_single_sender(SF sf, NF nf)
       : sf_(std::move(sf)), nf_(std::move(nf)) {}
   auto now() {
     return nf_();
@@ -3957,7 +3957,7 @@ template <PUSHMI_TYPE_CONSTRAINT(TimeSender<is_single<>>) Data, class DSF, class
 #if __cpp_concepts
   requires Invocable<DNF&, Data&>
 #endif
-class time_single_deferred_2 {
+class time_single_sender_2 {
   Data data_;
   DSF sf_;
   DNF nf_;
@@ -3965,10 +3965,10 @@ class time_single_deferred_2 {
  public:
   using properties = property_set<is_time<>, is_single<>>;
 
-  constexpr time_single_deferred_2() = default;
-  constexpr explicit time_single_deferred_2(Data data)
+  constexpr time_single_sender_2() = default;
+  constexpr explicit time_single_sender_2(Data data)
       : data_(std::move(data)) {}
-  constexpr time_single_deferred_2(Data data, DSF sf, DNF nf = DNF{})
+  constexpr time_single_sender_2(Data data, DSF sf, DNF nf = DNF{})
       : data_(std::move(data)), sf_(std::move(sf)), nf_(std::move(nf)) {}
   auto now() {
     return nf_(data_);
@@ -3982,72 +3982,72 @@ class time_single_deferred_2 {
 };
 
 template <class A, class B, class C>
-using time_single_deferred_base =
+using time_single_sender_base =
   std::conditional_t<
     (bool)TimeSender<A, is_single<>>,
-    time_single_deferred_2<A, B, C>,
-    any_time_single_deferred<A, B, C>>;
+    time_single_sender_2<A, B, C>,
+    any_time_single_sender<A, B, C>>;
 } // namespace detail
 
 template <class A, class B, class C>
-struct time_single_deferred<A, B, C>
-  : detail::time_single_deferred_base<A, B, C> {
-  constexpr time_single_deferred() = default;
-  using detail::time_single_deferred_base<A, B, C>::time_single_deferred_base;
+struct time_single_sender<A, B, C>
+  : detail::time_single_sender_base<A, B, C> {
+  constexpr time_single_sender() = default;
+  using detail::time_single_sender_base<A, B, C>::time_single_sender_base;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_time_single_deferred
-PUSHMI_INLINE_VAR constexpr struct make_time_single_deferred_fn {
+// make_time_single_sender
+PUSHMI_INLINE_VAR constexpr struct make_time_single_sender_fn {
   inline auto operator()() const  {
-    return time_single_deferred<ignoreSF, systemNowF>{};
+    return time_single_sender<ignoreSF, systemNowF>{};
   }
   template <class SF>
   auto operator()(SF sf) const {
-    return time_single_deferred<SF, systemNowF>{std::move(sf)};
+    return time_single_sender<SF, systemNowF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE (class SF, class NF)
     (requires Invocable<NF&>)
   auto operator()(SF sf, NF nf) const {
-    return time_single_deferred<SF, NF>{std::move(sf), std::move(nf)};
+    return time_single_sender<SF, NF>{std::move(sf), std::move(nf)};
   }
   PUSHMI_TEMPLATE (class Data, class DSF)
     (requires TimeSender<Data, is_single<>>)
   auto operator()(Data d, DSF sf) const {
-    return time_single_deferred<Data, DSF, passDNF>{std::move(d), std::move(sf)};
+    return time_single_sender<Data, DSF, passDNF>{std::move(d), std::move(sf)};
   }
   PUSHMI_TEMPLATE (class Data, class DSF, class DNF)
     (requires TimeSender<Data, is_single<>> && Invocable<DNF&, Data&>)
   auto operator()(Data d, DSF sf, DNF nf) const  {
-    return time_single_deferred<Data, DSF, DNF>{std::move(d), std::move(sf),
+    return time_single_sender<Data, DSF, DNF>{std::move(d), std::move(sf),
       std::move(nf)};
   }
-} const make_time_single_deferred {};
+} const make_time_single_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-time_single_deferred() -> time_single_deferred<ignoreSF, systemNowF>;
+time_single_sender() -> time_single_sender<ignoreSF, systemNowF>;
 
 template <class SF>
-time_single_deferred(SF) -> time_single_deferred<SF, systemNowF>;
+time_single_sender(SF) -> time_single_sender<SF, systemNowF>;
 
 PUSHMI_TEMPLATE (class SF, class NF)
   (requires Invocable<NF&>)
-time_single_deferred(SF, NF) -> time_single_deferred<SF, NF>;
+time_single_sender(SF, NF) -> time_single_sender<SF, NF>;
 
 PUSHMI_TEMPLATE (class Data, class DSF)
   (requires TimeSender<Data, is_single<>>)
-time_single_deferred(Data, DSF) -> time_single_deferred<Data, DSF, passDNF>;
+time_single_sender(Data, DSF) -> time_single_sender<Data, DSF, passDNF>;
 
 PUSHMI_TEMPLATE (class Data, class DSF, class DNF)
   (requires TimeSender<Data, is_single<>> && Invocable<DNF&, Data&>)
-time_single_deferred(Data, DSF, DNF) -> time_single_deferred<Data, DSF, DNF>;
+time_single_sender(Data, DSF, DNF) -> time_single_sender<Data, DSF, DNF>;
 #endif
 
 template<>
-struct construct_deduced<time_single_deferred>
-  : make_time_single_deferred_fn {};
+struct construct_deduced<time_single_sender>
+  : make_time_single_sender_fn {};
 
 // template <
 //     class V,
@@ -4055,7 +4055,7 @@ struct construct_deduced<time_single_deferred>
 //     class TP = std::chrono::system_clock::time_point,
 //     TimeSenderTo<single<V, E>, is_single<>> Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return time_single_deferred<V, E>{std::move(w)};
+//   return time_single_sender<V, E>{std::move(w)};
 // }
 
 } // namespace pushmi
@@ -4067,7 +4067,7 @@ struct construct_deduced<time_single_deferred>
 
 //#include <chrono>
 //#include <functional>
-//#include "time_single_deferred.h"
+//#include "time_single_sender.h"
 
 namespace pushmi {
 namespace detail {
@@ -4174,7 +4174,7 @@ any_time_executor_ref(Wrapped&) ->
 namespace detail {
 template<class E, class TP>
 using any_time_executor_base =
-  any_time_single_deferred<any_time_executor_ref<E, TP>, E, TP>;
+  any_time_single_sender<any_time_executor_ref<E, TP>, E, TP>;
 
 template<class T, class E, class TP>
 using not_any_time_executor =
@@ -4697,7 +4697,7 @@ struct construct_deduced<flow_single> : make_flow_single_fn {};
 namespace pushmi {
 
 template <class V, class PE, class E>
-class flow_single_deferred<V, PE, E> {
+class flow_single_sender<V, PE, E> {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(V)]; // can hold a V in-situ
@@ -4716,7 +4716,7 @@ class flow_single_deferred<V, PE, E> {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  flow_single_deferred(Wrapped obj, std::false_type) : flow_single_deferred() {
+  flow_single_sender(Wrapped obj, std::false_type) : flow_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -4732,8 +4732,8 @@ class flow_single_deferred<V, PE, E> {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  flow_single_deferred(Wrapped obj, std::true_type) noexcept
-    : flow_single_deferred() {
+  flow_single_sender(Wrapped obj, std::true_type) noexcept
+    : flow_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -4753,26 +4753,26 @@ class flow_single_deferred<V, PE, E> {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, flow_single_deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, flow_single_sender>::value, U>;
  public:
   using properties = property_set<is_sender<>, is_flow<>, is_single<>>;
 
-  flow_single_deferred() = default;
-  flow_single_deferred(flow_single_deferred&& that) noexcept
-      : flow_single_deferred() {
+  flow_single_sender() = default;
+  flow_single_sender(flow_single_sender&& that) noexcept
+      : flow_single_sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
   PUSHMI_TEMPLATE (class Wrapped)
     (requires FlowSender<wrapped_t<Wrapped>, is_single<>>)
-  explicit flow_single_deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-    : flow_single_deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
-  ~flow_single_deferred() {
+  explicit flow_single_sender(Wrapped obj) noexcept(insitu<Wrapped>())
+    : flow_single_sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
+  ~flow_single_sender() {
     vptr_->op_(data_, nullptr);
   }
-  flow_single_deferred& operator=(flow_single_deferred&& that) noexcept {
-    this->~flow_single_deferred();
-    new ((void*)this) flow_single_deferred(std::move(that));
+  flow_single_sender& operator=(flow_single_sender&& that) noexcept {
+    this->~flow_single_sender();
+    new ((void*)this) flow_single_sender(std::move(that));
     return *this;
   }
   void submit(flow_single<V, PE, E> out) {
@@ -4782,18 +4782,18 @@ class flow_single_deferred<V, PE, E> {
 
 // Class static definitions:
 template <class V, class PE, class E>
-constexpr typename flow_single_deferred<V, PE, E>::vtable const
-    flow_single_deferred<V, PE, E>::noop_;
+constexpr typename flow_single_sender<V, PE, E>::vtable const
+    flow_single_sender<V, PE, E>::noop_;
 
 template <class SF>
-class flow_single_deferred<SF> {
+class flow_single_sender<SF> {
   SF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_flow<>, is_single<>>;
 
-  constexpr flow_single_deferred() = default;
-  constexpr explicit flow_single_deferred(SF sf)
+  constexpr flow_single_sender() = default;
+  constexpr explicit flow_single_sender(SF sf)
       : sf_(std::move(sf)) {}
 
   PUSHMI_TEMPLATE(class Out)
@@ -4804,17 +4804,17 @@ class flow_single_deferred<SF> {
 };
 
 template <PUSHMI_TYPE_CONSTRAINT(Sender<is_single<>, is_flow<>>) Data, class DSF>
-class flow_single_deferred<Data, DSF> {
+class flow_single_sender<Data, DSF> {
   Data data_;
   DSF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_single<>>;
 
-  constexpr flow_single_deferred() = default;
-  constexpr explicit flow_single_deferred(Data data)
+  constexpr flow_single_sender() = default;
+  constexpr explicit flow_single_sender(Data data)
       : data_(std::move(data)) {}
-  constexpr flow_single_deferred(Data data, DSF sf)
+  constexpr flow_single_sender(Data data, DSF sf)
       : data_(std::move(data)), sf_(std::move(sf)) {}
   PUSHMI_TEMPLATE(class Out)
     (requires PUSHMI_EXP(lazy::Receiver<Out, is_single<>, is_flow<>> PUSHMI_AND
@@ -4825,57 +4825,57 @@ class flow_single_deferred<Data, DSF> {
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_flow_single_deferred
-PUSHMI_INLINE_VAR constexpr struct make_flow_single_deferred_fn {
+// make_flow_single_sender
+PUSHMI_INLINE_VAR constexpr struct make_flow_single_sender_fn {
   inline auto operator()() const {
-    return flow_single_deferred<ignoreSF>{};
+    return flow_single_sender<ignoreSF>{};
   }
   PUSHMI_TEMPLATE(class SF)
     (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
   auto operator()(SF sf) const {
-    return flow_single_deferred<SF>{std::move(sf)};
+    return flow_single_sender<SF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE(class Data)
     (requires True<> && Sender<Data, is_single<>, is_flow<>>)
   auto operator()(Data d) const {
-    return flow_single_deferred<Data, passDSF>{std::move(d)};
+    return flow_single_sender<Data, passDSF>{std::move(d)};
   }
   PUSHMI_TEMPLATE(class Data, class DSF)
     (requires Sender<Data, is_single<>, is_flow<>>)
   auto operator()(Data d, DSF sf) const {
-    return flow_single_deferred<Data, DSF>{std::move(d), std::move(sf)};
+    return flow_single_sender<Data, DSF>{std::move(d), std::move(sf)};
   }
-} const make_flow_single_deferred {};
+} const make_flow_single_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-flow_single_deferred() -> flow_single_deferred<ignoreSF>;
+flow_single_sender() -> flow_single_sender<ignoreSF>;
 
 PUSHMI_TEMPLATE(class SF)
   (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
-flow_single_deferred(SF) -> flow_single_deferred<SF>;
+flow_single_sender(SF) -> flow_single_sender<SF>;
 
 PUSHMI_TEMPLATE(class Data)
   (requires True<> && Sender<Data, is_single<>, is_flow<>>)
-flow_single_deferred(Data) -> flow_single_deferred<Data, passDSF>;
+flow_single_sender(Data) -> flow_single_sender<Data, passDSF>;
 
 PUSHMI_TEMPLATE(class Data, class DSF)
   (requires Sender<Data, is_single<>, is_flow<>>)
-flow_single_deferred(Data, DSF) -> flow_single_deferred<Data, DSF>;
+flow_single_sender(Data, DSF) -> flow_single_sender<Data, DSF>;
 #endif
 
 template <class V, class PE = std::exception_ptr, class E = PE>
-using any_flow_single_deferred = flow_single_deferred<V, PE, E>;
+using any_flow_single_sender = flow_single_sender<V, PE, E>;
 
 template<>
-struct construct_deduced<flow_single_deferred>
-  : make_flow_single_deferred_fn {};
+struct construct_deduced<flow_single_sender>
+  : make_flow_single_sender_fn {};
 
 // // TODO constrain me
 // template <class V, class E = std::exception_ptr, Sender Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return flow_single_deferred<V, E>{std::move(w)};
+//   return flow_single_sender<V, E>{std::move(w)};
 // }
 
 } // namespace pushmi
@@ -5307,7 +5307,7 @@ struct construct_deduced<many> : make_many_fn {};
 namespace pushmi {
 
 template <class V, class E = std::exception_ptr>
-class any_many_deferred {
+class any_many_sender {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(V)]; // can hold a V in-situ
@@ -5326,7 +5326,7 @@ class any_many_deferred {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  any_many_deferred(Wrapped obj, std::false_type) : any_many_deferred() {
+  any_many_sender(Wrapped obj, std::false_type) : any_many_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -5342,8 +5342,8 @@ class any_many_deferred {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  any_many_deferred(Wrapped obj, std::true_type) noexcept
-      : any_many_deferred() {
+  any_many_sender(Wrapped obj, std::true_type) noexcept
+      : any_many_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -5362,27 +5362,27 @@ class any_many_deferred {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, any_many_deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, any_many_sender>::value, U>;
  public:
   using properties = property_set<is_sender<>, is_many<>>;
 
-  any_many_deferred() = default;
-  any_many_deferred(any_many_deferred&& that) noexcept
-      : any_many_deferred() {
+  any_many_sender() = default;
+  any_many_sender(any_many_sender&& that) noexcept
+      : any_many_sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
 
   PUSHMI_TEMPLATE(class Wrapped)
     (requires SenderTo<wrapped_t<Wrapped>, many<V, E>, is_many<>>)
-  explicit any_many_deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-    : any_many_deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
-  ~any_many_deferred() {
+  explicit any_many_sender(Wrapped obj) noexcept(insitu<Wrapped>())
+    : any_many_sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
+  ~any_many_sender() {
     vptr_->op_(data_, nullptr);
   }
-  any_many_deferred& operator=(any_many_deferred&& that) noexcept {
-    this->~any_many_deferred();
-    new ((void*)this) any_many_deferred(std::move(that));
+  any_many_sender& operator=(any_many_sender&& that) noexcept {
+    this->~any_many_sender();
+    new ((void*)this) any_many_sender(std::move(that));
     return *this;
   }
   void submit(many<V, E> out) {
@@ -5392,18 +5392,18 @@ class any_many_deferred {
 
 // Class static definitions:
 template <class V, class E>
-constexpr typename any_many_deferred<V, E>::vtable const
-  any_many_deferred<V, E>::noop_;
+constexpr typename any_many_sender<V, E>::vtable const
+  any_many_sender<V, E>::noop_;
 
 template <class SF>
-class many_deferred<SF> {
+class many_sender<SF> {
   SF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_many<>>;
 
-  constexpr many_deferred() = default;
-  constexpr explicit many_deferred(SF sf)
+  constexpr many_sender() = default;
+  constexpr explicit many_sender(SF sf)
       : sf_(std::move(sf)) {}
 
   PUSHMI_TEMPLATE(class Out)
@@ -5415,17 +5415,17 @@ class many_deferred<SF> {
 
 namespace detail {
 template <PUSHMI_TYPE_CONSTRAINT(Sender<is_many<>>) Data, class DSF>
-class many_deferred_2 {
+class many_sender_2 {
   Data data_;
   DSF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_many<>>;
 
-  constexpr many_deferred_2() = default;
-  constexpr explicit many_deferred_2(Data data)
+  constexpr many_sender_2() = default;
+  constexpr explicit many_sender_2(Data data)
       : data_(std::move(data)) {}
-  constexpr many_deferred_2(Data data, DSF sf)
+  constexpr many_sender_2(Data data, DSF sf)
       : data_(std::move(data)), sf_(std::move(sf)) {}
   PUSHMI_TEMPLATE(class Out)
     (requires PUSHMI_EXP(lazy::Receiver<Out, is_many<>> PUSHMI_AND
@@ -5436,70 +5436,70 @@ class many_deferred_2 {
 };
 
 template <class A, class B>
-using many_deferred_base =
+using many_sender_base =
   std::conditional_t<
     (bool)Sender<A, is_many<>>,
-    many_deferred_2<A, B>,
-    any_many_deferred<A, B>>;
+    many_sender_2<A, B>,
+    any_many_sender<A, B>>;
 } // namespace detail
 
 template <class A, class B>
-struct many_deferred<A, B>
-  : detail::many_deferred_base<A, B> {
-  constexpr many_deferred() = default;
-  using detail::many_deferred_base<A, B>::many_deferred_base;
+struct many_sender<A, B>
+  : detail::many_sender_base<A, B> {
+  constexpr many_sender() = default;
+  using detail::many_sender_base<A, B>::many_sender_base;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_many_deferred
-PUSHMI_INLINE_VAR constexpr struct make_many_deferred_fn {
+// make_many_sender
+PUSHMI_INLINE_VAR constexpr struct make_many_sender_fn {
   inline auto operator()() const {
-    return many_deferred<ignoreSF>{};
+    return many_sender<ignoreSF>{};
   }
   PUSHMI_TEMPLATE(class SF)
     (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
   auto operator()(SF sf) const {
-    return many_deferred<SF>{std::move(sf)};
+    return many_sender<SF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE(class Data)
     (requires True<> && Sender<Data, is_many<>>)
   auto operator()(Data d) const {
-    return many_deferred<Data, passDSF>{std::move(d)};
+    return many_sender<Data, passDSF>{std::move(d)};
   }
   PUSHMI_TEMPLATE(class Data, class DSF)
     (requires Sender<Data, is_many<>>)
   auto operator()(Data d, DSF sf) const {
-    return many_deferred<Data, DSF>{std::move(d), std::move(sf)};
+    return many_sender<Data, DSF>{std::move(d), std::move(sf)};
   }
-} const make_many_deferred {};
+} const make_many_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-many_deferred() -> many_deferred<ignoreSF>;
+many_sender() -> many_sender<ignoreSF>;
 
 PUSHMI_TEMPLATE(class SF)
   (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
-many_deferred(SF) -> many_deferred<SF>;
+many_sender(SF) -> many_sender<SF>;
 
 PUSHMI_TEMPLATE(class Data)
   (requires True<> && Sender<Data, is_many<>>)
-many_deferred(Data) -> many_deferred<Data, passDSF>;
+many_sender(Data) -> many_sender<Data, passDSF>;
 
 PUSHMI_TEMPLATE(class Data, class DSF)
   (requires Sender<Data, is_many<>>)
-many_deferred(Data, DSF) -> many_deferred<Data, DSF>;
+many_sender(Data, DSF) -> many_sender<Data, DSF>;
 #endif
 
 template<>
-struct construct_deduced<many_deferred> : make_many_deferred_fn {};
+struct construct_deduced<many_sender> : make_many_sender_fn {};
 
 // template <
 //     class V,
 //     class E = std::exception_ptr,
 //     SenderTo<many<V, E>, is_many<>> Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return many_deferred<V, E>{std::move(w)};
+//   return many_sender<V, E>{std::move(w)};
 // }
 
 } // namespace pushmi
@@ -5514,7 +5514,7 @@ struct construct_deduced<many_deferred> : make_many_deferred_fn {};
 //#include <deque>
 //#include <thread>
 //#include "executor.h"
-//#include "time_single_deferred.h"
+//#include "time_single_sender.h"
 
 namespace pushmi {
 
@@ -5809,7 +5809,7 @@ struct __new_thread_submit {
 };
 
 inline auto new_thread() {
-  return make_time_single_deferred(__new_thread_submit{});
+  return make_time_single_sender(__new_thread_submit{});
 }
 
 }
@@ -5825,13 +5825,13 @@ inline auto new_thread() {
 //#include "../piping.h"
 //#include "../boosters.h"
 //#include "../single.h"
-//#include "../deferred.h"
-//#include "../single_deferred.h"
+//#include "../sender.h"
+//#include "../single_sender.h"
 //#include "../many.h"
-//#include "../many_deferred.h"
-//#include "../time_single_deferred.h"
+//#include "../many_sender.h"
+//#include "../time_single_sender.h"
 //#include "../flow_single.h"
-//#include "../flow_single_deferred.h"
+//#include "../flow_single_sender.h"
 //#include "../detail/if_constexpr.h"
 //#include "../detail/functional.h"
 
@@ -5969,17 +5969,17 @@ auto submit_transform_out(SDSF, TSDSF tsdsf) {
 template <class Cardinality, bool IsTime = false, bool IsFlow = false>
 struct make_sender;
 template <>
-struct make_sender<is_none<>> : construct_deduced<deferred> {};
+struct make_sender<is_none<>> : construct_deduced<sender> {};
 template <>
-struct make_sender<is_single<>> : construct_deduced<single_deferred> {};
+struct make_sender<is_single<>> : construct_deduced<single_sender> {};
 template <>
-struct make_sender<is_many<>> : construct_deduced<many_deferred> {};
+struct make_sender<is_many<>> : construct_deduced<many_sender> {};
 template <>
-struct make_sender<is_single<>, false, true> : construct_deduced<flow_single_deferred> {};
+struct make_sender<is_single<>, false, true> : construct_deduced<flow_single_sender> {};
 template <>
-struct make_sender<is_single<>, true, false> : construct_deduced<time_single_deferred> {};
+struct make_sender<is_single<>, true, false> : construct_deduced<time_single_sender> {};
 
-PUSHMI_INLINE_VAR constexpr struct deferred_from_fn {
+PUSHMI_INLINE_VAR constexpr struct sender_from_fn {
   PUSHMI_TEMPLATE(class In, class... FN)
     (requires Sender<In>)
   auto operator()(In in, FN&&... fn) const {
@@ -5990,7 +5990,7 @@ PUSHMI_INLINE_VAR constexpr struct deferred_from_fn {
             property_query_v<properties_t<In>, is_flow<>>>;
     return MakeSender{}(std::move(in), (FN&&) fn...);
   }
-} const deferred_from {};
+} const sender_from {};
 
 PUSHMI_TEMPLATE(
     class In,
@@ -5999,7 +5999,7 @@ PUSHMI_TEMPLATE(
     bool SingleSenderRequires,
     bool TimeSingleSenderRequires)
   (requires Sender<In> && Receiver<Out>)
-constexpr bool deferred_requires_from() {
+constexpr bool sender_requires_from() {
   PUSHMI_IF_CONSTEXPR_RETURN( ((bool) TimeSenderTo<In, Out, is_single<>>) (
     return TimeSingleSenderRequires;
   ) else (
@@ -6177,7 +6177,7 @@ PUSHMI_INLINE_VAR constexpr detail::now_fn top{};
 // LICENSE file in the root directory of this source tree.
 
 //#include <functional>
-//#include "../time_single_deferred.h"
+//#include "../time_single_sender.h"
 //#include "../boosters.h"
 //#include "extension_operators.h"
 //#include "../trampoline.h"
@@ -6435,7 +6435,7 @@ PUSHMI_INLINE_VAR constexpr detail::get_fn<T> get{};
 
 //#include <vector>
 
-//#include <pushmi/time_single_deferred.h>
+//#include <pushmi/time_single_sender.h>
 
 namespace pushmi {
 
@@ -6486,7 +6486,7 @@ struct subject<T, PS> {
     }
   };
 
-  // need a template overload of none/deferred and the rest that stores a 'ptr' with its own lifetime management
+  // need a template overload of none/sender and the rest that stores a 'ptr' with its own lifetime management
   struct subject_receiver {
 
     using properties = property_set_insert_t<property_set<is_receiver<>, is_single<>>, PS>;
@@ -6521,6 +6521,665 @@ struct subject<T, PS> {
   }
 };
 
+} // namespace pushmi
+//#pragma once
+// Copyright (c) 2018-present, Facebook, Inc.
+//
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+//#include "../piping.h"
+//#include "../executor.h"
+//#include "../new_thread.h"
+//#include "extension_operators.h"
+
+namespace pushmi {
+namespace detail {
+  using new_thread_t = decltype(new_thread());
+
+  template<class ValueType_, class ExecutorType_>
+  struct NewThreadAsyncToken {
+  public:
+    using ValueType = ValueType_;
+    using ExecutorType = ExecutorType_;
+    struct Data {
+      ValueType v_;
+      std::condition_variable cv_;
+      std::mutex cvm_;
+      bool flag_ = false;
+    };
+    NewThreadAsyncToken(ExecutorType e) :
+      e_{std::move(e)}, dataPtr_{std::make_shared<Data>()} {}
+
+    ExecutorType e_;
+    std::shared_ptr<Data> dataPtr_;
+  };
+
+  template<class ValueType_, class ExecutorType_>
+  struct InlineAsyncToken {
+  public:
+    using ValueType = ValueType_;
+    using ExecutorType = ExecutorType_;
+
+    InlineAsyncToken(ExecutorType e) :
+      e_{std::move(e)} {}
+
+    ExecutorType e_;
+    ValueType value_;
+  };
+
+  template<class Executor, class Out>
+  struct async_fork_fn_data : public Out {
+    using out_t = Out;
+    Executor exec;
+
+    async_fork_fn_data(Out out, Executor exec) :
+      Out(std::move(out)), exec(std::move(exec)) {}
+  };
+
+  template<class Out, class Executor>
+  auto make_async_fork_fn_data(Out out, Executor ex) {
+    return async_fork_fn_data<Executor, Out>{std::move(out), std::move(ex)};
+  }
+
+
+  // Generic version
+  template<class Executor, class MakeReceiver>
+  struct async_fork_customization_generic {
+  private:
+    struct value_fn {
+      template <class Data, class Value>
+      void operator()(Data& data, Value&& value) const {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            [value = (Value&&) value,
+             out = std::move(static_cast<typename Data::out_t&>(data)),
+             exec = data.exec](auto) mutable {
+              // Token hard coded for this executor type at the moment
+              auto token = InlineAsyncToken<
+                  std::decay_t<decltype(value)>, std::decay_t<Executor>>{exec};
+              token.value_ = std::forward<Value>(value);
+              ::pushmi::set_value(out, std::move(token));
+            }
+          )
+        );
+      }
+    };
+    template <class Out>
+    struct error_fn {
+    private:
+      template <class E>
+      struct on_value_impl {
+        E e_;
+        Out out_;
+        void operator()(any) {
+          ::pushmi::set_error(out_, std::move(e_));
+        }
+      };
+    public:
+      template <class Data, class E>
+      void operator()(Data& data, E e) const noexcept {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            on_value_impl<E>{std::move(e), std::move(static_cast<Out&>(data))}
+          )
+        );
+      }
+    };
+    template <class Out>
+    struct done_fn {
+      struct on_value_impl {
+        Out out_;
+        void operator()(any) {
+          ::pushmi::set_done(out_);
+        }
+      };
+      template <class Data>
+      void operator()(Data& data) const {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            on_value_impl{std::move(static_cast<Out&>(data))}
+          )
+        );
+      }
+    };
+
+  public:
+    template<class Out>
+    auto operator()(Out out, Executor exec) {
+      return MakeReceiver{}(
+        make_async_fork_fn_data(std::move(out), std::move(exec)),
+        // copy 'f' to allow multiple calls to submit
+        value_fn{},
+        error_fn<Out>{},
+        done_fn<Out>{}
+      );
+    }
+  };
+
+  // Customisation for NewThreadAsyncToken
+  template<class MakeReceiver>
+  struct async_fork_customization_new_thread_t {
+  private:
+    using Executor = new_thread_t;
+    struct value_fn {
+      template <class Data, class Value>
+      void operator()(Data& data, Value&& value) const {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            [value = (Value&&) value,
+             out = std::move(static_cast<typename Data::out_t&>(data)),
+             exec = data.exec](auto) mutable {
+              // Token hard coded for this executor type at the moment
+              auto token = NewThreadAsyncToken<
+                  std::decay_t<decltype(value)>, std::decay_t<decltype(exec)>>{
+                std::move(exec)};
+              token.dataPtr_->v_ = std::move(value);
+              token.dataPtr_->flag_ = true;
+              ::pushmi::set_value(out, std::move(token));
+            }
+          )
+        );
+      }
+    };
+    template <class Out>
+    struct error_fn {
+    private:
+      template <class E>
+      struct on_value_impl {
+        E e_;
+        Out out_;
+        void operator()(any) {
+          ::pushmi::set_error(out_, std::move(e_));
+        }
+      };
+    public:
+      template <class Data, class E>
+      void operator()(Data& data, E e) const noexcept {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            on_value_impl<E>{std::move(e), std::move(static_cast<Out&>(data))}
+          )
+        );
+      }
+    };
+    template <class Out>
+    struct done_fn {
+      struct on_value_impl {
+        Out out_;
+        void operator()(any) {
+          ::pushmi::set_done(out_);
+        }
+      };
+      template <class Data>
+      void operator()(Data& data) const {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            on_value_impl{std::move(static_cast<Out&>(data))}
+          )
+        );
+      }
+    };
+
+  public:
+    template<class Out>
+    auto operator()(Out out, Executor exec) {
+      return MakeReceiver{}(
+        make_async_fork_fn_data(std::move(out), std::move(exec)),
+        // copy 'f' to allow multiple calls to submit
+        value_fn{},
+        error_fn<Out>{},
+        done_fn<Out>{}
+      );
+    }
+  };
+
+  // Generalisation to customise the entire protocol
+  template<class MakeReceiver, class Executor, class Out>
+  auto async_fork_customization(Executor exec, Out out) {
+    return async_fork_customization_generic<Executor, MakeReceiver>{}(out, exec);
+  }
+
+  template<class MakeReceiver, class Out>
+  auto async_fork_customization(new_thread_t exec, Out out) {
+    return async_fork_customization_new_thread_t<MakeReceiver>{}(out, exec);
+  }
+
+  struct async_fork_fn {
+  private:
+    template <class ExecutorFactory, class MakeReceiver>
+    struct out_impl {
+      ExecutorFactory ef_;
+      PUSHMI_TEMPLATE(class Out)
+        (requires Receiver<Out>)
+      auto operator()(Out out) const {
+        auto exec = ef_();
+        // Call customization point for fork
+        // TODO: how should this actually customise.
+        return async_fork_customization<MakeReceiver>(exec, out);
+      }
+    };
+    template <class ExecutorFactory>
+    struct in_impl {
+      ExecutorFactory ef_;
+      PUSHMI_TEMPLATE(class In)
+        (requires Sender<In>)
+      auto operator()(In in) const {
+        return ::pushmi::detail::sender_from(
+          std::move(in),
+          ::pushmi::detail::submit_transform_out<In>(
+            out_impl<ExecutorFactory, receiver_from_fn<In>>{ef_}
+          )
+        );
+      }
+    };
+  public:
+    PUSHMI_TEMPLATE(class ExecutorFactory)
+      (requires Invocable<ExecutorFactory&>)
+    auto operator()(ExecutorFactory ef) const {
+      return in_impl<ExecutorFactory>{std::move(ef)};
+    }
+  };
+
+  template<class Out>
+  struct async_join_fn_data : public Out {
+    using out_t = Out;
+    async_join_fn_data(Out out) :
+      Out(std::move(out)) {}
+  };
+
+  template<class Out>
+  auto make_async_join_fn_data(Out out) {
+    return async_join_fn_data<Out>{std::move(out)};
+  }
+
+  // Generic version, using inline execution
+  template<class Token, class Data>
+  struct async_join_on_value_impl {
+    void operator()(Data& data, Token&& token) {
+      ::pushmi::set_value(
+        std::move(static_cast<typename Data::out_t&>(data)),
+        std::move(token.value_));
+    }
+  };
+
+  struct condition {
+    bool* flag_;
+    bool operator()() const {
+      return *flag_;
+    }
+  };
+
+  // Customisation for NewThreadAsyncToken
+  template<class Data, class Value>
+  struct async_join_on_value_impl<NewThreadAsyncToken<Value, new_thread_t>, Data> {
+    using token_t = NewThreadAsyncToken<Value, new_thread_t>;
+  private:
+    using out_t = typename Data::out_t;
+    struct thread_fn {
+      struct on_value_fn {
+        token_t asyncToken_;
+        out_t out_;
+        void operator()(any) {
+          ::pushmi::set_value(out_, std::move(asyncToken_.dataPtr_->v_));
+        }
+      };
+      token_t asyncToken_;
+      out_t out_;
+      void operator()() {
+        std::unique_lock<std::mutex> lk(asyncToken_.dataPtr_->cvm_);
+        if(!asyncToken_.dataPtr_->flag_) {
+          asyncToken_.dataPtr_->cv_.wait(
+            lk, condition{&asyncToken_.dataPtr_->flag_}
+          );
+        }
+        ::pushmi::submit(
+          asyncToken_.e_,
+          ::pushmi::now(asyncToken_.e_),
+          ::pushmi::make_single(on_value_fn{asyncToken_, out_})
+        );
+      }
+    };
+    struct on_value_fn {
+      token_t asyncToken_;
+      out_t out_;
+      void operator()(any) {
+        // Token hard coded for this executor type at the moment
+        std::thread t(thread_fn{asyncToken_, out_});
+        t.detach();
+      }
+    };
+  public:
+    void operator()(Data& data, token_t&& asyncToken) {
+      ::pushmi::submit(
+        asyncToken.e_,
+        ::pushmi::now(asyncToken.e_),
+        ::pushmi::make_single(
+          on_value_fn{asyncToken, std::move(static_cast<out_t&>(data))}
+        )
+      );
+    }
+  };
+
+  // TODO: This should be transformed to use a single customisation point as for
+  // fork. To do this we need to get the executor consistently rather than
+  // getting it from the value method.
+  struct async_join_fn {
+  private:
+    struct value_fn {
+      template <class Data, class Token>
+      void operator()(Data& data, Token&& asyncToken) const {
+        async_join_on_value_impl<std::decay_t<Token>, Data>{}(
+          data,
+          std::move(asyncToken) // BUGBUG this is suspect
+        );
+      }
+    };
+    template <class Out>
+    struct error_fn {
+      template <class Data, class E>
+      void operator()(Data& data, E e) const noexcept {
+        auto out = std::move(static_cast<Out&>(data));
+        ::pushmi::set_error(out, std::move(e));
+      }
+    };
+    template <class Out>
+    struct done_fn {
+      template <class Data>
+      void operator()(Data& data) const noexcept {
+        auto out = std::move(static_cast<Out&>(data));
+        ::pushmi::set_done(out);
+      }
+    };
+    template <class MakeReceiver>
+    struct out_impl {
+      PUSHMI_TEMPLATE (class Out)
+        (requires Receiver<Out>)
+      auto operator()(Out out) const {
+        return MakeReceiver{}(
+          make_async_join_fn_data(std::move(out)),
+          // copy 'f' to allow multiple calls to submit
+          ::pushmi::on_value(value_fn{}),
+          ::pushmi::on_error(error_fn<Out>{}),
+          ::pushmi::on_done(done_fn<Out>{})
+        );
+      }
+    };
+    struct in_impl {
+      PUSHMI_TEMPLATE(class In)
+        (requires Sender<In>)
+      auto operator()(In in) const {
+        return ::pushmi::detail::sender_from(
+          std::move(in),
+          ::pushmi::detail::submit_transform_out<In>(
+              out_impl<receiver_from_fn<In>>{}
+          )
+        );
+      }
+    };
+  public:
+    auto operator()() const {
+      return in_impl{};
+    }
+  };
+
+  // Generic version implemented as inline
+  template<class F, class Token, class Data>
+  struct async_transform_on_value_impl {
+    F f_;
+    async_transform_on_value_impl() = default;
+    constexpr explicit async_transform_on_value_impl(F f)
+      : f_(std::move(f)) {}
+
+    template<class Out, class V>
+    auto operator()(Out& out, V&& inputToken) {
+      auto outputToken = inputToken;
+      outputToken.value_ = f_(std::move(inputToken.value_));
+      ::pushmi::set_value(out, outputToken);
+    }
+  };
+
+  // Customisation for NewThreadAsyncToken
+  template<class F, class Data, class Value>
+  struct async_transform_on_value_impl<
+      F, NewThreadAsyncToken<Value, new_thread_t>, Data> {
+
+    using token_t = NewThreadAsyncToken<Value, new_thread_t>;
+  private:
+    using Result = invoke_result_t<F&, typename token_t::ValueType&>;
+    using Executor = typename token_t::ExecutorType;
+    static_assert(::pushmi::SemiMovable<NewThreadAsyncToken<Result, Executor>>,
+      "none of the functions supplied to transform can convert this value");
+    using OutputToken = NewThreadAsyncToken<Result, Executor>;
+
+    struct thread_fn {
+      token_t inputToken_;
+      OutputToken outputToken_;
+      F func_;
+      void operator()() {
+        std::unique_lock<std::mutex> inlk(inputToken_.dataPtr_->cvm_);
+        // Wait for input value
+        if(!inputToken_.dataPtr_->flag_) {
+          inputToken_.dataPtr_->cv_.wait(
+            inlk, condition{&inputToken_.dataPtr_->flag_}
+          );
+        }
+        // Compute
+        auto result = func_(inputToken_.dataPtr_->v_);
+        // Move output and notify
+        std::unique_lock<std::mutex> outlk(outputToken_.dataPtr_->cvm_);
+        outputToken_.dataPtr_->v_ = std::move(result);
+        outputToken_.dataPtr_->flag_ = true;
+        outputToken_.dataPtr_->cv_.notify_all();
+      }
+    };
+
+    F f_;
+
+  public:
+    async_transform_on_value_impl() = default;
+    constexpr explicit async_transform_on_value_impl(F f)
+      : f_(std::move(f)) {}
+
+    template<class Out>
+    auto operator()(Out& out, token_t&& inputToken) {
+      static_assert(::pushmi::SingleReceiver<Out, NewThreadAsyncToken<Result, Executor>>,
+        "Result of value transform cannot be delivered to Out");
+      OutputToken outputToken{inputToken.e_};
+      std::thread t(thread_fn{inputToken, outputToken, f_});
+      t.detach();
+      ::pushmi::set_value(out, outputToken);
+    }
+  };
+
+  // TODO: This should be transformed to use a single customisation point as for
+  // fork. To do this we need to get the executor consistently rather than
+  // getting it from the value method.
+  struct async_transform_fn {
+  private:
+    template <class F>
+    struct on_value_fn {
+      F f_;
+      template <class Data, class Token>
+      void operator()(Data& data, Token&& asyncToken) {
+        async_transform_on_value_impl<F, std::decay_t<Token>, Data>(
+            std::move(f_))(data, std::move(asyncToken)
+        );
+      }
+    };
+    template <class F, class MakeReceiver>
+    struct out_impl {
+      F f_;
+      PUSHMI_TEMPLATE(class Out)
+        (requires Receiver<Out>)
+      auto operator()(Out out) const {
+        return MakeReceiver{}(
+          std::move(out),
+          // copy 'f' to allow multiple calls to submit
+          ::pushmi::on_value(on_value_fn<F>{f_})
+        );
+      }
+    };
+    template <class F>
+    struct in_impl {
+      F f_;
+      PUSHMI_TEMPLATE(class In)
+        (requires Sender<In>)
+      auto operator()(In in) {
+        return ::pushmi::detail::sender_from(
+          std::move(in),
+          ::pushmi::detail::submit_transform_out<In>(
+              out_impl<F, receiver_from_fn<In>>{f_}
+          )
+        );
+      }
+    };
+    template <class F>
+    static auto make_in_impl(F f) {
+      return in_impl<F>{std::move(f)};
+    }
+  public:
+    template <class... FN>
+    auto operator()(FN... fn) const {
+      return make_in_impl(overload(std::move(fn)...));
+    }
+  };
+
+  // Generic version implemented as inline
+  template<
+    class ValueFunction,
+    class ShapeF,
+    class SharedF,
+    class ResultS,
+    class Token,
+    class Data>
+  struct async_bulk_on_value_impl {
+    ValueFunction f_;
+    ShapeF shapeF_;
+    SharedF sharedF_;
+    ResultS resultS_;
+
+    async_bulk_on_value_impl() = default;
+    constexpr explicit async_bulk_on_value_impl(
+      ValueFunction f,
+      ShapeF shapeF,
+      SharedF sharedF,
+      ResultS resultS)
+      : f_(std::move(f)),
+        shapeF_(std::move(shapeF)),
+        sharedF_(std::move(sharedF)),
+        resultS_(std::move(resultS)) {}
+
+    template<class Out, class V>
+    auto operator()(Out& out, V&& inputToken) {
+      auto shape = shapeF_(inputToken.value_);
+      auto shared = sharedF_(inputToken.value_, shape);
+      using ShapeType = decltype(shape);
+      for(ShapeType i{}; i <= shape; ++i) {
+        f_(inputToken.value_, i, shared);
+      }
+      auto outputToken = inputToken;
+      outputToken.value_ = resultS_(shared);
+      ::pushmi::set_value(out, std::move(outputToken));
+    }
+  };
+
+
+  // TODO: This should be transformed to use a single customisation point as for
+  // fork. To do this we need to get the executor consistently rather than
+  // getting it from the value method.
+  struct async_bulk_fn {
+  private:
+    template <class ValueFunction, class ShapeF, class SharedF, class ResultS>
+    struct on_value_fn {
+      ValueFunction vfn_;
+      ShapeF shapeF_;
+      SharedF sharedF_;
+      ResultS resultS_;
+      template <class Data, class Token>
+      void operator()(Data& data, Token&& asyncToken) {
+        async_bulk_on_value_impl<
+          ValueFunction,
+          ShapeF,
+          SharedF,
+          ResultS,
+          std::decay_t<Token>,
+          Data>(
+            std::move(vfn_),
+            std::move(shapeF_),
+            std::move(sharedF_),
+            std::move(resultS_))(data, std::move(asyncToken));
+      }
+    };
+    template <class ValueFunction, class ShapeF, class SharedF, class ResultS, class MakeReceiver>
+    struct out_impl {
+      ValueFunction vfn_;
+      ShapeF shapeF_;
+      SharedF sharedF_;
+      ResultS resultS_;
+      PUSHMI_TEMPLATE (class Out)
+        (requires Receiver<Out>)
+      auto operator()(Out out) const {
+        return MakeReceiver{}(
+          std::move(out),
+          // copy 'f' to allow multiple calls to submit
+          ::pushmi::on_value(
+            on_value_fn<ValueFunction, ShapeF, SharedF, ResultS>{
+                vfn_, shapeF_, sharedF_, resultS_}
+          )
+        );
+      }
+    };
+    template <class ValueFunction, class ShapeF, class SharedF, class ResultS>
+    struct in_impl {
+      ValueFunction vfn_;
+      ShapeF shapeF_;
+      SharedF sharedF_;
+      ResultS resultS_;
+      PUSHMI_TEMPLATE (class In)
+        (requires Sender<In>)
+      auto operator()(In in) const {
+        return ::pushmi::detail::sender_from(
+          std::move(in),
+          ::pushmi::detail::submit_transform_out<In>(
+            out_impl<ValueFunction, ShapeF, SharedF, ResultS, receiver_from_fn<In>>{
+              vfn_, shapeF_, sharedF_, resultS_}
+          )
+        );
+      }
+    };
+  public:
+    template <class ValueFunction, class ShapeF, class SharedF, class ResultS>
+    auto operator()(ValueFunction, ShapeF, SharedF, ResultS) const;
+  };
+
+  template <class ValueFunction, class ShapeF, class SharedF, class ResultS>
+  auto async_bulk_fn::operator()(
+      ValueFunction vfn, ShapeF shapeF, SharedF sharedF, ResultS resultS)
+      const {
+    return in_impl<ValueFunction, ShapeF, SharedF, ResultS>{
+      std::move(vfn), std::move(shapeF), std::move(sharedF), std::move(resultS)};
+  }
+} // namespace detail
+
+namespace operators {
+PUSHMI_INLINE_VAR constexpr detail::async_join_fn async_join{};
+PUSHMI_INLINE_VAR constexpr detail::async_fork_fn async_fork{};
+PUSHMI_INLINE_VAR constexpr detail::async_transform_fn async_transform{};
+PUSHMI_INLINE_VAR constexpr detail::async_bulk_fn async_bulk{};
+} // namespace operators
 } // namespace pushmi
 // clang-format off
 // clang format does not support the '<>' in the lambda syntax yet.. []<>()->{}
@@ -6530,8 +7189,8 @@ struct subject<T, PS> {
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-//#include "../deferred.h"
-//#include "../single_deferred.h"
+//#include "../sender.h"
+//#include "../single_sender.h"
 //#include "../detail/functional.h"
 
 namespace pushmi {
@@ -6556,11 +7215,11 @@ namespace detail {
 namespace operators {
 template <class V>
 auto empty() {
-  return make_single_deferred(detail::single_empty_impl<V>{});
+  return make_single_sender(detail::single_empty_impl<V>{});
 }
 
 inline auto empty() {
-  return make_deferred(detail::empty_impl{});
+  return make_sender(detail::empty_impl{});
 }
 
 } // namespace operators
@@ -6571,7 +7230,7 @@ inline auto empty() {
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-//#include "../many_deferred.h"
+//#include "../many_sender.h"
 //#include "extension_operators.h"
 //#include "submit.h"
 
@@ -6610,7 +7269,7 @@ PUSHMI_INLINE_VAR constexpr struct from_fn {
           typename std::iterator_traits<I>::iterator_category,
           std::forward_iterator_tag>)
   auto operator()(I begin, S end) const {
-    return make_many_deferred(out_impl<I, S>{begin, end});
+    return make_many_sender(out_impl<I, S>{begin, end});
   }
 
   PUSHMI_TEMPLATE(class R)
@@ -6631,7 +7290,7 @@ PUSHMI_INLINE_VAR constexpr struct from_fn {
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-//#include "../single_deferred.h"
+//#include "../single_sender.h"
 //#include "submit.h"
 //#include "extension_operators.h"
 
@@ -6654,7 +7313,7 @@ PUSHMI_INLINE_VAR constexpr struct just_fn {
   PUSHMI_TEMPLATE(class V)
     (requires SemiMovable<V>)
   auto operator()(V v) const {
-    return make_single_deferred(impl<V>{std::move(v)});
+    return make_single_sender(impl<V>{std::move(v)});
   }
 } just {};
 } // namespace operators
@@ -6668,7 +7327,7 @@ PUSHMI_INLINE_VAR constexpr struct just_fn {
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-//#include "../deferred.h"
+//#include "../sender.h"
 //#include "submit.h"
 //#include "extension_operators.h"
 
@@ -6699,13 +7358,13 @@ namespace operators {
 PUSHMI_TEMPLATE(class E)
   (requires SemiMovable<E>)
 auto error(E e) {
-  return make_deferred(detail::error_impl<E>{std::move(e)});
+  return make_sender(detail::error_impl<E>{std::move(e)});
 }
 
 PUSHMI_TEMPLATE(class V, class E)
   (requires SemiMovable<V> && SemiMovable<E>)
 auto error(E e) {
-  return make_single_deferred(detail::single_error_impl<V, E>{std::move(e)});
+  return make_single_sender(detail::single_error_impl<V, E>{std::move(e)});
 }
 
 } // namespace operators
@@ -6719,7 +7378,7 @@ auto error(E e) {
 // LICENSE file in the root directory of this source tree.
 
 //#include "../single.h"
-//#include "../single_deferred.h"
+//#include "../single_sender.h"
 //#include "submit.h"
 //#include "extension_operators.h"
 
@@ -6747,7 +7406,7 @@ PUSHMI_INLINE_VAR constexpr struct defer_fn {
   PUSHMI_TEMPLATE(class F)
     (requires Invocable<F&>)
   auto operator()(F f) const {
-    return make_single_deferred(impl<F>{std::move(f)});
+    return make_single_sender(impl<F>{std::move(f)});
   }
 } defer {};
 
@@ -6819,7 +7478,7 @@ struct on_fn {
     PUSHMI_TEMPLATE (class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         detail::submit_transform_out<In>(
           out_impl<In, ExecutorFactory>{ef_},
@@ -6992,9 +7651,9 @@ auto on(ExecutorFactory factory) {
 
 //#include <cassert>
 //#include "extension_operators.h"
-//#include "../deferred.h"
-//#include "../single_deferred.h"
-//#include "../time_single_deferred.h"
+//#include "../sender.h"
+//#include "../single_sender.h"
+//#include "../time_single_sender.h"
 
 namespace pushmi {
 
@@ -7056,13 +7715,13 @@ struct tap_fn {
   template <class In, class SideEffects>
   static auto impl(In in, SideEffects sideEffects) {
     PUSHMI_STATIC_ASSERT(
-      ::pushmi::detail::deferred_requires_from<In, SideEffects,
+      ::pushmi::detail::sender_requires_from<In, SideEffects,
         SenderTo<In, SideEffects, is_none<>>,
         SenderTo<In, SideEffects, is_single<>>,
         TimeSenderTo<In, SideEffects, is_single<>> >(),
         "'In' is not deliverable to 'SideEffects'");
 
-    return ::pushmi::detail::deferred_from(
+    return ::pushmi::detail::sender_from(
       std::move(in),
       ::pushmi::detail::submit_transform_out<In>(
         out_impl<In, SideEffects>{std::move(sideEffects)}
@@ -7088,7 +7747,7 @@ struct tap_fn {
       (requires Receiver<Out>)
     auto operator()(Out out) const {
       PUSHMI_STATIC_ASSERT(
-        ::pushmi::detail::deferred_requires_from<In, SideEffects,
+        ::pushmi::detail::sender_requires_from<In, SideEffects,
           SenderTo<In, Out, is_none<>>,
           SenderTo<In, Out, is_single<>>,
           TimeSenderTo<In, Out, is_single<>> >(),
@@ -7097,7 +7756,7 @@ struct tap_fn {
           detail::make_tap(sideEffects_, std::move(out)))};
       using Gang = decltype(gang);
       PUSHMI_STATIC_ASSERT(
-        ::pushmi::detail::deferred_requires_from<In, SideEffects,
+        ::pushmi::detail::sender_requires_from<In, SideEffects,
           SenderTo<In, Gang>,
           SenderTo<In, Gang, is_single<>>,
           TimeSenderTo<In, Gang, is_single<>> >(),
@@ -7181,6 +7840,11 @@ struct transform_on<F, is_many<>> {
   }
 };
 
+template<class Cardinality, class F>
+auto make_transform_on(F f) {
+  return transform_on<F, Cardinality>(std::move(f));
+}
+
 struct transform_fn {
 private:
   template <class F>
@@ -7190,11 +7854,11 @@ struct transform_fn {
       (requires Sender<In>)
     auto operator()(In in) const {
       using Cardinality = property_set_index_t<properties_t<In>, is_silent<>>;
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(
           // copy 'f_' to allow multiple calls to connect to multiple 'in'
-          transform_on<F, Cardinality>{f_}
+          make_transform_on<Cardinality>(f_)
         )
       );
     }
@@ -7261,7 +7925,7 @@ struct filter_fn {
     PUSHMI_TEMPLATE(class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(out_impl<In, Predicate>{p_})
       );
@@ -7327,7 +7991,7 @@ struct switch_on_error_fn {
     PUSHMI_TEMPLATE (class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(
           out_impl<In, ErrorSelector>{es_}
@@ -7461,7 +8125,7 @@ struct via_fn {
     PUSHMI_TEMPLATE (class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(
           out_impl<In, ExecutorFactory>{ef_}
diff --git a/include/pushmi/boosters.h b/include/pushmi/boosters.h
index 7187449..1522e12 100644
--- a/include/pushmi/boosters.h
+++ b/include/pushmi/boosters.h
@@ -42,19 +42,19 @@ template<>
 struct construct_deduced<flow_single>;
 
 template<>
-struct construct_deduced<deferred>;
+struct construct_deduced<sender>;
 
 template<>
-struct construct_deduced<single_deferred>;
+struct construct_deduced<single_sender>;
 
 template<>
-struct construct_deduced<many_deferred>;
+struct construct_deduced<many_sender>;
 
 template<>
-struct construct_deduced<flow_single_deferred>;
+struct construct_deduced<flow_single_sender>;
 
 template<>
-struct construct_deduced<time_single_deferred>;
+struct construct_deduced<time_single_sender>;
 
 template <template <class...> class T, class... AN>
 using deduced_type_t = pushmi::invoke_result_t<construct_deduced<T>, AN...>;
diff --git a/include/pushmi/executor.h b/include/pushmi/executor.h
index d6558c3..4a2d9a5 100644
--- a/include/pushmi/executor.h
+++ b/include/pushmi/executor.h
@@ -6,7 +6,7 @@
 
 #include <chrono>
 #include <functional>
-#include "time_single_deferred.h"
+#include "time_single_sender.h"
 
 namespace pushmi {
 namespace detail {
@@ -113,7 +113,7 @@ any_time_executor_ref(Wrapped&) ->
 namespace detail {
 template<class E, class TP>
 using any_time_executor_base =
-  any_time_single_deferred<any_time_executor_ref<E, TP>, E, TP>;
+  any_time_single_sender<any_time_executor_ref<E, TP>, E, TP>;
 
 template<class T, class E, class TP>
 using not_any_time_executor =
diff --git a/include/pushmi/flow_single_deferred.h b/include/pushmi/flow_single_sender.h
similarity index 69%
rename from include/pushmi/flow_single_deferred.h
rename to include/pushmi/flow_single_sender.h
index be46b66..18cca5e 100644
--- a/include/pushmi/flow_single_deferred.h
+++ b/include/pushmi/flow_single_sender.h
@@ -9,7 +9,7 @@
 namespace pushmi {
 
 template <class V, class PE, class E>
-class flow_single_deferred<V, PE, E> {
+class flow_single_sender<V, PE, E> {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(V)]; // can hold a V in-situ
@@ -28,7 +28,7 @@ class flow_single_deferred<V, PE, E> {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  flow_single_deferred(Wrapped obj, std::false_type) : flow_single_deferred() {
+  flow_single_sender(Wrapped obj, std::false_type) : flow_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -44,8 +44,8 @@ class flow_single_deferred<V, PE, E> {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  flow_single_deferred(Wrapped obj, std::true_type) noexcept
-    : flow_single_deferred() {
+  flow_single_sender(Wrapped obj, std::true_type) noexcept
+    : flow_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -65,26 +65,26 @@ class flow_single_deferred<V, PE, E> {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, flow_single_deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, flow_single_sender>::value, U>;
  public:
   using properties = property_set<is_sender<>, is_flow<>, is_single<>>;
 
-  flow_single_deferred() = default;
-  flow_single_deferred(flow_single_deferred&& that) noexcept
-      : flow_single_deferred() {
+  flow_single_sender() = default;
+  flow_single_sender(flow_single_sender&& that) noexcept
+      : flow_single_sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
   PUSHMI_TEMPLATE (class Wrapped)
     (requires FlowSender<wrapped_t<Wrapped>, is_single<>>)
-  explicit flow_single_deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-    : flow_single_deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
-  ~flow_single_deferred() {
+  explicit flow_single_sender(Wrapped obj) noexcept(insitu<Wrapped>())
+    : flow_single_sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
+  ~flow_single_sender() {
     vptr_->op_(data_, nullptr);
   }
-  flow_single_deferred& operator=(flow_single_deferred&& that) noexcept {
-    this->~flow_single_deferred();
-    new ((void*)this) flow_single_deferred(std::move(that));
+  flow_single_sender& operator=(flow_single_sender&& that) noexcept {
+    this->~flow_single_sender();
+    new ((void*)this) flow_single_sender(std::move(that));
     return *this;
   }
   void submit(flow_single<V, PE, E> out) {
@@ -94,18 +94,18 @@ class flow_single_deferred<V, PE, E> {
 
 // Class static definitions:
 template <class V, class PE, class E>
-constexpr typename flow_single_deferred<V, PE, E>::vtable const
-    flow_single_deferred<V, PE, E>::noop_;
+constexpr typename flow_single_sender<V, PE, E>::vtable const
+    flow_single_sender<V, PE, E>::noop_;
 
 template <class SF>
-class flow_single_deferred<SF> {
+class flow_single_sender<SF> {
   SF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_flow<>, is_single<>>;
 
-  constexpr flow_single_deferred() = default;
-  constexpr explicit flow_single_deferred(SF sf)
+  constexpr flow_single_sender() = default;
+  constexpr explicit flow_single_sender(SF sf)
       : sf_(std::move(sf)) {}
 
   PUSHMI_TEMPLATE(class Out)
@@ -116,17 +116,17 @@ class flow_single_deferred<SF> {
 };
 
 template <PUSHMI_TYPE_CONSTRAINT(Sender<is_single<>, is_flow<>>) Data, class DSF>
-class flow_single_deferred<Data, DSF> {
+class flow_single_sender<Data, DSF> {
   Data data_;
   DSF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_single<>>;
 
-  constexpr flow_single_deferred() = default;
-  constexpr explicit flow_single_deferred(Data data)
+  constexpr flow_single_sender() = default;
+  constexpr explicit flow_single_sender(Data data)
       : data_(std::move(data)) {}
-  constexpr flow_single_deferred(Data data, DSF sf)
+  constexpr flow_single_sender(Data data, DSF sf)
       : data_(std::move(data)), sf_(std::move(sf)) {}
   PUSHMI_TEMPLATE(class Out)
     (requires PUSHMI_EXP(lazy::Receiver<Out, is_single<>, is_flow<>> PUSHMI_AND
@@ -137,57 +137,57 @@ class flow_single_deferred<Data, DSF> {
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_flow_single_deferred
-PUSHMI_INLINE_VAR constexpr struct make_flow_single_deferred_fn {
+// make_flow_single_sender
+PUSHMI_INLINE_VAR constexpr struct make_flow_single_sender_fn {
   inline auto operator()() const {
-    return flow_single_deferred<ignoreSF>{};
+    return flow_single_sender<ignoreSF>{};
   }
   PUSHMI_TEMPLATE(class SF)
     (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
   auto operator()(SF sf) const {
-    return flow_single_deferred<SF>{std::move(sf)};
+    return flow_single_sender<SF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE(class Data)
     (requires True<> && Sender<Data, is_single<>, is_flow<>>)
   auto operator()(Data d) const {
-    return flow_single_deferred<Data, passDSF>{std::move(d)};
+    return flow_single_sender<Data, passDSF>{std::move(d)};
   }
   PUSHMI_TEMPLATE(class Data, class DSF)
     (requires Sender<Data, is_single<>, is_flow<>>)
   auto operator()(Data d, DSF sf) const {
-    return flow_single_deferred<Data, DSF>{std::move(d), std::move(sf)};
+    return flow_single_sender<Data, DSF>{std::move(d), std::move(sf)};
   }
-} const make_flow_single_deferred {};
+} const make_flow_single_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-flow_single_deferred() -> flow_single_deferred<ignoreSF>;
+flow_single_sender() -> flow_single_sender<ignoreSF>;
 
 PUSHMI_TEMPLATE(class SF)
   (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
-flow_single_deferred(SF) -> flow_single_deferred<SF>;
+flow_single_sender(SF) -> flow_single_sender<SF>;
 
 PUSHMI_TEMPLATE(class Data)
   (requires True<> && Sender<Data, is_single<>, is_flow<>>)
-flow_single_deferred(Data) -> flow_single_deferred<Data, passDSF>;
+flow_single_sender(Data) -> flow_single_sender<Data, passDSF>;
 
 PUSHMI_TEMPLATE(class Data, class DSF)
   (requires Sender<Data, is_single<>, is_flow<>>)
-flow_single_deferred(Data, DSF) -> flow_single_deferred<Data, DSF>;
+flow_single_sender(Data, DSF) -> flow_single_sender<Data, DSF>;
 #endif
 
 template <class V, class PE = std::exception_ptr, class E = PE>
-using any_flow_single_deferred = flow_single_deferred<V, PE, E>;
+using any_flow_single_sender = flow_single_sender<V, PE, E>;
 
 template<>
-struct construct_deduced<flow_single_deferred>
-  : make_flow_single_deferred_fn {};
+struct construct_deduced<flow_single_sender>
+  : make_flow_single_sender_fn {};
 
 // // TODO constrain me
 // template <class V, class E = std::exception_ptr, Sender Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return flow_single_deferred<V, E>{std::move(w)};
+//   return flow_single_sender<V, E>{std::move(w)};
 // }
 
 } // namespace pushmi
diff --git a/include/pushmi/forwards.h b/include/pushmi/forwards.h
index 3c21015..cc32ca9 100644
--- a/include/pushmi/forwards.h
+++ b/include/pushmi/forwards.h
@@ -51,7 +51,7 @@ template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
 class none;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class deferred;
+class sender;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
 class single;
@@ -60,19 +60,19 @@ template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
 class many;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class single_deferred;
+class single_sender;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class many_deferred;
+class many_sender;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class time_single_deferred;
+class time_single_sender;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
 class flow_single;
 
 template <PUSHMI_TYPE_CONSTRAINT(SemiMovable)... TN>
-class flow_single_deferred;
+class flow_single_sender;
 
 template<
   class E = std::exception_ptr,
diff --git a/include/pushmi/many_deferred.h b/include/pushmi/many_sender.h
similarity index 69%
rename from include/pushmi/many_deferred.h
rename to include/pushmi/many_sender.h
index 05cff51..1991977 100644
--- a/include/pushmi/many_deferred.h
+++ b/include/pushmi/many_sender.h
@@ -9,7 +9,7 @@
 namespace pushmi {
 
 template <class V, class E = std::exception_ptr>
-class any_many_deferred {
+class any_many_sender {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(V)]; // can hold a V in-situ
@@ -28,7 +28,7 @@ class any_many_deferred {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  any_many_deferred(Wrapped obj, std::false_type) : any_many_deferred() {
+  any_many_sender(Wrapped obj, std::false_type) : any_many_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -44,8 +44,8 @@ class any_many_deferred {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  any_many_deferred(Wrapped obj, std::true_type) noexcept
-      : any_many_deferred() {
+  any_many_sender(Wrapped obj, std::true_type) noexcept
+      : any_many_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -64,27 +64,27 @@ class any_many_deferred {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, any_many_deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, any_many_sender>::value, U>;
  public:
   using properties = property_set<is_sender<>, is_many<>>;
 
-  any_many_deferred() = default;
-  any_many_deferred(any_many_deferred&& that) noexcept
-      : any_many_deferred() {
+  any_many_sender() = default;
+  any_many_sender(any_many_sender&& that) noexcept
+      : any_many_sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
 
   PUSHMI_TEMPLATE(class Wrapped)
     (requires SenderTo<wrapped_t<Wrapped>, many<V, E>, is_many<>>)
-  explicit any_many_deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-    : any_many_deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
-  ~any_many_deferred() {
+  explicit any_many_sender(Wrapped obj) noexcept(insitu<Wrapped>())
+    : any_many_sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
+  ~any_many_sender() {
     vptr_->op_(data_, nullptr);
   }
-  any_many_deferred& operator=(any_many_deferred&& that) noexcept {
-    this->~any_many_deferred();
-    new ((void*)this) any_many_deferred(std::move(that));
+  any_many_sender& operator=(any_many_sender&& that) noexcept {
+    this->~any_many_sender();
+    new ((void*)this) any_many_sender(std::move(that));
     return *this;
   }
   void submit(many<V, E> out) {
@@ -94,18 +94,18 @@ class any_many_deferred {
 
 // Class static definitions:
 template <class V, class E>
-constexpr typename any_many_deferred<V, E>::vtable const
-  any_many_deferred<V, E>::noop_;
+constexpr typename any_many_sender<V, E>::vtable const
+  any_many_sender<V, E>::noop_;
 
 template <class SF>
-class many_deferred<SF> {
+class many_sender<SF> {
   SF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_many<>>;
 
-  constexpr many_deferred() = default;
-  constexpr explicit many_deferred(SF sf)
+  constexpr many_sender() = default;
+  constexpr explicit many_sender(SF sf)
       : sf_(std::move(sf)) {}
 
   PUSHMI_TEMPLATE(class Out)
@@ -117,17 +117,17 @@ class many_deferred<SF> {
 
 namespace detail {
 template <PUSHMI_TYPE_CONSTRAINT(Sender<is_many<>>) Data, class DSF>
-class many_deferred_2 {
+class many_sender_2 {
   Data data_;
   DSF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_many<>>;
 
-  constexpr many_deferred_2() = default;
-  constexpr explicit many_deferred_2(Data data)
+  constexpr many_sender_2() = default;
+  constexpr explicit many_sender_2(Data data)
       : data_(std::move(data)) {}
-  constexpr many_deferred_2(Data data, DSF sf)
+  constexpr many_sender_2(Data data, DSF sf)
       : data_(std::move(data)), sf_(std::move(sf)) {}
   PUSHMI_TEMPLATE(class Out)
     (requires PUSHMI_EXP(lazy::Receiver<Out, is_many<>> PUSHMI_AND
@@ -138,70 +138,70 @@ class many_deferred_2 {
 };
 
 template <class A, class B>
-using many_deferred_base =
+using many_sender_base =
   std::conditional_t<
     (bool)Sender<A, is_many<>>,
-    many_deferred_2<A, B>,
-    any_many_deferred<A, B>>;
+    many_sender_2<A, B>,
+    any_many_sender<A, B>>;
 } // namespace detail
 
 template <class A, class B>
-struct many_deferred<A, B>
-  : detail::many_deferred_base<A, B> {
-  constexpr many_deferred() = default;
-  using detail::many_deferred_base<A, B>::many_deferred_base;
+struct many_sender<A, B>
+  : detail::many_sender_base<A, B> {
+  constexpr many_sender() = default;
+  using detail::many_sender_base<A, B>::many_sender_base;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_many_deferred
-PUSHMI_INLINE_VAR constexpr struct make_many_deferred_fn {
+// make_many_sender
+PUSHMI_INLINE_VAR constexpr struct make_many_sender_fn {
   inline auto operator()() const {
-    return many_deferred<ignoreSF>{};
+    return many_sender<ignoreSF>{};
   }
   PUSHMI_TEMPLATE(class SF)
     (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
   auto operator()(SF sf) const {
-    return many_deferred<SF>{std::move(sf)};
+    return many_sender<SF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE(class Data)
     (requires True<> && Sender<Data, is_many<>>)
   auto operator()(Data d) const {
-    return many_deferred<Data, passDSF>{std::move(d)};
+    return many_sender<Data, passDSF>{std::move(d)};
   }
   PUSHMI_TEMPLATE(class Data, class DSF)
     (requires Sender<Data, is_many<>>)
   auto operator()(Data d, DSF sf) const {
-    return many_deferred<Data, DSF>{std::move(d), std::move(sf)};
+    return many_sender<Data, DSF>{std::move(d), std::move(sf)};
   }
-} const make_many_deferred {};
+} const make_many_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-many_deferred() -> many_deferred<ignoreSF>;
+many_sender() -> many_sender<ignoreSF>;
 
 PUSHMI_TEMPLATE(class SF)
   (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
-many_deferred(SF) -> many_deferred<SF>;
+many_sender(SF) -> many_sender<SF>;
 
 PUSHMI_TEMPLATE(class Data)
   (requires True<> && Sender<Data, is_many<>>)
-many_deferred(Data) -> many_deferred<Data, passDSF>;
+many_sender(Data) -> many_sender<Data, passDSF>;
 
 PUSHMI_TEMPLATE(class Data, class DSF)
   (requires Sender<Data, is_many<>>)
-many_deferred(Data, DSF) -> many_deferred<Data, DSF>;
+many_sender(Data, DSF) -> many_sender<Data, DSF>;
 #endif
 
 template<>
-struct construct_deduced<many_deferred> : make_many_deferred_fn {};
+struct construct_deduced<many_sender> : make_many_sender_fn {};
 
 // template <
 //     class V,
 //     class E = std::exception_ptr,
 //     SenderTo<many<V, E>, is_many<>> Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return many_deferred<V, E>{std::move(w)};
+//   return many_sender<V, E>{std::move(w)};
 // }
 
 } // namespace pushmi
diff --git a/include/pushmi/new_thread.h b/include/pushmi/new_thread.h
index 1384b95..a2646f6 100644
--- a/include/pushmi/new_thread.h
+++ b/include/pushmi/new_thread.h
@@ -26,7 +26,7 @@ struct __new_thread_submit {
 };
 
 inline auto new_thread() {
-  return make_time_single_deferred(__new_thread_submit{});
+  return make_time_single_sender(__new_thread_submit{});
 }
 
 }
diff --git a/include/pushmi/o/async.h b/include/pushmi/o/async.h
new file mode 100644
index 0000000..2e93429
--- /dev/null
+++ b/include/pushmi/o/async.h
@@ -0,0 +1,659 @@
+#pragma once
+// Copyright (c) 2018-present, Facebook, Inc.
+//
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+#include "../piping.h"
+#include "../executor.h"
+#include "../new_thread.h"
+#include "extension_operators.h"
+
+namespace pushmi {
+namespace detail {
+  using new_thread_t = decltype(new_thread());
+
+  template<class ValueType_, class ExecutorType_>
+  struct NewThreadAsyncToken {
+  public:
+    using ValueType = ValueType_;
+    using ExecutorType = ExecutorType_;
+    struct Data {
+      ValueType v_;
+      std::condition_variable cv_;
+      std::mutex cvm_;
+      bool flag_ = false;
+    };
+    NewThreadAsyncToken(ExecutorType e) :
+      e_{std::move(e)}, dataPtr_{std::make_shared<Data>()} {}
+
+    ExecutorType e_;
+    std::shared_ptr<Data> dataPtr_;
+  };
+
+  template<class ValueType_, class ExecutorType_>
+  struct InlineAsyncToken {
+  public:
+    using ValueType = ValueType_;
+    using ExecutorType = ExecutorType_;
+
+    InlineAsyncToken(ExecutorType e) :
+      e_{std::move(e)} {}
+
+    ExecutorType e_;
+    ValueType value_;
+  };
+
+  template<class Executor, class Out>
+  struct async_fork_fn_data : public Out {
+    using out_t = Out;
+    Executor exec;
+
+    async_fork_fn_data(Out out, Executor exec) :
+      Out(std::move(out)), exec(std::move(exec)) {}
+  };
+
+  template<class Out, class Executor>
+  auto make_async_fork_fn_data(Out out, Executor ex) {
+    return async_fork_fn_data<Executor, Out>{std::move(out), std::move(ex)};
+  }
+
+
+  // Generic version
+  template<class Executor, class MakeReceiver>
+  struct async_fork_customization_generic {
+  private:
+    struct value_fn {
+      template <class Data, class Value>
+      void operator()(Data& data, Value&& value) const {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            [value = (Value&&) value,
+             out = std::move(static_cast<typename Data::out_t&>(data)),
+             exec = data.exec](auto) mutable {
+              // Token hard coded for this executor type at the moment
+              auto token = InlineAsyncToken<
+                  std::decay_t<decltype(value)>, std::decay_t<Executor>>{exec};
+              token.value_ = std::forward<Value>(value);
+              ::pushmi::set_value(out, std::move(token));
+            }
+          )
+        );
+      }
+    };
+    template <class Out>
+    struct error_fn {
+    private:
+      template <class E>
+      struct on_value_impl {
+        E e_;
+        Out out_;
+        void operator()(any) {
+          ::pushmi::set_error(out_, std::move(e_));
+        }
+      };
+    public:
+      template <class Data, class E>
+      void operator()(Data& data, E e) const noexcept {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            on_value_impl<E>{std::move(e), std::move(static_cast<Out&>(data))}
+          )
+        );
+      }
+    };
+    template <class Out>
+    struct done_fn {
+      struct on_value_impl {
+        Out out_;
+        void operator()(any) {
+          ::pushmi::set_done(out_);
+        }
+      };
+      template <class Data>
+      void operator()(Data& data) const {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            on_value_impl{std::move(static_cast<Out&>(data))}
+          )
+        );
+      }
+    };
+
+  public:
+    template<class Out>
+    auto operator()(Out out, Executor exec) {
+      return MakeReceiver{}(
+        make_async_fork_fn_data(std::move(out), std::move(exec)),
+        // copy 'f' to allow multiple calls to submit
+        value_fn{},
+        error_fn<Out>{},
+        done_fn<Out>{}
+      );
+    }
+  };
+
+  // Customisation for NewThreadAsyncToken
+  template<class MakeReceiver>
+  struct async_fork_customization_new_thread_t {
+  private:
+    using Executor = new_thread_t;
+    struct value_fn {
+      template <class Data, class Value>
+      void operator()(Data& data, Value&& value) const {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            [value = (Value&&) value,
+             out = std::move(static_cast<typename Data::out_t&>(data)),
+             exec = data.exec](auto) mutable {
+              // Token hard coded for this executor type at the moment
+              auto token = NewThreadAsyncToken<
+                  std::decay_t<decltype(value)>, std::decay_t<decltype(exec)>>{
+                std::move(exec)};
+              token.dataPtr_->v_ = std::move(value);
+              token.dataPtr_->flag_ = true;
+              ::pushmi::set_value(out, std::move(token));
+            }
+          )
+        );
+      }
+    };
+    template <class Out>
+    struct error_fn {
+    private:
+      template <class E>
+      struct on_value_impl {
+        E e_;
+        Out out_;
+        void operator()(any) {
+          ::pushmi::set_error(out_, std::move(e_));
+        }
+      };
+    public:
+      template <class Data, class E>
+      void operator()(Data& data, E e) const noexcept {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            on_value_impl<E>{std::move(e), std::move(static_cast<Out&>(data))}
+          )
+        );
+      }
+    };
+    template <class Out>
+    struct done_fn {
+      struct on_value_impl {
+        Out out_;
+        void operator()(any) {
+          ::pushmi::set_done(out_);
+        }
+      };
+      template <class Data>
+      void operator()(Data& data) const {
+        ::pushmi::submit(
+          data.exec,
+          ::pushmi::now(data.exec),
+          ::pushmi::make_single(
+            on_value_impl{std::move(static_cast<Out&>(data))}
+          )
+        );
+      }
+    };
+
+  public:
+    template<class Out>
+    auto operator()(Out out, Executor exec) {
+      return MakeReceiver{}(
+        make_async_fork_fn_data(std::move(out), std::move(exec)),
+        // copy 'f' to allow multiple calls to submit
+        value_fn{},
+        error_fn<Out>{},
+        done_fn<Out>{}
+      );
+    }
+  };
+
+  // Generalisation to customise the entire protocol
+  template<class MakeReceiver, class Executor, class Out>
+  auto async_fork_customization(Executor exec, Out out) {
+    return async_fork_customization_generic<Executor, MakeReceiver>{}(out, exec);
+  }
+
+  template<class MakeReceiver, class Out>
+  auto async_fork_customization(new_thread_t exec, Out out) {
+    return async_fork_customization_new_thread_t<MakeReceiver>{}(out, exec);
+  }
+
+  struct async_fork_fn {
+  private:
+    template <class ExecutorFactory, class MakeReceiver>
+    struct out_impl {
+      ExecutorFactory ef_;
+      PUSHMI_TEMPLATE(class Out)
+        (requires Receiver<Out>)
+      auto operator()(Out out) const {
+        auto exec = ef_();
+        // Call customization point for fork
+        // TODO: how should this actually customise.
+        return async_fork_customization<MakeReceiver>(exec, out);
+      }
+    };
+    template <class ExecutorFactory>
+    struct in_impl {
+      ExecutorFactory ef_;
+      PUSHMI_TEMPLATE(class In)
+        (requires Sender<In>)
+      auto operator()(In in) const {
+        return ::pushmi::detail::sender_from(
+          std::move(in),
+          ::pushmi::detail::submit_transform_out<In>(
+            out_impl<ExecutorFactory, receiver_from_fn<In>>{ef_}
+          )
+        );
+      }
+    };
+  public:
+    PUSHMI_TEMPLATE(class ExecutorFactory)
+      (requires Invocable<ExecutorFactory&>)
+    auto operator()(ExecutorFactory ef) const {
+      return in_impl<ExecutorFactory>{std::move(ef)};
+    }
+  };
+
+  template<class Out>
+  struct async_join_fn_data : public Out {
+    using out_t = Out;
+    async_join_fn_data(Out out) :
+      Out(std::move(out)) {}
+  };
+
+  template<class Out>
+  auto make_async_join_fn_data(Out out) {
+    return async_join_fn_data<Out>{std::move(out)};
+  }
+
+  // Generic version, using inline execution
+  template<class Token, class Data>
+  struct async_join_on_value_impl {
+    void operator()(Data& data, Token&& token) {
+      ::pushmi::set_value(
+        std::move(static_cast<typename Data::out_t&>(data)),
+        std::move(token.value_));
+    }
+  };
+
+  struct condition {
+    bool* flag_;
+    bool operator()() const {
+      return *flag_;
+    }
+  };
+
+  // Customisation for NewThreadAsyncToken
+  template<class Data, class Value>
+  struct async_join_on_value_impl<NewThreadAsyncToken<Value, new_thread_t>, Data> {
+    using token_t = NewThreadAsyncToken<Value, new_thread_t>;
+  private:
+    using out_t = typename Data::out_t;
+    struct thread_fn {
+      struct on_value_fn {
+        token_t asyncToken_;
+        out_t out_;
+        void operator()(any) {
+          ::pushmi::set_value(out_, std::move(asyncToken_.dataPtr_->v_));
+        }
+      };
+      token_t asyncToken_;
+      out_t out_;
+      void operator()() {
+        std::unique_lock<std::mutex> lk(asyncToken_.dataPtr_->cvm_);
+        if(!asyncToken_.dataPtr_->flag_) {
+          asyncToken_.dataPtr_->cv_.wait(
+            lk, condition{&asyncToken_.dataPtr_->flag_}
+          );
+        }
+        ::pushmi::submit(
+          asyncToken_.e_,
+          ::pushmi::now(asyncToken_.e_),
+          ::pushmi::make_single(on_value_fn{asyncToken_, out_})
+        );
+      }
+    };
+    struct on_value_fn {
+      token_t asyncToken_;
+      out_t out_;
+      void operator()(any) {
+        // Token hard coded for this executor type at the moment
+        std::thread t(thread_fn{asyncToken_, out_});
+        t.detach();
+      }
+    };
+  public:
+    void operator()(Data& data, token_t&& asyncToken) {
+      ::pushmi::submit(
+        asyncToken.e_,
+        ::pushmi::now(asyncToken.e_),
+        ::pushmi::make_single(
+          on_value_fn{asyncToken, std::move(static_cast<out_t&>(data))}
+        )
+      );
+    }
+  };
+
+  // TODO: This should be transformed to use a single customisation point as for
+  // fork. To do this we need to get the executor consistently rather than
+  // getting it from the value method.
+  struct async_join_fn {
+  private:
+    struct value_fn {
+      template <class Data, class Token>
+      void operator()(Data& data, Token&& asyncToken) const {
+        async_join_on_value_impl<std::decay_t<Token>, Data>{}(
+          data,
+          std::move(asyncToken) // BUGBUG this is suspect
+        );
+      }
+    };
+    template <class Out>
+    struct error_fn {
+      template <class Data, class E>
+      void operator()(Data& data, E e) const noexcept {
+        auto out = std::move(static_cast<Out&>(data));
+        ::pushmi::set_error(out, std::move(e));
+      }
+    };
+    template <class Out>
+    struct done_fn {
+      template <class Data>
+      void operator()(Data& data) const noexcept {
+        auto out = std::move(static_cast<Out&>(data));
+        ::pushmi::set_done(out);
+      }
+    };
+    template <class MakeReceiver>
+    struct out_impl {
+      PUSHMI_TEMPLATE (class Out)
+        (requires Receiver<Out>)
+      auto operator()(Out out) const {
+        return MakeReceiver{}(
+          make_async_join_fn_data(std::move(out)),
+          // copy 'f' to allow multiple calls to submit
+          ::pushmi::on_value(value_fn{}),
+          ::pushmi::on_error(error_fn<Out>{}),
+          ::pushmi::on_done(done_fn<Out>{})
+        );
+      }
+    };
+    struct in_impl {
+      PUSHMI_TEMPLATE(class In)
+        (requires Sender<In>)
+      auto operator()(In in) const {
+        return ::pushmi::detail::sender_from(
+          std::move(in),
+          ::pushmi::detail::submit_transform_out<In>(
+              out_impl<receiver_from_fn<In>>{}
+          )
+        );
+      }
+    };
+  public:
+    auto operator()() const {
+      return in_impl{};
+    }
+  };
+
+  // Generic version implemented as inline
+  template<class F, class Token, class Data>
+  struct async_transform_on_value_impl {
+    F f_;
+    async_transform_on_value_impl() = default;
+    constexpr explicit async_transform_on_value_impl(F f)
+      : f_(std::move(f)) {}
+
+    template<class Out, class V>
+    auto operator()(Out& out, V&& inputToken) {
+      auto outputToken = inputToken;
+      outputToken.value_ = f_(std::move(inputToken.value_));
+      ::pushmi::set_value(out, outputToken);
+    }
+  };
+
+  // Customisation for NewThreadAsyncToken
+  template<class F, class Data, class Value>
+  struct async_transform_on_value_impl<
+      F, NewThreadAsyncToken<Value, new_thread_t>, Data> {
+
+    using token_t = NewThreadAsyncToken<Value, new_thread_t>;
+  private:
+    using Result = invoke_result_t<F&, typename token_t::ValueType&>;
+    using Executor = typename token_t::ExecutorType;
+    static_assert(::pushmi::SemiMovable<NewThreadAsyncToken<Result, Executor>>,
+      "none of the functions supplied to transform can convert this value");
+    using OutputToken = NewThreadAsyncToken<Result, Executor>;
+
+    struct thread_fn {
+      token_t inputToken_;
+      OutputToken outputToken_;
+      F func_;
+      void operator()() {
+        std::unique_lock<std::mutex> inlk(inputToken_.dataPtr_->cvm_);
+        // Wait for input value
+        if(!inputToken_.dataPtr_->flag_) {
+          inputToken_.dataPtr_->cv_.wait(
+            inlk, condition{&inputToken_.dataPtr_->flag_}
+          );
+        }
+        // Compute
+        auto result = func_(inputToken_.dataPtr_->v_);
+        // Move output and notify
+        std::unique_lock<std::mutex> outlk(outputToken_.dataPtr_->cvm_);
+        outputToken_.dataPtr_->v_ = std::move(result);
+        outputToken_.dataPtr_->flag_ = true;
+        outputToken_.dataPtr_->cv_.notify_all();
+      }
+    };
+
+    F f_;
+
+  public:
+    async_transform_on_value_impl() = default;
+    constexpr explicit async_transform_on_value_impl(F f)
+      : f_(std::move(f)) {}
+
+    template<class Out>
+    auto operator()(Out& out, token_t&& inputToken) {
+      static_assert(::pushmi::SingleReceiver<Out, NewThreadAsyncToken<Result, Executor>>,
+        "Result of value transform cannot be delivered to Out");
+      OutputToken outputToken{inputToken.e_};
+      std::thread t(thread_fn{inputToken, outputToken, f_});
+      t.detach();
+      ::pushmi::set_value(out, outputToken);
+    }
+  };
+
+  // TODO: This should be transformed to use a single customisation point as for
+  // fork. To do this we need to get the executor consistently rather than
+  // getting it from the value method.
+  struct async_transform_fn {
+  private:
+    template <class F>
+    struct on_value_fn {
+      F f_;
+      template <class Data, class Token>
+      void operator()(Data& data, Token&& asyncToken) {
+        async_transform_on_value_impl<F, std::decay_t<Token>, Data>(
+            std::move(f_))(data, std::move(asyncToken)
+        );
+      }
+    };
+    template <class F, class MakeReceiver>
+    struct out_impl {
+      F f_;
+      PUSHMI_TEMPLATE(class Out)
+        (requires Receiver<Out>)
+      auto operator()(Out out) const {
+        return MakeReceiver{}(
+          std::move(out),
+          // copy 'f' to allow multiple calls to submit
+          ::pushmi::on_value(on_value_fn<F>{f_})
+        );
+      }
+    };
+    template <class F>
+    struct in_impl {
+      F f_;
+      PUSHMI_TEMPLATE(class In)
+        (requires Sender<In>)
+      auto operator()(In in) {
+        return ::pushmi::detail::sender_from(
+          std::move(in),
+          ::pushmi::detail::submit_transform_out<In>(
+              out_impl<F, receiver_from_fn<In>>{f_}
+          )
+        );
+      }
+    };
+    template <class F>
+    static auto make_in_impl(F f) {
+      return in_impl<F>{std::move(f)};
+    }
+  public:
+    template <class... FN>
+    auto operator()(FN... fn) const {
+      return make_in_impl(overload(std::move(fn)...));
+    }
+  };
+
+  // Generic version implemented as inline
+  template<
+    class ValueFunction,
+    class ShapeF,
+    class SharedF,
+    class ResultS,
+    class Token,
+    class Data>
+  struct async_bulk_on_value_impl {
+    ValueFunction f_;
+    ShapeF shapeF_;
+    SharedF sharedF_;
+    ResultS resultS_;
+
+    async_bulk_on_value_impl() = default;
+    constexpr explicit async_bulk_on_value_impl(
+      ValueFunction f,
+      ShapeF shapeF,
+      SharedF sharedF,
+      ResultS resultS)
+      : f_(std::move(f)),
+        shapeF_(std::move(shapeF)),
+        sharedF_(std::move(sharedF)),
+        resultS_(std::move(resultS)) {}
+
+    template<class Out, class V>
+    auto operator()(Out& out, V&& inputToken) {
+      auto shape = shapeF_(inputToken.value_);
+      auto shared = sharedF_(inputToken.value_, shape);
+      using ShapeType = decltype(shape);
+      for(ShapeType i{}; i <= shape; ++i) {
+        f_(inputToken.value_, i, shared);
+      }
+      auto outputToken = inputToken;
+      outputToken.value_ = resultS_(shared);
+      ::pushmi::set_value(out, std::move(outputToken));
+    }
+  };
+
+
+  // TODO: This should be transformed to use a single customisation point as for
+  // fork. To do this we need to get the executor consistently rather than
+  // getting it from the value method.
+  struct async_bulk_fn {
+  private:
+    template <class ValueFunction, class ShapeF, class SharedF, class ResultS>
+    struct on_value_fn {
+      ValueFunction vfn_;
+      ShapeF shapeF_;
+      SharedF sharedF_;
+      ResultS resultS_;
+      template <class Data, class Token>
+      void operator()(Data& data, Token&& asyncToken) {
+        async_bulk_on_value_impl<
+          ValueFunction,
+          ShapeF,
+          SharedF,
+          ResultS,
+          std::decay_t<Token>,
+          Data>(
+            std::move(vfn_),
+            std::move(shapeF_),
+            std::move(sharedF_),
+            std::move(resultS_))(data, std::move(asyncToken));
+      }
+    };
+    template <class ValueFunction, class ShapeF, class SharedF, class ResultS, class MakeReceiver>
+    struct out_impl {
+      ValueFunction vfn_;
+      ShapeF shapeF_;
+      SharedF sharedF_;
+      ResultS resultS_;
+      PUSHMI_TEMPLATE (class Out)
+        (requires Receiver<Out>)
+      auto operator()(Out out) const {
+        return MakeReceiver{}(
+          std::move(out),
+          // copy 'f' to allow multiple calls to submit
+          ::pushmi::on_value(
+            on_value_fn<ValueFunction, ShapeF, SharedF, ResultS>{
+                vfn_, shapeF_, sharedF_, resultS_}
+          )
+        );
+      }
+    };
+    template <class ValueFunction, class ShapeF, class SharedF, class ResultS>
+    struct in_impl {
+      ValueFunction vfn_;
+      ShapeF shapeF_;
+      SharedF sharedF_;
+      ResultS resultS_;
+      PUSHMI_TEMPLATE (class In)
+        (requires Sender<In>)
+      auto operator()(In in) const {
+        return ::pushmi::detail::sender_from(
+          std::move(in),
+          ::pushmi::detail::submit_transform_out<In>(
+            out_impl<ValueFunction, ShapeF, SharedF, ResultS, receiver_from_fn<In>>{
+              vfn_, shapeF_, sharedF_, resultS_}
+          )
+        );
+      }
+    };
+  public:
+    template <class ValueFunction, class ShapeF, class SharedF, class ResultS>
+    auto operator()(ValueFunction, ShapeF, SharedF, ResultS) const;
+  };
+
+  template <class ValueFunction, class ShapeF, class SharedF, class ResultS>
+  auto async_bulk_fn::operator()(
+      ValueFunction vfn, ShapeF shapeF, SharedF sharedF, ResultS resultS)
+      const {
+    return in_impl<ValueFunction, ShapeF, SharedF, ResultS>{
+      std::move(vfn), std::move(shapeF), std::move(sharedF), std::move(resultS)};
+  }
+} // namespace detail
+
+namespace operators {
+PUSHMI_INLINE_VAR constexpr detail::async_join_fn async_join{};
+PUSHMI_INLINE_VAR constexpr detail::async_fork_fn async_fork{};
+PUSHMI_INLINE_VAR constexpr detail::async_transform_fn async_transform{};
+PUSHMI_INLINE_VAR constexpr detail::async_bulk_fn async_bulk{};
+} // namespace operators
+} // namespace pushmi
diff --git a/include/pushmi/o/defer.h b/include/pushmi/o/defer.h
index 994a428..b2c5c44 100644
--- a/include/pushmi/o/defer.h
+++ b/include/pushmi/o/defer.h
@@ -7,7 +7,7 @@
 // LICENSE file in the root directory of this source tree.
 
 #include "../single.h"
-#include "../single_deferred.h"
+#include "../single_sender.h"
 #include "submit.h"
 #include "extension_operators.h"
 
@@ -35,7 +35,7 @@ PUSHMI_INLINE_VAR constexpr struct defer_fn {
   PUSHMI_TEMPLATE(class F)
     (requires Invocable<F&>)
   auto operator()(F f) const {
-    return make_single_deferred(impl<F>{std::move(f)});
+    return make_single_sender(impl<F>{std::move(f)});
   }
 } defer {};
 
diff --git a/include/pushmi/o/empty.h b/include/pushmi/o/empty.h
index fdaa177..4859412 100644
--- a/include/pushmi/o/empty.h
+++ b/include/pushmi/o/empty.h
@@ -6,8 +6,8 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-#include "../deferred.h"
-#include "../single_deferred.h"
+#include "../sender.h"
+#include "../single_sender.h"
 #include "../detail/functional.h"
 
 namespace pushmi {
@@ -32,11 +32,11 @@ namespace detail {
 namespace operators {
 template <class V>
 auto empty() {
-  return make_single_deferred(detail::single_empty_impl<V>{});
+  return make_single_sender(detail::single_empty_impl<V>{});
 }
 
 inline auto empty() {
-  return make_deferred(detail::empty_impl{});
+  return make_sender(detail::empty_impl{});
 }
 
 } // namespace operators
diff --git a/include/pushmi/o/error.h b/include/pushmi/o/error.h
index 2b2a2c5..871079c 100644
--- a/include/pushmi/o/error.h
+++ b/include/pushmi/o/error.h
@@ -6,7 +6,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-#include "../deferred.h"
+#include "../sender.h"
 #include "submit.h"
 #include "extension_operators.h"
 
@@ -37,13 +37,13 @@ namespace operators {
 PUSHMI_TEMPLATE(class E)
   (requires SemiMovable<E>)
 auto error(E e) {
-  return make_deferred(detail::error_impl<E>{std::move(e)});
+  return make_sender(detail::error_impl<E>{std::move(e)});
 }
 
 PUSHMI_TEMPLATE(class V, class E)
   (requires SemiMovable<V> && SemiMovable<E>)
 auto error(E e) {
-  return make_single_deferred(detail::single_error_impl<V, E>{std::move(e)});
+  return make_single_sender(detail::single_error_impl<V, E>{std::move(e)});
 }
 
 } // namespace operators
diff --git a/include/pushmi/o/extension_operators.h b/include/pushmi/o/extension_operators.h
index 1009d94..35a2475 100644
--- a/include/pushmi/o/extension_operators.h
+++ b/include/pushmi/o/extension_operators.h
@@ -10,13 +10,13 @@
 #include "../piping.h"
 #include "../boosters.h"
 #include "../single.h"
-#include "../deferred.h"
-#include "../single_deferred.h"
+#include "../sender.h"
+#include "../single_sender.h"
 #include "../many.h"
-#include "../many_deferred.h"
-#include "../time_single_deferred.h"
+#include "../many_sender.h"
+#include "../time_single_sender.h"
 #include "../flow_single.h"
-#include "../flow_single_deferred.h"
+#include "../flow_single_sender.h"
 #include "../detail/if_constexpr.h"
 #include "../detail/functional.h"
 
@@ -154,17 +154,17 @@ auto submit_transform_out(SDSF, TSDSF tsdsf) {
 template <class Cardinality, bool IsTime = false, bool IsFlow = false>
 struct make_sender;
 template <>
-struct make_sender<is_none<>> : construct_deduced<deferred> {};
+struct make_sender<is_none<>> : construct_deduced<sender> {};
 template <>
-struct make_sender<is_single<>> : construct_deduced<single_deferred> {};
+struct make_sender<is_single<>> : construct_deduced<single_sender> {};
 template <>
-struct make_sender<is_many<>> : construct_deduced<many_deferred> {};
+struct make_sender<is_many<>> : construct_deduced<many_sender> {};
 template <>
-struct make_sender<is_single<>, false, true> : construct_deduced<flow_single_deferred> {};
+struct make_sender<is_single<>, false, true> : construct_deduced<flow_single_sender> {};
 template <>
-struct make_sender<is_single<>, true, false> : construct_deduced<time_single_deferred> {};
+struct make_sender<is_single<>, true, false> : construct_deduced<time_single_sender> {};
 
-PUSHMI_INLINE_VAR constexpr struct deferred_from_fn {
+PUSHMI_INLINE_VAR constexpr struct sender_from_fn {
   PUSHMI_TEMPLATE(class In, class... FN)
     (requires Sender<In>)
   auto operator()(In in, FN&&... fn) const {
@@ -175,7 +175,7 @@ PUSHMI_INLINE_VAR constexpr struct deferred_from_fn {
             property_query_v<properties_t<In>, is_flow<>>>;
     return MakeSender{}(std::move(in), (FN&&) fn...);
   }
-} const deferred_from {};
+} const sender_from {};
 
 PUSHMI_TEMPLATE(
     class In,
@@ -184,7 +184,7 @@ PUSHMI_TEMPLATE(
     bool SingleSenderRequires,
     bool TimeSingleSenderRequires)
   (requires Sender<In> && Receiver<Out>)
-constexpr bool deferred_requires_from() {
+constexpr bool sender_requires_from() {
   PUSHMI_IF_CONSTEXPR_RETURN( ((bool) TimeSenderTo<In, Out, is_single<>>) (
     return TimeSingleSenderRequires;
   ) else (
diff --git a/include/pushmi/o/filter.h b/include/pushmi/o/filter.h
index d4c9042..a664173 100644
--- a/include/pushmi/o/filter.h
+++ b/include/pushmi/o/filter.h
@@ -44,7 +44,7 @@ struct filter_fn {
     PUSHMI_TEMPLATE(class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(out_impl<In, Predicate>{p_})
       );
diff --git a/include/pushmi/o/from.h b/include/pushmi/o/from.h
index ff1812b..a3e6a0f 100644
--- a/include/pushmi/o/from.h
+++ b/include/pushmi/o/from.h
@@ -4,7 +4,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-#include "../many_deferred.h"
+#include "../many_sender.h"
 #include "extension_operators.h"
 #include "submit.h"
 
@@ -43,7 +43,7 @@ PUSHMI_INLINE_VAR constexpr struct from_fn {
           typename std::iterator_traits<I>::iterator_category,
           std::forward_iterator_tag>)
   auto operator()(I begin, S end) const {
-    return make_many_deferred(out_impl<I, S>{begin, end});
+    return make_many_sender(out_impl<I, S>{begin, end});
   }
 
   PUSHMI_TEMPLATE(class R)
diff --git a/include/pushmi/o/just.h b/include/pushmi/o/just.h
index 1482da6..aaad6ea 100644
--- a/include/pushmi/o/just.h
+++ b/include/pushmi/o/just.h
@@ -6,7 +6,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-#include "../single_deferred.h"
+#include "../single_sender.h"
 #include "submit.h"
 #include "extension_operators.h"
 
@@ -29,7 +29,7 @@ PUSHMI_INLINE_VAR constexpr struct just_fn {
   PUSHMI_TEMPLATE(class V)
     (requires SemiMovable<V>)
   auto operator()(V v) const {
-    return make_single_deferred(impl<V>{std::move(v)});
+    return make_single_sender(impl<V>{std::move(v)});
   }
 } just {};
 } // namespace operators
diff --git a/include/pushmi/o/on.h b/include/pushmi/o/on.h
index 69b9399..b146a91 100644
--- a/include/pushmi/o/on.h
+++ b/include/pushmi/o/on.h
@@ -63,7 +63,7 @@ struct on_fn {
     PUSHMI_TEMPLATE (class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         detail::submit_transform_out<In>(
           out_impl<In, ExecutorFactory>{ef_},
diff --git a/include/pushmi/o/submit.h b/include/pushmi/o/submit.h
index 44f5285..6a9ed00 100644
--- a/include/pushmi/o/submit.h
+++ b/include/pushmi/o/submit.h
@@ -7,7 +7,7 @@
 // LICENSE file in the root directory of this source tree.
 
 #include <functional>
-#include "../time_single_deferred.h"
+#include "../time_single_sender.h"
 #include "../boosters.h"
 #include "extension_operators.h"
 #include "../trampoline.h"
diff --git a/include/pushmi/o/switch_on_error.h b/include/pushmi/o/switch_on_error.h
index 9d535c4..7310dd0 100644
--- a/include/pushmi/o/switch_on_error.h
+++ b/include/pushmi/o/switch_on_error.h
@@ -43,7 +43,7 @@ struct switch_on_error_fn {
     PUSHMI_TEMPLATE (class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(
           out_impl<In, ErrorSelector>{es_}
diff --git a/include/pushmi/o/tap.h b/include/pushmi/o/tap.h
index 95295ec..434f3e2 100644
--- a/include/pushmi/o/tap.h
+++ b/include/pushmi/o/tap.h
@@ -8,9 +8,9 @@
 
 #include <cassert>
 #include "extension_operators.h"
-#include "../deferred.h"
-#include "../single_deferred.h"
-#include "../time_single_deferred.h"
+#include "../sender.h"
+#include "../single_sender.h"
+#include "../time_single_sender.h"
 
 namespace pushmi {
 
@@ -72,13 +72,13 @@ struct tap_fn {
   template <class In, class SideEffects>
   static auto impl(In in, SideEffects sideEffects) {
     PUSHMI_STATIC_ASSERT(
-      ::pushmi::detail::deferred_requires_from<In, SideEffects,
+      ::pushmi::detail::sender_requires_from<In, SideEffects,
         SenderTo<In, SideEffects, is_none<>>,
         SenderTo<In, SideEffects, is_single<>>,
         TimeSenderTo<In, SideEffects, is_single<>> >(),
         "'In' is not deliverable to 'SideEffects'");
 
-    return ::pushmi::detail::deferred_from(
+    return ::pushmi::detail::sender_from(
       std::move(in),
       ::pushmi::detail::submit_transform_out<In>(
         out_impl<In, SideEffects>{std::move(sideEffects)}
@@ -104,7 +104,7 @@ struct tap_fn {
       (requires Receiver<Out>)
     auto operator()(Out out) const {
       PUSHMI_STATIC_ASSERT(
-        ::pushmi::detail::deferred_requires_from<In, SideEffects,
+        ::pushmi::detail::sender_requires_from<In, SideEffects,
           SenderTo<In, Out, is_none<>>,
           SenderTo<In, Out, is_single<>>,
           TimeSenderTo<In, Out, is_single<>> >(),
@@ -113,7 +113,7 @@ struct tap_fn {
           detail::make_tap(sideEffects_, std::move(out)))};
       using Gang = decltype(gang);
       PUSHMI_STATIC_ASSERT(
-        ::pushmi::detail::deferred_requires_from<In, SideEffects,
+        ::pushmi::detail::sender_requires_from<In, SideEffects,
           SenderTo<In, Gang>,
           SenderTo<In, Gang, is_single<>>,
           TimeSenderTo<In, Gang, is_single<>> >(),
diff --git a/include/pushmi/o/transform.h b/include/pushmi/o/transform.h
index 18dc488..67013a8 100644
--- a/include/pushmi/o/transform.h
+++ b/include/pushmi/o/transform.h
@@ -60,6 +60,11 @@ struct transform_on<F, is_many<>> {
   }
 };
 
+template<class Cardinality, class F>
+auto make_transform_on(F f) {
+  return transform_on<F, Cardinality>(std::move(f));
+}
+
 struct transform_fn {
 private:
   template <class F>
@@ -69,11 +74,11 @@ struct transform_fn {
       (requires Sender<In>)
     auto operator()(In in) const {
       using Cardinality = property_set_index_t<properties_t<In>, is_silent<>>;
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(
           // copy 'f_' to allow multiple calls to connect to multiple 'in'
-          transform_on<F, Cardinality>{f_}
+          make_transform_on<Cardinality>(f_)
         )
       );
     }
diff --git a/include/pushmi/o/via.h b/include/pushmi/o/via.h
index 2e47ca5..71abb4d 100644
--- a/include/pushmi/o/via.h
+++ b/include/pushmi/o/via.h
@@ -109,7 +109,7 @@ struct via_fn {
     PUSHMI_TEMPLATE (class In)
       (requires Sender<In>)
     auto operator()(In in) const {
-      return ::pushmi::detail::deferred_from(
+      return ::pushmi::detail::sender_from(
         std::move(in),
         ::pushmi::detail::submit_transform_out<In>(
           out_impl<In, ExecutorFactory>{ef_}
diff --git a/include/pushmi/deferred.h b/include/pushmi/sender.h
similarity index 71%
rename from include/pushmi/deferred.h
rename to include/pushmi/sender.h
index a20a04b..f100677 100644
--- a/include/pushmi/deferred.h
+++ b/include/pushmi/sender.h
@@ -8,11 +8,11 @@
 
 namespace pushmi {
 namespace detail {
-struct erase_deferred_t {};
+struct erase_sender_t {};
 } // namespace detail
 
 template <class E>
-class deferred<detail::erase_deferred_t, E> {
+class sender<detail::erase_sender_t, E> {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(std::promise<void>)]; // can hold a void promise in-situ
@@ -31,7 +31,7 @@ class deferred<detail::erase_deferred_t, E> {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  deferred(Wrapped obj, std::false_type) : deferred() {
+  sender(Wrapped obj, std::false_type) : sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -47,7 +47,7 @@ class deferred<detail::erase_deferred_t, E> {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  deferred(Wrapped obj, std::true_type) noexcept : deferred() {
+  sender(Wrapped obj, std::true_type) noexcept : sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -66,25 +66,25 @@ class deferred<detail::erase_deferred_t, E> {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, sender>::value, U>;
  public:
   using properties = property_set<is_sender<>, is_none<>>;
 
-  deferred() = default;
-  deferred(deferred&& that) noexcept : deferred() {
+  sender() = default;
+  sender(sender&& that) noexcept : sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
   PUSHMI_TEMPLATE(class Wrapped)
     (requires SenderTo<wrapped_t<Wrapped>, any_none<E>, is_none<>>)
-  explicit deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-    : deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
-  ~deferred() {
+  explicit sender(Wrapped obj) noexcept(insitu<Wrapped>())
+    : sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
+  ~sender() {
     vptr_->op_(data_, nullptr);
   }
-  deferred& operator=(deferred&& that) noexcept {
-    this->~deferred();
-    new ((void*)this) deferred(std::move(that));
+  sender& operator=(sender&& that) noexcept {
+    this->~sender();
+    new ((void*)this) sender(std::move(that));
     return *this;
   }
   void submit(any_none<E> out) {
@@ -94,18 +94,18 @@ class deferred<detail::erase_deferred_t, E> {
 
 // Class static definitions:
 template <class E>
-constexpr typename deferred<detail::erase_deferred_t, E>::vtable const
-    deferred<detail::erase_deferred_t, E>::noop_;
+constexpr typename sender<detail::erase_sender_t, E>::vtable const
+    sender<detail::erase_sender_t, E>::noop_;
 
 template <class SF>
-class deferred<SF> {
+class sender<SF> {
   SF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_none<>>;
 
-  constexpr deferred() = default;
-  constexpr explicit deferred(SF sf) : sf_(std::move(sf)) {}
+  constexpr sender() = default;
+  constexpr explicit sender(SF sf) : sf_(std::move(sf)) {}
   PUSHMI_TEMPLATE(class Out)
     (requires Receiver<Out, is_none<>> && Invocable<SF&, Out>)
   void submit(Out out) {
@@ -114,7 +114,7 @@ class deferred<SF> {
 };
 
 template <PUSHMI_TYPE_CONSTRAINT(Sender<is_none<>>) Data, class DSF>
-class deferred<Data, DSF> {
+class sender<Data, DSF> {
   Data data_;
   DSF sf_;
   static_assert(Sender<Data, is_none<>>, "The Data template parameter "
@@ -123,10 +123,10 @@ class deferred<Data, DSF> {
  public:
   using properties = property_set<is_sender<>, is_none<>>;
 
-  constexpr deferred() = default;
-  constexpr explicit deferred(Data data)
+  constexpr sender() = default;
+  constexpr explicit sender(Data data)
       : data_(std::move(data)) {}
-  constexpr deferred(Data data, DSF sf)
+  constexpr sender(Data data, DSF sf)
       : data_(std::move(data)), sf_(std::move(sf)) {}
 
   PUSHMI_TEMPLATE(class Out)
@@ -137,60 +137,60 @@ class deferred<Data, DSF> {
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_deferred
-PUSHMI_INLINE_VAR constexpr struct make_deferred_fn {
+// make_sender
+PUSHMI_INLINE_VAR constexpr struct make_sender_fn {
   inline auto operator()() const {
-    return deferred<ignoreSF>{};
+    return sender<ignoreSF>{};
   }
   template <class SF>
   auto operator()(SF sf) const {
-    return deferred<SF>{std::move(sf)};
+    return sender<SF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE(class Wrapped)
     (requires Sender<Wrapped, is_none<>>)
   auto operator()(Wrapped w) const {
-    return deferred<detail::erase_deferred_t, std::exception_ptr>{std::move(w)};
+    return sender<detail::erase_sender_t, std::exception_ptr>{std::move(w)};
   }
   PUSHMI_TEMPLATE(class Data, class DSF)
     (requires Sender<Data, is_none<>>)
   auto operator()(Data data, DSF sf) const {
-    return deferred<Data, DSF>{std::move(data), std::move(sf)};
+    return sender<Data, DSF>{std::move(data), std::move(sf)};
   }
-} const make_deferred {};
+} const make_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-deferred() -> deferred<ignoreSF>;
+sender() -> sender<ignoreSF>;
 
 template <class SF>
-deferred(SF) -> deferred<SF>;
+sender(SF) -> sender<SF>;
 
 PUSHMI_TEMPLATE(class Wrapped)
   (requires Sender<Wrapped, is_none<>>)
-deferred(Wrapped) ->
-    deferred<detail::erase_deferred_t, std::exception_ptr>;
+sender(Wrapped) ->
+    sender<detail::erase_sender_t, std::exception_ptr>;
 
 PUSHMI_TEMPLATE(class Data, class DSF)
   (requires Sender<Data, is_none<>>)
-deferred(Data, DSF) -> deferred<Data, DSF>;
+sender(Data, DSF) -> sender<Data, DSF>;
 #endif
 
 template <class E = std::exception_ptr>
-using any_deferred = deferred<detail::erase_deferred_t, E>;
+using any_sender = sender<detail::erase_sender_t, E>;
 
 template<>
-struct construct_deduced<deferred> : make_deferred_fn {};
+struct construct_deduced<sender> : make_sender_fn {};
 
 // template <SenderTo<any_none<std::exception_ptr>, is_none<>> Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return deferred<detail::erase_deferred_t, std::exception_ptr>{std::move(w)};
+//   return sender<detail::erase_sender_t, std::exception_ptr>{std::move(w)};
 // }
 //
 // template <class E, SenderTo<any_none<E>, is_none<>> Wrapped>
 //   requires Same<is_none<>, properties_t<Wrapped>>
 // auto erase_cast(Wrapped w) {
-//   return deferred<detail::erase_deferred_t, E>{std::move(w)};
+//   return sender<detail::erase_sender_t, E>{std::move(w)};
 // }
 
 } // namespace pushmi
diff --git a/include/pushmi/single_deferred.h b/include/pushmi/single_sender.h
similarity index 68%
rename from include/pushmi/single_deferred.h
rename to include/pushmi/single_sender.h
index 2f9ed45..1c2e556 100644
--- a/include/pushmi/single_deferred.h
+++ b/include/pushmi/single_sender.h
@@ -9,7 +9,7 @@
 namespace pushmi {
 
 template <class V, class E = std::exception_ptr>
-class any_single_deferred {
+class any_single_sender {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(V)]; // can hold a V in-situ
@@ -28,7 +28,7 @@ class any_single_deferred {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  any_single_deferred(Wrapped obj, std::false_type) : any_single_deferred() {
+  any_single_sender(Wrapped obj, std::false_type) : any_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -44,8 +44,8 @@ class any_single_deferred {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  any_single_deferred(Wrapped obj, std::true_type) noexcept
-      : any_single_deferred() {
+  any_single_sender(Wrapped obj, std::true_type) noexcept
+      : any_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -64,27 +64,27 @@ class any_single_deferred {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, any_single_deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, any_single_sender>::value, U>;
  public:
   using properties = property_set<is_sender<>, is_single<>>;
 
-  any_single_deferred() = default;
-  any_single_deferred(any_single_deferred&& that) noexcept
-      : any_single_deferred() {
+  any_single_sender() = default;
+  any_single_sender(any_single_sender&& that) noexcept
+      : any_single_sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
 
   PUSHMI_TEMPLATE(class Wrapped)
     (requires SenderTo<wrapped_t<Wrapped>, single<V, E>, is_single<>>)
-  explicit any_single_deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-    : any_single_deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
-  ~any_single_deferred() {
+  explicit any_single_sender(Wrapped obj) noexcept(insitu<Wrapped>())
+    : any_single_sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {}
+  ~any_single_sender() {
     vptr_->op_(data_, nullptr);
   }
-  any_single_deferred& operator=(any_single_deferred&& that) noexcept {
-    this->~any_single_deferred();
-    new ((void*)this) any_single_deferred(std::move(that));
+  any_single_sender& operator=(any_single_sender&& that) noexcept {
+    this->~any_single_sender();
+    new ((void*)this) any_single_sender(std::move(that));
     return *this;
   }
   void submit(single<V, E> out) {
@@ -94,18 +94,18 @@ class any_single_deferred {
 
 // Class static definitions:
 template <class V, class E>
-constexpr typename any_single_deferred<V, E>::vtable const
-  any_single_deferred<V, E>::noop_;
+constexpr typename any_single_sender<V, E>::vtable const
+  any_single_sender<V, E>::noop_;
 
 template <class SF>
-class single_deferred<SF> {
+class single_sender<SF> {
   SF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_single<>>;
 
-  constexpr single_deferred() = default;
-  constexpr explicit single_deferred(SF sf)
+  constexpr single_sender() = default;
+  constexpr explicit single_sender(SF sf)
       : sf_(std::move(sf)) {}
 
   PUSHMI_TEMPLATE(class Out)
@@ -117,17 +117,17 @@ class single_deferred<SF> {
 
 namespace detail {
 template <PUSHMI_TYPE_CONSTRAINT(Sender<is_single<>>) Data, class DSF>
-class single_deferred_2 {
+class single_sender_2 {
   Data data_;
   DSF sf_;
 
  public:
   using properties = property_set<is_sender<>, is_single<>>;
 
-  constexpr single_deferred_2() = default;
-  constexpr explicit single_deferred_2(Data data)
+  constexpr single_sender_2() = default;
+  constexpr explicit single_sender_2(Data data)
       : data_(std::move(data)) {}
-  constexpr single_deferred_2(Data data, DSF sf)
+  constexpr single_sender_2(Data data, DSF sf)
       : data_(std::move(data)), sf_(std::move(sf)) {}
   PUSHMI_TEMPLATE(class Out)
     (requires PUSHMI_EXP(lazy::Receiver<Out, is_single<>> PUSHMI_AND
@@ -138,70 +138,70 @@ class single_deferred_2 {
 };
 
 template <class A, class B>
-using single_deferred_base =
+using single_sender_base =
   std::conditional_t<
     (bool)Sender<A, is_single<>>,
-    single_deferred_2<A, B>,
-    any_single_deferred<A, B>>;
+    single_sender_2<A, B>,
+    any_single_sender<A, B>>;
 } // namespace detail
 
 template <class A, class B>
-struct single_deferred<A, B>
-  : detail::single_deferred_base<A, B> {
-  constexpr single_deferred() = default;
-  using detail::single_deferred_base<A, B>::single_deferred_base;
+struct single_sender<A, B>
+  : detail::single_sender_base<A, B> {
+  constexpr single_sender() = default;
+  using detail::single_sender_base<A, B>::single_sender_base;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_single_deferred
-PUSHMI_INLINE_VAR constexpr struct make_single_deferred_fn {
+// make_single_sender
+PUSHMI_INLINE_VAR constexpr struct make_single_sender_fn {
   inline auto operator()() const {
-    return single_deferred<ignoreSF>{};
+    return single_sender<ignoreSF>{};
   }
   PUSHMI_TEMPLATE(class SF)
     (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
   auto operator()(SF sf) const {
-    return single_deferred<SF>{std::move(sf)};
+    return single_sender<SF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE(class Data)
     (requires True<> && Sender<Data, is_single<>>)
   auto operator()(Data d) const {
-    return single_deferred<Data, passDSF>{std::move(d)};
+    return single_sender<Data, passDSF>{std::move(d)};
   }
   PUSHMI_TEMPLATE(class Data, class DSF)
     (requires Sender<Data, is_single<>>)
   auto operator()(Data d, DSF sf) const {
-    return single_deferred<Data, DSF>{std::move(d), std::move(sf)};
+    return single_sender<Data, DSF>{std::move(d), std::move(sf)};
   }
-} const make_single_deferred {};
+} const make_single_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-single_deferred() -> single_deferred<ignoreSF>;
+single_sender() -> single_sender<ignoreSF>;
 
 PUSHMI_TEMPLATE(class SF)
   (requires True<> PUSHMI_BROKEN_SUBSUMPTION(&& not Sender<SF>))
-single_deferred(SF) -> single_deferred<SF>;
+single_sender(SF) -> single_sender<SF>;
 
 PUSHMI_TEMPLATE(class Data)
   (requires True<> && Sender<Data, is_single<>>)
-single_deferred(Data) -> single_deferred<Data, passDSF>;
+single_sender(Data) -> single_sender<Data, passDSF>;
 
 PUSHMI_TEMPLATE(class Data, class DSF)
   (requires Sender<Data, is_single<>>)
-single_deferred(Data, DSF) -> single_deferred<Data, DSF>;
+single_sender(Data, DSF) -> single_sender<Data, DSF>;
 #endif
 
 template<>
-struct construct_deduced<single_deferred> : make_single_deferred_fn {};
+struct construct_deduced<single_sender> : make_single_sender_fn {};
 
 // template <
 //     class V,
 //     class E = std::exception_ptr,
 //     SenderTo<single<V, E>, is_single<>> Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return single_deferred<V, E>{std::move(w)};
+//   return single_sender<V, E>{std::move(w)};
 // }
 
 } // namespace pushmi
diff --git a/include/pushmi/subject.h b/include/pushmi/subject.h
index 463c300..323700d 100644
--- a/include/pushmi/subject.h
+++ b/include/pushmi/subject.h
@@ -7,7 +7,7 @@
 
 #include <vector>
 
-#include <pushmi/time_single_deferred.h>
+#include <pushmi/time_single_sender.h>
 
 namespace pushmi {
 
@@ -58,7 +58,7 @@ struct subject<T, PS> {
     }
   };
 
-  // need a template overload of none/deferred and the rest that stores a 'ptr' with its own lifetime management
+  // need a template overload of none/sender and the rest that stores a 'ptr' with its own lifetime management
   struct subject_receiver {
 
     using properties = property_set_insert_t<property_set<is_receiver<>, is_single<>>, PS>;
diff --git a/include/pushmi/time_single_deferred.h b/include/pushmi/time_single_sender.h
similarity index 68%
rename from include/pushmi/time_single_deferred.h
rename to include/pushmi/time_single_sender.h
index f481872..5ab0b49 100644
--- a/include/pushmi/time_single_deferred.h
+++ b/include/pushmi/time_single_sender.h
@@ -12,7 +12,7 @@ template <
     class V,
     class E = std::exception_ptr,
     class TP = std::chrono::system_clock::time_point>
-class any_time_single_deferred {
+class any_time_single_sender {
   union data {
     void* pobj_ = nullptr;
     char buffer_[sizeof(std::promise<int>)]; // can hold a V in-situ
@@ -33,8 +33,8 @@ class any_time_single_deferred {
   static constexpr vtable const noop_ {};
   vtable const* vptr_ = &noop_;
   template <class Wrapped>
-  any_time_single_deferred(Wrapped obj, std::false_type)
-    : any_time_single_deferred() {
+  any_time_single_sender(Wrapped obj, std::false_type)
+    : any_time_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -56,8 +56,8 @@ class any_time_single_deferred {
     vptr_ = &vtbl;
   }
   template <class Wrapped>
-  any_time_single_deferred(Wrapped obj, std::true_type) noexcept
-    : any_time_single_deferred() {
+  any_time_single_sender(Wrapped obj, std::true_type) noexcept
+    : any_time_single_sender() {
     struct s {
       static void op(data& src, data* dst) {
         if (dst)
@@ -81,28 +81,28 @@ class any_time_single_deferred {
   }
   template <class T, class U = std::decay_t<T>>
   using wrapped_t =
-    std::enable_if_t<!std::is_same<U, any_time_single_deferred>::value, U>;
+    std::enable_if_t<!std::is_same<U, any_time_single_sender>::value, U>;
 
  public:
   using properties = property_set<is_time<>, is_single<>>;
 
-  any_time_single_deferred() = default;
-  any_time_single_deferred(any_time_single_deferred&& that) noexcept
-      : any_time_single_deferred() {
+  any_time_single_sender() = default;
+  any_time_single_sender(any_time_single_sender&& that) noexcept
+      : any_time_single_sender() {
     that.vptr_->op_(that.data_, &data_);
     std::swap(that.vptr_, vptr_);
   }
   PUSHMI_TEMPLATE (class Wrapped)
     (requires TimeSenderTo<wrapped_t<Wrapped>, single<V, E>>)
-  explicit any_time_single_deferred(Wrapped obj) noexcept(insitu<Wrapped>())
-  : any_time_single_deferred{std::move(obj), bool_<insitu<Wrapped>()>{}} {
+  explicit any_time_single_sender(Wrapped obj) noexcept(insitu<Wrapped>())
+  : any_time_single_sender{std::move(obj), bool_<insitu<Wrapped>()>{}} {
   }
-  ~any_time_single_deferred() {
+  ~any_time_single_sender() {
     vptr_->op_(data_, nullptr);
   }
-  any_time_single_deferred& operator=(any_time_single_deferred&& that) noexcept {
-    this->~any_time_single_deferred();
-    new ((void*)this) any_time_single_deferred(std::move(that));
+  any_time_single_sender& operator=(any_time_single_sender&& that) noexcept {
+    this->~any_time_single_sender();
+    new ((void*)this) any_time_single_sender(std::move(that));
     return *this;
   }
   TP now() {
@@ -115,24 +115,24 @@ class any_time_single_deferred {
 
 // Class static definitions:
 template <class V, class E, class TP>
-constexpr typename any_time_single_deferred<V, E, TP>::vtable const
-    any_time_single_deferred<V, E, TP>::noop_;
+constexpr typename any_time_single_sender<V, E, TP>::vtable const
+    any_time_single_sender<V, E, TP>::noop_;
 
 template <class SF, class NF>
 #if __cpp_concepts
   requires Invocable<NF&>
 #endif
-class time_single_deferred<SF, NF> {
+class time_single_sender<SF, NF> {
   SF sf_;
   NF nf_;
 
  public:
   using properties = property_set<is_time<>, is_single<>>;
 
-  constexpr time_single_deferred() = default;
-  constexpr explicit time_single_deferred(SF sf)
+  constexpr time_single_sender() = default;
+  constexpr explicit time_single_sender(SF sf)
       : sf_(std::move(sf)) {}
-  constexpr time_single_deferred(SF sf, NF nf)
+  constexpr time_single_sender(SF sf, NF nf)
       : sf_(std::move(sf)), nf_(std::move(nf)) {}
   auto now() {
     return nf_();
@@ -150,7 +150,7 @@ template <PUSHMI_TYPE_CONSTRAINT(TimeSender<is_single<>>) Data, class DSF, class
 #if __cpp_concepts
   requires Invocable<DNF&, Data&>
 #endif
-class time_single_deferred_2 {
+class time_single_sender_2 {
   Data data_;
   DSF sf_;
   DNF nf_;
@@ -158,10 +158,10 @@ class time_single_deferred_2 {
  public:
   using properties = property_set<is_time<>, is_single<>>;
 
-  constexpr time_single_deferred_2() = default;
-  constexpr explicit time_single_deferred_2(Data data)
+  constexpr time_single_sender_2() = default;
+  constexpr explicit time_single_sender_2(Data data)
       : data_(std::move(data)) {}
-  constexpr time_single_deferred_2(Data data, DSF sf, DNF nf = DNF{})
+  constexpr time_single_sender_2(Data data, DSF sf, DNF nf = DNF{})
       : data_(std::move(data)), sf_(std::move(sf)), nf_(std::move(nf)) {}
   auto now() {
     return nf_(data_);
@@ -175,72 +175,72 @@ class time_single_deferred_2 {
 };
 
 template <class A, class B, class C>
-using time_single_deferred_base =
+using time_single_sender_base =
   std::conditional_t<
     (bool)TimeSender<A, is_single<>>,
-    time_single_deferred_2<A, B, C>,
-    any_time_single_deferred<A, B, C>>;
+    time_single_sender_2<A, B, C>,
+    any_time_single_sender<A, B, C>>;
 } // namespace detail
 
 template <class A, class B, class C>
-struct time_single_deferred<A, B, C>
-  : detail::time_single_deferred_base<A, B, C> {
-  constexpr time_single_deferred() = default;
-  using detail::time_single_deferred_base<A, B, C>::time_single_deferred_base;
+struct time_single_sender<A, B, C>
+  : detail::time_single_sender_base<A, B, C> {
+  constexpr time_single_sender() = default;
+  using detail::time_single_sender_base<A, B, C>::time_single_sender_base;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// make_time_single_deferred
-PUSHMI_INLINE_VAR constexpr struct make_time_single_deferred_fn {
+// make_time_single_sender
+PUSHMI_INLINE_VAR constexpr struct make_time_single_sender_fn {
   inline auto operator()() const  {
-    return time_single_deferred<ignoreSF, systemNowF>{};
+    return time_single_sender<ignoreSF, systemNowF>{};
   }
   template <class SF>
   auto operator()(SF sf) const {
-    return time_single_deferred<SF, systemNowF>{std::move(sf)};
+    return time_single_sender<SF, systemNowF>{std::move(sf)};
   }
   PUSHMI_TEMPLATE (class SF, class NF)
     (requires Invocable<NF&>)
   auto operator()(SF sf, NF nf) const {
-    return time_single_deferred<SF, NF>{std::move(sf), std::move(nf)};
+    return time_single_sender<SF, NF>{std::move(sf), std::move(nf)};
   }
   PUSHMI_TEMPLATE (class Data, class DSF)
     (requires TimeSender<Data, is_single<>>)
   auto operator()(Data d, DSF sf) const {
-    return time_single_deferred<Data, DSF, passDNF>{std::move(d), std::move(sf)};
+    return time_single_sender<Data, DSF, passDNF>{std::move(d), std::move(sf)};
   }
   PUSHMI_TEMPLATE (class Data, class DSF, class DNF)
     (requires TimeSender<Data, is_single<>> && Invocable<DNF&, Data&>)
   auto operator()(Data d, DSF sf, DNF nf) const  {
-    return time_single_deferred<Data, DSF, DNF>{std::move(d), std::move(sf),
+    return time_single_sender<Data, DSF, DNF>{std::move(d), std::move(sf),
       std::move(nf)};
   }
-} const make_time_single_deferred {};
+} const make_time_single_sender {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // deduction guides
 #if __cpp_deduction_guides >= 201703
-time_single_deferred() -> time_single_deferred<ignoreSF, systemNowF>;
+time_single_sender() -> time_single_sender<ignoreSF, systemNowF>;
 
 template <class SF>
-time_single_deferred(SF) -> time_single_deferred<SF, systemNowF>;
+time_single_sender(SF) -> time_single_sender<SF, systemNowF>;
 
 PUSHMI_TEMPLATE (class SF, class NF)
   (requires Invocable<NF&>)
-time_single_deferred(SF, NF) -> time_single_deferred<SF, NF>;
+time_single_sender(SF, NF) -> time_single_sender<SF, NF>;
 
 PUSHMI_TEMPLATE (class Data, class DSF)
   (requires TimeSender<Data, is_single<>>)
-time_single_deferred(Data, DSF) -> time_single_deferred<Data, DSF, passDNF>;
+time_single_sender(Data, DSF) -> time_single_sender<Data, DSF, passDNF>;
 
 PUSHMI_TEMPLATE (class Data, class DSF, class DNF)
   (requires TimeSender<Data, is_single<>> && Invocable<DNF&, Data&>)
-time_single_deferred(Data, DSF, DNF) -> time_single_deferred<Data, DSF, DNF>;
+time_single_sender(Data, DSF, DNF) -> time_single_sender<Data, DSF, DNF>;
 #endif
 
 template<>
-struct construct_deduced<time_single_deferred>
-  : make_time_single_deferred_fn {};
+struct construct_deduced<time_single_sender>
+  : make_time_single_sender_fn {};
 
 // template <
 //     class V,
@@ -248,7 +248,7 @@ struct construct_deduced<time_single_deferred>
 //     class TP = std::chrono::system_clock::time_point,
 //     TimeSenderTo<single<V, E>, is_single<>> Wrapped>
 // auto erase_cast(Wrapped w) {
-//   return time_single_deferred<V, E>{std::move(w)};
+//   return time_single_sender<V, E>{std::move(w)};
 // }
 
 } // namespace pushmi
diff --git a/include/pushmi/trampoline.h b/include/pushmi/trampoline.h
index a385eaa..f48a425 100644
--- a/include/pushmi/trampoline.h
+++ b/include/pushmi/trampoline.h
@@ -9,7 +9,7 @@
 #include <deque>
 #include <thread>
 #include "executor.h"
-#include "time_single_deferred.h"
+#include "time_single_sender.h"
 
 namespace pushmi {
 
diff --git a/test/AsyncTest.cpp b/test/AsyncTest.cpp
new file mode 100644
index 0000000..b420bee
--- /dev/null
+++ b/test/AsyncTest.cpp
@@ -0,0 +1,192 @@
+#include "catch.hpp"
+
+#include <type_traits>
+
+#include <chrono>
+#include <condition_variable>
+#include <set>
+
+using namespace std::literals;
+
+#include "pushmi/flow_single_sender.h"
+#include "pushmi/o/async.h"
+#include "pushmi/o/empty.h"
+#include "pushmi/o/just.h"
+#include "pushmi/o/on.h"
+#include "pushmi/o/transform.h"
+#include "pushmi/o/tap.h"
+#include "pushmi/o/via.h"
+#include "pushmi/o/submit.h"
+#include "pushmi/o/extension_operators.h"
+
+#include "pushmi/trampoline.h"
+#include "pushmi/new_thread.h"
+
+// Pause ensures that the tasks take long enough that the enqueue task
+// runs ahead and multiple threads are launched
+void pause() {
+  std::this_thread::sleep_for(100ms);
+}
+
+using namespace pushmi::aliases;
+
+struct __inline_submit {
+
+  template<class TP, class Out>
+  void operator()(TP at, Out out) const {
+    auto tr = ::pushmi::trampoline();
+    ::pushmi::submit(tr, std::move(at), std::move(out));
+  }
+};
+
+inline auto inline_executor() {
+  return ::pushmi::make_time_single_sender(__inline_submit{});
+}
+
+SCENARIO( "async", "[async]" ) {
+  GIVEN( "A new_thread time_single_sender" ) {
+    auto nt = v::new_thread();
+    using NT = decltype(nt);
+
+    std::mutex threads_mutex;
+
+    WHEN( "async task chain used with via" ) {
+      {
+        std::vector<std::string> values;
+        std::set<std::thread::id> threads;
+        auto workerTask = [&threads, &threads_mutex](auto v) mutable {
+          std::lock_guard<std::mutex> lck(threads_mutex);
+          threads.insert(std::this_thread::get_id());
+          pause();
+          return v + 1;
+        };
+
+        auto comparablething = op::just(2.0) |
+          op::via([&](){return nt;}) |
+          op::transform([exec = nt](auto v){
+            auto token = pushmi::detail::NewThreadAsyncToken<
+                std::decay_t<decltype(v)>, std::decay_t<decltype(exec)>>{
+              exec};
+            token.dataPtr_->v_ = std::forward<decltype(v)>(v);
+            return token;
+          }) |
+          op::transform([workerTask](auto v) mutable {
+            v.dataPtr_->v_ = workerTask(v.dataPtr_->v_);
+            return v;
+          }) |
+          op::transform([workerTask](auto v) mutable {
+            v.dataPtr_->v_ = workerTask(v.dataPtr_->v_);
+            return v;
+          }) |
+          op::transform([workerTask](auto v) mutable {
+            v.dataPtr_->v_ = workerTask(v.dataPtr_->v_);
+            return v;
+          }) |
+          op::transform([workerTask](auto v) mutable {
+            v.dataPtr_->v_ = workerTask(v.dataPtr_->v_);
+            return v;
+          }) |
+          op::transform([workerTask](auto v) mutable {
+            v.dataPtr_->v_ = workerTask(v.dataPtr_->v_);
+            return v;
+          }) |
+          op::transform([workerTask](auto v) mutable {
+            v.dataPtr_->v_ = workerTask(v.dataPtr_->v_);
+            return v;
+          }) |
+          op::transform([](auto v){return v.dataPtr_->v_;}) |
+          op::blocking_submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
+
+        THEN( "only the first item was pushed" ) {
+          REQUIRE(values == std::vector<std::string>{"8.000000"});
+          // Should be inline on a single thread as transform is literal
+          REQUIRE(threads.size() == 1);
+        }
+      }
+
+      {
+        std::vector<std::string> values;
+        std::set<std::thread::id> threads;
+        auto workerTask = [&threads, &threads_mutex](auto v) mutable {
+          std::lock_guard<std::mutex> lck(threads_mutex);
+          threads.insert(std::this_thread::get_id());
+          std::this_thread::sleep_for(100ms);
+          pause();
+          return v + 1;
+        };
+
+        auto realthing = op::just(2.0) |
+          op::async_fork([&](){return nt;}) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_join() |
+          op::blocking_submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
+
+        THEN( "only the first item was pushed" ) {
+          REQUIRE(values == std::vector<std::string>{"8.000000"});
+          // Should be asynchronous on multiple threads
+          REQUIRE(threads.size() != 1);
+        }
+      }
+    }
+  }
+
+  GIVEN( "An inline time_single_sender" ) {
+    auto inline_exec = inline_executor();
+    std::mutex threads_mutex;
+
+    WHEN( "async task chain used with via" ) {
+      {
+        std::vector<std::string> values;
+        std::set<std::thread::id> threads;
+        auto workerTask = [&threads, &threads_mutex](auto v) mutable {
+          std::lock_guard<std::mutex> lck(threads_mutex);
+          threads.insert(std::this_thread::get_id());
+          pause();
+          return v + 1;
+        };
+
+        auto realthing = op::just(2.0) |
+          op::async_fork([&](){return inline_exec;}) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_transform(workerTask) |
+          op::async_join() |
+          op::blocking_submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
+
+        THEN( "only the first item was pushed" ) {
+          REQUIRE(values == std::vector<std::string>{"8.000000"});
+          // Should have all been inline on a single thread
+          REQUIRE(threads.size() == 1);
+        }
+      }
+    }
+
+    WHEN( "async bulk" ) {
+      {
+        std::vector<std::string> values;
+
+        auto realthing = op::just(2.0) |
+          op::async_fork([&](){return inline_exec;}) |
+          op::async_bulk(
+            [](const auto& input, size_t idx, auto& shared){shared += idx;}, // on_value
+            [](const auto& input) -> size_t { return 10; },                  // shape factory
+            [](const auto& input, size_t shape){ return 0; },                // shared factory
+            [](auto& shared){return shared;}) |                              // result selector
+          op::async_join() |
+          op::blocking_submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
+
+        THEN( "only the first item was pushed" ) {
+          REQUIRE(values == std::vector<std::string>{"55.000000"});
+        }
+      }
+    }
+  }
+}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index da19825..e32ca38 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -5,15 +5,19 @@ target_include_directories(catch PUBLIC
 
 include(../external/Catch2/contrib/Catch.cmake)
 
-
 if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
 
+add_executable(AsyncTest AsyncTest.cpp)
+target_link_libraries(AsyncTest pushmi catch Threads::Threads)
+catch_discover_tests(AsyncTest)
+
 add_executable(FlowTest FlowTest.cpp)
 target_link_libraries(FlowTest pushmi catch Threads::Threads)
 catch_discover_tests(FlowTest)
 
 add_executable(CompileTest CompileTest.cpp)
 target_link_libraries(CompileTest pushmi catch Threads::Threads)
+add_dependencies(CompileTest buildSingleHeader)
 # catch_discover_tests(CompileTest)
 
 add_executable(NewThreadTest NewThreadTest.cpp)
@@ -31,6 +35,7 @@ catch_discover_tests(PushmiTest)
 else()
 
 add_executable(PushmiTest PushmiTest.cpp
+  AsyncTest.cpp
   CompileTest.cpp
   TrampolineTest.cpp
   NewThreadTest.cpp
diff --git a/test/CompileTest.cpp b/test/CompileTest.cpp
index 6461b9d..deb74e6 100644
--- a/test/CompileTest.cpp
+++ b/test/CompileTest.cpp
@@ -55,10 +55,10 @@ void none_test() {
   auto any3 = pushmi::any_none<>(proxy0);
 }
 
-void deferred_test(){
-  auto in0 = pushmi::MAKE(deferred)();
-  auto in1 = pushmi::MAKE(deferred)(pushmi::ignoreSF{});
-  auto in3 = pushmi::MAKE(deferred)([&](auto out){
+void sender_test(){
+  auto in0 = pushmi::MAKE(sender)();
+  auto in1 = pushmi::MAKE(sender)(pushmi::ignoreSF{});
+  auto in3 = pushmi::MAKE(sender)([&](auto out){
     in0.submit(pushmi::MAKE(none)(std::move(out), [](auto d, auto e) noexcept {
       pushmi::set_error(d, e);
     }));
@@ -74,7 +74,7 @@ void deferred_test(){
   out1.error(std::exception_ptr{});
   in3.submit(out1);
 
-  auto any0 = pushmi::any_deferred<>(in0);
+  auto any0 = pushmi::any_sender<>(in0);
 }
 
 void single_test() {
@@ -189,10 +189,10 @@ void many_test() {
   auto any1 = pushmi::any_many<int>(proxy0);
 }
 
-void single_deferred_test(){
-  auto in0 = pushmi::MAKE(single_deferred)();
-  auto in1 = pushmi::MAKE(single_deferred)(pushmi::ignoreSF{});
-  auto in3 = pushmi::MAKE(single_deferred)([&](auto out){
+void single_sender_test(){
+  auto in0 = pushmi::MAKE(single_sender)();
+  auto in1 = pushmi::MAKE(single_sender)(pushmi::ignoreSF{});
+  auto in3 = pushmi::MAKE(single_sender)([&](auto out){
     in0.submit(pushmi::MAKE(single)(std::move(out),
       pushmi::on_value([](auto d, int v){ pushmi::set_value(d, v); })
     ));
@@ -208,13 +208,13 @@ void single_deferred_test(){
   }));
   in3.submit(out1);
 
-  auto any0 = pushmi::any_single_deferred<int>(in0);
+  auto any0 = pushmi::any_single_sender<int>(in0);
 }
 
-void many_deferred_test(){
-  auto in0 = pushmi::MAKE(many_deferred)();
-  auto in1 = pushmi::MAKE(many_deferred)(pushmi::ignoreSF{});
-  auto in3 = pushmi::MAKE(many_deferred)([&](auto out){
+void many_sender_test(){
+  auto in0 = pushmi::MAKE(many_sender)();
+  auto in1 = pushmi::MAKE(many_sender)(pushmi::ignoreSF{});
+  auto in3 = pushmi::MAKE(many_sender)([&](auto out){
     in0.submit(pushmi::MAKE(many)(std::move(out),
       pushmi::on_next([](auto d, int v){ pushmi::set_next(d, v); })
     ));
@@ -226,18 +226,18 @@ void many_deferred_test(){
   }));
   in3.submit(out1);
 
-  auto any0 = pushmi::any_many_deferred<int>(in0);
+  auto any0 = pushmi::any_many_sender<int>(in0);
 }
 
-void time_single_deferred_test(){
-  auto in0 = pushmi::MAKE(time_single_deferred)();
-  auto in1 = pushmi::MAKE(time_single_deferred)(pushmi::ignoreSF{});
-  auto in3 = pushmi::MAKE(time_single_deferred)([&](auto tp, auto out){
+void time_single_sender_test(){
+  auto in0 = pushmi::MAKE(time_single_sender)();
+  auto in1 = pushmi::MAKE(time_single_sender)(pushmi::ignoreSF{});
+  auto in3 = pushmi::MAKE(time_single_sender)([&](auto tp, auto out){
     in0.submit(tp, pushmi::MAKE(single)(std::move(out),
       pushmi::on_value([](auto d, int v){ pushmi::set_value(d, v); })
     ));
   });
-  auto in4 = pushmi::MAKE(time_single_deferred)(pushmi::ignoreSF{}, pushmi::systemNowF{});
+  auto in4 = pushmi::MAKE(time_single_sender)(pushmi::ignoreSF{}, pushmi::systemNowF{});
 
   std::promise<int> p0;
   auto promise0 = pushmi::MAKE(single)(std::move(p0));
@@ -249,7 +249,7 @@ void time_single_deferred_test(){
   }));
   in3.submit(in0.now(), out1);
 
-  auto any0 = pushmi::any_time_single_deferred<int>(in0);
+  auto any0 = pushmi::any_time_single_sender<int>(in0);
 
   in3 | op::submit();
   in3 | op::submit_at(in3.now() + 1s);
@@ -365,10 +365,10 @@ void flow_single_test() {
   auto any3 = pushmi::any_flow_single<int>(proxy0);
 }
 
-void flow_single_deferred_test(){
-  auto in0 = pushmi::MAKE(flow_single_deferred)();
-  auto in1 = pushmi::MAKE(flow_single_deferred)(pushmi::ignoreSF{});
-  auto in3 = pushmi::MAKE(flow_single_deferred)([&](auto out){
+void flow_single_sender_test(){
+  auto in0 = pushmi::MAKE(flow_single_sender)();
+  auto in1 = pushmi::MAKE(flow_single_sender)(pushmi::ignoreSF{});
+  auto in3 = pushmi::MAKE(flow_single_sender)([&](auto out){
     in0.submit(pushmi::MAKE(flow_single)(std::move(out),
       pushmi::on_value([](auto d, int v){ pushmi::set_value(d, v); })
     ));
@@ -380,5 +380,5 @@ void flow_single_deferred_test(){
   }));
   in3.submit(out1);
 
-  auto any0 = pushmi::any_flow_single_deferred<int>(in0);
+  auto any0 = pushmi::any_flow_single_sender<int>(in0);
 }
diff --git a/test/FlowTest.cpp b/test/FlowTest.cpp
index 9e9c4e1..ba3a0f6 100644
--- a/test/FlowTest.cpp
+++ b/test/FlowTest.cpp
@@ -5,7 +5,7 @@
 #include <chrono>
 using namespace std::literals;
 
-#include "pushmi/flow_single_deferred.h"
+#include "pushmi/flow_single_sender.h"
 #include "pushmi/o/submit.h"
 
 #include "pushmi/entangle.h"
@@ -22,11 +22,11 @@ using namespace pushmi::aliases;
 #define MAKE(x) make_##x
 #endif
 
-SCENARIO("flow single immediate cancellation", "[flow][deferred]") {
+SCENARIO("flow single immediate cancellation", "[flow][sender]") {
   int signals = 0;
 
-  GIVEN("A flow single deferred") {
-    auto f = mi::MAKE(flow_single_deferred)([&](auto out) {
+  GIVEN("A flow single sender") {
+    auto f = mi::MAKE(flow_single_sender)([&](auto out) {
       // boolean cancellation
       bool stop = false;
       auto set_stop = [](auto& stop) {
@@ -102,13 +102,13 @@ SCENARIO("flow single immediate cancellation", "[flow][deferred]") {
   }
 }
 
-SCENARIO("flow single cancellation trampoline", "[flow][deferred]") {
+SCENARIO("flow single cancellation trampoline", "[flow][sender]") {
   auto tr = mi::trampoline();
   using TR = decltype(tr);
   int signals = 0;
 
-  GIVEN("A flow single deferred") {
-    auto f = mi::MAKE(flow_single_deferred)([&](auto out) {
+  GIVEN("A flow single sender") {
+    auto f = mi::MAKE(flow_single_sender)([&](auto out) {
       // boolean cancellation
       bool stop = false;
       auto set_stop = [](auto& stop) {
@@ -213,14 +213,14 @@ struct moving_atomic : std::atomic<T> {
   moving_atomic(moving_atomic&& o) : std::atomic<T>(o.load()) {}
 };
 
-SCENARIO("flow single shared cancellation new thread", "[flow][deferred]") {
+SCENARIO("flow single shared cancellation new thread", "[flow][sender]") {
   auto nt = mi::new_thread();
   using NT = decltype(nt);
   std::atomic<int> signals{0};
   auto at = nt.now() + 200ms;
 
-  GIVEN("A flow single deferred") {
-    auto f = mi::MAKE(flow_single_deferred)([&](auto out) {
+  GIVEN("A flow single sender") {
+    auto f = mi::MAKE(flow_single_sender)([&](auto out) {
       // boolean cancellation
       bool stop = false;
       auto set_stop = [](auto& stop) {
@@ -383,14 +383,14 @@ SCENARIO("flow single shared cancellation new thread", "[flow][deferred]") {
   }
 }
 
-SCENARIO("flow single entangled cancellation new thread", "[flow][deferred]") {
+SCENARIO("flow single entangled cancellation new thread", "[flow][sender]") {
   auto nt = mi::new_thread();
   using NT = decltype(nt);
   std::atomic<int> signals{0};
   auto at = nt.now() + 200ms;
 
-  GIVEN("A flow single deferred") {
-    auto f = mi::MAKE(flow_single_deferred)([&](auto out) {
+  GIVEN("A flow single sender") {
+    auto f = mi::MAKE(flow_single_sender)([&](auto out) {
       // boolean cancellation
       bool stop = false;
       auto set_stop = [](auto& stop) {
diff --git a/test/NewThreadTest.cpp b/test/NewThreadTest.cpp
index 010e927..39a0e12 100644
--- a/test/NewThreadTest.cpp
+++ b/test/NewThreadTest.cpp
@@ -5,7 +5,7 @@
 #include <chrono>
 using namespace std::literals;
 
-#include "pushmi/flow_single_deferred.h"
+#include "pushmi/flow_single_sender.h"
 #include "pushmi/o/empty.h"
 #include "pushmi/o/just.h"
 #include "pushmi/o/on.h"
@@ -34,9 +34,9 @@ struct countdownsingle {
   }
 };
 
-SCENARIO( "new_thread executor", "[new_thread][deferred]" ) {
+SCENARIO( "new_thread executor", "[new_thread][sender]" ) {
 
-  GIVEN( "A new_thread time_single_deferred" ) {
+  GIVEN( "A new_thread time_single_sender" ) {
     auto nt = v::new_thread();
     using NT = decltype(nt);
 
@@ -140,14 +140,14 @@ SCENARIO( "new_thread executor", "[new_thread][deferred]" ) {
 
     WHEN( "used with on" ) {
       std::vector<std::string> values;
-      auto deferred = pushmi::make_single_deferred([](auto out) {
+      auto sender = pushmi::make_single_sender([](auto out) {
         ::pushmi::set_value(out, 2.0);
         // ignored
         ::pushmi::set_value(out, 1);
         ::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
         ::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
       });
-      deferred | op::on([&](){return nt;}) |
+      sender | op::on([&](){return nt;}) |
           op::blocking_submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
       THEN( "only the first item was pushed" ) {
         REQUIRE(values == std::vector<std::string>{"2.000000"});
@@ -156,14 +156,14 @@ SCENARIO( "new_thread executor", "[new_thread][deferred]" ) {
 
     WHEN( "used with via" ) {
       std::vector<std::string> values;
-      auto deferred = pushmi::make_single_deferred([](auto out) {
+      auto sender = pushmi::make_single_sender([](auto out) {
         ::pushmi::set_value(out, 2.0);
         // ignored
         ::pushmi::set_value(out, 1);
         ::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
         ::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
       });
-      deferred | op::via([&](){return nt;}) |
+      sender | op::via([&](){return nt;}) |
           op::blocking_submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
       THEN( "only the first item was pushed" ) {
         REQUIRE(values == std::vector<std::string>{"2.000000"});
diff --git a/test/PushmiTest.cpp b/test/PushmiTest.cpp
index eb0a932..8d95d77 100644
--- a/test/PushmiTest.cpp
+++ b/test/PushmiTest.cpp
@@ -5,7 +5,7 @@
 #include <chrono>
 using namespace std::literals;
 
-#include "pushmi/flow_single_deferred.h"
+#include "pushmi/flow_single_sender.h"
 #include "pushmi/o/empty.h"
 #include "pushmi/o/from.h"
 #include "pushmi/o/just.h"
@@ -22,9 +22,9 @@ using namespace std::literals;
 using namespace pushmi::aliases;
 
 
-SCENARIO( "empty can be used with tap and submit", "[empty][deferred]" ) {
+SCENARIO( "empty can be used with tap and submit", "[empty][sender]" ) {
 
-  GIVEN( "An empty deferred" ) {
+  GIVEN( "An empty sender" ) {
     auto e = op::empty();
     using E = decltype(e);
 
@@ -54,7 +54,7 @@ SCENARIO( "empty can be used with tap and submit", "[empty][deferred]" ) {
     }
   }
 
-  GIVEN( "An empty int single_deferred" ) {
+  GIVEN( "An empty int single_sender" ) {
     auto e = op::empty<int>();
     using E = decltype(e);
 
@@ -80,9 +80,9 @@ SCENARIO( "empty can be used with tap and submit", "[empty][deferred]" ) {
   }
 }
 
-SCENARIO( "just() can be used with transform and submit", "[just][deferred]" ) {
+SCENARIO( "just() can be used with transform and submit", "[just][sender]" ) {
 
-  GIVEN( "A just int single_deferred" ) {
+  GIVEN( "A just int single_sender" ) {
     auto j = op::just(20);
     using J = decltype(j);
 
@@ -119,9 +119,9 @@ SCENARIO( "just() can be used with transform and submit", "[just][deferred]" ) {
   }
 }
 
-SCENARIO( "from() can be used with transform and submit", "[from][deferred]" ) {
+SCENARIO( "from() can be used with transform and submit", "[from][sender]" ) {
 
-  GIVEN( "A from int many_deferred" ) {
+  GIVEN( "A from int many_sender" ) {
     int arr[] = {0, 9, 99};
     auto m = op::from(arr);
     using M = decltype(m);
diff --git a/test/TrampolineTest.cpp b/test/TrampolineTest.cpp
index 6c695c9..ed655d5 100644
--- a/test/TrampolineTest.cpp
+++ b/test/TrampolineTest.cpp
@@ -5,7 +5,7 @@
 #include <chrono>
 using namespace std::literals;
 
-#include "pushmi/flow_single_deferred.h"
+#include "pushmi/flow_single_sender.h"
 #include "pushmi/o/empty.h"
 #include "pushmi/o/just.h"
 #include "pushmi/o/on.h"
@@ -34,9 +34,9 @@ struct countdownsingle {
   }
 };
 
-SCENARIO( "trampoline executor", "[trampoline][deferred]" ) {
+SCENARIO( "trampoline executor", "[trampoline][sender]" ) {
 
-  GIVEN( "A trampoline time_single_deferred" ) {
+  GIVEN( "A trampoline time_single_sender" ) {
     auto tr = v::trampoline();
     using TR = decltype(tr);
 
@@ -135,14 +135,14 @@ SCENARIO( "trampoline executor", "[trampoline][deferred]" ) {
 
     WHEN( "used with on" ) {
       std::vector<std::string> values;
-      auto deferred = pushmi::make_single_deferred([](auto out) {
+      auto sender = pushmi::make_single_sender([](auto out) {
         ::pushmi::set_value(out, 2.0);
         // ignored
         ::pushmi::set_value(out, 1);
         ::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
         ::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
       });
-      deferred | op::on([&](){return tr;}) |
+      sender | op::on([&](){return tr;}) |
           op::submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
       THEN( "only the first item was pushed" ) {
         REQUIRE(values == std::vector<std::string>{"2.000000"});
@@ -151,14 +151,14 @@ SCENARIO( "trampoline executor", "[trampoline][deferred]" ) {
 
     WHEN( "used with via" ) {
       std::vector<std::string> values;
-      auto deferred = pushmi::make_single_deferred([](auto out) {
+      auto sender = pushmi::make_single_sender([](auto out) {
         ::pushmi::set_value(out, 2.0);
         // ignored
         ::pushmi::set_value(out, 1);
         ::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
         ::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
       });
-      deferred | op::via([&](){return tr;}) |
+      sender | op::via([&](){return tr;}) |
           op::submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
       THEN( "only the first item was pushed" ) {
         REQUIRE(values == std::vector<std::string>{"2.000000"});