diff --git a/include/unifex/allocate.hpp b/include/unifex/allocate.hpp
index d1fffe320..ab61277e0 100644
--- a/include/unifex/allocate.hpp
+++ b/include/unifex/allocate.hpp
@@ -93,6 +93,8 @@ namespace _alloc {
 
     static constexpr bool sends_done = sender_traits<Sender>::sends_done;
 
+    static constexpr blocking_kind blocking = sender_traits<Sender>::blocking;
+
     template(typename Self, typename Receiver)
       (requires same_as<remove_cvref_t<Self>, type> AND
                 receiver<Receiver>)
@@ -106,8 +108,8 @@ namespace _alloc {
           static_cast<Self&&>(s).sender_, (Receiver &&) r};
     }
 
-    friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
-      return blocking(self.sender_);
+    friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
+      return unifex::blocking(self.sender_);
     }
 
     Sender sender_;
diff --git a/include/unifex/async_manual_reset_event.hpp b/include/unifex/async_manual_reset_event.hpp
index 1b7b59107..0743561fd 100644
--- a/include/unifex/async_manual_reset_event.hpp
+++ b/include/unifex/async_manual_reset_event.hpp
@@ -16,6 +16,8 @@
 #pragma once
 
 #include <unifex/config.hpp>
+
+#include <unifex/blocking.hpp>
 #include <unifex/get_stop_token.hpp>
 #include <unifex/receiver_concepts.hpp>
 #include <unifex/scheduler_concepts.hpp>
@@ -54,6 +56,8 @@ struct _sender {
 
   static constexpr bool sends_done = false;
 
+  static constexpr blocking_kind blocking = blocking_kind::never;
+
   explicit _sender(async_manual_reset_event& evt) noexcept
     : evt_(&evt) {}
 
diff --git a/include/unifex/async_mutex.hpp b/include/unifex/async_mutex.hpp
index 5696233f4..66f5ccb38 100644
--- a/include/unifex/async_mutex.hpp
+++ b/include/unifex/async_mutex.hpp
@@ -60,6 +60,9 @@ class async_mutex {
 
     static constexpr bool sends_done = false;
 
+    // we complete inline if we manage to grab the lock immediately
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     lock_sender(const lock_sender &) = delete;
     lock_sender(lock_sender &&) = default;
 
diff --git a/include/unifex/async_trace.hpp b/include/unifex/async_trace.hpp
index 75d078455..3d39e5cfe 100644
--- a/include/unifex/async_trace.hpp
+++ b/include/unifex/async_trace.hpp
@@ -98,14 +98,12 @@ namespace _async_trace {
 
     static constexpr bool sends_done = false;
 
+    static constexpr blocking_kind blocking = blocking_kind::always_inline;
+
     template <typename Receiver>
     operation<Receiver> connect(Receiver&& r) const& {
       return operation<Receiver>{(Receiver &&) r};
     }
-
-    friend auto tag_invoke(tag_t<blocking>, const sender&) noexcept {
-      return blocking_kind::always_inline;
-    }
   };
 } // namespace _async_trace
 using async_trace_sender = _async_trace::sender;
diff --git a/include/unifex/at_coroutine_exit.hpp b/include/unifex/at_coroutine_exit.hpp
index 267832168..ec74563e3 100644
--- a/include/unifex/at_coroutine_exit.hpp
+++ b/include/unifex/at_coroutine_exit.hpp
@@ -188,6 +188,8 @@ struct _die_on_done {
 
     static constexpr bool sends_done = false;
 
+    static constexpr blocking_kind blocking = sender_traits<Sender>::blocking;
+
     template (typename Receiver)
       (requires sender_to<Sender, _die_on_done_rec_t<Receiver>>)
     auto connect(Receiver&& rec) &&
@@ -288,6 +290,7 @@ struct [[nodiscard]] _cleanup_task {
     return std::move(std::exchange(continuation_, {}).promise().args_);
   }
 
+  // TODO: how do we address always-inline awaitables
   friend constexpr auto tag_invoke(tag_t<blocking>, const _cleanup_task&) noexcept {
     return blocking_kind::always_inline;
   }
diff --git a/include/unifex/blocking.hpp b/include/unifex/blocking.hpp
index 6e3dd95af..f149a15bc 100644
--- a/include/unifex/blocking.hpp
+++ b/include/unifex/blocking.hpp
@@ -23,10 +23,19 @@
 namespace unifex {
 
 namespace _block {
-enum class _enum {
+enum class _enum : unsigned char {
+  // Caller guarantees that the receiver will be called inline on the
+  // current thread that called .start() before .start() returns.
+  always_inline = 0,
+
+  // Guarantees that the receiver will be called strongly-happens-before
+  // .start() returns. Does not guarantee the call to the receiver happens
+  // on the same thread that called .start(), however.
+  always,
+
   // No guarantees about the timing and context on which the receiver will
   // be called.
-  maybe = 0,
+  maybe,
 
   // Always completes asynchronously.
   // Guarantees that the receiver will not be called on the current thread
@@ -34,16 +43,23 @@ enum class _enum {
   // before .start() returns, however, or may be called on the current thread
   // some time after .start() returns.
   never,
+};
 
-  // Guarantees that the receiver will be called strongly-happens-before
-  // .start() returns. Does not guarantee the call to the receiver happens
-  // on the same thread that called .start(), however.
-  always,
+constexpr bool operator<(_enum lhs, _enum rhs) noexcept {
+  return static_cast<unsigned char>(lhs) < static_cast<unsigned char>(rhs);
+}
 
-  // Caller guarantees that the receiver will be called inline on the
-  // current thread that called .start() before .start() returns.
-  always_inline
-};
+constexpr bool operator>(_enum lhs, _enum rhs) noexcept {
+  return rhs < lhs;
+}
+
+constexpr bool operator<=(_enum lhs, _enum rhs) noexcept {
+  return !(lhs > rhs);
+}
+
+constexpr bool operator>=(_enum lhs, _enum rhs) noexcept {
+  return !(lhs < rhs);
+}
 
 struct blocking_kind {
   template <_enum Kind>
@@ -68,22 +84,23 @@ struct blocking_kind {
     return value;
   }
 
-  friend constexpr bool operator==(blocking_kind a, blocking_kind b) noexcept {
-    return a.value == b.value;
-  }
-
-  friend constexpr bool operator!=(blocking_kind a, blocking_kind b) noexcept {
-    return a.value != b.value;
-  }
-
   static constexpr constant<_enum::maybe> maybe {};
   static constexpr constant<_enum::never> never {};
   static constexpr constant<_enum::always> always {};
   static constexpr constant<_enum::always_inline> always_inline {};
 
-  _enum value{};
+  _enum value{_enum::maybe};
 };
 
+template <typename Sender, typename = void>
+struct _has_blocking : std::false_type {};
+
+template <typename Sender>
+struct _has_blocking<
+    Sender,
+    std::void_t<decltype(Sender::blocking)>>
+  : std::true_type {};
+
 struct _fn {
   template(typename Sender)
     (requires tag_invocable<_fn, const Sender&>)
@@ -95,30 +112,18 @@ struct _fn {
   template(typename Sender)
     (requires (!tag_invocable<_fn, const Sender&>))
   constexpr auto operator()(const Sender&) const noexcept {
-    return blocking_kind::maybe;
+    if constexpr (_has_blocking<Sender>::value) {
+      return blocking_kind::constant<Sender::blocking>{};
+    }
+    else {
+      return blocking_kind::maybe;
+    }
   }
 };
 
-namespace _cfn {
-  template <_enum Kind>
-  static constexpr auto _kind(blocking_kind::constant<Kind> kind) noexcept {
-    return kind;
-  }
-  static constexpr auto _kind(blocking_kind) noexcept {
-    return blocking_kind::maybe;
-  }
-
-  template <typename T>
-  constexpr auto cblocking() noexcept {
-    using blocking_t = remove_cvref_t<decltype(_fn{}(UNIFEX_DECLVAL(T&)))>;
-    return _cfn::_kind(blocking_t{});
-  }
-}
-
 } // namespace _block
 
 inline constexpr _block::_fn blocking {};
-using _block::_cfn::cblocking;
 using _block::blocking_kind;
 
 } // namespace unifex
diff --git a/include/unifex/bulk_join.hpp b/include/unifex/bulk_join.hpp
index 0848ea303..288603a17 100644
--- a/include/unifex/bulk_join.hpp
+++ b/include/unifex/bulk_join.hpp
@@ -101,6 +101,8 @@ class _join_sender<Source>::type {
 
     static constexpr bool sends_done = sender_traits<Source>::sends_done;
 
+    static constexpr blocking_kind blocking = sender_traits<Source>::blocking;
+
     template<typename Source2>
     explicit type(Source2&& s)
         noexcept(std::is_nothrow_constructible_v<Source, Source2>)
@@ -122,6 +124,10 @@ class _join_sender<Source>::type {
             join_receiver<remove_cvref_t<Receiver>>{static_cast<Receiver&&>(r)});
     }
 
+    friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& s) noexcept {
+      return unifex::blocking(s.source_);
+    }
+
 private:
     Source source_;
 };
diff --git a/include/unifex/bulk_schedule.hpp b/include/unifex/bulk_schedule.hpp
index ff98e813d..d7cbb4004 100644
--- a/include/unifex/bulk_schedule.hpp
+++ b/include/unifex/bulk_schedule.hpp
@@ -166,6 +166,8 @@ class _default_sender<Scheduler, Integral>::type {
 
     static constexpr bool sends_done = true;
 
+    static constexpr blocking_kind blocking = sender_traits<schedule_sender_t>::blocking;
+
     template<typename Scheduler2>
     explicit type(Scheduler2&& s, Integral count)
     : scheduler_(static_cast<Scheduler2&&>(s))
@@ -185,6 +187,10 @@ class _default_sender<Scheduler, Integral>::type {
                 static_cast<BulkReceiver&&>(r)});
     }
 
+    friend blocking_kind tag_invoke(tag_t<blocking>, const type& self) noexcept {
+      return unifex::blocking(self.scheduler_);
+    }
+
 private:
     Scheduler scheduler_;
     Integral count_;
diff --git a/include/unifex/bulk_transform.hpp b/include/unifex/bulk_transform.hpp
index 0d0c799eb..faed5cb60 100644
--- a/include/unifex/bulk_transform.hpp
+++ b/include/unifex/bulk_transform.hpp
@@ -162,6 +162,8 @@ class _tfx_sender<Source, Func, Policy>::type {
 
     static constexpr bool sends_done = sender_traits<Source>::sends_done;
 
+    static constexpr blocking_kind blocking = sender_traits<Source>::blocking;
+
     template<typename Source2, typename Func2>
     explicit type(Source2&& source, Func2&& func, Policy policy)
     : source_((Source2&&)source)
@@ -189,6 +191,10 @@ class _tfx_sender<Source, Func, Policy>::type {
                 static_cast<Receiver&&>(r)});
     }
 
+    friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& s) noexcept {
+      return unifex::blocking(s.source_);
+    }
+
 private:
     UNIFEX_NO_UNIQUE_ADDRESS Source source_;
     UNIFEX_NO_UNIQUE_ADDRESS Func func_;
diff --git a/include/unifex/connect_awaitable.hpp b/include/unifex/connect_awaitable.hpp
index 765c1ee17..5d64b1b36 100644
--- a/include/unifex/connect_awaitable.hpp
+++ b/include/unifex/connect_awaitable.hpp
@@ -235,6 +235,7 @@ namespace _as_sender {
         return unifex::connect_awaitable(((type&&) t).awaitable_, (Receiver&&) r);
       }
 
+      // TODO: how do we make this property statically discoverable?
       friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const type& t) noexcept {
         return unifex::blocking(t.awaitable_);
       }
@@ -267,6 +268,7 @@ namespace _as_sender {
         return unifex::connect_awaitable(((type&&) t).awaitable_, (Receiver&&) r);
       }
 
+      // TODO: how do we make this property statically discoverable?
       friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const type& t) noexcept {
         return unifex::blocking(t.awaitable_);
       }
diff --git a/include/unifex/create.hpp b/include/unifex/create.hpp
index 973f93539..b6a80bc1b 100644
--- a/include/unifex/create.hpp
+++ b/include/unifex/create.hpp
@@ -90,6 +90,10 @@ struct _snd_base {
 
     static constexpr bool sends_done = true;
 
+    // there's no way to know; maybe create() should have a way for the user to
+    // specify
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     template (typename Self, typename Receiver)
       (requires derived_from<remove_cvref_t<Self>, type> AND
         constructible_from<Fn, member_t<Self, Fn>> AND
@@ -157,7 +161,7 @@ struct _fn {
  * \fn template <class... ValueTypes> auto create(auto fn [, auto ctx])
  * \brief A utility for building a sender-based API out of a C-style API that
  *        accepts a void* context and a function pointer continuation.
- * 
+ *
  * \em Example:
  * \code
  *  // A void-returning C-style async API that accepts a context and a continuation:
diff --git a/include/unifex/dematerialize.hpp b/include/unifex/dematerialize.hpp
index 59a23051b..b9e939181 100644
--- a/include/unifex/dematerialize.hpp
+++ b/include/unifex/dematerialize.hpp
@@ -163,6 +163,8 @@ namespace _demat {
 
     static constexpr bool sends_done = sender_traits<Source>::sends_done;
 
+    static constexpr blocking_kind blocking = sender_traits<Source>::blocking;
+
     template <typename Source2>
     explicit type(Source2&& source)
         noexcept(std::is_nothrow_constructible_v<Source, Source2>)
@@ -180,8 +182,9 @@ namespace _demat {
           receiver_t<Receiver>{static_cast<Receiver&&>(r)});
     }
 
-    friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
-      return blocking(self.source_);
+    friend constexpr blocking_kind
+        tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
+      return unifex::blocking(self.source_);
     }
   private:
     Source source_;
diff --git a/include/unifex/detach_on_cancel.hpp b/include/unifex/detach_on_cancel.hpp
index 9e2940b4d..386ad2f1d 100644
--- a/include/unifex/detach_on_cancel.hpp
+++ b/include/unifex/detach_on_cancel.hpp
@@ -20,6 +20,8 @@
 #include <unifex/receiver_concepts.hpp>
 #include <unifex/sender_concepts.hpp>
 #include <unifex/type_list.hpp>
+
+#include <algorithm>
 #include <atomic>
 #include <exception>
 
@@ -204,21 +206,16 @@ struct _sender<Sender>::type {
 
   static constexpr bool sends_done = true;
 
-  friend constexpr auto tag_invoke(tag_t<blocking>, const type& sender) noexcept {
-    if constexpr (same_as<blocking_kind,
-                      decltype(blocking(sender.upstreamSender_))>) {
-      // the sender returns a runtime-determined blocking_kind
-      blocking_kind blockValue = blocking(sender.upstreamSender_);
-      if (blockValue == blocking_kind::never) {
-        blockValue = blocking_kind::maybe;
-      }
-      return blockValue;
-    } else if constexpr (blocking_kind::never == cblocking<Sender>()) {
-      // the sender always returns never
-      return blocking_kind::maybe;
-    } else {
-      return cblocking<Sender>();
-    }
+  // We will complete inline if started with a stop token that has had stop
+  // requested. If Sender is maybe or never then we're maybe overall; if Sender is
+  // always then we can report always; otherwise Sender is always_inline and we
+  // can report that.
+  static constexpr blocking_kind blocking =
+      std::min(blocking_kind::maybe(), sender_traits<Sender>::blocking());
+
+  friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const type& sender) noexcept {
+    blocking_kind other{blocking(sender)};
+    return std::min(blocking_kind::maybe(), other());
   }
 
   template <typename This, typename Receiver>
diff --git a/include/unifex/finally.hpp b/include/unifex/finally.hpp
index 5b973be9d..7228b1b89 100644
--- a/include/unifex/finally.hpp
+++ b/include/unifex/finally.hpp
@@ -26,6 +26,7 @@
 #include <unifex/std_concepts.hpp>
 #include <unifex/bind_back.hpp>
 
+#include <algorithm>
 #include <exception>
 #include <functional>
 #include <tuple>
@@ -72,26 +73,6 @@ namespace unifex
         Receiver,
         std::decay_t<Values>...>::type;
 
-    constexpr blocking_kind _blocking_kind(
-        blocking_kind source,
-        blocking_kind completion) noexcept {
-      if (source == blocking_kind::never || completion == blocking_kind::never) {
-        return blocking_kind::never;
-      } else if (
-          source == blocking_kind::always_inline &&
-          completion == blocking_kind::always_inline) {
-        return blocking_kind::always_inline;
-      } else if (
-          (source == blocking_kind::always_inline ||
-          source == blocking_kind::always) &&
-          (completion == blocking_kind::always_inline ||
-          completion == blocking_kind::always)) {
-        return blocking_kind::always;
-      } else {
-        return blocking_kind::maybe;
-      }
-    }
-
     template <
         typename SourceSender,
         typename CompletionSender,
@@ -684,6 +665,10 @@ namespace unifex
           sender_traits<SourceSender>::sends_done ||
           sender_traits<CompletionSender>::sends_done;
 
+      static constexpr blocking_kind blocking = std::max(
+          sender_traits<SourceSender>::blocking(),
+          sender_traits<CompletionSender>::blocking());
+
       template <typename SourceSender2, typename CompletionSender2>
       explicit type(
           SourceSender2&& source, CompletionSender2&& completion)
@@ -724,23 +709,10 @@ namespace unifex
                 static_cast<Receiver&&>(r)};
       }
 
-      friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
-        if constexpr (
-            blocking_kind::never == cblocking<SourceSender>() ||
-            blocking_kind::never == cblocking<CompletionSender>()) {
-          return blocking_kind::never;
-        } else if constexpr (
-            blocking_kind::maybe != cblocking<SourceSender>() &&
-            blocking_kind::maybe != cblocking<CompletionSender>()) {
-          return blocking_kind::constant<
-              _final::_blocking_kind(
-                  cblocking<SourceSender>(),
-                  cblocking<CompletionSender>())>{};
-        } else {
-          return _final::_blocking_kind(
-              blocking(self.source_),
-              blocking(self.completion_));
-        }
+      friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
+        blocking_kind source = blocking(self.source_);
+        blocking_kind completion = blocking(self.completion_);
+        return std::max(source(), completion());
       }
 
       SourceSender source_;
diff --git a/include/unifex/find_if.hpp b/include/unifex/find_if.hpp
index 28a4382dd..0b5f9a91a 100644
--- a/include/unifex/find_if.hpp
+++ b/include/unifex/find_if.hpp
@@ -383,8 +383,9 @@ struct _sender<Predecessor, Func, FuncPolicy>::type {
   template <typename Receiver>
   using receiver_type = receiver_t<Predecessor, Receiver, Func, FuncPolicy>;
 
+  // TODO: it's unclear whether this implementation is accurate
   friend constexpr auto tag_invoke(tag_t<blocking>, const type& sender) {
-    return blocking(sender.pred_);
+    return unifex::blocking(sender.pred_);
   }
 
   template(typename Sender, typename Receiver)
diff --git a/include/unifex/get_stop_token.hpp b/include/unifex/get_stop_token.hpp
index e402d33c0..af02eebeb 100644
--- a/include/unifex/get_stop_token.hpp
+++ b/include/unifex/get_stop_token.hpp
@@ -44,6 +44,7 @@ namespace _get_stop_token {
           return (StopToken&&) stoken_;
         }
 
+        // TODO: how do we express always-inline awaitables?
         friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const _awaiter&) noexcept {
           return blocking_kind::always_inline;
         }
diff --git a/include/unifex/indexed_for.hpp b/include/unifex/indexed_for.hpp
index 6fe60a041..eb481ee00 100644
--- a/include/unifex/indexed_for.hpp
+++ b/include/unifex/indexed_for.hpp
@@ -147,10 +147,12 @@ struct _sender<Predecessor, Policy, Range, Func>::type {
 
   static constexpr bool sends_done = sender_traits<Predecessor>::sends_done;
 
-  friend constexpr auto tag_invoke(
+  static constexpr blocking_kind blocking = sender_traits<Predecessor>::blocking;
+
+  friend constexpr blocking_kind tag_invoke(
       tag_t<blocking>,
       const sender& sender) {
-    return blocking(sender.pred_);
+    return unifex::blocking(sender.pred_);
   }
 
   template <typename Receiver>
diff --git a/include/unifex/inline_scheduler.hpp b/include/unifex/inline_scheduler.hpp
index 08e510524..ab780b4ef 100644
--- a/include/unifex/inline_scheduler.hpp
+++ b/include/unifex/inline_scheduler.hpp
@@ -76,11 +76,7 @@ namespace _inline_sched {
 
       static constexpr bool sends_done = true;
 
-      friend constexpr auto tag_invoke(
-          tag_t<blocking>,
-          const schedule_task&) noexcept {
-        return blocking_kind::always_inline;
-      }
+      static constexpr blocking_kind blocking = blocking_kind::always_inline;
 
       template <typename Receiver>
       operation<Receiver> connect(Receiver&& receiver) {
diff --git a/include/unifex/into_variant.hpp b/include/unifex/into_variant.hpp
index a8792ab81..38bf7be11 100644
--- a/include/unifex/into_variant.hpp
+++ b/include/unifex/into_variant.hpp
@@ -96,17 +96,19 @@ struct _sender<Predecessor>::type {
 
   static constexpr bool sends_done = sender_traits<Predecessor>::sends_done;
 
+  static constexpr blocking_kind blocking = sender_traits<Predecessor>::blocking;
+
   template <typename Receiver>
   using receiver_t = receiver_t<Receiver, sender_value_types_t<Predecessor, std::variant, std::tuple>>;
 
-  friend constexpr auto tag_invoke(tag_t<blocking>, const type& sender) {
-    return blocking(sender.pred_);
+  friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const type& sender) {
+    return unifex::blocking(sender.pred_);
   }
 
   template(typename Sender, typename Receiver)
     (requires same_as<remove_cvref_t<Sender>, type> AND receiver<Receiver> AND
         sender_to<member_t<Sender, Predecessor>, receiver_t<remove_cvref_t< Receiver>>>)
-  friend auto tag_invoke(tag_t<unifex::connect>, Sender&& s, Receiver&& r) 
+  friend auto tag_invoke(tag_t<unifex::connect>, Sender&& s, Receiver&& r)
     noexcept(
       std::is_nothrow_constructible_v<remove_cvref_t<Receiver>, Receiver> &&
       is_nothrow_connectable_v<member_t< Sender, Predecessor>, receiver_t<remove_cvref_t<Receiver>>>)
@@ -127,7 +129,7 @@ namespace _cpo {
         tag_invocable<_fn, Sender>,
         meta_tag_invoke_result<_fn>,
         meta_quote1<_into_variant::sender>>::template apply<Sender>;
-  
+
   public:
     template(typename Sender)
       (requires tag_invocable<_fn, Sender>)
@@ -136,10 +138,10 @@ namespace _cpo {
         -> _result_t<Sender> {
       return unifex::tag_invoke(_fn{}, (Sender &&)(predecessor));
     }
-  
+
     template(typename Sender)
       (requires(!tag_invocable<_fn, Sender>))
-    auto operator()(Sender&& predecessor) const 
+    auto operator()(Sender&& predecessor) const
         noexcept(std::is_nothrow_constructible_v<
           _into_variant::sender<Sender>, Sender>)
         -> _result_t<Sender> {
diff --git a/include/unifex/just.hpp b/include/unifex/just.hpp
index e806cd0e4..b538f7bca 100644
--- a/include/unifex/just.hpp
+++ b/include/unifex/just.hpp
@@ -78,6 +78,8 @@ class _sender<Values...>::type {
 
   static constexpr bool sends_done = false;
 
+  static constexpr auto blocking = blocking_kind::always_inline;
+
   template(typename... Values2)
     (requires (sizeof...(Values2) == sizeof...(Values)) AND
       constructible_from<std::tuple<Values...>, Values2...>)
@@ -94,10 +96,6 @@ class _sender<Values...>::type {
       -> operation<Receiver, Values...> {
     return {static_cast<This&&>(that).values_, static_cast<Receiver&&>(r)};
   }
-
-  friend constexpr auto tag_invoke(tag_t<blocking>, const type&) noexcept {
-    return blocking_kind::always_inline;
-  }
 };
 } // namespace _just
 
diff --git a/include/unifex/just_done.hpp b/include/unifex/just_done.hpp
index 2f1f02c63..e69afd2a6 100644
--- a/include/unifex/just_done.hpp
+++ b/include/unifex/just_done.hpp
@@ -59,6 +59,8 @@ class sender {
 
   static constexpr bool sends_done = true;
 
+  static constexpr auto blocking = blocking_kind::always_inline;
+
   template(typename This, typename Receiver)
       (requires same_as<remove_cvref_t<This>, sender> AND
         receiver<Receiver>)
@@ -67,10 +69,6 @@ class sender {
       -> operation<Receiver> {
     return {static_cast<Receiver&&>(r)};
   }
-
-  friend constexpr auto tag_invoke(tag_t<blocking>, const sender&) noexcept {
-    return blocking_kind::always_inline;
-  }
 };
 } // namespace _just_done
 
diff --git a/include/unifex/just_error.hpp b/include/unifex/just_error.hpp
index e152b525b..32d315f1f 100644
--- a/include/unifex/just_error.hpp
+++ b/include/unifex/just_error.hpp
@@ -70,6 +70,8 @@ class _sender<Error>::type {
 
   static constexpr bool sends_done = false;
 
+  static constexpr auto blocking =  blocking_kind::always_inline;
+
   template<typename Error2>
   explicit type(std::in_place_t, Error2&& error)
     noexcept(std::is_nothrow_constructible_v<Error, Error2>)
@@ -84,10 +86,6 @@ class _sender<Error>::type {
       -> operation<Receiver, Error> {
     return {static_cast<This&&>(that).error_, static_cast<Receiver&&>(r)};
   }
-
-  friend constexpr auto tag_invoke(tag_t<blocking>, const type&) noexcept {
-    return blocking_kind::always_inline;
-  }
 };
 } // namespace _just_error
 
diff --git a/include/unifex/just_void_or_done.hpp b/include/unifex/just_void_or_done.hpp
index 279f0fa1d..14caf5046 100644
--- a/include/unifex/just_void_or_done.hpp
+++ b/include/unifex/just_void_or_done.hpp
@@ -64,6 +64,8 @@ struct _sender {
 
   static constexpr bool sends_done = true;
 
+  static constexpr auto blocking =  blocking_kind::always_inline;
+
   // clang-format off
   UNIFEX_TEMPLATE(typename Receiver)
       (requires receiver<Receiver>)
@@ -72,10 +74,6 @@ struct _sender {
     return operation<Receiver>{static_cast<Receiver&&>(r), s.isVoid_};
   }
   // clang-format on
-
-  friend constexpr auto tag_invoke(tag_t<blocking>, const _sender&) noexcept {
-    return blocking_kind::always_inline;
-  }
 };
 
 inline constexpr struct just_void_or_done_fn {
diff --git a/include/unifex/let_done.hpp b/include/unifex/let_done.hpp
index ca26d949a..1f5dce742 100644
--- a/include/unifex/let_done.hpp
+++ b/include/unifex/let_done.hpp
@@ -286,6 +286,12 @@ class _sndr<Source, Done>::type {
 
   static constexpr bool sends_done = sender_traits<final_sender_t>::sends_done;
 
+  static constexpr blocking_kind blocking = std::max(
+      sender_traits<Source>::blocking(),
+      std::min(
+          sender_traits<final_sender_t>::blocking(),
+          blocking_kind::maybe()));
+
   template <typename Source2, typename Done2>
   explicit type(Source2&& source, Done2&& done)
     noexcept(
@@ -318,6 +324,11 @@ class _sndr<Source, Done>::type {
     };
   }
 
+  friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& s) noexcept {
+    blocking_kind pred = unifex::blocking(s);
+    return std::max(pred(), std::min(sender_traits<final_sender_t>::blocking(), blocking_kind::maybe()));
+  }
+
 private:
   Source source_;
   Done done_;
diff --git a/include/unifex/let_error.hpp b/include/unifex/let_error.hpp
index cbe6bd077..6d3c49337 100644
--- a/include/unifex/let_error.hpp
+++ b/include/unifex/let_error.hpp
@@ -326,6 +326,14 @@ struct sends_done_impl : std::bool_constant<sender_traits<Sender>::sends_done> {
 template<typename... Senders>
 using any_sends_done = std::disjunction<sends_done_impl<Senders>...>;
 
+template <typename First, typename... Rest>
+struct max_blocking_kind {
+  constexpr _block::_enum operator()() const noexcept {
+    _block::_enum enums[]{sender_traits<First>::blocking, sender_traits<Rest>::blocking...};
+    return *std::max_element(std::begin(enums), std::end(enums));
+  }
+};
+
 template <typename Source, typename Func>
 class _sndr<Source, Func>::type final {
 
@@ -338,6 +346,9 @@ class _sndr<Source, Func>::type final {
   template <typename... Errors>
   using sends_done_impl = any_sends_done<Source, final_sender<Errors>...>;
 
+  template <typename... Errors>
+  using max_successor_blocking = max_blocking_kind<final_sender<Errors>...>;
+
 public:
   template <
       template <typename...>
@@ -365,6 +376,15 @@ class _sndr<Source, Func>::type final {
     sender_traits<Source>::sends_done ||
     sender_error_types_t<Source, sends_done_impl>::value;
 
+  // the successors' blocking trait only affects our blocking_kind if the
+  // predecessor fails so the successors can't raise our blocking_kind past
+  // maybe
+  static constexpr blocking_kind blocking = std::max(
+      sender_traits<Source>::blocking(),
+      std::min(
+          sender_error_types_t<Source, max_successor_blocking>{}(),
+          blocking_kind::maybe()));
+
   template <typename Source2, typename Func2>
   explicit type(Source2&& source, Func2&& func)
     noexcept(
@@ -397,6 +417,16 @@ class _sndr<Source, Func>::type final {
     };
   }
 
+  friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& s) noexcept {
+    // get the runtime blocking_kind for the predecessor
+    blocking_kind pred = blocking(s.source_);
+    // we have to go with the static result for the successors since we don't
+    // know how pred_ will complete
+    blocking_kind succ = sender_error_types_t<Source, max_successor_blocking>{}();
+
+    return std::max(pred(), std::min(succ(), blocking_kind::maybe()));
+  }
+
 private:
   Source source_;
   Func func_;
diff --git a/include/unifex/let_value.hpp b/include/unifex/let_value.hpp
index ebaf52a60..0d82d5bf7 100644
--- a/include/unifex/let_value.hpp
+++ b/include/unifex/let_value.hpp
@@ -26,6 +26,7 @@
 #include <unifex/std_concepts.hpp>
 #include <unifex/bind_back.hpp>
 
+#include <algorithm>
 #include <exception>
 #include <functional>
 #include <tuple>
@@ -281,51 +282,15 @@ struct sends_done_impl : std::bool_constant<sender_traits<Sender>::sends_done> {
 template <typename... Successors>
 using any_sends_done = std::disjunction<sends_done_impl<Successors>...>;
 
-template <typename Sender, typename... Rest>
-struct max_blocking_kind {
-  constexpr auto operator()() noexcept { return cblocking<Sender>(); }
-};
 
-template <typename First, typename Second, typename... Rest>
-struct max_blocking_kind<First, Second, Rest...> {
-  constexpr auto operator()() noexcept {
-    constexpr blocking_kind first = cblocking<First>();
-    constexpr blocking_kind second = cblocking<Second>();
-
-    if constexpr (first == second) {
-      return max_blocking_kind<First, Rest...>{}();
-    } else if constexpr (
-        first == blocking_kind::always &&
-        second == blocking_kind::always_inline) {
-      return max_blocking_kind<First, Rest...>{}();
-    } else if constexpr (
-        first == blocking_kind::always_inline &&
-        second == blocking_kind::always) {
-      return max_blocking_kind<Second, Rest...>{}();
-    } else {
-      return blocking_kind::maybe;
-    }
+template <typename First, typename... Rest>
+struct max_blocking_kind {
+  constexpr _block::_enum operator()() const noexcept {
+    _block::_enum enums[]{sender_traits<First>::blocking, sender_traits<Rest>::blocking...};
+    return *std::max_element(std::begin(enums), std::end(enums));
   }
 };
 
-constexpr blocking_kind _blocking_kind(blocking_kind source, blocking_kind completion) noexcept {
-  if (source == blocking_kind::never || completion == blocking_kind::never) {
-    return blocking_kind::never;
-  } else if (
-      source == blocking_kind::always_inline &&
-      completion == blocking_kind::always_inline) {
-    return blocking_kind::always_inline;
-  } else if (
-      (source == blocking_kind::always_inline ||
-       source == blocking_kind::always) &&
-      (completion == blocking_kind::always_inline ||
-       completion == blocking_kind::always)) {
-    return blocking_kind::always;
-  } else {
-    return blocking_kind::maybe;
-  }
-}
-
 template <typename Predecessor, typename SuccessorFactory>
 class _sender<Predecessor, SuccessorFactory>::type {
   using sender = type;
@@ -386,6 +351,12 @@ class _sender<Predecessor, SuccessorFactory>::type {
     sender_traits<Predecessor>::sends_done ||
     successor_types<any_sends_done>::value;
 
+  static constexpr blocking_kind blocking = std::max(
+      sender_traits<Predecessor>::blocking(),
+      std::min(
+          successor_types<_let_v::max_blocking_kind>{}(),
+          blocking_kind::maybe()));
+
  public:
   template <typename Predecessor2, typename SuccessorFactory2>
   explicit type(Predecessor2&& pred, SuccessorFactory2&& func)
@@ -404,17 +375,14 @@ class _sender<Predecessor, SuccessorFactory>::type {
         static_cast<Receiver&&>(receiver)};
   }
 
-  friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const type&) noexcept {
-    constexpr blocking_kind succ = successor_types<_let_v::max_blocking_kind>{}();
-    if constexpr (
-        blocking_kind::never == cblocking<Predecessor>() || blocking_kind::never == succ) {
-      return blocking_kind::never;
-    } else if constexpr (
-        blocking_kind::maybe != cblocking<Predecessor>() && blocking_kind::maybe != succ) {
-      return blocking_kind::constant<_let_v::_blocking_kind(cblocking<Predecessor>(), succ)>{};
-    } else {
-      return _let_v::_blocking_kind(cblocking<Predecessor>(), succ);
-    }
+  friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& sender) noexcept {
+    // get the runtime blocking_kind for the predecessor
+    blocking_kind pred = blocking(sender.pred_);
+    // we have to go with the static result for the successors since we don't
+    // know how pred_ will complete
+    blocking_kind succ = successor_types<_let_v::max_blocking_kind>{}();
+
+    return std::max(pred(), std::min(succ(), blocking_kind::maybe()));
   }
 };
 
diff --git a/include/unifex/let_value_with.hpp b/include/unifex/let_value_with.hpp
index 6366b3e47..c833e98a5 100644
--- a/include/unifex/let_value_with.hpp
+++ b/include/unifex/let_value_with.hpp
@@ -59,6 +59,8 @@ class _sender<StateFactory, SuccessorFactory>::type {
 
   static constexpr bool sends_done = sender_traits<InnerOp>::sends_done;
 
+  static constexpr blocking_kind blocking = sender_traits<InnerOp>::blocking;
+
   template<typename StateFactory2, typename SuccessorFactory2>
   explicit type(StateFactory2&& stateFactory, SuccessorFactory2&& func) :
     stateFactory_((StateFactory2&&)stateFactory),
diff --git a/include/unifex/let_value_with_stop_source.hpp b/include/unifex/let_value_with_stop_source.hpp
index 53e90e517..a780d44cb 100644
--- a/include/unifex/let_value_with_stop_source.hpp
+++ b/include/unifex/let_value_with_stop_source.hpp
@@ -116,6 +116,8 @@ class _stop_source_sender<SuccessorFactory>::type {
 
     static constexpr bool sends_done = sender_traits<InnerOp>::sends_done;
 
+    static constexpr blocking_kind blocking = sender_traits<InnerOp>::blocking;
+
     template<typename SuccessorFactory2>
     explicit type(SuccessorFactory2&& func) : func_((SuccessorFactory2&&)func)
     {}
diff --git a/include/unifex/let_value_with_stop_token.hpp b/include/unifex/let_value_with_stop_token.hpp
index 2d76909c1..907c43e45 100644
--- a/include/unifex/let_value_with_stop_token.hpp
+++ b/include/unifex/let_value_with_stop_token.hpp
@@ -143,6 +143,8 @@ class _stop_token_sender<SuccessorFactory>::type {
 
   static constexpr bool sends_done = sender_traits<inner_sender_t>::sends_done;
 
+  static constexpr blocking_kind blocking = sender_traits<inner_sender_t>::blocking;
+
   template <typename SuccessorFactory2>
   explicit type(SuccessorFactory2&& func) noexcept(
       std::is_nothrow_constructible_v<SuccessorFactory, SuccessorFactory2&&>)
diff --git a/include/unifex/manual_event_loop.hpp b/include/unifex/manual_event_loop.hpp
index b109a7b9d..658671583 100644
--- a/include/unifex/manual_event_loop.hpp
+++ b/include/unifex/manual_event_loop.hpp
@@ -89,12 +89,6 @@ class context {
  public:
   class scheduler {
     class schedule_task {
-      friend constexpr auto tag_invoke(
-          tag_t<blocking>,
-          const schedule_task&) noexcept {
-        return blocking_kind::never;
-      }
-
      public:
       template <
           template <typename...> class Variant,
@@ -106,6 +100,8 @@ class context {
 
       static constexpr bool sends_done = true;
 
+      static constexpr blocking_kind blocking = blocking_kind::never;
+
       template <typename Receiver>
       operation<Receiver> connect(Receiver&& receiver) const {
         return operation<Receiver>{(Receiver &&) receiver, loop_};
diff --git a/include/unifex/materialize.hpp b/include/unifex/materialize.hpp
index 8b06dfa0f..4d71605c6 100644
--- a/include/unifex/materialize.hpp
+++ b/include/unifex/materialize.hpp
@@ -182,6 +182,8 @@ namespace unifex
 
       static constexpr bool sends_done = false;
 
+      static constexpr blocking_kind blocking = sender_traits<Source>::blocking;
+
       template(typename Source2)
           (requires constructible_from<Source, Source2>)
       explicit type(Source2&& source) noexcept(
@@ -201,6 +203,10 @@ namespace unifex
             receiver_t<Receiver>{static_cast<Receiver&&>(r)});
       }
 
+      friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& s) noexcept {
+        return unifex::blocking(s.source_);
+      }
+
     private:
       Source source_;
     };
diff --git a/include/unifex/never.hpp b/include/unifex/never.hpp
index 7dec44e64..d73ef6821 100644
--- a/include/unifex/never.hpp
+++ b/include/unifex/never.hpp
@@ -84,6 +84,9 @@ struct sender {
 
   static constexpr bool sends_done = true;
 
+  // we'll complete inline if started with a stopped stop token
+  static constexpr blocking_kind blocking = blocking_kind::maybe;
+
   template <typename Receiver>
   operation<Receiver> connect(Receiver&& receiver) {
     return operation<Receiver>{(Receiver &&) receiver};
diff --git a/include/unifex/new_thread_context.hpp b/include/unifex/new_thread_context.hpp
index 5900f6f1d..aef70f491 100644
--- a/include/unifex/new_thread_context.hpp
+++ b/include/unifex/new_thread_context.hpp
@@ -76,6 +76,10 @@ class context {
 
     static constexpr bool sends_done = true;
 
+    // we report failure to construct a thread inline; maybe we should
+    // terminate in that case and change this to never
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     explicit schedule_sender(context* ctx) noexcept
       : context_(ctx) {}
 
diff --git a/include/unifex/range_stream.hpp b/include/unifex/range_stream.hpp
index d4627a076..a48010552 100644
--- a/include/unifex/range_stream.hpp
+++ b/include/unifex/range_stream.hpp
@@ -57,11 +57,7 @@ struct next_sender {
 
   static constexpr bool sends_done = true;
 
-  friend constexpr auto tag_invoke(
-      tag_t<blocking>,
-      const stream&) noexcept {
-    return blocking_kind::always_inline;
-  }
+  static constexpr blocking_kind blocking = blocking_kind::always_inline;
 
   template <typename Receiver>
   operation<Receiver> connect(Receiver&& receiver) && {
diff --git a/include/unifex/ready_done_sender.hpp b/include/unifex/ready_done_sender.hpp
index c4cf41989..5d5329988 100644
--- a/include/unifex/ready_done_sender.hpp
+++ b/include/unifex/ready_done_sender.hpp
@@ -52,11 +52,7 @@ namespace _ready_done {
 
     static constexpr bool sends_done = true;
 
-    friend constexpr auto tag_invoke(
-        tag_t<blocking>,
-        const sender&) {
-      return blocking_kind::always_inline;
-    }
+    static constexpr blocking_kind blocking =  blocking_kind::always_inline;
 
     template <typename Receiver>
     operation<Receiver> connect(Receiver&& receiver) const& {
diff --git a/include/unifex/repeat_effect_until.hpp b/include/unifex/repeat_effect_until.hpp
index a08bc3041..fc9516cb4 100644
--- a/include/unifex/repeat_effect_until.hpp
+++ b/include/unifex/repeat_effect_until.hpp
@@ -202,6 +202,8 @@ class _sndr<Source, Predicate>::type {
 
   static constexpr bool sends_done = true;
 
+  static constexpr blocking_kind blocking = sender_traits<Source>::blocking;
+
   template <typename Source2, typename Predicate2>
   explicit type(Source2&& source, Predicate2&& predicate)
     noexcept(
@@ -231,6 +233,10 @@ class _sndr<Source, Predicate>::type {
     };
   }
 
+  friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
+    return unifex::blocking(self.source_);
+  }
+
 private:
   UNIFEX_NO_UNIQUE_ADDRESS Source source_;
   UNIFEX_NO_UNIQUE_ADDRESS Predicate predicate_;
diff --git a/include/unifex/retry_when.hpp b/include/unifex/retry_when.hpp
index e4393c02d..2d03181e7 100644
--- a/include/unifex/retry_when.hpp
+++ b/include/unifex/retry_when.hpp
@@ -350,6 +350,8 @@ class _sender<Source, Func>::type {
   static constexpr bool sends_done =
     sender_error_types_t<Source, sends_done_impl>::value;
 
+  // TODO: blocking and is_always_scheduler_affine; I don't have the brains to figure them out right now
+
   template <typename Source2, typename Func2>
   explicit type(Source2&& source, Func2&& func)
     noexcept(std::is_nothrow_constructible_v<Source, Source2> &&
diff --git a/include/unifex/scheduler_concepts.hpp b/include/unifex/scheduler_concepts.hpp
index 6271ef29a..d2671cefa 100644
--- a/include/unifex/scheduler_concepts.hpp
+++ b/include/unifex/scheduler_concepts.hpp
@@ -206,6 +206,10 @@ struct sender {
 
   static constexpr bool sends_done = true;
 
+  // never is very likely, but we don't actually know because it depends on the
+  // receiver's scheduler's type, which we don't know
+  static constexpr blocking_kind blocking = blocking_kind::maybe;
+
   template(typename Receiver)
     (requires receiver<Receiver>)
   friend auto tag_invoke(tag_t<connect>, sender, Receiver &&r)
@@ -281,6 +285,10 @@ namespace _schedule_after {
 
     static constexpr bool sends_done = true;
 
+    // never is very likely, but we don't actually know because it depends on the
+    // receiver's scheduler's type, which we don't know
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     explicit type(Duration d)
       : duration_(d)
     {}
@@ -365,6 +373,10 @@ namespace _schedule_at {
 
     static constexpr bool sends_done = true;
 
+    // never is very likely, but we don't actually know because it depends on the
+    // receiver's scheduler's type, which we don't know
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     explicit type(TimePoint tp)
       : time_point_(tp)
     {}
@@ -435,6 +447,8 @@ namespace _current {
     Scheduler await_resume() {
       return (Scheduler&&) sched_;
     }
+
+    // TODO: we need to handle always-inline awaitables
     friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const _awaiter&) noexcept {
       return blocking_kind::always_inline;
     }
diff --git a/include/unifex/sender_concepts.hpp b/include/unifex/sender_concepts.hpp
index ae6bb9777..1d69ec12b 100644
--- a/include/unifex/sender_concepts.hpp
+++ b/include/unifex/sender_concepts.hpp
@@ -16,6 +16,8 @@
 #pragma once
 
 #include <unifex/config.hpp>
+
+#include <unifex/blocking.hpp>
 #include <unifex/detail/unifex_fwd.hpp>
 #include <unifex/tag_invoke.hpp>
 #include <unifex/type_list.hpp>
@@ -42,12 +44,21 @@ struct sender_traits;
 
 /// \cond
 namespace detail {
+  using unifex::_block::_has_blocking;
+
   template <template <template <typename...> class, template <typename...> class> class>
   struct _has_value_types;
 
   template <template <template <typename...> class> class>
   struct _has_error_types;
 
+  template <typename Sender, bool = _has_blocking<Sender>::value>
+  struct _blocking : blocking_kind::constant<blocking_kind::maybe> {};
+
+  template <typename Sender>
+  struct _blocking<Sender, true>
+    : blocking_kind::constant<Sender::blocking> {};
+
   template <typename S>
   UNIFEX_CONCEPT_FRAGMENT(  //
     _has_sender_types_impl, //
@@ -98,6 +109,8 @@ namespace detail {
     using error_types = typename S::template error_types<Variant>;
 
     static constexpr bool sends_done = S::sends_done;
+
+    static constexpr blocking_kind blocking = _blocking<S>::value;
   };
 
   template <typename S>
diff --git a/include/unifex/sequence.hpp b/include/unifex/sequence.hpp
index 00ed80908..6484ae617 100644
--- a/include/unifex/sequence.hpp
+++ b/include/unifex/sequence.hpp
@@ -27,6 +27,7 @@
 #include <unifex/type_list.hpp>
 #include <unifex/std_concepts.hpp>
 
+#include <algorithm>
 #include <exception>
 #include <type_traits>
 #include <utility>
@@ -37,25 +38,6 @@ namespace unifex
 {
   namespace _seq
   {
-    constexpr blocking_kind _blocking_kind(
-        blocking_kind predBlocking, blocking_kind succBlocking) noexcept {
-      if (predBlocking == blocking_kind::never) {
-        return blocking_kind::never;
-      } else if (
-          predBlocking == blocking_kind::always_inline &&
-          succBlocking == blocking_kind::always_inline) {
-        return blocking_kind::always_inline;
-      } else if (
-          (predBlocking == blocking_kind::always_inline ||
-          predBlocking == blocking_kind::always) &&
-          (succBlocking == blocking_kind::always_inline ||
-          succBlocking == blocking_kind::always)) {
-        return blocking_kind::always;
-      } else {
-        return blocking_kind::maybe;
-      }
-    }
-
     template <typename Predecessor, typename Successor, typename Receiver>
     struct _op {
       class type;
@@ -333,6 +315,13 @@ namespace unifex
         sender_traits<Predecessor>::sends_done ||
         sender_traits<Successor>::sends_done;
 
+      static constexpr blocking_kind blocking = std::max(
+          sender_traits<Predecessor>::blocking(),
+          std::min(
+              // TODO: we only need the min(, maybe) if pred can throw or cancel
+              sender_traits<Successor>::blocking(),
+              blocking_kind::maybe()));
+
       template(typename Predecessor2, typename Successor2)
           (requires constructible_from<Predecessor, Predecessor2> AND
               constructible_from<Successor, Successor2>)
@@ -342,17 +331,12 @@ namespace unifex
         : predecessor_(static_cast<Predecessor&&>(predecessor))
         , successor_(static_cast<Successor&&>(successor)) {}
 
-      friend auto tag_invoke(tag_t<blocking>, const type& self) {
-        if constexpr (
-            blocking_kind::maybe != cblocking<Predecessor>() &&
-            blocking_kind::maybe != cblocking<Successor>()) {
-          return blocking_kind::constant<
-              _seq::_blocking_kind(cblocking<Predecessor>(), cblocking<Successor>())>();
-        } else {
-          return _seq::_blocking_kind(
-              blocking(self.predecessor_),
-              blocking(self.successor_));
-        }
+      friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const type& self) {
+        blocking_kind pred = blocking(self.predecessor_);
+        blocking_kind succ = blocking(self.successor_);
+
+        // TODO: we only need the min(, maybe) if pred can throw or cancel
+        return std::max(pred(), std::min(succ(), blocking_kind::maybe()));
       }
 
       template(typename Receiver, typename Sender)
diff --git a/include/unifex/single.hpp b/include/unifex/single.hpp
index 987090498..7b7893081 100644
--- a/include/unifex/single.hpp
+++ b/include/unifex/single.hpp
@@ -23,6 +23,7 @@
 #include <unifex/scope_guard.hpp>
 #include <unifex/bind_back.hpp>
 
+#include <algorithm>
 #include <optional>
 #include <type_traits>
 
@@ -101,6 +102,19 @@ struct _stream<Sender>::type {
 
     static constexpr bool sends_done = true;
 
+    static constexpr blocking_kind blocking = std::min(
+        sender_traits<Sender>::blocking(),
+        blocking_kind::maybe());
+
+    friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const next_sender& s) noexcept {
+      if (s.sender_) {
+        return unifex::blocking(*s.sender_);
+      }
+      else {
+        return blocking_kind::always_inline;
+      }
+    }
+
     template <typename Receiver>
     auto connect(Receiver&& receiver) {
       if (sender_) {
diff --git a/include/unifex/spawn_future.hpp b/include/unifex/spawn_future.hpp
index cd3b5a6cd..90c89e1af 100644
--- a/include/unifex/spawn_future.hpp
+++ b/include/unifex/spawn_future.hpp
@@ -819,6 +819,8 @@ struct [[nodiscard]] _future<Scope, T...>::type final {
 
   static constexpr bool sends_done = true;
 
+  static constexpr blocking_kind blocking = sender_traits<sender_t>::blocking;
+
   explicit type(
       Scope& scope,
       typename _spawn_future_op<T...>::type*
@@ -838,9 +840,8 @@ struct [[nodiscard]] _future<Scope, T...>::type final {
     return connect(std::move(self).sender_, static_cast<Receiver&&>(receiver));
   }
 
-  friend auto tag_invoke(tag_t<blocking>, const type&) noexcept {
-    // we're never when nest succeeds and always_inline when it fails
-    return blocking_kind::maybe;
+  friend blocking_kind tag_invoke(tag_t<blocking>, const type& sender) noexcept {
+    return unifex::blocking(sender.sender_);
   }
 };
 
diff --git a/include/unifex/static_thread_pool.hpp b/include/unifex/static_thread_pool.hpp
index 5c2854970..9c54b2fce 100644
--- a/include/unifex/static_thread_pool.hpp
+++ b/include/unifex/static_thread_pool.hpp
@@ -68,6 +68,8 @@ namespace _static_thread_pool {
 
         static constexpr bool sends_done = true;
 
+        static constexpr blocking_kind blocking = blocking_kind::never;
+
       private:
         template <typename Receiver>
         operation<Receiver> make_operation_(Receiver&& r) const {
diff --git a/include/unifex/stop_if_requested.hpp b/include/unifex/stop_if_requested.hpp
index 47a74ef47..d4cb110f3 100644
--- a/include/unifex/stop_if_requested.hpp
+++ b/include/unifex/stop_if_requested.hpp
@@ -77,16 +77,14 @@ struct _fn {
 
     static constexpr bool sends_done = true;
 
+    static constexpr blocking_kind blocking = blocking_kind::always_inline;
+
     template (typename Receiver)
       (requires receiver_of<Receiver>)
     auto connect(Receiver&& rec) const
       -> typename _op<remove_cvref_t<Receiver>>::type {
       return typename _op<remove_cvref_t<Receiver>>::type{(Receiver&&) rec};
     }
-
-    friend constexpr auto tag_invoke(tag_t<unifex::blocking>, const _sender&) noexcept {
-      return blocking_kind::always_inline;
-    }
   };
 
 public:
diff --git a/include/unifex/stop_when.hpp b/include/unifex/stop_when.hpp
index 6d640ab4b..e5ea6561b 100644
--- a/include/unifex/stop_when.hpp
+++ b/include/unifex/stop_when.hpp
@@ -325,6 +325,12 @@ class _sndr<Source, Trigger>::type {
 
   static constexpr bool sends_done = true;
 
+  // TODO: if Source is always or always-inline, the trigger will never have a
+  //       chance to finish first; maybe we should do something about that
+  static constexpr blocking_kind blocking = std::max(
+      sender_traits<Source>::blocking(),
+      sender_traits<Trigger>::blocking());
+
   template <typename Source2, typename Trigger2>
   explicit type(Source2&& source, Trigger2&& trigger) noexcept(
       std::is_nothrow_constructible_v<Source, Source2>&&
@@ -358,6 +364,12 @@ class _sndr<Source, Trigger>::type {
         ((Self &&) self).source_, ((Self &&) self).trigger_, (Receiver &&) r};
   }
 
+  friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& s) noexcept {
+    blocking_kind source = unifex::blocking(s.source_);
+    blocking_kind trigger = unifex::blocking(s.trigger_);
+    return std::max(source(), trigger());
+  }
+
 private:
   UNIFEX_NO_UNIQUE_ADDRESS Source source_;
   UNIFEX_NO_UNIQUE_ADDRESS Trigger trigger_;
diff --git a/include/unifex/task.hpp b/include/unifex/task.hpp
index 1c8385e1a..a66bec1cb 100644
--- a/include/unifex/task.hpp
+++ b/include/unifex/task.hpp
@@ -210,7 +210,9 @@ struct _promise {
 
     template <typename Awaitable>
     decltype(auto) transform_awaitable_(Awaitable&& awaitable) {
-      if constexpr (blocking_kind::always_inline == cblocking<Awaitable>()) {
+      using blocking_t = decltype(blocking(awaitable));
+
+      if constexpr (!same_as<blocking_kind, blocking_t> && (blocking_kind::always_inline == blocking_t{})) {
         return Awaitable{(Awaitable&&) awaitable};
       } else {
         return unifex::await_transform(
@@ -221,7 +223,7 @@ struct _promise {
 
     template <typename Sender>
     decltype(auto) transform_sender_(Sender&& sndr) {
-      if constexpr (blocking_kind::always_inline == cblocking<Sender>()) {
+      if constexpr (blocking_kind::always_inline == sender_traits<remove_cvref_t<Sender>>::blocking) {
         return unifex::await_transform(*this, (Sender&&) sndr);
       } else if constexpr (is_sender_for_v<remove_cvref_t<Sender>, schedule>) {
         // If we are co_await'ing a sender that is the result of calling schedule,
@@ -390,6 +392,11 @@ struct _task<T>::type : _task_base, coro_holder {
 
   static constexpr bool sends_done = true;
 
+  // we can't tell whether the coroutine has any suspend points beyond the
+  // initial one and, even if we could, we wouldn't know if any of those suspend
+  // points are async
+  static constexpr blocking_kind blocking = blocking_kind::maybe;
+
   type(type&& t) noexcept = default;
 
   type& operator=(type&& t) noexcept = default;
diff --git a/include/unifex/then.hpp b/include/unifex/then.hpp
index 6afa84e3d..b3688b09f 100644
--- a/include/unifex/then.hpp
+++ b/include/unifex/then.hpp
@@ -158,13 +158,11 @@ struct _sender<Predecessor, Func>::type {
 
   static constexpr bool sends_done = sender_traits<Predecessor>::sends_done;
 
+  static constexpr auto blocking = sender_traits<Predecessor>::blocking;
+
   template <typename Receiver>
   using receiver_t = receiver_t<Receiver, Func>;
 
-  friend constexpr auto tag_invoke(tag_t<blocking>, const type& sender) {
-    return blocking(sender.pred_);
-  }
-
   template(typename Sender, typename Receiver)
     (requires same_as<remove_cvref_t<Sender>, type> AND receiver<Receiver> AND
         sender_to<member_t<Sender, Predecessor>, receiver_t<remove_cvref_t<Receiver>>>)
@@ -180,6 +178,10 @@ struct _sender<Predecessor, Func>::type {
         static_cast<Sender&&>(s).func_,
         static_cast<Receiver&&>(r)});
   }
+
+  friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
+    return unifex::blocking(self.pred_);
+  }
 };
 
 namespace _cpo {
diff --git a/include/unifex/thread_unsafe_event_loop.hpp b/include/unifex/thread_unsafe_event_loop.hpp
index c420bf703..9d3e803cb 100644
--- a/include/unifex/thread_unsafe_event_loop.hpp
+++ b/include/unifex/thread_unsafe_event_loop.hpp
@@ -153,6 +153,8 @@ namespace _thread_unsafe_event_loop {
 
     static constexpr bool sends_done = true;
 
+    static constexpr blocking_kind blocking = blocking_kind::never;
+
     template <typename Receiver>
     after_operation<Duration, remove_cvref_t<Receiver>> connect(Receiver&& r) const& {
       return after_operation<Duration, remove_cvref_t<Receiver>>{
diff --git a/include/unifex/timed_single_thread_context.hpp b/include/unifex/timed_single_thread_context.hpp
index 1ce76c621..b10a4e192 100644
--- a/include/unifex/timed_single_thread_context.hpp
+++ b/include/unifex/timed_single_thread_context.hpp
@@ -142,6 +142,9 @@ namespace _timed_single_thread_context {
 
     static constexpr bool sends_done = true;
 
+    // stop requests are always delivered on the context's thread
+    static constexpr blocking_kind blocking = blocking_kind::never;
+
     template <typename Receiver>
     after_operation<Duration, Receiver> connect(Receiver&& receiver) const {
       return after_operation<Duration, Receiver>{
@@ -213,6 +216,9 @@ namespace _timed_single_thread_context {
 
     static constexpr bool sends_done = true;
 
+    // stop requests are always delivered on the context's thread
+    static constexpr blocking_kind blocking = blocking_kind::never;
+
     template <typename Receiver>
     at_operation<remove_cvref_t<Receiver>> connect(Receiver&& receiver) {
       return at_operation<remove_cvref_t<Receiver>>{
diff --git a/include/unifex/trampoline_scheduler.hpp b/include/unifex/trampoline_scheduler.hpp
index aecfce76f..90d78edc0 100644
--- a/include/unifex/trampoline_scheduler.hpp
+++ b/include/unifex/trampoline_scheduler.hpp
@@ -115,7 +115,7 @@ class scheduler {
           }
         }
       }
-      
+
     public:
       using operation_base::start;
     };
@@ -139,6 +139,9 @@ class scheduler {
 
     static constexpr bool sends_done = true;
 
+    // it's always_inline until we blow the stack, then it's never
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     template <typename Receiver>
     operation<Receiver> connect(Receiver&& receiver) const& {
       return operation<Receiver>{(Receiver &&) receiver, maxRecursionDepth_};
diff --git a/include/unifex/unstoppable.hpp b/include/unifex/unstoppable.hpp
index ac1544296..52fdefb80 100644
--- a/include/unifex/unstoppable.hpp
+++ b/include/unifex/unstoppable.hpp
@@ -47,6 +47,8 @@ struct _sender<Sender>::type final {
 
   static constexpr bool sends_done = sender_traits<Sender>::sends_done;
 
+  static constexpr blocking_kind blocking = sender_traits<Sender>::blocking;
+
   template(typename Self, typename Receiver)  //
       (requires same_as<type, remove_cvref_t<Self>> AND
            sender_to<member_t<Self, Sender>, Receiver>)  //
@@ -62,8 +64,8 @@ struct _sender<Sender>::type final {
         static_cast<Receiver&&>(r));
   }
 
-  friend auto tag_invoke(tag_t<blocking>, const type& s) noexcept {
-    return blocking(s.sender_);
+  friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const type& s) noexcept {
+    return unifex::blocking(s.sender_);
   }
 };
 
diff --git a/include/unifex/upon_done.hpp b/include/unifex/upon_done.hpp
index ac6b16d19..cf94759e0 100644
--- a/include/unifex/upon_done.hpp
+++ b/include/unifex/upon_done.hpp
@@ -163,11 +163,13 @@ struct _sender<Predecessor, Func>::type {
 
   static constexpr bool sends_done = false;
 
+  static constexpr blocking_kind blocking = sender_traits<Predecessor>::blocking;
+
   template <typename Receiver>
   using receiver_t = receiver_t<Receiver, Func>;
 
-  friend constexpr auto tag_invoke(tag_t<blocking>, const type& sender) {
-    return blocking(sender.pred_);
+  friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const type& sender) {
+    return unifex::blocking(sender.pred_);
   }
 
   template(typename Sender, typename Receiver)
diff --git a/include/unifex/upon_error.hpp b/include/unifex/upon_error.hpp
index 0ba8b8baf..8b77b7baa 100644
--- a/include/unifex/upon_error.hpp
+++ b/include/unifex/upon_error.hpp
@@ -144,11 +144,13 @@ struct _sender<Predecessor, Func>::type {
 
   static constexpr bool sends_done = sender_traits<Predecessor>::sends_done;
 
+  static constexpr blocking_kind blocking = sender_traits<Predecessor>::blocking;
+
   template <typename Receiver>
   using receiver_t = receiver_t<Receiver, Func>;
 
-  friend constexpr auto tag_invoke(tag_t<blocking>, const type& sender) {
-    return blocking(sender.pred_);
+  friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const type& sender) noexcept {
+    return unifex::blocking(sender.pred_);
   }
 
   template(typename Sender, typename Receiver)
diff --git a/include/unifex/v1/async_scope.hpp b/include/unifex/v1/async_scope.hpp
index 37dbc17a9..eeac04aea 100644
--- a/include/unifex/v1/async_scope.hpp
+++ b/include/unifex/v1/async_scope.hpp
@@ -36,6 +36,7 @@
 #include <unifex/type_traits.hpp>
 #include <unifex/v2/async_scope.hpp>
 
+#include <algorithm>
 #include <atomic>
 #include <memory>
 #include <tuple>
@@ -240,6 +241,10 @@ struct _attach_sender<Sender>::type final {
 
   static constexpr bool sends_done = sender_traits<Sender>::sends_done;
 
+  static constexpr blocking_kind blocking = std::min(
+      blocking_kind::maybe(),
+      sender_traits<Sender>::blocking());
+
   template <typename Sender2>
   explicit type(inplace_stop_token stoken, Sender2&& sender) noexcept(
       std::is_nothrow_constructible_v<Sender, Sender2>)
@@ -266,13 +271,19 @@ struct _attach_sender<Sender>::type final {
         static_cast<Receiver&&>(receiver)};
   }
 
-  friend constexpr auto
-  tag_invoke(tag_t<unifex::blocking>, const type& s) noexcept {
-    if constexpr (blocking_kind::never == cblocking<Sender>()) {
-      // we might return synchronously from start() so we're at most maybe
-      return blocking_kind::maybe;
-    } else {
-      return blocking(s.sender_);
+  friend constexpr blocking_kind
+  tag_invoke(tag_t<unifex::blocking>, [[maybe_unused]] const type& self) noexcept {
+    if constexpr (sender_traits<Sender>::blocking == blocking_kind::always_inline) {
+      // we can be constexpr in this case
+      return blocking_kind::always_inline;
+    }
+    else {
+      if (self.scope_) {
+        return unifex::blocking(self.sender_);
+      } else {
+        // we complete inline with done when there's no scope
+        return blocking_kind::always_inline;
+      }
     }
   }
 
diff --git a/include/unifex/v2/async_scope.hpp b/include/unifex/v2/async_scope.hpp
index 475d58f04..2d486b00e 100644
--- a/include/unifex/v2/async_scope.hpp
+++ b/include/unifex/v2/async_scope.hpp
@@ -24,6 +24,7 @@
 #include <unifex/sequence.hpp>
 #include <unifex/type_traits.hpp>
 
+#include <algorithm>
 #include <atomic>
 #include <cstddef>
 #include <memory>
@@ -329,6 +330,9 @@ struct _nest_sender<Sender>::type final {
 
   static constexpr bool sends_done = true;
 
+  static constexpr blocking_kind blocking =
+      std::min(blocking_kind::maybe(), sender_traits<Sender>::blocking());
+
   type() noexcept = default;
 
   template <typename Sender2>
@@ -440,14 +444,18 @@ struct _nest_sender<Sender>::type final {
     }
   }
 
-  friend constexpr auto
-  tag_invoke(tag_t<unifex::blocking>, const type&) noexcept {
+  friend constexpr blocking_kind tag_invoke(
+      tag_t<unifex::blocking>, [[maybe_unused]] const type& self) noexcept {
     if constexpr (
-        cblocking<Sender>() == blocking_kind::always_inline ||
-        cblocking<Sender>() == blocking_kind::always) {
-      return cblocking<Sender>();
+        sender_traits<Sender>::blocking == blocking_kind::always_inline) {
+      // we can be constexpr in this case
+      return blocking_kind::always_inline;
     } else {
-      return blocking_kind::maybe;
+      if (self.scope_) {
+        return unifex::blocking(self.sender_.get());
+      } else {
+        return blocking_kind::always_inline;
+      }
     }
   }
 
diff --git a/include/unifex/variant_sender.hpp b/include/unifex/variant_sender.hpp
index fe8f3d8fd..141b86eca 100644
--- a/include/unifex/variant_sender.hpp
+++ b/include/unifex/variant_sender.hpp
@@ -22,6 +22,7 @@
 #include <unifex/std_concepts.hpp>
 #include <unifex/manual_lifetime.hpp>
 
+#include <algorithm>
 #include <exception>
 #include <tuple>
 #include <type_traits>
@@ -71,33 +72,6 @@ struct _op<Ops...>::type {
   std::variant<manual_lifetime<Ops>...> variantOp_;
 };
 
-template <typename Sender, typename... Rest>
-struct max_blocking_kind {
-  constexpr auto operator()() noexcept { return cblocking<Sender>(); }
-};
-
-template <typename First, typename Second, typename... Rest>
-struct max_blocking_kind<First, Second, Rest...> {
-  constexpr auto operator()() noexcept {
-    constexpr blocking_kind first = cblocking<First>();
-    constexpr blocking_kind second = cblocking<Second>();
-
-    if constexpr (first == second) {
-      return max_blocking_kind<First, Rest...>{}();
-    } else if constexpr (
-        first == blocking_kind::always &&
-        second == blocking_kind::always_inline) {
-      return max_blocking_kind<First, Rest...>{}();
-    } else if constexpr (
-        first == blocking_kind::always_inline &&
-        second == blocking_kind::always) {
-      return max_blocking_kind<Second, Rest...>{}();
-    } else {
-      return blocking_kind::maybe;
-    }
-  }
-};
-
 template <typename... Senders>
 struct _sender {
   class type;
@@ -109,6 +83,21 @@ template <typename... Senders>
 class _sender<Senders...>::type {
   std::variant<Senders...> senderVariant_;
 
+  static_assert(sizeof...(Senders) > 0);
+
+  static constexpr blocking_kind compute_blocking() noexcept {
+    _block::_enum enums[]{sender_traits<Senders>::blocking...};
+
+    auto [min, max] = std::minmax_element(std::begin(enums), std::end(enums));
+
+    if (*min == *max) {
+      return *min;
+    }
+    else {
+      return std::min(*max, blocking_kind::maybe());
+    }
+  }
+
  public:
 
   template <
@@ -121,6 +110,8 @@ class _sender<Senders...>::type {
 
   static constexpr bool sends_done = std::disjunction_v<std::bool_constant<sender_traits<Senders>::sends_done>...>;
 
+  static constexpr blocking_kind blocking = compute_blocking();
+
   template<typename ConcreteSender>
   type(ConcreteSender&& concreteSender)
     noexcept(std::is_nothrow_constructible_v<std::variant<Senders...>, decltype(concreteSender)>)
@@ -149,8 +140,8 @@ class _sender<Senders...>::type {
         static_cast<decltype(that)>(that).senderVariant_);
   }
 
-  friend constexpr auto tag_invoke(tag_t<blocking>, const type&) noexcept {
-    return _variant_sender::max_blocking_kind<Senders...>{}();
+  friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const type& sender) noexcept {
+    return std::visit(unifex::blocking, sender.senderVariant_);
   }
 };
 } // namespace _variant_sender
diff --git a/include/unifex/via.hpp b/include/unifex/via.hpp
index 2ff99004d..763846f13 100644
--- a/include/unifex/via.hpp
+++ b/include/unifex/via.hpp
@@ -306,10 +306,10 @@ struct _sender<Predecessor, Successor>::type {
 
   friend constexpr auto tag_invoke(tag_t<blocking>, const sender& self) noexcept {
     if constexpr (
-        blocking_kind::maybe != cblocking<Predecessor>() &&
-        blocking_kind::maybe != cblocking<Successor>()) {
+        blocking_kind::maybe != sender_traits<Predecessor>::blocking &&
+        blocking_kind::maybe != sender_traits<Successor>::blocking) {
       return blocking_kind::constant<
-          _via::_blocking_kind(cblocking<Predecessor>(), cblocking<Successor>())>();
+          _via::_blocking_kind(sender_traits<Predecessor>::blocking, sender_traits<Successor>::blocking)>();
     } else {
       return _via::_blocking_kind(blocking(self.pred_), blocking(self.succ_));
     }
diff --git a/include/unifex/when_all.hpp b/include/unifex/when_all.hpp
index e23c684bf..3ef4edd3f 100644
--- a/include/unifex/when_all.hpp
+++ b/include/unifex/when_all.hpp
@@ -26,6 +26,7 @@
 #include <unifex/blocking.hpp>
 #include <unifex/std_concepts.hpp>
 
+#include <algorithm>
 #include <atomic>
 #include <cstddef>
 #include <optional>
@@ -306,6 +307,13 @@ inline constexpr bool when_all_connectable_v =
 template <typename... Senders>
 class _sender<Senders...>::type {
   using sender = type;
+
+  static constexpr blocking_kind compute_blocking() noexcept {
+    const _block::_enum enums[]{sender_traits<Senders>::blocking...};
+
+    return *std::max_element(std::begin(enums), std::end(enums));
+  }
+
 public:
   static_assert(sizeof...(Senders) > 0);
 
@@ -319,6 +327,8 @@ class _sender<Senders...>::type {
 
   static constexpr bool sends_done = true;
 
+  static constexpr blocking_kind blocking = compute_blocking();
+
   template <typename... Senders2>
   explicit type(Senders2&&... senders)
     : senders_((Senders2 &&) senders...) {}
@@ -335,47 +345,17 @@ class _sender<Senders...>::type {
     }, static_cast<Sender &&>(sender).senders_);
   }
 
-private:
-
   // Customise the 'blocking' CPO to combine the blocking-nature
   // of each of the child operations.
-  friend blocking_kind tag_invoke(tag_t<blocking>, const sender& s) noexcept {
-    bool alwaysInline = true;
-    bool alwaysBlocking = true;
-    bool neverBlocking =  false;
-
-    auto handleBlockingStatus = [&](blocking_kind kind) noexcept {
-      switch (kind) {
-        case blocking_kind::never:
-          neverBlocking = true;
-          [[fallthrough]];
-        case blocking_kind::maybe:
-          alwaysBlocking = false;
-          [[fallthrough]];
-        case blocking_kind::always:
-          alwaysInline = false;
-          [[fallthrough]];
-        case blocking_kind::always_inline:
-          break;
-      }
-    };
+  friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const sender& s) noexcept {
+    return std::apply([](const auto&... senders) noexcept {
+      const _block::_enum enums[]{blocking(senders)...};
 
-    std::apply([&](const auto&... senders) {
-      (void)std::initializer_list<int>{
-        (handleBlockingStatus(blocking(senders)), 0)... };
+      return *std::max_element(std::begin(enums), std::end(enums));
     }, s.senders_);
-
-    if (neverBlocking) {
-      return blocking_kind::never;
-    } else if (alwaysInline) {
-      return blocking_kind::always_inline;
-    } else if (alwaysBlocking) {
-      return blocking_kind::always;
-    } else {
-      return blocking_kind::maybe;
-    }
   }
 
+private:
   std::tuple<Senders...> senders_;
 };
 
diff --git a/include/unifex/when_all_range.hpp b/include/unifex/when_all_range.hpp
index 0ec86c47f..5f93bd63a 100644
--- a/include/unifex/when_all_range.hpp
+++ b/include/unifex/when_all_range.hpp
@@ -20,6 +20,7 @@
 #include <atomic>
 #include <cstddef>
 #include <functional>
+#include <numeric>
 #include <optional>
 #include <type_traits>
 #include <variant>
@@ -291,6 +292,10 @@ struct _sender<Sender>::type final {
 
   static constexpr bool sends_done = true;
 
+  static constexpr blocking_kind blocking = std::min(
+      blocking_kind::maybe(),
+      sender_traits<Sender>::blocking());
+
 private:
   template(typename Sender2, typename Receiver)  //
       (requires unifex::same_as<unifex::remove_cvref_t<Sender2>, type> AND
@@ -306,17 +311,25 @@ struct _sender<Sender>::type final {
   }
 
   // Combine the blocking-nature of each of the child operations.
-  friend constexpr auto tag_invoke(
-      unifex::tag_t<unifex::blocking> /* unused */, const type&) noexcept {
+  friend constexpr blocking_kind tag_invoke(
+      unifex::tag_t<unifex::blocking>,
+      [[maybe_unused]] const type& sender) noexcept {
     if constexpr (
-        unifex::cblocking<Sender>() == unifex::blocking_kind::always_inline ||
-        unifex::cblocking<Sender>() == unifex::blocking_kind::always) {
-      return unifex::cblocking<Sender>();
+        unifex::sender_traits<Sender>::blocking ==
+        unifex::blocking_kind::always_inline) {
+      // we can be constexpr in this case
+      return blocking_kind::always_inline;
     } else {
-      // we complete inline if the input is empty so every other case is "maybe"
-      return unifex::blocking_kind::maybe;
+      return std::accumulate(
+          std::begin(sender.senders_),
+          std::end(sender.senders_),
+          blocking_kind::always_inline(),
+          [](auto max, const auto& sender) noexcept {
+            blocking_kind next = unifex::blocking(sender);
+            return std::max(max, next());
+          });
     }
-  }
+}
 
   std::vector<Sender> senders_;
 };
diff --git a/include/unifex/win32/windows_thread_pool.hpp b/include/unifex/win32/windows_thread_pool.hpp
index 9a81021fc..0c9d11471 100644
--- a/include/unifex/win32/windows_thread_pool.hpp
+++ b/include/unifex/win32/windows_thread_pool.hpp
@@ -213,6 +213,8 @@ class windows_thread_pool::_cancellable_schedule_op_base<StopToken>::type {
     void start_impl(const StopToken& stopToken) & noexcept {
         if (state_ != nullptr) {
             // Short-circuit all of this if stopToken.stop_requested() is already true.
+            //
+            // TODO: this means done can be delivered on "the wrong thread"
             if (stopToken.stop_requested()) {
                 set_done_impl();
                 return;
@@ -339,8 +341,8 @@ class windows_thread_pool::_cancellable_schedule_op_base<StopToken>::type {
         ::WaitForThreadpoolWorkCallbacks(work_, cancelPending);
 
         // Destruct the stop-callback before calling set_done() as the call
-        // to set_done() will invalidate the stop-token and we need to 
-        // make sure that 
+        // to set_done() will invalidate the stop-token and we need to
+        // make sure that
         stopCallback_.destruct();
 
         // Now that the work has been successfully cancelled we can
@@ -368,7 +370,7 @@ class windows_thread_pool::_cancellable_schedule_op_base<StopToken>::type {
     // Flag set once start() has finished calling ThreadpoolSubmitWork()
     static constexpr std::uint32_t submit_complete_flag = 1;
 
-    // Flag set by request_stop() 
+    // Flag set by request_stop()
     static constexpr std::uint32_t stop_requested_flag = 2;
 
     // Flag set by cancellable_work_callback() when it starts executing.
@@ -377,7 +379,7 @@ class windows_thread_pool::_cancellable_schedule_op_base<StopToken>::type {
 
     // Flag set by cancellable_work_callback() after having deregistered
     // the stop-callback, just before it calls the receiver.
-    static constexpr std::uint32_t running_flag = 8; 
+    static constexpr std::uint32_t running_flag = 8;
 
     PTP_WORK work_;
     TP_CALLBACK_ENVIRON environ_;
@@ -437,6 +439,10 @@ class windows_thread_pool::schedule_sender {
 
     static constexpr bool sends_done = true;
 
+    // it's *almost* never, but done is sometimes delivered inline, which should
+    // probably be fixed (see TODOs in start_impl())
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     template(typename Receiver)
         (requires receiver_of<Receiver> AND
             is_stop_never_possible_v<stop_token_type_t<Receiver>>)
@@ -509,7 +515,7 @@ class windows_thread_pool::_time_schedule_op_base<StopToken>::type {
     void start_impl(const StopToken& stopToken, FILETIME dueTime) noexcept {
         auto startTimer = [&]() noexcept {
             const DWORD periodInMs = 0;   // Single-shot
-            const DWORD maxDelayInMs = 0; // Max delay to allow timer coalescing 
+            const DWORD maxDelayInMs = 0; // Max delay to allow timer coalescing
             ::SetThreadpoolTimer(timer_, &dueTime, periodInMs, maxDelayInMs);
         };
 
@@ -518,6 +524,8 @@ class windows_thread_pool::_time_schedule_op_base<StopToken>::type {
             if (state != nullptr) {
                 // Short-circuit extra work submitting the
                 // timer if stop has already been requested.
+                //
+                // TODO: this means done can be delivered on "the wrong thread"
                 if (stopToken.stop_requested()) {
                     set_done_impl();
                     return;
@@ -619,7 +627,7 @@ class windows_thread_pool::_time_schedule_op_base<StopToken>::type {
     // Flag set once start() has finished calling ThreadpoolSubmitWork()
     static constexpr std::uint32_t submit_complete_flag = 1;
 
-    // Flag set by request_stop() 
+    // Flag set by request_stop()
     static constexpr std::uint32_t stop_requested_flag = 2;
 
     // Flag set by cancellable_work_callback() when it starts executing.
@@ -628,7 +636,7 @@ class windows_thread_pool::_time_schedule_op_base<StopToken>::type {
 
     // Flag set by cancellable_work_callback() after having deregistered
     // the stop-callback, just before it calls the receiver.
-    static constexpr std::uint32_t running_flag = 8; 
+    static constexpr std::uint32_t running_flag = 8;
 
     PTP_TIMER timer_;
     TP_CALLBACK_ENVIRON environ_;
@@ -642,7 +650,7 @@ class windows_thread_pool::_time_schedule_op_base<StopToken>::type {
 template<typename Receiver>
 class windows_thread_pool::_schedule_at_op<Receiver>::type final
     : public windows_thread_pool::time_schedule_op_base<stop_token_type_t<Receiver>> {
-    using base = windows_thread_pool::time_schedule_op_base<stop_token_type_t<Receiver>>; 
+    using base = windows_thread_pool::time_schedule_op_base<stop_token_type_t<Receiver>>;
 public:
     template<typename Receiver2>
     explicit type(windows_thread_pool& pool, windows_thread_pool::clock_type::time_point dueTime, Receiver2&& r)
@@ -657,7 +665,7 @@ class windows_thread_pool::_schedule_at_op<Receiver>::type final
         FILETIME ft;
         ft.dwLowDateTime = ticks.LowPart;
         ft.dwHighDateTime = ticks.HighPart;
-        
+
         this->start_impl(get_stop_token(receiver_), ft);
     }
 
@@ -692,6 +700,10 @@ class windows_thread_pool::schedule_at_sender {
 
     static constexpr bool sends_done = true;
 
+    // it's *almost* never, but done is sometimes delivered inline, which should
+    // probably be fixed (see TODOs in start_impl())
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     explicit schedule_at_sender(windows_thread_pool& pool, filetime_clock::time_point dueTime)
     : pool_(&pool)
     , dueTime_(dueTime)
@@ -718,7 +730,7 @@ class windows_thread_pool::schedule_at_sender {
 template<typename Duration, typename Receiver>
 class windows_thread_pool::_schedule_after_op<Duration, Receiver>::type final
     : public windows_thread_pool::time_schedule_op_base<stop_token_type_t<Receiver>> {
-    using base = windows_thread_pool::time_schedule_op_base<stop_token_type_t<Receiver>>; 
+    using base = windows_thread_pool::time_schedule_op_base<stop_token_type_t<Receiver>>;
 public:
     template<typename Receiver2>
     explicit type(windows_thread_pool& pool, Duration duration, Receiver2&& r)
@@ -735,7 +747,7 @@ class windows_thread_pool::_schedule_after_op<Duration, Receiver>::type final
         FILETIME ft;
         ft.dwLowDateTime = ticks.LowPart;
         ft.dwHighDateTime = ticks.HighPart;
-        
+
         this->start_impl(get_stop_token(receiver_), ft);
     }
 
@@ -772,6 +784,10 @@ class windows_thread_pool::_schedule_after_sender<Duration>::type {
 
     static constexpr bool sends_done = true;
 
+    // it's *almost* never, but done is sometimes delivered inline, which should
+    // probably be fixed (see TODOs in start_impl())
+    static constexpr blocking_kind blocking = blocking_kind::maybe;
+
     explicit type(windows_thread_pool& pool, Duration duration)
     : pool_(&pool)
     , duration_(duration)
diff --git a/include/unifex/with_query_value.hpp b/include/unifex/with_query_value.hpp
index 38d019ce3..70a81ed39 100644
--- a/include/unifex/with_query_value.hpp
+++ b/include/unifex/with_query_value.hpp
@@ -113,6 +113,8 @@ class _sender<CPO, Value, Sender>::type {
 
   static constexpr bool sends_done = sender_traits<Sender>::sends_done;
 
+  static constexpr blocking_kind blocking = sender_traits<Sender>::blocking;
+
   template <typename Sender2, typename Value2>
   explicit type(Sender2&& sender, Value2&& value)
     : sender_((Sender2 &&) sender)
@@ -147,6 +149,10 @@ class _sender<CPO, Value, Sender>::type {
         static_cast<Self&&>(s).value_};
   }
 
+  friend constexpr blocking_kind tag_invoke(tag_t<unifex::blocking>, const type& s) noexcept {
+    return unifex::blocking(s.sender_);
+  }
+
 private:
   Sender sender_;
   Value value_;
diff --git a/test/async_scope_v2_test.cpp b/test/async_scope_v2_test.cpp
index 1ac958f36..a52c157d6 100644
--- a/test/async_scope_v2_test.cpp
+++ b/test/async_scope_v2_test.cpp
@@ -87,6 +87,9 @@ struct throwing_sender final {
 
   static constexpr bool sends_done = false;
 
+  static constexpr unifex::blocking_kind blocking
+      = unifex::blocking_kind::always_inline;
+
   UNIFEX_TEMPLATE(typename Receiver)                                //
   (requires unifex::sender_to<decltype(unifex::just()), Receiver>)  //
       friend auto tag_invoke(
@@ -299,6 +302,9 @@ TEST_F(
       !unifex::is_nothrow_connectable_v<throwing_sender_t&, nothrow_receiver>);
   static_assert(
       !unifex::is_nothrow_connectable_v<throwing_sender_t&, nothrow_receiver&>);
+  static_assert(
+      unifex::blocking_kind::always_inline ==
+      unifex::sender_traits<throwing_sender_t>::blocking);
 }
 
 TEST_F(async_scope_v2_test, nest_owns_one_refcount) {
diff --git a/test/finally_test.cpp b/test/finally_test.cpp
index 2d887fc53..338836b8d 100644
--- a/test/finally_test.cpp
+++ b/test/finally_test.cpp
@@ -72,11 +72,11 @@ TEST(Finally, Error) {
 TEST(Finally, BlockingKind) {
   auto snd1 = finally(just(), just());
   using Snd1 = decltype(snd1);
-  static_assert(blocking_kind::always_inline == cblocking<Snd1>());
+  static_assert(blocking_kind::always_inline == sender_traits<Snd1>::blocking);
 
   timed_single_thread_context context;
-  
+
   auto snd2 = finally(just(), schedule(context.get_scheduler()));
   using Snd2 = decltype(snd2);
-  static_assert(blocking_kind::maybe == cblocking<Snd2>());
+  static_assert(blocking_kind::never == sender_traits<Snd2>::blocking);
 }
diff --git a/test/just_tests.cpp b/test/just_tests.cpp
new file mode 100644
index 000000000..7af711ccf
--- /dev/null
+++ b/test/just_tests.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *   https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <unifex/just.hpp>
+
+#include <unifex/blocking.hpp>
+#include <unifex/sender_concepts.hpp>
+
+#include <gtest/gtest.h>
+
+using unifex::blocking_kind;
+using unifex::just;
+using unifex::sender_traits;
+
+namespace {
+
+TEST(just_tests, just_void) {
+  using just_t = decltype(just());
+
+  static_assert(blocking_kind::always_inline == sender_traits<just_t>::blocking);
+}
+
+}  // namespace
diff --git a/test/let_value_test.cpp b/test/let_value_test.cpp
index 6fb6d0b55..cbb7edddc 100644
--- a/test/let_value_test.cpp
+++ b/test/let_value_test.cpp
@@ -63,9 +63,7 @@ struct sender {
 
   static constexpr bool sends_done = false;
 
-  friend constexpr auto tag_invoke(tag_t<blocking>, const sender&) noexcept {
-    return blocking_kind::never;
-  }
+  static constexpr blocking_kind blocking = blocking_kind::never;
 };
 
 inline const struct _fn {
@@ -179,13 +177,13 @@ TEST(Let, Pipeable) {
 TEST(Let, InlineBlockingKind) {
   auto snd = let_value(just(), just);
   using Snd = decltype(snd);
-  static_assert(blocking_kind::always_inline == cblocking<Snd>());
+  static_assert(blocking_kind::always_inline == sender_traits<Snd>::blocking);
 }
 
 TEST(Let, PipeInlineBlockingKind) {
   auto snd = just() | let_value(just);
   using Snd = decltype(snd);
-  static_assert(blocking_kind::always_inline == cblocking<Snd>());
+  static_assert(blocking_kind::always_inline == sender_traits<Snd>::blocking);
 }
 
 TEST(Let, MaybeBlockingKind) {
@@ -193,11 +191,11 @@ TEST(Let, MaybeBlockingKind) {
 
   auto snd1 = let_value(schedule(context.get_scheduler()), just);
   using Snd1 = decltype(snd1);
-  static_assert(blocking_kind::maybe == cblocking<Snd1>());
+  static_assert(blocking_kind::never == sender_traits<Snd1>::blocking);
 
   auto snd2 = let_value(multi_sender(), just);
   using Snd2 = decltype(snd2);
-  static_assert(blocking_kind::maybe == cblocking<Snd2>());
+  static_assert(blocking_kind::maybe == sender_traits<Snd2>::blocking);
 }
 
 TEST(Let, PipeMaybeBlockingKind) {
@@ -207,37 +205,37 @@ TEST(Let, PipeMaybeBlockingKind) {
     return schedule(context.get_scheduler());
   });
   using Snd1 = decltype(snd1);
-  static_assert(blocking_kind::maybe == cblocking<Snd1>());
+  static_assert(blocking_kind::maybe == sender_traits<Snd1>::blocking);
 
   auto snd2 = just() | let_value(multi_sender);
   using Snd2 = decltype(snd2);
-  static_assert(blocking_kind::maybe == cblocking<Snd2>());
+  static_assert(blocking_kind::maybe == sender_traits<Snd2>::blocking);
 }
 
 TEST(Let, NeverBlockingKind) {
   auto snd1 = let_value(never_block(), never_block);
   using Snd1 = decltype(snd1);
-  static_assert(blocking_kind::never == cblocking<Snd1>());
+  static_assert(blocking_kind::never == sender_traits<Snd1>::blocking);
 
   timed_single_thread_context context;
 
   auto snd2 = let_value(schedule(context.get_scheduler()), never_block);
   using Snd2 = decltype(snd2);
-  static_assert(blocking_kind::never == cblocking<Snd2>());
+  static_assert(blocking_kind::never == sender_traits<Snd2>::blocking);
 
   auto snd3 = let_value(never_block(), multi_sender);
   using Snd3 = decltype(snd3);
-  static_assert(blocking_kind::never == cblocking<Snd3>());
+  static_assert(blocking_kind::never == sender_traits<Snd3>::blocking);
 }
 
 TEST(Let, PipeNeverBlockingKind) {
   auto snd1 = never_block() | let_value(never_block);
   using Snd1 = decltype(snd1);
-  static_assert(blocking_kind::never == cblocking<Snd1>());
+  static_assert(blocking_kind::never == sender_traits<Snd1>::blocking);
 
   auto snd2 = never_block() | let_value(multi_sender);
   using Snd2 = decltype(snd2);
-  static_assert(blocking_kind::never == cblocking<Snd2>());
+  static_assert(blocking_kind::never == sender_traits<Snd2>::blocking);
 }
 
 TEST(Let, SimpleLetValueWithAllocate) {
diff --git a/test/task_scheduler_affinity_test.cpp b/test/task_scheduler_affinity_test.cpp
index 2ac55a3b1..e4d88005c 100644
--- a/test/task_scheduler_affinity_test.cpp
+++ b/test/task_scheduler_affinity_test.cpp
@@ -26,6 +26,7 @@
 #include <unifex/never.hpp>
 #include <unifex/single_thread_context.hpp>
 #include <unifex/stop_if_requested.hpp>
+#include <unifex/stop_when.hpp>
 #include <unifex/sync_wait.hpp>
 #include <unifex/task.hpp>
 #include <unifex/then.hpp>
@@ -136,6 +137,7 @@ task<std::thread::id> test_context_restored_on_error(Scheduler s) {
   }
   co_return id;
 }
+
 } // anonymous namespace
 
 TEST_F(TaskSchedulerAffinityTest, TransformSenderOnSeparateThread) {
diff --git a/test/variant_sender_test.cpp b/test/variant_sender_test.cpp
index b4d241e2e..96e65f7fd 100644
--- a/test/variant_sender_test.cpp
+++ b/test/variant_sender_test.cpp
@@ -188,14 +188,14 @@ TEST(Variant, CombineJustAndJust_Invalid) {
 
   auto just_variant_sender = func(true);
   using JustInt = decltype(just_variant_sender);
-  static_assert(blocking_kind::always_inline == cblocking<JustInt>());
+  static_assert(blocking_kind::always_inline == sender_traits<JustInt>::blocking);
   EXPECT_FALSE(just_variant_sender.sends_done);
   auto op = unifex::connect(just_variant_sender, rec);
   unifex::start(op);
 
   auto just_string_sender = func(false);
   using JustString = decltype(just_variant_sender);
-  static_assert(blocking_kind::always_inline == cblocking<JustString>());
+  static_assert(blocking_kind::always_inline == sender_traits<JustString>::blocking);
   EXPECT_FALSE(just_variant_sender.sends_done);
   auto op2 = unifex::connect(just_string_sender, rec);
   unifex::start(op2);
@@ -214,7 +214,7 @@ using is_noexcept = unifex::is_nothrow_connectable<conditionally_lvalue_t<test_s
 
 TEST(Variant, BlockingKind) {
   // default
-  static_assert(blocking_kind::maybe == cblocking<test_sender_t<true, true>>());
+  static_assert(blocking_kind::maybe == sender_traits<test_sender_t<true, true>>::blocking);
 }
 
 TEST(Variant, TestNoexcept) {
diff --git a/test/when_all_2_test.cpp b/test/when_all_2_test.cpp
index fe9ebf5b1..600a139ce 100644
--- a/test/when_all_2_test.cpp
+++ b/test/when_all_2_test.cpp
@@ -76,6 +76,7 @@ struct _cancel_only_sender {
     receiver_t receiver_;
     receiver_stop_token_t stoken_ = get_stop_token(receiver_);
     cancel_operation<receiver_t> cancel_{*this};
+    // TODO: this could invoke set_done before start is invoked
     decltype(make_stop_callback(stoken_, cancel_)) callback_ =
         make_stop_callback(stoken_, cancel_);
 
diff --git a/test/windows_threadpool_test.cpp b/test/windows_threadpool_test.cpp
index 36b80dbee..8197da2d5 100644
--- a/test/windows_threadpool_test.cpp
+++ b/test/windows_threadpool_test.cpp
@@ -16,6 +16,8 @@
 
 #ifdef _WIN32
 
+#define NOMINMAX
+
 #include <unifex/win32/windows_thread_pool.hpp>
 #include <unifex/sync_wait.hpp>
 #include <unifex/then.hpp>