diff --git a/include/exec/__detail/__sender_facade.hpp b/include/exec/__detail/__sender_facade.hpp
index 537d1deda..98086f36c 100644
--- a/include/exec/__detail/__sender_facade.hpp
+++ b/include/exec/__detail/__sender_facade.hpp
@@ -91,13 +91,6 @@ namespace exec {
       __declval<__data_placeholder&>(),
       __declval<__receiver_placeholder<_Env>&>()));
 
-    struct __dependent_sender {
-      using is_sender = void;
-      using __t = __dependent_sender;
-      friend auto tag_invoke(get_completion_signatures_t, __dependent_sender, no_env)
-        -> dependent_completion_signatures<no_env>;
-    };
-
     struct __sender_transform_failed {
       using __t = __sender_transform_failed;
     };
@@ -109,8 +102,6 @@ namespace exec {
       } else {
         if constexpr (__mvalid<__tfx_sender_, _Kernel, _Sender, _Env>) {
           return __mtype<__tfx_sender_<_Kernel, _Sender, _Env>>{};
-        } else if constexpr (same_as<_Env, no_env>) {
-          return __dependent_sender{};
         } else {
           return __sender_transform_failed{};
         }
@@ -120,7 +111,6 @@ namespace exec {
 
     template <class _Kernel, class _Sender, class _Data, class _Receiver>
     auto __transform_sender(_Kernel& __kernel, _Sender&& __sndr, _Data& __data, _Receiver& __rcvr) {
-      static_assert(!same_as<env_of_t<_Receiver>, no_env>);
       if constexpr (__lacks_transform_sender<_Kernel>) {
         return (_Sender&&) __sndr;
       } else {
@@ -141,11 +131,7 @@ namespace exec {
       __declval<_As>()...));
 
     template <class _Kernel, class _Env>
-    using __get_env_ = decltype(__declval<_Kernel&>().get_env(__declval<_Env>()));
-
-    template <class _Kernel, class _Env>
-    using __env_t =
-      __minvoke< __if_c<same_as<_Env, no_env>, __mconst<no_env>, __q<__get_env_>>, _Kernel, _Env>;
+    using __env_t = decltype(__declval<_Kernel&>().get_env(__declval<_Env>()));
 
     template <class _Kernel, class _Env, class _Tag, class... _As>
     auto __completions_from_sig(_Tag (*)(_As...))
@@ -312,19 +298,13 @@ namespace exec {
                 __completions_t<_NewEnv, __pre_completions_t<_NewSender, _NewEnv>>;
               if constexpr (__valid_completion_signatures<_Completions, _Env>) {
                 return (_Completions(*)()) nullptr;
-              } else if constexpr (same_as<no_env, _Env>) {
-                return (dependent_completion_signatures<no_env>(*)()) nullptr;
               } else {
                 // assume this is an error message and return it directly
                 return (_Completions(*)()) nullptr;
               }
-            } else if constexpr (same_as<no_env, _Env>) {
-              return (dependent_completion_signatures<no_env>(*)()) nullptr;
             } else {
               return (__diagnostic_t<_Env>(*)()) nullptr;
             }
-          } else if constexpr (same_as<no_env, _Env>) {
-            return (dependent_completion_signatures<no_env>(*)()) nullptr;
           } else if constexpr (same_as<_NewSender, __sender_transform_failed>) {
             return (__diagnostic_t<_Env>(*)()) nullptr;
           } else {
diff --git a/include/exec/any_sender_of.hpp b/include/exec/any_sender_of.hpp
index 65ff4585f..dd741fe9d 100644
--- a/include/exec/any_sender_of.hpp
+++ b/include/exec/any_sender_of.hpp
@@ -794,6 +794,7 @@ namespace exec {
       using _Receiver = stdexec::__t<_ReceiverId>;
 
       struct __t {
+        using is_receiver = void;
         __operation_base<_Receiver>* __op_;
 
         template <same_as<set_next_t> _SetNext, same_as<__t> _Self, class _Item>
diff --git a/include/exec/env.hpp b/include/exec/env.hpp
index 75cba0a50..831ad8166 100644
--- a/include/exec/env.hpp
+++ b/include/exec/env.hpp
@@ -95,7 +95,7 @@ namespace exec {
         return {{}, ((_Self&&) __self).__default_, (_Receiver&&) __rcvr};
       }
 
-      template <__none_of<no_env> _Env>
+      template <class _Env>
       friend auto tag_invoke(get_completion_signatures_t, __sender, _Env&&)
         -> __completions_t<_Env> {
         return {};
diff --git a/include/exec/finally.hpp b/include/exec/finally.hpp
index 45ba30608..98ac21f1c 100644
--- a/include/exec/finally.hpp
+++ b/include/exec/finally.hpp
@@ -263,7 +263,7 @@ namespace exec {
             (_Rec&&) __receiver};
         }
 
-        template <__decays_to<__t> _Self, __none_of<no_env> _Env>
+        template <__decays_to<__t> _Self, class _Env>
         friend auto tag_invoke(get_completion_signatures_t, _Self&&, _Env&&) noexcept
           -> __completion_signatures_t<
             __copy_cvref_t<_Self, _InitialSender>,
diff --git a/include/exec/sequence/any_sequence_of.hpp b/include/exec/sequence/any_sequence_of.hpp
index 708812ef2..8056aed3f 100644
--- a/include/exec/sequence/any_sequence_of.hpp
+++ b/include/exec/sequence/any_sequence_of.hpp
@@ -21,7 +21,7 @@
 namespace exec {
   namespace __any {
     namespace __next {
-      template <__is_completion_signatures _Sigs>
+      template <__valid_completion_signatures _Sigs>
       struct __rcvr_next_vfun {
         using __return_sigs = completion_signatures<set_value_t(), set_stopped_t()>;
         using __void_sender = typename any_receiver_ref<__return_sigs>::template any_sender<>;
@@ -37,7 +37,7 @@ namespace exec {
         template <class _Sigs>
         using __item_sender = typename any_receiver_ref<_Sigs>::template any_sender<>;
 
-        template <__is_completion_signatures _Sigs>
+        template <__valid_completion_signatures _Sigs>
         constexpr __void_sender (*operator()(_Sigs*) const)(void*, __item_sender<_Sigs>&&) {
           return +[](void* __r, __item_sender<_Sigs>&& __sndr) noexcept -> __void_sender {
             return __void_sender{
@@ -295,7 +295,7 @@ namespace exec {
     template <
       std::same_as<exec::set_next_t> _SetNext,
       std::same_as<__t> _Self,
-      stdexec::__sender _Sender>
+      stdexec::sender _Sender>
       requires stdexec::__callable<set_next_t, _Self&, _Sender>
     friend auto tag_invoke(_SetNext, _Self& __self, _Sender&& __sender) {
       return exec::set_next(__self.__receiver_, static_cast<_Sender&&>(__sender));
diff --git a/include/exec/sequence_senders.hpp b/include/exec/sequence_senders.hpp
index 9fa7c03ee..b20d0fb03 100644
--- a/include/exec/sequence_senders.hpp
+++ b/include/exec/sequence_senders.hpp
@@ -333,15 +333,6 @@ namespace exec {
           __nothrow_callable<get_env_t, _Receiver&>
           && __nothrow_callable<transform_sender_t, _Domain, _Sender, env_of_t<_Receiver&>>;
         using _TfxSender = __tfx_sndr<_Sender, _Receiver>;
-        if constexpr (!enable_sender<__decay_t<_Sender>>)
-          __connect::_PLEASE_UPDATE_YOUR_SENDER_TYPE<__decay_t<_Sender>>();
-
-        if constexpr (!enable_sender<__decay_t<_TfxSender>>)
-          __connect::_PLEASE_UPDATE_YOUR_SENDER_TYPE<__decay_t<_TfxSender>>();
-
-        if constexpr (!enable_receiver<__decay_t<_Receiver>>)
-          __connect::_PLEASE_UPDATE_YOUR_RECEIVER_TYPE<__decay_t<_Receiver>>();
-
         if constexpr (__next_connectable_with_tag_invoke<_TfxSender, _Receiver>) {
           using _Result = tag_invoke_result_t<
             connect_t,
diff --git a/include/exec/when_any.hpp b/include/exec/when_any.hpp
index 24ffaed5b..614436214 100644
--- a/include/exec/when_any.hpp
+++ b/include/exec/when_any.hpp
@@ -122,7 +122,7 @@ namespace exec {
             try {
               __result_.emplace(std::tuple{_CPO{}, (_Args&&) __args...});
             } catch (...) {
-              __result_.emplace(set_error_t{}, std::current_exception());
+              __result_.emplace(std::tuple{set_error_t{}, std::current_exception()});
             }
           }
           // stop pending operations
diff --git a/include/nvexec/stream/when_all.cuh b/include/nvexec/stream/when_all.cuh
index e129d4068..ac6fd7319 100644
--- a/include/nvexec/stream/when_all.cuh
+++ b/include/nvexec/stream/when_all.cuh
@@ -49,7 +49,15 @@ namespace nvexec::STDEXEC_STREAM_DETAIL_NS {
 
     template <class Env, class... Senders>
     struct completions {
-      using __t = dependent_completion_signatures<Env>;
+      template <class Sender, class Env>
+      using too_many_completions = __mbool<(__v<__count_of<set_value_t, Sender, Env>> > 1)>;
+
+      using InvalidArg = //
+        __minvoke<
+          __mfind_if<__mbind_back_q<too_many_completions, Env>, __q<__mfront>>,
+          Senders...>;
+
+      using __t = stdexec::__when_all::__too_many_value_completions_error<InvalidArg, Env>;
     };
 
     template <class... As, class TupleT>
@@ -63,7 +71,6 @@ namespace nvexec::STDEXEC_STREAM_DETAIL_NS {
     struct completions<Env, Senders...> {
       using non_values = //
         __concat_completion_signatures_t<
-
           completion_signatures< set_error_t(cudaError_t), set_stopped_t()>,
           __try_make_completion_signatures<
             Senders,
diff --git a/include/stdexec/__detail/__meta.hpp b/include/stdexec/__detail/__meta.hpp
index ed00a87b2..2c0e167df 100644
--- a/include/stdexec/__detail/__meta.hpp
+++ b/include/stdexec/__detail/__meta.hpp
@@ -389,7 +389,7 @@ namespace stdexec {
   struct _BAD_SUBSTITUTION_ { };
 
   template <class... _Args>
-  struct _WITH_TYPES_ { };
+  struct _WITH_TYPES_;
 
   template <template <class...> class _Fun>
   struct _WITH_META_FUNCTION_T_ {
diff --git a/include/stdexec/__detail/__p2300.hpp b/include/stdexec/__detail/__p2300.hpp
index 26de0efda..d9e6d619c 100644
--- a/include/stdexec/__detail/__p2300.hpp
+++ b/include/stdexec/__detail/__p2300.hpp
@@ -89,7 +89,8 @@ namespace std {
     using stop_token_of_t STDEXEC_STD_DEPRECATED = stdexec::stop_token_of_t<_StopTokenProvider>;
 
     // [exec.env], execution environments
-    using no_env STDEXEC_STD_DEPRECATED = stdexec::no_env;
+    struct __no_env {};
+    using no_env STDEXEC_STD_DEPRECATED = __no_env;
     using get_env_t STDEXEC_STD_DEPRECATED = stdexec::get_env_t;
     //using forwarding_env_query_t STDEXEC_STD_DEPRECATED = stdexec::forwarding_env_query_t; // BUGBUG
     STDEXEC_STD_DEPRECATED
@@ -138,13 +139,13 @@ namespace std {
     inline constexpr stdexec::start_t start{};
 
     // [exec.snd], senders
-    template <class _Sender, class _Env = stdexec::no_env>
+    template <class _Sender, class _Env = __no_env>
     concept sender /*STDEXEC_STD_DEPRECATED*/ = stdexec::sender_in<_Sender, _Env>;
 
     template <class _Sender, class _Receiver>
     concept sender_to /*STDEXEC_STD_DEPRECATED*/ = stdexec::sender_to<_Sender, _Receiver>;
 
-    template <class _Sender, class _SetSig, class _Env = stdexec::no_env>
+    template <class _Sender, class _SetSig, class _Env = __no_env>
     concept sender_of /*STDEXEC_STD_DEPRECATED*/ = stdexec::sender_of<_Sender, _SetSig, _Env>;
 
     // [exec.sndtraits], completion signatures
@@ -152,17 +153,20 @@ namespace std {
     STDEXEC_STD_DEPRECATED
     inline constexpr stdexec::get_completion_signatures_t get_completion_signatures{};
 
-    template <class _Sender, class _Env = stdexec::no_env>
+    template <class _Sender, class _Env = __no_env>
     using completion_signatures_of_t STDEXEC_STD_DEPRECATED =
       stdexec::completion_signatures_of_t<_Sender, _Env>;
 
+    template <class _Env>
+    struct __dependent_completion_signatures { };
+
     template <class _Env>
     using dependent_completion_signatures STDEXEC_STD_DEPRECATED =
-      stdexec::dependent_completion_signatures<_Env>;
+      __dependent_completion_signatures<_Env>;
 
     template <                                                     //
       class _Sender,                                               //
-      class _Env = stdexec::no_env,                                //
+      class _Env = __no_env,                                //
       template <class...> class _Tuple = stdexec::__decayed_tuple, //
       template <class...> class _Variant = stdexec::__variant>
     using value_types_of_t STDEXEC_STD_DEPRECATED =
@@ -170,12 +174,12 @@ namespace std {
 
     template <                      //
       class _Sender,                //
-      class _Env = stdexec::no_env, //
+      class _Env = __no_env, //
       template <class...> class _Variant = stdexec::__variant>
     using error_types_of_t STDEXEC_STD_DEPRECATED =
       stdexec::error_types_of_t<_Sender, _Env, _Variant>;
 
-    template <class _Sender, class _Env = stdexec::no_env>
+    template <class _Sender, class _Env = __no_env>
     STDEXEC_STD_DEPRECATED inline constexpr bool sends_stopped =
       stdexec::sends_stopped<_Sender, _Env>;
 
@@ -295,7 +299,7 @@ namespace std {
     // [exec.utils.mkcmplsigs]
     template <       //
       class _Sender, //
-      class _Env = stdexec::no_env,
+      class _Env = __no_env,
       class _Sigs = stdexec::completion_signatures<>,                                   //
       template <class...> class _SetValue = stdexec::__compl_sigs::__default_set_value, //
       template <class> class _SetError = stdexec::__compl_sigs::__default_set_error,    //
diff --git a/include/stdexec/execution.hpp b/include/stdexec/execution.hpp
index 9eb7d8768..ea9cbf1e9 100644
--- a/include/stdexec/execution.hpp
+++ b/include/stdexec/execution.hpp
@@ -39,43 +39,6 @@
 #include "coroutine.hpp"
 #include "stop_token.hpp"
 
-#ifndef STDEXEC_DISABLE_R5_DEPRECATION_WARNINGS
-#define STDEXEC_R5_SENDER_DEPRECATION_WARNING \
-  [[deprecated( \
-    "Deprecated sender type detected. " \
-    "Please give the type a nested `is_sender` type alias, or " \
-    "specialize stdexec::enable_sender<your-sender-type> to be `true`. " \
-    "To suppress this deprecation warning, define `STDEXEC_DISABLE_R5_DEPRECATION_WARNINGS`.")]]
-#define STDEXEC_R5_RECEIVER_DEPRECATION_WARNING \
-  [[deprecated( \
-    "Deprecated receiver type detected. " \
-    "Please give the type a nested `is_receiver` type alias, or " \
-    "specialize stdexec::enable_receiver<your-receiver-type> to be `true`." \
-    "To suppress this deprecation warning, define `STDEXEC_DISABLE_R5_DEPRECATION_WARNINGS`.")]]
-#define STDEXEC_R5_DEPENDENT_COMPLETION_SIGNATURES_DEPRECATION_WARNING \
-  [[deprecated( \
-    "The `dependent_completion_signatures<>` type is deprecated. There is " \
-    "no need to define a customization of `get_completion_signatures` for " \
-    "sender types whose completions are dependent on the receiver's environment. " \
-    "Give your sender type a nested `is_sender` type alias instead, " \
-    "specialize stdexec::enable_sender<your-sender-type> to be `true`. " \
-    "To suppress this deprecation warning, define `STDEXEC_DISABLE_R5_DEPRECATION_WARNINGS`.")]]
-#define STDEXEC_R5_NO_ENV_DEPRECATION_WARNING \
-  [[deprecated( \
-    "The `no_env` type is deprecated. The stdexec library no longer needs to use " \
-    "it to probe a type for satisfaction of the `sender` concept. " \
-    "Give your sender type a nested `is_sender` type alias instead, or " \
-    "specialize stdexec::enable_sender<your-sender-type> to be `true`. " \
-    "To suppress this deprecation warning, define `STDEXEC_DISABLE_R5_DEPRECATION_WARNINGS`.")]]
-#else
-#define STDEXEC_R5_SENDER_DEPRECATION_WARNING
-#define STDEXEC_R5_RECEIVER_DEPRECATION_WARNING
-#define STDEXEC_R5_DEPENDENT_COMPLETION_SIGNATURES_DEPRECATION_WARNING
-#define STDEXEC_R5_NO_ENV_DEPRECATION_WARNING
-#endif
-
-#define STDEXEC_LEGACY_R5_CONCEPTS() 1
-
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wpragmas")
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-warning-option")
@@ -410,13 +373,6 @@ namespace stdexec {
   /////////////////////////////////////////////////////////////////////////////
   // env_of
   namespace __env {
-    struct no_env {
-      using __t = no_env;
-      using __id = no_env;
-      template <class _Tag, same_as<no_env> _Self, class... _Ts>
-      friend void tag_invoke(_Tag, _Self, _Ts&&...) = delete;
-    };
-
     struct empty_env {
       using __t = empty_env;
       using __id = empty_env;
@@ -536,9 +492,7 @@ namespace stdexec {
       decltype(auto) operator()(_Env&& __env, _Base&& __base) const noexcept {
         using __env_t = __decay_t<_Env>;
         using __base_t = __decay_t<_Base>;
-        if constexpr (__one_of<no_env, __env_t, __base_t>) {
-          return no_env();
-        } else if constexpr (__same_as<__env_t, empty_env>) {
+        if constexpr (__same_as<__env_t, empty_env>) {
           return _Base((_Base&&) __base);
         } else if constexpr (__same_as<__base_t, empty_env>) {
           return _Env((_Env&&) __env);
@@ -606,28 +560,17 @@ namespace stdexec {
         return tag_invoke(*this, __with_env);
       }
 
-      // NOT TO SPEC: The overload below checks the non-standard
-      // enable_sender to determine whether to provide backwards
-      // compatible behavior for R5 version sender types. When we
-      // deprecate R5 support, we can bring this overload in line with
-      // P2300R7.
       template <class _EnvProvider>
-      constexpr decltype(auto) operator()(const _EnvProvider& __with_env) const noexcept {
-        if constexpr (!enable_sender<_EnvProvider>) {
-          return __with_env;
-        } else {
-          return empty_env{};
-        }
+      constexpr empty_env operator()(const _EnvProvider&) const noexcept {
+        return {};
       }
     };
   } // namespace __env
 
-  using __env::no_env;
   using __env::empty_env;
   using __empty_env [[deprecated("Please use stdexec::empty_env now.")]] = empty_env;
 
   using __env::__env_promise;
-  using no_env_promise = __env_promise<no_env>;
 
   inline constexpr __env::__make_env_t __make_env{};
   inline constexpr __env::__join_env_t __join_env{};
@@ -642,19 +585,12 @@ namespace stdexec {
   template <class... _Ts>
   using __make_env_t = __call_result_t<__env::__make_env_t, _Ts...>;
 
-#if STDEXEC_LEGACY_R5_CONCEPTS()
-  using __default_env = no_env;
-#else
   using __default_env = empty_env;
-#endif
 
   template <class _EnvProvider>
   concept environment_provider = //
     requires(_EnvProvider& __ep) {
       { get_env(std::as_const(__ep)) } -> queryable;
-      // NOT TO SPEC: Remove the following line when we deprecate all
-      // R5 entities.
-      { get_env(std::as_const(__ep)) } -> __none_of<no_env, void>;
     };
 
   /////////////////////////////////////////////////////////////////////////////
@@ -756,6 +692,45 @@ namespace stdexec {
     }
   } __try_call{};
 
+  namespace __error__ {
+    inline constexpr __mstring __unrecognized_sender_type_diagnostic =
+      "The given type cannot be used as a sender with the given environment "
+      "because the attempt to compute the completion signatures failed."__csz;
+
+    template <__mstring _Diagnostic = __unrecognized_sender_type_diagnostic>
+    struct _UNRECOGNIZED_SENDER_TYPE_;
+
+    template <class _Sender>
+    struct _WITH_SENDER_;
+
+    template <class... _Senders>
+    struct _WITH_SENDERS_;
+
+    template <class _Env>
+    struct _WITH_ENVIRONMENT_;
+
+    template <class _Ty>
+    struct _WITH_TYPE_;
+
+    template <class _Receiver>
+    struct _WITH_RECEIVER_;
+
+    template <class _Sig>
+    struct _MISSING_COMPLETION_SIGNAL_;
+  }
+
+  using __error__::_UNRECOGNIZED_SENDER_TYPE_;
+  using __error__::_WITH_ENVIRONMENT_;
+  using __error__::_WITH_TYPE_;
+  using __error__::_WITH_RECEIVER_;
+  using __error__::_MISSING_COMPLETION_SIGNAL_;
+
+  template <class _Sender>
+  using _WITH_SENDER_ = __error__::_WITH_SENDER_<__name_of<_Sender>>;
+
+  template <class... _Senders>
+  using _WITH_SENDERS_ = __error__::_WITH_SENDERS_<__name_of<_Senders>...>;
+
   /////////////////////////////////////////////////////////////////////////////
   // completion_signatures
   namespace __compl_sigs {
@@ -791,16 +766,6 @@ namespace stdexec {
     void __test(_Tag (*)(_Args...) noexcept) = delete;
 #endif
 
-    // BUGBUG not to spec!
-    struct __dependent {
-#if !STDEXEC_STD_NO_COROUTINES_
-      bool await_ready();
-      template <class _Env>
-      void await_suspend(__coro::coroutine_handle<__env_promise<_Env>>);
-      __dependent await_resume();
-#endif
-    };
-
 #if STDEXEC_NVHPC()
     template <class _Sig>
     concept __completion_signature = __compl_sigs::__is_compl_sig<_Sig>;
@@ -818,9 +783,6 @@ namespace stdexec {
 
   using __compl_sigs::__completion_signature;
 
-  template <same_as<no_env>>
-  using dependent_completion_signatures = __compl_sigs::__dependent;
-
   template <__compl_sigs::__completion_signature... _Sigs>
   struct completion_signatures {
     // Uncomment this to see where completion_signatures is
@@ -853,20 +815,35 @@ namespace stdexec {
     using __maybe_for_all_sigs = __meval<__for_all_sigs, _Completions, _TaggedTuple, _Variant>;
   } // namespace __compl_sigs
 
-  template <class _Ty>
-  concept __is_completion_signatures = __is_instance_of<_Ty, completion_signatures>;
+  template <class _Completions>
+  concept __valid_completion_signatures = //
+    __is_instance_of<_Completions, completion_signatures>;
 
-  template <class...>
-  auto __concat_completion_signatures_impl() //
-    -> dependent_completion_signatures<no_env>;
+  template <class _Completions>
+  using __invalid_completion_signatures_t = //
+    __mbool<!__valid_completion_signatures<_Completions>>;
 
-  template <__is_completion_signatures... _Completions>
-  auto __concat_completion_signatures_impl()
-    -> __minvoke< __mconcat<__munique<__q<completion_signatures>>>, _Completions...>;
+  template <__mstring _Msg = "Expected an instance of template completion_signatures<>"__csz>
+  struct _INVALID_COMPLETION_SIGNATURES_TYPE_ {
+    template <class... _Completions>
+    using __f = //
+      __mexception<
+        _INVALID_COMPLETION_SIGNATURES_TYPE_<>,
+        __minvoke<
+          __mfind_if<
+            __q<__invalid_completion_signatures_t>,
+            __mcompose<__q<_WITH_TYPE_>, __q<__mfront>>>,
+          _Completions...>>;
+  };
 
   template <class... _Completions>
   using __concat_completion_signatures_impl_t = //
-    decltype(__concat_completion_signatures_impl<_Completions...>());
+    __minvoke<
+      __if_c<
+        (__valid_completion_signatures<_Completions> &&...),
+        __mconcat<__munique<__q<completion_signatures>>>,
+        _INVALID_COMPLETION_SIGNATURES_TYPE_<>>,
+      _Completions...>;
 
   template <class... _Completions>
   struct __concat_completion_signatures_ {
@@ -876,28 +853,8 @@ namespace stdexec {
   template <class... _Completions>
   using __concat_completion_signatures_t = __t<__concat_completion_signatures_<_Completions...>>;
 
-  template <class _Completions, class _Env>
-  inline constexpr bool __expecting_completion_signatures = false;
-
-  template <class... _Sigs, class _Env>
-  inline constexpr bool __expecting_completion_signatures<completion_signatures<_Sigs...>, _Env> =
-    true;
-
-  template <>
-  inline constexpr bool
-    __expecting_completion_signatures<dependent_completion_signatures<no_env>, no_env> = true;
-
-  template <class _Completions, class _Env>
-  concept __valid_completion_signatures = __expecting_completion_signatures<_Completions, _Env>;
-
   /////////////////////////////////////////////////////////////////////////////
   // [execution.receivers]
-  template <class _Receiver>
-  struct _WITH_RECEIVER_ { };
-
-  template <class _Sig>
-  struct _MISSING_COMPLETION_SIGNAL_ { };
-
   template <class _Receiver, class _Tag, class... _Args>
   auto __try_completion(_Tag (*)(_Args...))
     -> __mexception<_MISSING_COMPLETION_SIGNAL_<_Tag(_Args...)>, _WITH_RECEIVER_<_Receiver>>;
@@ -910,33 +867,6 @@ namespace stdexec {
   auto __try_completions(completion_signatures<_Sigs...>*)
     -> decltype((__msuccess(), ..., stdexec::__try_completion<_Receiver>((_Sigs*) nullptr)));
 
-  namespace __error__ {
-    inline constexpr __mstring __unrecognized_sender_type_diagnostic =
-      "The given type cannot be used as a sender with the given environment "
-      "because the attempt to compute the completion signatures failed."__csz;
-
-    template <__mstring _Diagnostic = __unrecognized_sender_type_diagnostic>
-    struct _UNRECOGNIZED_SENDER_TYPE_;
-
-    template <class _Sender>
-    struct _WITH_SENDER_;
-
-    template <class... _Senders>
-    struct _WITH_SENDERS_;
-
-    template <class _Env>
-    struct _WITH_ENVIRONMENT_;
-  }
-
-  using __error__::_UNRECOGNIZED_SENDER_TYPE_;
-  using __error__::_WITH_ENVIRONMENT_;
-
-  template <class _Sender>
-  using _WITH_SENDER_ = __error__::_WITH_SENDER_<__name_of<_Sender>>;
-
-  template <class... _Senders>
-  using _WITH_SENDERS_ = __error__::_WITH_SENDERS_<__name_of<_Senders>...>;
-
   template <class _Sender, class _Env>
   using __unrecognized_sender_error = //
     __mexception< _UNRECOGNIZED_SENDER_TYPE_<>, _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>>;
@@ -955,25 +885,9 @@ namespace stdexec {
   template <class _Receiver>
   inline constexpr bool enable_receiver = __enable_receiver<_Receiver>; // NOT TO SPEC
 
-  //   NOT TO SPEC:
-  //   As we upgrade the receiver related entities from R5 to R7,
-  //   we allow types that do not yet satisfy enable_receiver to
-  //   still satisfy the receiver concept if the type provides an
-  //   explicit get_env. All R5 receivers provided an explicit get_env,
-  //   so this is backwards compatible.
-  template <class _Receiver>
-  concept __receiver_r5_or_r7 = //
-    enable_receiver<_Receiver>  //
-    || tag_invocable<get_env_t, _Receiver>;
-
-  template <class _Receiver>
-  concept __receiver = //
-    // Nested requirement here is to make this an atomic constraint
-    requires { requires __receiver_r5_or_r7<__decay_t<_Receiver>>; };
-
   template <class _Receiver>
   concept receiver =
-    __receiver<_Receiver> &&                     //
+    enable_receiver<__decay_t<_Receiver>> &&                     //
     environment_provider<__cref_t<_Receiver>> && //
     move_constructible<__decay_t<_Receiver>> &&  //
     constructible_from<__decay_t<_Receiver>, _Receiver>;
@@ -1159,7 +1073,7 @@ namespace stdexec {
     // constraint that failed.
     template <class _Sigs, class _Env = empty_env, class _Sender>
     void __debug_sender(_Sender&& __sndr, const _Env& = {}) {
-      if constexpr (!__is_debug_env<_Env> && !same_as<_Env, no_env>) {
+      if constexpr (!__is_debug_env<_Env>) {
         if (sizeof(_Sender) == ~0) { // never true
           using _Receiver = __debug_receiver<__cvref_id<_Sender>, _Env, _Sigs>;
           using _Operation = connect_result_t<_Sender, _Receiver>;
@@ -1174,7 +1088,7 @@ namespace stdexec {
 
     template <class _Env = empty_env, class _Sender>
     void __debug_sender(_Sender&& __sndr, const _Env& = {}) {
-      if constexpr (!__is_debug_env<_Env> && !same_as<_Env, no_env>) {
+      if constexpr (!__is_debug_env<_Env>) {
         if (sizeof(_Sender) == ~0) { // never true
           using _Sigs = __completion_signatures_of_t<_Sender, __debug_env_t<_Env>>;
           if constexpr (!same_as<_Sigs, __debug::__completion_signatures>) {
@@ -1235,14 +1149,6 @@ namespace stdexec {
   /////////////////////////////////////////////////////////////////////////////
   // [execution.sndtraits]
   namespace __get_completion_signatures {
-#if STDEXEC_LEGACY_R5_CONCEPTS()
-    template <class _Sender, class _Env>
-    concept __r7_style_sender = same_as<_Env, no_env> && enable_sender<__decay_t<_Sender>>;
-#else
-    template <class, class>
-    concept __r7_style_sender = false;
-#endif
-
     template <class _Sender, class _Env>
     using __tfx_sender = transform_sender_result_t<__env_domain_of_t<_Env>, _Sender, _Env>;
 
@@ -1254,44 +1160,29 @@ namespace stdexec {
     using __member_alias_t = //
       typename __decay_t<__tfx_sender<_Sender, _Env>>::completion_signatures;
 
-    template <class _Sender, class _Env = no_env>
+    template <class _Sender, class _Env = empty_env>
     concept __with_member_alias = __mvalid<__member_alias_t, _Sender, _Env>;
 
     struct get_completion_signatures_t {
       template <class _Sender, class _Env>
       static auto __impl() {
-        static_assert(STDEXEC_LEGACY_R5_CONCEPTS() || !same_as<_Env, no_env>);
         static_assert(sizeof(_Sender), "Incomplete type used with get_completion_signatures");
         static_assert(sizeof(_Env), "Incomplete type used with get_completion_signatures");
 
         if constexpr (__with_tag_invoke<_Sender, _Env>) {
           using _TfxSender = __tfx_sender<_Sender, _Env>;
           using _Result = tag_invoke_result_t<get_completion_signatures_t, _TfxSender, _Env>;
-          if constexpr (same_as<_Env, no_env> && __merror<_Result>) {
-            return (dependent_completion_signatures<no_env>(*)()) nullptr;
-          } else {
-            return (_Result(*)()) nullptr;
-          }
+          return (_Result(*)()) nullptr;
         } else if constexpr (__with_member_alias<_Sender, _Env>) {
           using _Result = __member_alias_t<_Sender, _Env>;
-          if constexpr (same_as<_Env, no_env> && __merror<_Result>) {
-            return (dependent_completion_signatures<no_env>(*)()) nullptr;
-          } else {
-            return (_Result(*)()) nullptr;
-          }
+          return (_Result(*)()) nullptr;
         } else if constexpr (__awaitable<_Sender, __env_promise<_Env>>) {
           using _Result = __await_result_t<_Sender, __env_promise<_Env>>;
-          if constexpr (same_as<_Result, dependent_completion_signatures<no_env>>) {
-            return (dependent_completion_signatures<no_env>(*)()) nullptr;
-          } else {
-            return (completion_signatures<
-                    // set_value_t() or set_value_t(T)
-                    __minvoke<__remove<void, __qf<set_value_t>>, _Result>,
-                    set_error_t(std::exception_ptr),
-                    set_stopped_t()>(*)()) nullptr;
-          }
-        } else if constexpr (__r7_style_sender<_Sender, _Env>) {
-          return (dependent_completion_signatures<no_env>(*)()) nullptr;
+          return (completion_signatures<
+                  // set_value_t() or set_value_t(T)
+                  __minvoke<__remove<void, __qf<set_value_t>>, _Result>,
+                  set_error_t(std::exception_ptr),
+                  set_stopped_t()>(*)()) nullptr;
         } else if constexpr (__is_debug_env<_Env>) {
           using __tag_invoke::tag_invoke;
           // This ought to cause a hard error that indicates where the problem is.
@@ -1330,58 +1221,20 @@ namespace stdexec {
   template <class _Sender>
   inline constexpr bool enable_sender = __enable_sender<_Sender>;
 
-  // NOT TO SPEC (YET)
-#if !STDEXEC_LEGACY_R5_CONCEPTS()
-  // Here is the R7 sender concepts, not yet enabled.
-  template <class _Sender, class = empty_env>
-  concept __sender = //
-    enable_sender<__decay_t<_Sender>>;
-
-  template <class _Sender>
-  concept sender =                             //
-    __sender<_Sender> &&                       //
-    environment_provider<__cref_t<_Sender>> && //
-    move_constructible<__decay_t<_Sender>> &&  //
-    constructible_from<__decay_t<_Sender>, _Sender>;
-
   template <class _Sender, class _Env = empty_env>
-  concept sender_in =  //
-    sender<_Sender> && //
-    requires(_Sender&& __sndr, _Env&& __env) {
-      {
-        get_completion_signatures((_Sender&&) __sndr, (_Env&&) __env)
-      } -> __valid_completion_signatures<_Env>;
-    };
-
-  template <class _Sender, class _Env = empty_env>
-    requires sender_in<_Sender, _Env>
-  using completion_signatures_of_t = __completion_signatures_of_t<_Sender, _Env>;
-
-#else
-
-  template <class _Sender, class _Env = no_env>
-  concept __sender = //
-    requires(_Sender&& __sndr, _Env&& __env) {
-      get_completion_signatures((_Sender&&) __sndr, (_Env&&) __env);
-    } && //
-    __valid_completion_signatures<__completion_signatures_of_t<_Sender, _Env>, _Env>;
-
-  template <class _Sender, class _Env = no_env>
   concept sender =
-    // NOT TO SPEC
-    // The sender related concepts are temporarily "in flight" being
-    // upgraded from P2300R5 to the get_env / enable_sender aware version
-    // in P2300R7.
-    __sender<_Sender> &&                       //
-    __sender<_Sender, _Env> &&                 //
+    enable_sender<__decay_t<_Sender>> &&                  //
     environment_provider<__cref_t<_Sender>> && //
     move_constructible<__decay_t<_Sender>> &&  //
     constructible_from<__decay_t<_Sender>, _Sender>;
 
   template <class _Sender, class _Env = empty_env>
   concept sender_in =          //
-    __sender<_Sender, _Env> && //
-    sender<_Sender, _Env>;
+    sender<_Sender> && //
+    requires(_Sender&& __sndr, _Env&& __env) {
+      { get_completion_signatures((_Sender&&) __sndr, (_Env&&) __env) }
+        -> __valid_completion_signatures;
+    };
 
 #if STDEXEC_ENABLE_EXTRA_TYPE_CHECKING()
   // __checked_completion_signatures is for catching logic bugs in a typed
@@ -1390,22 +1243,19 @@ namespace stdexec {
   // enforces that at compile time.
   template <class _Sender, class _Env>
   auto __checked_completion_signatures(_Sender&& __sndr, const _Env& __env) noexcept {
-    using _WithEnv = __completion_signatures_of_t<_Sender, _Env>;
-    // using _WithoutEnv = __completion_signatures_of_t<_Sender, no_env>;
-    // static_assert(__one_of< _WithoutEnv, _WithEnv, dependent_completion_signatures<no_env>>);
-    stdexec::__debug_sender<_WithEnv>((_Sender&&) __sndr, __env);
-    return _WithEnv{};
+    using __completions_t = __completion_signatures_of_t<_Sender, _Env>;
+    stdexec::__debug_sender<__completions_t>((_Sender&&) __sndr, __env);
+    return __completions_t{};
   }
 
-  template <class _Sender, class _Env = no_env>
+  template <class _Sender, class _Env = empty_env>
     requires sender_in<_Sender, _Env>
   using completion_signatures_of_t =
     decltype(stdexec::__checked_completion_signatures(__declval<_Sender>(), __declval<_Env>()));
 #else
-  template <class _Sender, class _Env = no_env>
+  template <class _Sender, class _Env = empty_env>
     requires sender_in<_Sender, _Env>
   using completion_signatures_of_t = __completion_signatures_of_t<_Sender, _Env>;
-#endif
 #endif
 
   struct __not_a_variant {
@@ -1550,7 +1400,7 @@ namespace stdexec {
     template <class _Error>
     using __default_set_error = completion_signatures<set_error_t(_Error)>;
 
-    template <__is_completion_signatures... _Sigs>
+    template <__valid_completion_signatures... _Sigs>
     using __ensure_concat_ = __minvoke<__mconcat<__q<completion_signatures>>, _Sigs...>;
 
     template <class... _Sigs>
@@ -1572,21 +1422,6 @@ namespace stdexec {
     using __compl_sigs_t =
       decltype(__compl_sigs_v<_Sender, _Env, _Sigs, _SetVal, _SetErr, _SetStp>);
 
-    template <bool>
-    struct __make_compl_sigs {
-      template <class _Sender, class _Env, class _Sigs, class _SetVal, class _SetErr, class _SetStp>
-      using __f = __compl_sigs_t<_Sender, _Env, _Sigs, _SetVal, _SetErr, _SetStp>;
-    };
-
-    template <>
-    struct __make_compl_sigs<true> {
-      template <class _Sender, class _Env, class _Sigs, class _SetVal, class _SetErr, class _SetStp>
-      using __f = //
-        __msuccess_or_t<
-          __compl_sigs_t<_Sender, _Env, _Sigs, _SetVal, _SetErr, _SetStp>,
-          dependent_completion_signatures<_Env>>;
-    };
-
     template <                                                    //
       class _Sender,                                              //
       class _Env = __default_env,                                 //
@@ -1595,8 +1430,8 @@ namespace stdexec {
       class _SetError = __q<__default_set_error>,                 //
       class _SetStopped = completion_signatures<set_stopped_t()>> //
     using __try_make_completion_signatures =                      //
-      __minvoke<
-        __make_compl_sigs<same_as<_Env, no_env>>,
+      __meval<
+        __compl_sigs_t,
         _Sender,
         _Env,
         _Sigs,
@@ -1675,10 +1510,10 @@ namespace stdexec {
   template <                                                                 //
     class _Sender,                                                           //
     class _Env = __default_env,                                              //
-    __valid_completion_signatures<_Env> _Sigs = completion_signatures<>,     //
+    __valid_completion_signatures _Sigs = completion_signatures<>,     //
     template <class...> class _SetValue = __compl_sigs::__default_set_value, //
     template <class> class _SetError = __compl_sigs::__default_set_error,    //
-    __valid_completion_signatures<_Env> _SetStopped = completion_signatures<set_stopped_t()>>
+    __valid_completion_signatures _SetStopped = completion_signatures<set_stopped_t()>>
     requires sender_in<_Sender, _Env>
   using make_completion_signatures = //
     __msuccess_or_t<                 //
@@ -1979,18 +1814,6 @@ namespace stdexec {
   namespace __connect {
     struct connect_t;
 
-    template <class _Tp>
-    STDEXEC_R5_SENDER_DEPRECATION_WARNING //
-      void
-      _PLEASE_UPDATE_YOUR_SENDER_TYPE() {
-    }
-
-    template <class _Tp>
-    STDEXEC_R5_RECEIVER_DEPRECATION_WARNING //
-      void
-      _PLEASE_UPDATE_YOUR_RECEIVER_TYPE() {
-    }
-
     template <class _Sender, class _Receiver>
     using __tfx_sender = //
       transform_sender_result_t<
@@ -2032,14 +1855,9 @@ namespace stdexec {
 
       template <class _Sender, class _Receiver>
       static constexpr auto __select_impl() noexcept {
-        // Report that 2300R5-style senders and receivers are deprecated:
-        if constexpr (!enable_sender<__decay_t<_Sender>>)
-          _PLEASE_UPDATE_YOUR_SENDER_TYPE<__decay_t<_Sender>>();
-
-        if constexpr (!enable_receiver<__decay_t<_Receiver>>)
-          _PLEASE_UPDATE_YOUR_RECEIVER_TYPE< __decay_t<_Receiver>>();
-
+        #if STDEXEC_ENABLE_EXTRA_TYPE_CHECKING()
         static_assert(__check_signatures<_Sender, env_of_t<_Receiver>>());
+        #endif
 
         using _Domain = __env_domain_of_t<env_of_t<_Receiver&>>;
         constexpr bool _NothrowTfxSender =
@@ -2111,7 +1929,6 @@ namespace stdexec {
   template <class _Sender, class _Receiver>
   concept sender_to =
     receiver<_Receiver> &&                     //
-    __sender<_Sender, env_of_t<_Receiver>> &&  // NOT TO SPEC: for simpler diagnostics
     sender_in<_Sender, env_of_t<_Receiver>> && //
     __receiver_from<_Receiver, _Sender> &&     //
     requires(_Sender&& __sndr, _Receiver&& __rcvr) {
@@ -2901,7 +2718,9 @@ namespace stdexec {
     namespace __no {
       struct __nope { };
 
-      struct __receiver : __nope { };
+      struct __receiver : __nope {
+        using is_receiver = void;
+      };
 
       template <same_as<set_error_t> _Tag>
       void tag_invoke(_Tag, __receiver, std::exception_ptr) noexcept;
@@ -4765,17 +4584,11 @@ namespace stdexec {
 
         template <class _Sender, class _Env>
         using __completions = //
-          __minvoke_if_c<
-            same_as<
-              __completion_signatures_of_t<_Sender, _Env>,
-              dependent_completion_signatures<no_env>>,
-            __mconst<dependent_completion_signatures<no_env>>,
-            __mbind_front_q<
-              __mapply,
-              __transform<
-                __mbind_front_q<__tfx_signal_t, _Env, _Fun, _Set, __completion_sched<_Sender>>,
-                __q<__concat_completion_signatures_t> >,
-              __completion_signatures_of_t<_Sender, _Env>>>;
+          __mapply<
+            __transform<
+              __mbind_front_q<__tfx_signal_t, _Env, _Fun, _Set, __completion_sched<_Sender>>,
+              __q<__concat_completion_signatures_t> >,
+            __completion_signatures_of_t<_Sender, _Env>>;
 
         template <__decays_to<__t> _Self, receiver _Receiver>
           requires sender_to<__copy_cvref_t<_Self, _Sender>, __receiver_t<_Self, _Receiver>>
@@ -6794,7 +6607,7 @@ namespace stdexec {
         return {{}, (_Receiver&&) __rcvr};
       }
 
-      template <__none_of<no_env> _Env>
+      template <class _Env>
       friend auto tag_invoke(get_completion_signatures_t, __sender, _Env&&)
         -> __completions_t<_Env> {
         return {};
diff --git a/test/exec/test_any_sender.cpp b/test/exec/test_any_sender.cpp
index 2ab3b532c..cfb2b80f9 100644
--- a/test/exec/test_any_sender.cpp
+++ b/test/exec/test_any_sender.cpp
@@ -59,6 +59,8 @@ namespace {
   };
 
   struct sink_receiver {
+    using is_receiver = void;
+
     std::variant<std::monostate, int, std::exception_ptr, set_stopped_t> value_{};
 
     friend void tag_invoke(set_value_t, sink_receiver&& r, int value) noexcept {
diff --git a/test/stdexec/concepts/test_awaitables.cpp b/test/stdexec/concepts/test_awaitables.cpp
index 6edd978c3..d4641a998 100644
--- a/test/stdexec/concepts/test_awaitables.cpp
+++ b/test/stdexec/concepts/test_awaitables.cpp
@@ -77,7 +77,11 @@ namespace {
     }
   };
 
-  using dependent = ex::dependent_completion_signatures<ex::no_env>;
+  struct invalid_awaiter {
+    bool await_ready();
+    bool await_suspend(__coro::coroutine_handle<>);
+    //void await_resume();
+  };
 
   STDEXEC_PRAGMA_PUSH()
   STDEXEC_PRAGMA_IGNORE_GNU("-Wpragmas")
@@ -94,7 +98,7 @@ namespace {
     using promise_type = promise<__coro::suspend_always>;
 
    private:
-    friend dependent operator co_await(awaitable_sender_2) {
+    friend invalid_awaiter operator co_await(awaitable_sender_2) {
       return {};
     }
   };
@@ -103,7 +107,7 @@ namespace {
     using promise_type = promise<awaiter>;
 
    private:
-    friend dependent operator co_await(awaitable_sender_3) {
+    friend invalid_awaiter operator co_await(awaitable_sender_3) {
       return {};
     }
   };
@@ -118,10 +122,6 @@ namespace {
     friend awaiter tag_invoke(ex::as_awaitable_t, awaitable_sender_4, Promise&) {
       return {};
     }
-
-    friend dependent tag_invoke(ex::as_awaitable_t, awaitable_sender_4, ex::no_env_promise&) {
-      return {};
-    }
   };
 
   struct awaitable_sender_5 {
@@ -145,36 +145,28 @@ namespace {
   }
 
   void test_awaitable_sender2() {
-    static_assert(ex::sender<awaitable_sender_2>);
-    static_assert(sender_with_env<awaitable_sender_2>);
+    static_assert(!ex::sender<awaitable_sender_2>);
+    static_assert(!sender_with_env<awaitable_sender_2>);
     static_assert(!ex::sender_in<awaitable_sender_2, ex::empty_env>);
 
-    static_assert(ex::__awaitable<awaitable_sender_2>);
+    static_assert(!ex::__awaitable<awaitable_sender_2>);
     static_assert(ex::__awaitable<awaitable_sender_2, promise<__coro::suspend_always>>);
 
     static_assert(
       !ex::__get_completion_signatures::__with_member_alias<awaitable_sender_2, ex::empty_env>);
-
-#if STDEXEC_LEGACY_R5_CONCEPTS()
-    static_assert(std::is_same_v<ex::completion_signatures_of_t<awaitable_sender_2>, dependent>);
-#endif
   }
 
   void test_awaitable_sender3() {
-    static_assert(ex::sender<awaitable_sender_3>);
-    static_assert(sender_with_env<awaitable_sender_3>);
+    static_assert(!ex::sender<awaitable_sender_3>);
+    static_assert(!sender_with_env<awaitable_sender_3>);
     static_assert(!ex::sender_in<awaitable_sender_3, ex::empty_env>);
 
     static_assert(ex::__awaiter<awaiter>);
-    static_assert(ex::__awaitable<awaitable_sender_3>);
+    static_assert(!ex::__awaitable<awaitable_sender_3>);
     static_assert(ex::__awaitable<awaitable_sender_3, promise<awaiter>>);
 
     static_assert(
       !ex::__get_completion_signatures::__with_member_alias<awaitable_sender_3, ex::empty_env>);
-
-#if STDEXEC_LEGACY_R5_CONCEPTS()
-    static_assert(std::is_same_v<ex::completion_signatures_of_t<awaitable_sender_3>, dependent>);
-#endif
   }
 
   template <class Signatures>
@@ -186,15 +178,11 @@ namespace {
     static_assert(ex::__awaiter<awaiter>);
     static_assert(!ex::__awaitable<awaitable_sender_4>);
     static_assert(ex::__awaitable<awaitable_sender_4, promise<awaiter>>);
-    static_assert(ex::__awaitable<awaitable_sender_4, ex::no_env_promise>);
     static_assert(ex::__awaitable<awaitable_sender_4, ex::__env_promise<ex::empty_env>>);
 
     static_assert(
       !ex::__get_completion_signatures::__with_member_alias<awaitable_sender_4, ex::empty_env>);
 
-#if STDEXEC_LEGACY_R5_CONCEPTS()
-    static_assert(std::is_same_v<ex::completion_signatures_of_t<awaitable_sender_4>, dependent>);
-#endif
     static_assert(
       !ex::__get_completion_signatures::__with_member_alias<awaitable_sender_4, ex::empty_env>);
 
@@ -214,7 +202,6 @@ namespace {
     static_assert(ex::__awaiter<awaiter>);
     static_assert(!ex::__awaitable<awaitable_sender_5>);
     static_assert(ex::__awaitable<awaitable_sender_5, promise<awaiter>>);
-    static_assert(ex::__awaitable<awaitable_sender_5, ex::no_env_promise>);
     static_assert(ex::__awaitable<awaitable_sender_5, ex::__env_promise<ex::empty_env>>);
 
     static_assert(
diff --git a/test/stdexec/concepts/test_concept_scheduler.cpp b/test/stdexec/concepts/test_concept_scheduler.cpp
index d156b2595..2c232776a 100644
--- a/test/stdexec/concepts/test_concept_scheduler.cpp
+++ b/test/stdexec/concepts/test_concept_scheduler.cpp
@@ -166,44 +166,6 @@ namespace {
     "[concepts][scheduler]") {
     REQUIRE(!ex::scheduler<sched_no_completion>);
   }
-
-#if STDEXEC_LEGACY_R5_CONCEPTS()
-  struct sched_no_env {
-    // P2300R5 senders defined sender queries on the sender itself.
-    struct my_sender {
-      // Intentionally left out:
-      //using is_sender = void;
-      using completion_signatures = ex::completion_signatures< //
-        ex::set_value_t(),                                     //
-        ex::set_error_t(std::exception_ptr),                   //
-        ex::set_stopped_t()>;
-
-      template <typename CPO>
-      friend sched_no_env tag_invoke(ex::get_completion_scheduler_t<CPO>, my_sender) {
-        return {};
-      }
-    };
-
-    friend my_sender tag_invoke(ex::schedule_t, sched_no_env) {
-      return {};
-    }
-
-    friend bool operator==(sched_no_env, sched_no_env) noexcept {
-      return true;
-    }
-
-    friend bool operator!=(sched_no_env, sched_no_env) noexcept {
-      return false;
-    }
-  };
-
-  TEST_CASE(
-    "type without sender get_env is still a scheduler",
-    "[concepts][scheduler][r5_backwards_compatibility]") {
-    static_assert(ex::scheduler<sched_no_env>);
-    REQUIRE(ex::scheduler<sched_no_env>);
-  }
-#endif
 }
 
 STDEXEC_PRAGMA_POP()
\ No newline at end of file
diff --git a/test/stdexec/concepts/test_concepts_sender.cpp b/test/stdexec/concepts/test_concepts_sender.cpp
index 862a3dc0d..d59ae8cd8 100644
--- a/test/stdexec/concepts/test_concepts_sender.cpp
+++ b/test/stdexec/concepts/test_concepts_sender.cpp
@@ -254,7 +254,7 @@ namespace {
   // nvc++ doesn't yet implement subsumption correctly
   struct not_a_sender_tag { };
 
-  struct sender_no_env_tag { };
+  struct sender_tag { };
 
   struct sender_env_tag { };
 
@@ -266,7 +266,7 @@ namespace {
   }
 
   template <ex::sender T>
-  sender_no_env_tag test_subsumption(T&&) {
+  sender_tag test_subsumption(T&&) {
     return {};
   }
 
@@ -289,7 +289,7 @@ namespace {
     "check for subsumption relationships between the sender concepts",
     "[concepts][sender]") {
     ::has_type<not_a_sender_tag>(::test_subsumption(42));
-    ::has_type<sender_no_env_tag>(::test_subsumption(ex::get_scheduler()));
+    ::has_type<sender_tag>(::test_subsumption(ex::get_scheduler()));
     ::has_type<sender_env_tag>(::test_subsumption(ex::just(42)));
     ::has_type<sender_of_tag>(::test_subsumption(ex::just()));
   }
diff --git a/test/stdexec/cpos/test_cpo_connect.cpp b/test/stdexec/cpos/test_cpo_connect.cpp
index 808bdbe93..9ed17159b 100644
--- a/test/stdexec/cpos/test_cpo_connect.cpp
+++ b/test/stdexec/cpos/test_cpo_connect.cpp
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#define STDEXEC_DISABLE_R5_DEPRECATION_WARNINGS
-
 #include <catch2/catch.hpp>
 #include <stdexec/execution.hpp>
 #include "test_common/receivers.hpp"
@@ -84,6 +82,7 @@ namespace {
   }
 
   struct strange_receiver {
+    using is_receiver = void;
     bool* called_;
 
     friend inline op_state<strange_receiver>