diff --git a/include/exec/any_sender_of.hpp b/include/exec/any_sender_of.hpp
index 645f094a6..09e12efef 100644
--- a/include/exec/any_sender_of.hpp
+++ b/include/exec/any_sender_of.hpp
@@ -855,7 +855,7 @@ namespace exec {
       STDEXEC::inplace_stop_source __stop_source_{};
       using __stop_callback = typename STDEXEC::stop_token_of_t<
         STDEXEC::env_of_t<_Receiver>
-      >::template callback_type<__forward_stop_request>;
+      >::template callback_type<STDEXEC::__forward_stop_request>;
       std::optional<__stop_callback> __on_stop_{};
     };
 
diff --git a/include/exec/start_now.hpp b/include/exec/start_now.hpp
index 76f4afc2c..6dd850f2f 100644
--- a/include/exec/start_now.hpp
+++ b/include/exec/start_now.hpp
@@ -188,7 +188,7 @@ namespace exec {
 
     struct start_now_t {
       template <
-        STDEXEC::queryable _Env,
+        STDEXEC::__queryable _Env,
         exec::__scope::__async_scope _AsyncScope,
         STDEXEC::sender... _Sender
       >
diff --git a/include/exec/task.hpp b/include/exec/task.hpp
index baf07645d..bd59e0dce 100644
--- a/include/exec/task.hpp
+++ b/include/exec/task.hpp
@@ -334,7 +334,7 @@ namespace exec {
 
      private:
       using __scheduler_t =
-        __query_result_or_t<get_scheduler_t, _Context, STDEXEC::inline_scheduler>;
+        __call_result_or_t<get_scheduler_t, STDEXEC::inline_scheduler, _Context>;
 
       struct __final_awaitable {
         static constexpr auto await_ready() noexcept -> bool {
diff --git a/include/stdexec/__detail/__completion_behavior.hpp b/include/stdexec/__detail/__completion_behavior.hpp
index c05d1fd15..69dd05ddc 100644
--- a/include/stdexec/__detail/__completion_behavior.hpp
+++ b/include/stdexec/__detail/__completion_behavior.hpp
@@ -95,50 +95,45 @@ namespace STDEXEC {
   //////////////////////////////////////////////////////////////////////////////////////////
   // get_completion_behavior: A sender can define this attribute to describe the sender's
   // completion behavior
-  namespace __queries {
-    template <__completion_tag _Tag>
-    struct get_completion_behavior_t {
-     private:
-      template <class _Attrs, class... _Env>
-      STDEXEC_ATTRIBUTE(always_inline, host, device)
-      static constexpr auto __validate() noexcept {
-        using __result_t = __member_query_result_t<_Attrs, get_completion_behavior_t, _Env...>;
-        static_assert(
-          __nothrow_member_queryable_with<_Attrs, get_completion_behavior_t, _Env...>,
-          "The get_completion_behavior query must be noexcept.");
-        static_assert(
-          __std::convertible_to<__result_t, completion_behavior::behavior>,
-          "The get_completion_behavior query must return one of the static member variables in "
-          "execution::completion_behavior.");
-        return __result_t{};
-      }
+  template <__completion_tag _Tag>
+  struct get_completion_behavior_t {
+   private:
+    template <class _Attrs, class... _Env>
+    STDEXEC_ATTRIBUTE(always_inline, host, device)
+    static constexpr auto __validate() noexcept {
+      using __result_t = __member_query_result_t<_Attrs, get_completion_behavior_t, _Env...>;
+      static_assert(
+        __nothrow_member_queryable_with<_Attrs, get_completion_behavior_t, _Env...>,
+        "The get_completion_behavior query must be noexcept.");
+      static_assert(
+        __std::convertible_to<__result_t, completion_behavior::behavior>,
+        "The get_completion_behavior query must return one of the static member variables in "
+        "execution::completion_behavior.");
+      return __result_t{};
+    }
 
-     public:
-      template <class _Sig>
-      static inline constexpr get_completion_behavior_t (*signature)(_Sig) = nullptr;
+   public:
+    template <class _Sig>
+    static inline constexpr get_completion_behavior_t (*signature)(_Sig) = nullptr;
 
-      template <class _Attrs, class... _Env>
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      constexpr auto operator()(const _Attrs&, const _Env&...) const noexcept {
-        if constexpr (
-          __member_queryable_with<const _Attrs&, get_completion_behavior_t<_Tag>, _Env...>) {
-          return __validate<_Attrs, _Env...>();
-        } else if constexpr (__member_queryable_with<
-                               const _Attrs&,
-                               get_completion_behavior_t<_Tag>
-                             >) {
-          return __validate<_Attrs>();
-        } else {
-          return completion_behavior::unknown;
-        }
+    template <class _Attrs, class... _Env>
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    constexpr auto operator()(const _Attrs&, const _Env&...) const noexcept {
+      if constexpr (
+        __member_queryable_with<const _Attrs&, get_completion_behavior_t<_Tag>, _Env...>) {
+        return __validate<_Attrs, _Env...>();
+      } else if constexpr (__member_queryable_with<const _Attrs&, get_completion_behavior_t<_Tag>>) {
+        return __validate<_Attrs>();
+      } else {
+        return completion_behavior::unknown;
       }
+    }
 
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      static constexpr auto query(forwarding_query_t) noexcept -> bool {
-        return true;
-      }
-    };
-  } // namespace __queries
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    static constexpr auto query(forwarding_query_t) noexcept -> bool {
+      return true;
+    }
+  };
 
   [[deprecated("use STDEXEC::completion_behavior::weakest instead")]]
   inline constexpr const auto& min = completion_behavior::weakest;
diff --git a/include/stdexec/__detail/__config.hpp b/include/stdexec/__detail/__config.hpp
index 0e40c1a00..1edb0b7fd 100644
--- a/include/stdexec/__detail/__config.hpp
+++ b/include/stdexec/__detail/__config.hpp
@@ -179,7 +179,9 @@
 #endif
 
 STDEXEC_NAMESPACE_STD_BEGIN
-namespace execution {
+namespace execution::system_context_replaceability {
+}
+namespace this_thread {
 }
 STDEXEC_NAMESPACE_STD_END
 
@@ -207,6 +209,18 @@ STDEXEC_NAMESPACE_STD_END
 #  error stdexec cannot be defined directly in namespace std, but a namespace nested inside std is allowed.
 #endif
 
+// clang-format off
+#if STDEXEC_NAMESPACE_IS_WITHIN_STD()
+#  define STDEXEC_P2300_NAMESPACE_BEGIN(...)   STDEXEC_NAMESPACE_STD_BEGIN __VA_OPT__(namespace __VA_ARGS__ {)
+#  define STDEXEC_P2300_NAMESPACE_END(...)     __VA_OPT__(}) STDEXEC_NAMESPACE_STD_END
+#  define STDEXEC_P2300_DEPRECATED_SYMBOL(...) using __VA_ARGS__;
+#else
+#  define STDEXEC_P2300_NAMESPACE_BEGIN(...)   namespace STDEXEC {
+#  define STDEXEC_P2300_NAMESPACE_END(...)     }
+#  define STDEXEC_P2300_DEPRECATED_SYMBOL(...)
+#endif
+// clang-format on
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 #if __cpp_impl_coroutine >= 2019'02L && __cpp_lib_coroutine >= 2019'02L
 #  include <coroutine> // IWYU pragma: keep
diff --git a/include/stdexec/__detail/__debug.hpp b/include/stdexec/__detail/__debug.hpp
index b9a889f44..2846d69ec 100644
--- a/include/stdexec/__detail/__debug.hpp
+++ b/include/stdexec/__detail/__debug.hpp
@@ -29,13 +29,11 @@
 namespace STDEXEC {
   /////////////////////////////////////////////////////////////////////////////
   // Some utilities for debugging senders
-  namespace __queries {
-    struct __debug_env_t : __query<__debug_env_t> {
-      static constexpr auto query(forwarding_query_t) noexcept -> bool {
-        return true;
-      }
-    };
-  } // namespace __queries
+  struct __debug_env_t : __query<__debug_env_t> {
+    static constexpr auto query(forwarding_query_t) noexcept -> bool {
+      return true;
+    }
+  };
 
   namespace __debug {
     struct _COMPLETION_SIGNATURES_MISMATCH_ { };
@@ -59,7 +57,7 @@ namespace STDEXEC {
     }
 
     template <class _Env>
-    using __env_t = env<prop<__queries::__debug_env_t, bool>, _Env>;
+    using __env_t = env<prop<__debug_env_t, bool>, _Env>;
 
     template <class _CvSender, class _Env, class... _Sigs>
     struct __receiver {
diff --git a/include/stdexec/__detail/__domain.hpp b/include/stdexec/__detail/__domain.hpp
index 221a2b714..acb785ed3 100644
--- a/include/stdexec/__detail/__domain.hpp
+++ b/include/stdexec/__detail/__domain.hpp
@@ -204,206 +204,201 @@ namespace STDEXEC {
     }
   } // namespace __detail
 
-  namespace __queries {
-    //! @brief A wrapper around an environment that hides a set of queries.
-    template <class _Env, class... _Queries>
-    struct __hide_query {
-      constexpr explicit __hide_query(_Env&& __env, _Queries...) noexcept
-        : __env_{static_cast<_Env&&>(__env)} {
-      }
+  //! @brief A wrapper around an environment that hides a set of queries.
+  template <class _Env, class... _Queries>
+  struct __hide_query {
+    constexpr explicit __hide_query(_Env&& __env, _Queries...) noexcept
+      : __env_{static_cast<_Env&&>(__env)} {
+    }
 
-      template <__none_of<_Queries...> _Query, class... _As>
-        requires __queryable_with<_Env, _Query, _As...>
-      constexpr auto operator()(_Query, _As&&... __as) const
-        noexcept(__nothrow_queryable_with<_Env, _Query, _As...>)
-          -> __query_result_t<_Env, _Query, _As...> {
-        return __query<_Query>()(__env_, static_cast<_As&&>(__as)...);
-      }
+    template <__none_of<_Queries...> _Query, class... _As>
+      requires __queryable_with<_Env, _Query, _As...>
+    constexpr auto operator()(_Query, _As&&... __as) const
+      noexcept(__nothrow_queryable_with<_Env, _Query, _As...>)
+        -> __query_result_t<_Env, _Query, _As...> {
+      return __query<_Query>()(__env_, static_cast<_As&&>(__as)...);
+    }
 
-     private:
-      _Env __env_;
-    };
+   private:
+    _Env __env_;
+  };
 
-    template <class _Env, class... _Queries>
-    STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
-      __hide_query(_Env&&, _Queries...) -> __hide_query<_Env, _Queries...>;
+  template <class _Env, class... _Queries>
+  STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
+    __hide_query(_Env&&, _Queries...) -> __hide_query<_Env, _Queries...>;
 
-    //! @brief A wrapper around an environment that hides the get_scheduler and get_domain
-    //! queries.
-    template <class _Env>
-    struct __hide_scheduler : __hide_query<_Env, get_scheduler_t, get_domain_t> {
-      constexpr explicit __hide_scheduler(_Env&& __env) noexcept
-        : __hide_query<_Env, get_scheduler_t, get_domain_t>{static_cast<_Env&&>(__env), {}, {}} {
-      }
-    };
-
-    template <class _Env>
-    STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __hide_scheduler(_Env&&) -> __hide_scheduler<_Env>;
+  //! @brief A wrapper around an environment that hides the get_scheduler and get_domain
+  //! queries.
+  template <class _Env>
+  struct __hide_scheduler : __hide_query<_Env, get_scheduler_t, get_domain_t> {
+    constexpr explicit __hide_scheduler(_Env&& __env) noexcept
+      : __hide_query<_Env, get_scheduler_t, get_domain_t>{static_cast<_Env&&>(__env), {}, {}} {
+    }
+  };
 
-    //////////////////////////////////////////////////////////////////////////////////////////
-    //! @brief A query type for asking a sender's attributes for the domain on which that
-    //! sender will complete. As with @c get_domain, it is used in tag dispatching to find a
-    //! custom implementation of a sender algorithm.
-    //!
-    //! @tparam _Tag one of set_value_t, set_error_t, or set_stopped_t
-    template <class _Tag>
-    struct get_completion_domain_t {
-      template <class Sig>
-      static inline constexpr get_completion_domain_t<_Tag> (*signature)(Sig) = nullptr;
-
-      // This function object reads the completion domain from an attribute object or a
-      // scheduler, accounting for the fact that the query member function may or may not
-      // accept an environment.
-      struct __read_query_t {
-        template <class _Attrs>
-          requires __queryable_with<_Attrs, get_completion_domain_t>
-        constexpr auto operator()(const _Attrs&, __ignore = {}) const noexcept {
-          return __decay_t<__query_result_t<_Attrs, get_completion_domain_t>>{};
-        }
+  template <class _Env>
+  STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __hide_scheduler(_Env&&) -> __hide_scheduler<_Env>;
 
-        template <class _Attrs, class _Env>
-          requires __queryable_with<_Attrs, get_completion_domain_t, const _Env&>
-        constexpr auto operator()(const _Attrs&, const _Env&) const noexcept {
-          return __decay_t<__query_result_t<_Attrs, get_completion_domain_t, const _Env&>>{};
-        }
-      };
+  //////////////////////////////////////////////////////////////////////////////////////////
+  //! @brief A query type for asking a sender's attributes for the domain on which that
+  //! sender will complete. As with @c get_domain, it is used in tag dispatching to find a
+  //! custom implementation of a sender algorithm.
+  //!
+  //! @tparam _Tag one of set_value_t, set_error_t, or set_stopped_t
+  template <class _Tag>
+  struct get_completion_domain_t {
+    template <class Sig>
+    static inline constexpr get_completion_domain_t<_Tag> (*signature)(Sig) = nullptr;
+
+    // This function object reads the completion domain from an attribute object or a
+    // scheduler, accounting for the fact that the query member function may or may not
+    // accept an environment.
+    struct __read_query_t {
+      template <class _Attrs>
+        requires __queryable_with<_Attrs, get_completion_domain_t>
+      constexpr auto operator()(const _Attrs&, __ignore = {}) const noexcept {
+        return __decay_t<__query_result_t<_Attrs, get_completion_domain_t>>{};
+      }
 
-     private:
-      template <class _Sch, class... _Env, class _Domain>
-      static consteval auto __check_domain_(_Domain) noexcept {
-        static_assert(
-          __same_as<_Domain, __detail::__scheduler_domain_t<_Sch, const _Env&...>>,
-          "the sender claims to complete on a domain that is not the domain of its completion "
-          "scheduler");
+      template <class _Attrs, class _Env>
+        requires __queryable_with<_Attrs, get_completion_domain_t, const _Env&>
+      constexpr auto operator()(const _Attrs&, const _Env&) const noexcept {
+        return __decay_t<__query_result_t<_Attrs, get_completion_domain_t, const _Env&>>{};
       }
+    };
+
+   private:
+    template <class _Sch, class... _Env, class _Domain>
+    static consteval auto __check_domain_(_Domain) noexcept {
+      static_assert(
+        __same_as<_Domain, __detail::__scheduler_domain_t<_Sch, const _Env&...>>,
+        "the sender claims to complete on a domain that is not the domain of its completion "
+        "scheduler");
+    }
 
-      template <class _Attrs, class... _Env, class _Domain>
-      static consteval auto __check_domain(_Domain) noexcept -> _Domain {
-        // Sanity check: if a completion scheduler can be determined from the attributes
-        // (not the environment), then its domain must match the domain returned by the attributes.
-        if constexpr (!__same_as<_Tag, void>) {
-          if constexpr (__callable<get_completion_scheduler_t<_Tag>, const _Attrs&, const _Env&...>) {
-            using __sch_t =
-              __call_result_t<get_completion_scheduler_t<_Tag>, const _Attrs&, const _Env&...>;
-            // Skip check if the "scheduler" is the same as the domain or the attributes
-            // (this can happen with __prop_like which answers any query with the same type)
-            if constexpr (!__same_as<__sch_t, _Attrs>) {
-              __check_domain_<__sch_t, _Env...>(_Domain{});
-            }
+    template <class _Attrs, class... _Env, class _Domain>
+    static consteval auto __check_domain(_Domain) noexcept -> _Domain {
+      // Sanity check: if a completion scheduler can be determined from the attributes
+      // (not the environment), then its domain must match the domain returned by the attributes.
+      if constexpr (!__same_as<_Tag, void>) {
+        if constexpr (__callable<get_completion_scheduler_t<_Tag>, const _Attrs&, const _Env&...>) {
+          using __sch_t =
+            __call_result_t<get_completion_scheduler_t<_Tag>, const _Attrs&, const _Env&...>;
+          // Skip check if the "scheduler" is the same as the domain or the attributes
+          // (this can happen with __prop_like which answers any query with the same type)
+          if constexpr (!__same_as<__sch_t, _Attrs>) {
+            __check_domain_<__sch_t, _Env...>(_Domain{});
           }
         }
-        return {};
       }
+      return {};
+    }
 
-      template <class _Attrs, class... _Env>
-      static constexpr auto __get_domain() noexcept {
-        // If __attrs has a completion domain, then return it:
-        if constexpr (__callable<__read_query_t, const _Attrs&, const _Env&...>) {
-          using __domain_t = __call_result_t<__read_query_t, const _Attrs&, const _Env&...>;
+    template <class _Attrs, class... _Env>
+    static constexpr auto __get_domain() noexcept {
+      // If __attrs has a completion domain, then return it:
+      if constexpr (__callable<__read_query_t, const _Attrs&, const _Env&...>) {
+        using __domain_t = __call_result_t<__read_query_t, const _Attrs&, const _Env&...>;
+        return __check_domain<_Attrs, _Env...>(__domain_t{});
+        // Otherwise, if _Tag is void, fall back to querying for the set_value_t completion domain:
+      } else if constexpr (__same_as<_Tag, void>) {
+        if constexpr (
+          __callable<get_completion_domain_t<set_value_t>, const _Attrs&, const _Env&...>) {
+          using __domain_t =
+            __call_result_t<get_completion_domain_t<set_value_t>, const _Attrs&, const _Env&...>;
           return __check_domain<_Attrs, _Env...>(__domain_t{});
-          // Otherwise, if _Tag is void, fall back to querying for the set_value_t completion domain:
-        } else if constexpr (__same_as<_Tag, void>) {
-          if constexpr (
-            __callable<get_completion_domain_t<set_value_t>, const _Attrs&, const _Env&...>) {
-            using __domain_t =
-              __call_result_t<get_completion_domain_t<set_value_t>, const _Attrs&, const _Env&...>;
-            return __check_domain<_Attrs, _Env...>(__domain_t{});
-          } else {
-            return void();
-          }
+        } else {
+          return void();
         }
-        // Otherwise, if __attrs has a completion scheduler, we can ask that scheduler for its
-        // completion domain.
-        else if constexpr (
-          __callable<get_completion_scheduler_t<_Tag>, const _Attrs&, const _Env&...>) {
-          using __sch_t =
-            __call_result_t<get_completion_scheduler_t<_Tag>, const _Attrs&, const _Env&...>;
-          using X [[maybe_unused]] = decltype(__declval<__sch_t>().schedule());
-          using __read_query_t = typename get_completion_domain_t<set_value_t>::__read_query_t;
-
-          if constexpr (__callable<__read_query_t, __sch_t, const _Env&...>) {
-            using __domain_t = __call_result_t<__read_query_t, __sch_t, const _Env&...>;
-            return __domain_t{};
-          }
-          // Otherwise, if the scheduler's sender indicates that it completes inline, we can ask
-          // the environment for its domain.
-          else if constexpr (
-            __completes_inline<_Tag, env_of_t<__call_result_t<schedule_t, __sch_t>>, _Env...>
-            && __callable<get_domain_t, const _Env&...>) {
-            return __call_result_t<get_domain_t, const _Env&...>{};
-          }
-          // Otherwise, if we are asking "late" (with an environment), return the default_domain
-          else if constexpr (sizeof...(_Env) != 0) {
-            return default_domain{};
-          }
+      }
+      // Otherwise, if __attrs has a completion scheduler, we can ask that scheduler for its
+      // completion domain.
+      else if constexpr (
+        __callable<get_completion_scheduler_t<_Tag>, const _Attrs&, const _Env&...>) {
+        using __sch_t =
+          __call_result_t<get_completion_scheduler_t<_Tag>, const _Attrs&, const _Env&...>;
+        using X [[maybe_unused]] = decltype(__declval<__sch_t>().schedule());
+        using __read_query_t = typename get_completion_domain_t<set_value_t>::__read_query_t;
+
+        if constexpr (__callable<__read_query_t, __sch_t, const _Env&...>) {
+          using __domain_t = __call_result_t<__read_query_t, __sch_t, const _Env&...>;
+          return __domain_t{};
         }
-        // Otherwise, if the attributes indicates that the sender completes inline, we can ask
+        // Otherwise, if the scheduler's sender indicates that it completes inline, we can ask
         // the environment for its domain.
         else if constexpr (
-          __completes_inline<_Tag, _Attrs, _Env...> && __callable<get_domain_t, const _Env&...>) {
+          __completes_inline<_Tag, env_of_t<__call_result_t<schedule_t, __sch_t>>, _Env...>
+          && __callable<get_domain_t, const _Env&...>) {
           return __call_result_t<get_domain_t, const _Env&...>{};
         }
         // Otherwise, if we are asking "late" (with an environment), return the default_domain
         else if constexpr (sizeof...(_Env) != 0) {
           return default_domain{};
         }
-        // Otherwise, no completion domain can be determined. Return void.
       }
+      // Otherwise, if the attributes indicates that the sender completes inline, we can ask
+      // the environment for its domain.
+      else if constexpr (
+        __completes_inline<_Tag, _Attrs, _Env...> && __callable<get_domain_t, const _Env&...>) {
+        return __call_result_t<get_domain_t, const _Env&...>{};
+      }
+      // Otherwise, if we are asking "late" (with an environment), return the default_domain
+      else if constexpr (sizeof...(_Env) != 0) {
+        return default_domain{};
+      }
+      // Otherwise, no completion domain can be determined. Return void.
+    }
 
-      template <class _Attrs, class... _Env>
-      using __result_t = __unless_one_of_t<decltype(__get_domain<_Attrs, _Env...>()), void>;
+    template <class _Attrs, class... _Env>
+    using __result_t = __unless_one_of_t<decltype(__get_domain<_Attrs, _Env...>()), void>;
 
-     public:
-      template <class _Attrs, class... _Env>
-      constexpr auto
-        operator()(const _Attrs&, const _Env&...) const noexcept -> __result_t<_Attrs, _Env...> {
-        return {};
-      }
+   public:
+    template <class _Attrs, class... _Env>
+    constexpr auto
+      operator()(const _Attrs&, const _Env&...) const noexcept -> __result_t<_Attrs, _Env...> {
+      return {};
+    }
 
-      static constexpr auto query(forwarding_query_t) noexcept -> bool {
-        return true;
-      }
-    };
+    static constexpr auto query(forwarding_query_t) noexcept -> bool {
+      return true;
+    }
+  };
 
-    struct get_domain_t {
-      template <class _Sig>
-      static inline constexpr get_domain_t (*signature)(_Sig) = nullptr;
-
-      // Query with a .query member function:
-      template <class _Env>
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      constexpr auto operator()(const _Env&) const noexcept -> auto {
-        if constexpr (__member_queryable_with<const _Env&, get_domain_t>) {
-          return __decay_t<__member_query_result_t<_Env, get_domain_t>>{};
-        } else if constexpr (__callable<get_scheduler_t, const _Env&>) {
-          using __sch_t = __call_result_t<get_scheduler_t, const _Env&>;
-          using __env_t = __hide_scheduler<const _Env&>;
-          using __cmpl_sch_t =
-            __call_result_t<get_completion_scheduler_t<set_value_t>, __sch_t, __env_t>;
-          return __detail::__scheduler_domain_t<__cmpl_sch_t, __env_t>{};
-        } else {
-          return default_domain{};
-        }
-      }
+  struct get_domain_t {
+    template <class _Sig>
+    static inline constexpr get_domain_t (*signature)(_Sig) = nullptr;
 
-      // Query with tag_invoke (legacy):
-      template <class _Env>
-        requires __tag_invocable<get_domain_t, const _Env&>
-      [[deprecated("use a query member function instead of tag_invoke for queries")]]
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device) //
-        constexpr auto operator()(const _Env&) const noexcept {
-        return __decay_t<__tag_invoke_result_t<get_domain_t, const _Env&>>{};
+    // Query with a .query member function:
+    template <class _Env>
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    constexpr auto operator()(const _Env&) const noexcept -> auto {
+      if constexpr (__member_queryable_with<const _Env&, get_domain_t>) {
+        return __decay_t<__member_query_result_t<_Env, get_domain_t>>{};
+      } else if constexpr (__callable<get_scheduler_t, const _Env&>) {
+        using __sch_t = __call_result_t<get_scheduler_t, const _Env&>;
+        using __env_t = __hide_scheduler<const _Env&>;
+        using __cmpl_sch_t =
+          __call_result_t<get_completion_scheduler_t<set_value_t>, __sch_t, __env_t>;
+        return __detail::__scheduler_domain_t<__cmpl_sch_t, __env_t>{};
+      } else {
+        return default_domain{};
       }
+    }
 
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      static consteval auto query(forwarding_query_t) noexcept -> bool {
-        return true;
-      }
-    };
-  } // namespace __queries
+    // Query with tag_invoke (legacy):
+    template <class _Env>
+      requires __tag_invocable<get_domain_t, const _Env&>
+    [[deprecated("use a query member function instead of tag_invoke for queries")]]
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device) //
+      constexpr auto operator()(const _Env&) const noexcept {
+      return __decay_t<__tag_invoke_result_t<get_domain_t, const _Env&>>{};
+    }
 
-  using __queries::get_completion_domain_t;
-  using __queries::get_domain_t;
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    static consteval auto query(forwarding_query_t) noexcept -> bool {
+      return true;
+    }
+  };
 
 #if !STDEXEC_GCC() || defined(__OPTIMIZE_SIZE__)
   template <class _Tag>
diff --git a/include/stdexec/__detail/__env.hpp b/include/stdexec/__detail/__env.hpp
index 7496ba32d..2993297c5 100644
--- a/include/stdexec/__detail/__env.hpp
+++ b/include/stdexec/__detail/__env.hpp
@@ -261,13 +261,8 @@ namespace STDEXEC {
   using __get_env::get_env_t;
   inline constexpr get_env_t get_env{};
 
-  // template <class _EnvProvider>
-  // concept environment_provider = requires(_EnvProvider& __ep) {
-  //   { get_env(std::as_const(__ep)) } -> queryable;
-  // };
-
   template <class _EnvProvider>
-  concept environment_provider = __minvocable_q<__call_result_t, get_env_t, const _EnvProvider&>;
+  concept __environment_provider = __minvocable_q<__call_result_t, get_env_t, const _EnvProvider&>;
 
 } // namespace STDEXEC
 
diff --git a/include/stdexec/__detail/__execution_fwd.hpp b/include/stdexec/__detail/__execution_fwd.hpp
index c6be96ab0..21003ad2a 100644
--- a/include/stdexec/__detail/__execution_fwd.hpp
+++ b/include/stdexec/__detail/__execution_fwd.hpp
@@ -119,44 +119,24 @@ namespace STDEXEC {
     weakly_parallel
   };
 
-  namespace __queries {
-    struct forwarding_query_t;
-    struct execute_may_block_caller_t;
-    struct get_forward_progress_guarantee_t;
-    struct get_scheduler_t;
-    struct get_delegation_scheduler_t;
-    struct get_allocator_t;
-    struct get_stop_token_t;
-    template <__completion_tag _CPO>
-    struct get_completion_scheduler_t;
-    template <class _CPO = void>
-    struct get_completion_domain_t;
-    template <__completion_tag _CPO>
-    struct get_completion_behavior_t;
-    struct get_domain_t;
-
-    struct __debug_env_t;
-  } // namespace __queries
-
-  using __queries::forwarding_query_t;
-  using __queries::execute_may_block_caller_t;
-  using __queries::get_forward_progress_guarantee_t;
-  using __queries::get_allocator_t;
-  using __queries::get_scheduler_t;
-  using __queries::get_delegation_scheduler_t;
-  using __queries::get_stop_token_t;
-  using __queries::get_completion_scheduler_t;
-  using __queries::get_completion_domain_t;
-  using __queries::get_completion_behavior_t;
-  using __queries::get_domain_t;
-
-  extern const forwarding_query_t forwarding_query;
-  extern const execute_may_block_caller_t execute_may_block_caller;
+  struct __execute_may_block_caller_t;
+  struct get_forward_progress_guarantee_t;
+  struct get_scheduler_t;
+  struct get_delegation_scheduler_t;
+  template <__completion_tag _CPO>
+  struct get_completion_scheduler_t;
+  template <class _CPO = void>
+  struct get_completion_domain_t;
+  template <__completion_tag _CPO>
+  struct get_completion_behavior_t;
+  struct get_domain_t;
+
+  struct __debug_env_t;
+
+  extern const __execute_may_block_caller_t execute_may_block_caller;
   extern const get_forward_progress_guarantee_t get_forward_progress_guarantee;
   extern const get_scheduler_t get_scheduler;
   extern const get_delegation_scheduler_t get_delegation_scheduler;
-  extern const get_allocator_t get_allocator;
-  extern const get_stop_token_t get_stop_token;
   template <__completion_tag _CPO>
   extern const get_completion_scheduler_t<_CPO> get_completion_scheduler;
   template <class _CPO = void>
@@ -164,7 +144,7 @@ namespace STDEXEC {
   extern const get_domain_t get_domain;
 
   template <class _Env>
-  concept __is_debug_env = __callable<__queries::__debug_env_t, _Env>;
+  concept __is_debug_env = __callable<__debug_env_t, _Env>;
 
   namespace __debug {
     struct __completion_signatures { };
@@ -174,15 +154,6 @@ namespace STDEXEC {
   STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
   constexpr auto get_completion_behavior() noexcept;
 
-  struct never_stop_token;
-  class inplace_stop_source;
-  class inplace_stop_token;
-  template <class _Fn>
-  class inplace_stop_callback;
-
-  template <class _Env>
-  using stop_token_of_t = __decay_t<__call_result_t<get_stop_token_t, _Env>>;
-
   template <class _Env>
   using __domain_of_t = __decay_t<__call_result_t<get_domain_t, _Env>>;
 
@@ -373,3 +344,54 @@ namespace STDEXEC {
   using __on::on_t;
   extern const on_t on;
 } // namespace STDEXEC
+
+STDEXEC_P2300_NAMESPACE_BEGIN()
+struct forwarding_query_t;
+struct get_allocator_t;
+struct get_stop_token_t;
+
+extern const forwarding_query_t forwarding_query;
+extern const get_allocator_t get_allocator;
+extern const get_stop_token_t get_stop_token;
+
+template <class _Env>
+using stop_token_of_t = STDEXEC::__decay_t<STDEXEC::__call_result_t<get_stop_token_t, _Env>>;
+
+struct never_stop_token;
+class inplace_stop_source;
+class inplace_stop_token;
+template <class _Fn>
+class inplace_stop_callback;
+STDEXEC_P2300_NAMESPACE_END()
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+STDEXEC_P2300_NAMESPACE_BEGIN(this_thread)
+struct sync_wait_t;
+struct sync_wait_with_variant_t;
+extern const sync_wait_t sync_wait;
+extern const sync_wait_with_variant_t sync_wait_with_variant;
+STDEXEC_P2300_NAMESPACE_END(this_thread)
+
+// NOT TO SPEC: make sync_wait et. al. available in namespace STDEXEC (possibly
+// std::execution) as well:
+namespace STDEXEC {
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::forwarding_query_t)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::get_allocator_t)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::get_stop_token_t)
+
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::forwarding_query)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::get_stop_token)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::get_allocator)
+
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::stop_token_of_t)
+
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::never_stop_token)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::inplace_stop_source)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::inplace_stop_token)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::inplace_stop_callback)
+
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::this_thread::sync_wait_t)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::this_thread::sync_wait)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::this_thread::sync_wait_with_variant_t)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::this_thread::sync_wait_with_variant)
+} // namespace STDEXEC
diff --git a/include/stdexec/__detail/__queries.hpp b/include/stdexec/__detail/__queries.hpp
index 04ccea6d7..b898f5d02 100644
--- a/include/stdexec/__detail/__queries.hpp
+++ b/include/stdexec/__detail/__queries.hpp
@@ -26,87 +26,59 @@
 namespace STDEXEC {
   //////////////////////////////////////////////////////////////////////////////////////////////////
   // [exec.queries]
-  namespace __queries {
-    //////////////////////////////////////////////////////////////////////////////////
-    // [exec.get.allocator]
-    struct get_allocator_t : __query<get_allocator_t> {
-      using __query<get_allocator_t>::operator();
-
-      // defined in __read_env.hpp
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      constexpr auto operator()() const noexcept;
-
-      template <class _Env>
-      STDEXEC_ATTRIBUTE(always_inline, host, device)
-      static constexpr void __validate() noexcept {
-        static_assert(__nothrow_callable<get_allocator_t, const _Env&>);
-        static_assert(__allocator_<__call_result_t<get_allocator_t, const _Env&>>);
-      }
-
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      static consteval auto query(forwarding_query_t) noexcept -> bool {
-        return true;
-      }
-    };
-
-    // NOT TO SPEC:
-    struct __is_scheduler_affine_t {
-      template <class _Result>
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      static consteval auto __ensure_bool_constant() noexcept {
-        if constexpr (__is_bool_constant<_Result>) {
-          return static_cast<bool>(_Result::value);
-        } else {
-          static_assert(
-            __is_bool_constant<_Result>,
-            "The __is_scheduler_affine query must be one of the following forms:\n"
-            "  static constexpr bool query(__is_scheduler_affine_t) noexcept;\n"
-            "  bool_constant<Bool> query(__is_scheduler_affine_t) const noexcept;\n"
-            "  bool_constant<Bool> query(__is_scheduler_affine_t, const Env&) const noexcept;\n");
-        }
-      }
 
-      template <class _Attrs, class... _Env>
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      consteval auto operator()() const noexcept -> bool {
-        return __completes_where_it_starts<set_value_t, _Attrs, const _Env&...>;
-      }
-
-      template <__queryable_with<__is_scheduler_affine_t> _Attrs, class... _Env>
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      consteval auto operator()() const noexcept -> bool {
-        if constexpr (__statically_queryable_with<_Attrs, __is_scheduler_affine_t>) {
-          return _Attrs::query(__is_scheduler_affine_t());
-        } else {
-          return __ensure_bool_constant<__query_result_t<_Attrs, __is_scheduler_affine_t>>();
-        }
+  // NOT TO SPEC:
+  struct __is_scheduler_affine_t {
+    template <class _Result>
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    static consteval auto __ensure_bool_constant() noexcept {
+      if constexpr (__is_bool_constant<_Result>) {
+        return static_cast<bool>(_Result::value);
+      } else {
+        static_assert(
+          __is_bool_constant<_Result>,
+          "The __is_scheduler_affine query must be one of the following forms:\n"
+          "  static constexpr bool query(__is_scheduler_affine_t) noexcept;\n"
+          "  bool_constant<Bool> query(__is_scheduler_affine_t) const noexcept;\n"
+          "  bool_constant<Bool> query(__is_scheduler_affine_t, const Env&) const noexcept;\n");
       }
+    }
 
-      template <class _Attrs, class _Env>
-        requires __queryable_with<_Attrs, __is_scheduler_affine_t, const _Env&>
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      consteval auto operator()() const noexcept -> bool {
-        using __result_t = __query_result_t<_Attrs, __is_scheduler_affine_t, const _Env&>;
-        return __ensure_bool_constant<__result_t>();
-      }
+    template <class _Attrs, class... _Env>
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    consteval auto operator()() const noexcept -> bool {
+      return __completes_where_it_starts<set_value_t, _Attrs, const _Env&...>;
+    }
 
-      template <class _Attrs, class... _Env>
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      consteval auto operator()(const _Attrs&, const _Env&...) const noexcept -> bool {
-        return operator()<_Attrs, _Env...>();
+    template <__queryable_with<__is_scheduler_affine_t> _Attrs, class... _Env>
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    consteval auto operator()() const noexcept -> bool {
+      if constexpr (__statically_queryable_with<_Attrs, __is_scheduler_affine_t>) {
+        return _Attrs::query(__is_scheduler_affine_t());
+      } else {
+        return __ensure_bool_constant<__query_result_t<_Attrs, __is_scheduler_affine_t>>();
       }
+    }
 
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      static consteval auto query(forwarding_query_t) noexcept -> bool {
-        return false;
-      }
-    };
-  } // namespace __queries
+    template <class _Attrs, class _Env>
+      requires __queryable_with<_Attrs, __is_scheduler_affine_t, const _Env&>
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    consteval auto operator()() const noexcept -> bool {
+      using __result_t = __query_result_t<_Attrs, __is_scheduler_affine_t, const _Env&>;
+      return __ensure_bool_constant<__result_t>();
+    }
 
-  using __queries::get_allocator_t;
-  using __queries::__is_scheduler_affine_t;
+    template <class _Attrs, class... _Env>
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    consteval auto operator()(const _Attrs&, const _Env&...) const noexcept -> bool {
+      return operator()<_Attrs, _Env...>();
+    }
 
-  inline constexpr get_allocator_t get_allocator{};
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    static consteval auto query(forwarding_query_t) noexcept -> bool {
+      return false;
+    }
+  };
 
   template <class _Sender, class... _Env>
   concept __is_scheduler_affine = requires {
@@ -142,3 +114,29 @@ namespace STDEXEC {
   template <class _Sender>
   STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __sync_attrs(const _Sender&) -> __sync_attrs<_Sender>;
 } // namespace STDEXEC
+
+STDEXEC_P2300_NAMESPACE_BEGIN()
+//////////////////////////////////////////////////////////////////////////////////
+// [exec.get.allocator]
+struct get_allocator_t : STDEXEC::__query<get_allocator_t> {
+  using STDEXEC::__query<get_allocator_t>::operator();
+
+  // defined in __read_env.hpp
+  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+  constexpr auto operator()() const noexcept;
+
+  template <class _Env>
+  STDEXEC_ATTRIBUTE(always_inline, host, device)
+  static constexpr void __validate() noexcept {
+    static_assert(STDEXEC::__nothrow_callable<get_allocator_t, const _Env&>);
+    static_assert(STDEXEC::__allocator_<STDEXEC::__call_result_t<get_allocator_t, const _Env&>>);
+  }
+
+  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+  static consteval auto query(forwarding_query_t) noexcept -> bool {
+    return true;
+  }
+};
+
+inline constexpr get_allocator_t get_allocator{};
+STDEXEC_P2300_NAMESPACE_END()
diff --git a/include/stdexec/__detail/__query.hpp b/include/stdexec/__detail/__query.hpp
index 2802c08c1..670805e98 100644
--- a/include/stdexec/__detail/__query.hpp
+++ b/include/stdexec/__detail/__query.hpp
@@ -28,11 +28,11 @@
 namespace STDEXEC {
   // [exec.queries.queryable]
   template <class T>
-  concept queryable = __std::destructible<T>;
+  concept __queryable = __std::destructible<T>;
 
   template <class _Env, class _Query, class... _Args>
   concept __member_queryable_with =
-    queryable<_Env>
+    __queryable<_Env>
     && requires(const _Env& __env, const _Query& __query, __declfn_t<_Args&&>... __args) {
          { __env.query(__query, __args()...) };
        };
@@ -120,55 +120,12 @@ namespace STDEXEC {
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
   // [exec.queries]
-  namespace __queries {
-    template <class _Tp>
-    concept __is_bool_constant = requires { typename __mbool<_Tp::value>; };
-
-    struct forwarding_query_t {
-      template <class _Query>
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      consteval auto operator()(_Query) const noexcept -> bool {
-        if constexpr (__queryable_with<_Query, forwarding_query_t>) {
-          return __query<forwarding_query_t>()(_Query());
-        } else {
-          return __std::derived_from<_Query, forwarding_query_t>;
-        }
-      }
-    };
-
-  } // namespace __queries
-
-  using __queries::forwarding_query_t;
-  inline constexpr forwarding_query_t forwarding_query{};
+  template <class _Tp>
+  concept __is_bool_constant = requires { typename __mbool<_Tp::value>; };
 
   template <class _Tag>
   concept __forwarding_query = forwarding_query(_Tag{});
 
-  struct query_or_t {
-    template <class _Query, class _Queryable, class _Default, class... _Args>
-    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto operator()(_Query, _Queryable&&, _Default&& __default, _Args&&...) const
-      noexcept(__nothrow_move_constructible<_Default>) -> _Default {
-      return static_cast<_Default&&>(__default);
-    }
-
-    template <class _Query, class _Queryable, class _Default, class... _Args>
-      requires __callable<_Query, _Queryable, _Args...>
-    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto
-      operator()(_Query __query, _Queryable&& __queryable, _Default&&, _Args&&... __args) const
-      noexcept(__nothrow_callable<_Query, _Queryable, _Args...>)
-        -> __call_result_t<_Query, _Queryable, _Args...> {
-      return static_cast<_Query&&>(
-        __query)(static_cast<_Queryable&&>(__queryable), static_cast<_Args&&>(__args)...);
-    }
-  };
-
-  inline constexpr query_or_t query_or{}; // NOT TO SPEC
-
-  template <class _Query, class _Queryable, class _Default, class... _Args>
-  using __query_result_or_t = __call_result_t<query_or_t, _Query, _Queryable, _Default, _Args...>;
-
   //////////////////////////////////////////////////////////////////////////////////////////
   // __is_completion_query
   template <class _Query>
@@ -180,3 +137,19 @@ namespace STDEXEC {
   template <class _Tag>
   inline constexpr bool __is_completion_query<get_completion_behavior_t<_Tag>> = true;
 } // namespace STDEXEC
+
+STDEXEC_P2300_NAMESPACE_BEGIN()
+struct forwarding_query_t {
+  template <class _Query>
+  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+  consteval auto operator()(_Query) const noexcept -> bool {
+    if constexpr (STDEXEC::__queryable_with<_Query, forwarding_query_t>) {
+      return STDEXEC::__query<forwarding_query_t>()(_Query());
+    } else {
+      return STDEXEC::__std::derived_from<_Query, forwarding_query_t>;
+    }
+  }
+};
+
+inline constexpr forwarding_query_t forwarding_query{};
+STDEXEC_P2300_NAMESPACE_END()
diff --git a/include/stdexec/__detail/__read_env.hpp b/include/stdexec/__detail/__read_env.hpp
index a43c33e5d..da7a9f7d6 100644
--- a/include/stdexec/__detail/__read_env.hpp
+++ b/include/stdexec/__detail/__read_env.hpp
@@ -144,25 +144,25 @@ namespace STDEXEC {
   template <>
   struct __sexpr_impl<__read::read_env_t> : __read::__read_env_impl { };
 
-  namespace __queries {
-    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto get_scheduler_t::operator()() const noexcept {
-      return read_env(get_scheduler);
-    }
-
-    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto get_delegation_scheduler_t::operator()() const noexcept {
-      return read_env(get_delegation_scheduler);
-    }
-
-    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto get_allocator_t::operator()() const noexcept {
-      return read_env(get_allocator);
-    }
-
-    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto get_stop_token_t::operator()() const noexcept {
-      return read_env(get_stop_token);
-    }
-  } // namespace __queries
+  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+  constexpr auto get_scheduler_t::operator()() const noexcept {
+    return read_env(get_scheduler);
+  }
+
+  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+  constexpr auto get_delegation_scheduler_t::operator()() const noexcept {
+    return read_env(get_delegation_scheduler);
+  }
 } // namespace STDEXEC
+
+STDEXEC_P2300_NAMESPACE_BEGIN()
+STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+constexpr auto get_allocator_t::operator()() const noexcept {
+  return STDEXEC::read_env(get_allocator);
+}
+
+STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+constexpr auto get_stop_token_t::operator()() const noexcept {
+  return STDEXEC::read_env(get_stop_token);
+}
+STDEXEC_P2300_NAMESPACE_END()
diff --git a/include/stdexec/__detail/__receivers.hpp b/include/stdexec/__detail/__receivers.hpp
index 2b4e47eb4..96947d203 100644
--- a/include/stdexec/__detail/__receivers.hpp
+++ b/include/stdexec/__detail/__receivers.hpp
@@ -183,7 +183,7 @@ namespace STDEXEC {
 
   template <class _Receiver>
   concept receiver = enable_receiver<__decay_t<_Receiver>>
-                  && environment_provider<__cref_t<_Receiver>>
+                  && __environment_provider<__cref_t<_Receiver>>
                   && __nothrow_move_constructible<__decay_t<_Receiver>>
                   && __std::constructible_from<__decay_t<_Receiver>, _Receiver>;
 
diff --git a/include/stdexec/__detail/__run_loop.hpp b/include/stdexec/__detail/__run_loop.hpp
index bf630e507..ddb5f4444 100644
--- a/include/stdexec/__detail/__run_loop.hpp
+++ b/include/stdexec/__detail/__run_loop.hpp
@@ -191,7 +191,7 @@ namespace STDEXEC {
       }
 
       STDEXEC_ATTRIBUTE(nodiscard, host, device)
-      constexpr auto query(execute_may_block_caller_t) const noexcept {
+      constexpr auto query(__execute_may_block_caller_t) const noexcept {
         return false;
       }
 
diff --git a/include/stdexec/__detail/__schedulers.hpp b/include/stdexec/__detail/__schedulers.hpp
index 72d4d52e4..de70058df 100644
--- a/include/stdexec/__detail/__schedulers.hpp
+++ b/include/stdexec/__detail/__schedulers.hpp
@@ -85,7 +85,6 @@ namespace STDEXEC {
     { get_scheduler(__sp) } -> scheduler;
   };
 
-  namespace __queries {
     struct get_scheduler_t : __query<get_scheduler_t> {
       using __query<get_scheduler_t>::operator();
 
@@ -279,16 +278,18 @@ namespace STDEXEC {
       }
     };
 
-    struct execute_may_block_caller_t : __query<execute_may_block_caller_t, true> {
+    struct __execute_may_block_caller_t : __query<__execute_may_block_caller_t, true> {
       template <class _Attrs>
       STDEXEC_ATTRIBUTE(always_inline, host, device)
       static constexpr void __validate() noexcept {
         static_assert(
-          __std::same_as<bool, __call_result_t<execute_may_block_caller_t, const _Attrs&>>);
-        static_assert(__nothrow_callable<execute_may_block_caller_t, const _Attrs&>);
+          __std::same_as<bool, __call_result_t<__execute_may_block_caller_t, const _Attrs&>>);
+        static_assert(__nothrow_callable<__execute_may_block_caller_t, const _Attrs&>);
       }
     };
 
+    using execute_may_block_caller_t [[deprecated]] = __execute_may_block_caller_t;
+
     struct get_forward_progress_guarantee_t
       : __query<
           get_forward_progress_guarantee_t,
@@ -303,15 +304,9 @@ namespace STDEXEC {
         static_assert(__nothrow_callable<get_forward_progress_guarantee_t, const _Attrs&>);
       }
     };
-  } // namespace __queries
-
-  using __queries::execute_may_block_caller_t;
-  using __queries::get_forward_progress_guarantee_t;
-  using __queries::get_scheduler_t;
-  using __queries::get_delegation_scheduler_t;
-  using __queries::get_completion_scheduler_t;
 
-  inline constexpr execute_may_block_caller_t execute_may_block_caller{};
+  [[deprecated]]
+  inline constexpr __execute_may_block_caller_t execute_may_block_caller{};
   inline constexpr get_forward_progress_guarantee_t get_forward_progress_guarantee{};
   inline constexpr get_scheduler_t get_scheduler{};
   inline constexpr get_delegation_scheduler_t get_delegation_scheduler{};
@@ -388,7 +383,7 @@ namespace STDEXEC {
         && (__callable<get_scheduler_t, const _Env&> || ...)) {
         return (
           __sched_env{get_completion_scheduler<set_value_t>(
-            get_scheduler(__env), __queries::__hide_scheduler{__env})},
+            get_scheduler(__env), __hide_scheduler{__env})},
           ...);
       } else {
         return __sched_env{__sch};
diff --git a/include/stdexec/__detail/__sender_concepts.hpp b/include/stdexec/__detail/__sender_concepts.hpp
index e085a8ecc..fc527b9b0 100644
--- a/include/stdexec/__detail/__sender_concepts.hpp
+++ b/include/stdexec/__detail/__sender_concepts.hpp
@@ -48,7 +48,7 @@ namespace STDEXEC {
   // [exec.snd.concepts]
   template <class _Sender>
   concept sender = enable_sender<__decay_t<_Sender>>       //
-                && environment_provider<__cref_t<_Sender>> //
+                && __environment_provider<__cref_t<_Sender>> //
                 && __std::move_constructible<__decay_t<_Sender>>
                 && __std::constructible_from<__decay_t<_Sender>, _Sender>;
 
diff --git a/include/stdexec/__detail/__stop_token.hpp b/include/stdexec/__detail/__stop_token.hpp
index 2271df24f..f6986f7e7 100644
--- a/include/stdexec/__detail/__stop_token.hpp
+++ b/include/stdexec/__detail/__stop_token.hpp
@@ -20,88 +20,86 @@
 
 #include "__concepts.hpp"
 
-STDEXEC_NAMESPACE_STD_BEGIN
-class stop_token;
+#if defined(__cpp_lib_jthread) && __cpp_lib_jthread >= 2019'11L
+#  include <stop_token>
+#endif
 
-template <class _Callback>
-class stop_callback;
-STDEXEC_NAMESPACE_STD_END
+STDEXEC_P2300_NAMESPACE_BEGIN()
 
-namespace STDEXEC {
-  namespace __stok {
-    template <template <class> class>
-    struct __check_type_alias_exists;
-  } // namespace __stok
-
-  template <class _Token, class _Callback>
-  struct __stop_callback_for {
-    using __t = _Token::template callback_type<_Callback>;
-  };
+template <template <class> class _Callback>
+struct __check_type_alias_exists;
+
+template <class _StopToken>
+inline constexpr bool __has_stop_callback_v = requires {
+  typename __check_type_alias_exists<_StopToken::template callback_type>;
+};
+
+#if defined(__cpp_lib_jthread) && __cpp_lib_jthread >= 2019'11L
+template <>
+inline constexpr bool __has_stop_callback_v<std::stop_token> = true;
+#endif
+
+template <class _Token>
+struct __stop_callback_for {
   template <class _Callback>
-  struct __stop_callback_for<std::stop_token, _Callback> {
-    using __t = std::stop_callback<_Callback>;
-  };
+  using __f = _Token::template callback_type<_Callback>;
+};
 
-  template <class _Token, class _Callback>
-  using stop_callback_for_t = __stop_callback_for<_Token, _Callback>::__t;
-
-  template <class _Token>
-  concept __stoppable_token =
-    __nothrow_copy_constructible<_Token> && __nothrow_move_constructible<_Token>
-    && __std::equality_comparable<_Token> && requires(const _Token& __token) {
-         { __token.stop_requested() } noexcept -> __boolean_testable_;
-         { __token.stop_possible() } noexcept -> __boolean_testable_;
-       }
-  // workaround ICE in appleclang 13.1
-#if !defined(__clang__)
-       && requires {
-         typename __stok::__check_type_alias_exists<_Token::template callback_type>;
-       }
+#if defined(__cpp_lib_jthread) && __cpp_lib_jthread >= 2019'11L
+template <>
+struct __stop_callback_for<std::stop_token> {
+  template <class _Callback>
+  using __f = std::stop_callback<_Callback>;
+};
 #endif
-      ;
-
-  template <class _Token>
-  concept __stoppable_token_or = __same_as<_Token, std::stop_token> || __stoppable_token<_Token>;
-
-  // The cast to bool below is to make __stoppable_token_or<_Token> an atomic constraint,
-  // hiding the disjunction within it for the sake of better compile-time performance.
-  template <class _Token>
-  concept stoppable_token = bool(__stoppable_token_or<_Token>);
-
-  template <class _Token, typename _Callback, typename _Initializer = _Callback>
-  concept stoppable_token_for = stoppable_token<_Token> && __callable<_Callback>
-                             && requires { typename stop_callback_for_t<_Token, _Callback>; }
-                             && __std::constructible_from<_Callback, _Initializer>
-                             && __std::constructible_from<
-                                  stop_callback_for_t<_Token, _Callback>,
-                                  const _Token&,
-                                  _Initializer
-                             >;
-
-  template <class _Token>
-  concept unstoppable_token = stoppable_token<_Token> && requires {
-    { _Token::stop_possible() } -> __boolean_testable_;
-  } && (!_Token::stop_possible());
-
-  // [stoptoken.never], class never_stop_token
-  struct never_stop_token {
-   private:
-    struct __callback_type {
-      constexpr explicit __callback_type(never_stop_token, __ignore) noexcept {
-      }
-    };
-   public:
-    template <class>
-    using callback_type = __callback_type;
-
-    static constexpr auto stop_requested() noexcept -> bool {
-      return false;
-    }
 
-    static constexpr auto stop_possible() noexcept -> bool {
-      return false;
+template <class _Token, class _Callback>
+using stop_callback_for_t = STDEXEC::__mcall1<__stop_callback_for<_Token>, _Callback>;
+
+template <class _Token>
+concept stoppable_token =
+  requires(const _Token __token) {
+    requires __has_stop_callback_v<_Token>;
+    { __token.stop_requested() } noexcept -> STDEXEC::__boolean_testable_;
+    { __token.stop_possible() } noexcept -> STDEXEC::__boolean_testable_;
+    { _Token(__token) } noexcept;
+  } && STDEXEC::__std::copyable<_Token> //
+  && STDEXEC::__std::equality_comparable<_Token>;
+
+template <class _Token>
+concept unstoppable_token =
+  stoppable_token<_Token> //
+  && requires {
+    { _Token::stop_possible() } -> STDEXEC::__boolean_testable_;
+  } //
+  && (!_Token::stop_possible());
+
+// [stoptoken.never], class never_stop_token
+struct never_stop_token {
+ private:
+  struct __callback_type {
+    constexpr explicit __callback_type(never_stop_token, STDEXEC::__ignore) noexcept {
     }
-
-    constexpr auto operator==(const never_stop_token&) const noexcept -> bool = default;
   };
+ public:
+  template <class>
+  using callback_type = __callback_type;
+
+  static constexpr auto stop_requested() noexcept -> bool {
+    return false;
+  }
+
+  static constexpr auto stop_possible() noexcept -> bool {
+    return false;
+  }
+
+  constexpr auto operator==(const never_stop_token&) const noexcept -> bool = default;
+};
+STDEXEC_P2300_NAMESPACE_END()
+
+namespace STDEXEC {
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::stop_callback_for_t)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::stoppable_token)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::unstoppable_token)
+  STDEXEC_P2300_DEPRECATED_SYMBOL(std::never_stop_token)
 } // namespace STDEXEC
diff --git a/include/stdexec/__detail/__sync_wait.hpp b/include/stdexec/__detail/__sync_wait.hpp
index 68ac91582..2c29453c5 100644
--- a/include/stdexec/__detail/__sync_wait.hpp
+++ b/include/stdexec/__detail/__sync_wait.hpp
@@ -37,296 +37,300 @@
 #include <tuple>
 #include <variant>
 
-namespace STDEXEC {
+namespace STDEXEC::__sync_wait {
   /////////////////////////////////////////////////////////////////////////////
   // [execution.senders.consumers.sync_wait]
   // [execution.senders.consumers.sync_wait_with_variant]
-  namespace __sync_wait {
-    struct sync_wait_t;
-
-    struct __env {
-      run_loop* __loop_ = nullptr;
-
-      [[nodiscard]]
-      constexpr auto query(get_scheduler_t) const noexcept -> run_loop::scheduler {
-        return __loop_->get_scheduler();
-      }
-
-      [[nodiscard]]
-      constexpr auto query(get_delegation_scheduler_t) const noexcept -> run_loop::scheduler {
-        return __loop_->get_scheduler();
+  struct __env {
+    run_loop* __loop_ = nullptr;
+
+    [[nodiscard]]
+    constexpr auto query(get_scheduler_t) const noexcept -> run_loop::scheduler {
+      return __loop_->get_scheduler();
+    }
+
+    [[nodiscard]]
+    constexpr auto query(get_delegation_scheduler_t) const noexcept -> run_loop::scheduler {
+      return __loop_->get_scheduler();
+    }
+
+    [[nodiscard]]
+    constexpr auto query(__root_t) const noexcept -> bool {
+      return true;
+    }
+  };
+
+  // What should sync_wait(just_stopped()) return?
+  template <class _CvSender, class _Continuation>
+  using __result_t = __value_types_of_t<
+    _CvSender,
+    __env,
+    __mtransform<__q<__decay_t>, _Continuation>,
+    __q<__msingle>
+  >;
+
+  template <class _CvSender>
+  using __sync_wait_result_t = __result_t<_CvSender, __qq<std::tuple>>;
+
+  template <class _CvSender>
+  using __sync_wait_with_variant_result_t =
+    __result_t<__result_of<into_variant, _CvSender>, __q<__midentity>>;
+
+  struct __state {
+    std::exception_ptr __eptr_;
+    run_loop __loop_;
+  };
+
+  template <class... _Values>
+  struct __receiver {
+    using receiver_concept = receiver_t;
+
+    template <class... _As>
+    constexpr void set_value(_As&&... __as) noexcept {
+      static_assert(__std::constructible_from<std::tuple<_Values...>, _As...>);
+      STDEXEC_TRY {
+        __values_->emplace(static_cast<_As&&>(__as)...);
       }
-
-      [[nodiscard]]
-      constexpr auto query(__root_t) const noexcept -> bool {
-        return true;
+      STDEXEC_CATCH_ALL {
+        __state_->__eptr_ = std::current_exception();
       }
-    };
-
-    // What should sync_wait(just_stopped()) return?
-    template <class _CvSender, class _Continuation>
-    using __result_t = __value_types_of_t<
-      _CvSender,
-      __env,
-      __mtransform<__q<__decay_t>, _Continuation>,
-      __q<__msingle>
-    >;
-
-    template <class _CvSender>
-    using __sync_wait_result_t = __result_t<_CvSender, __qq<std::tuple>>;
-
-    template <class _CvSender>
-    using __sync_wait_with_variant_result_t =
-      __result_t<__result_of<into_variant, _CvSender>, __q<__midentity>>;
-
-    struct __state {
-      std::exception_ptr __eptr_;
-      run_loop __loop_;
-    };
-
-    template <class... _Values>
-    struct __receiver {
-      using receiver_concept = receiver_t;
-
-      template <class... _As>
-      constexpr void set_value(_As&&... __as) noexcept {
-        static_assert(__std::constructible_from<std::tuple<_Values...>, _As...>);
-        STDEXEC_TRY {
-          __values_->emplace(static_cast<_As&&>(__as)...);
-        }
-        STDEXEC_CATCH_ALL {
-          __state_->__eptr_ = std::current_exception();
-        }
-        __state_->__loop_.finish();
+      __state_->__loop_.finish();
+    }
+
+    template <class _Error>
+    constexpr void set_error(_Error __err) noexcept {
+      if constexpr (__same_as<_Error, std::exception_ptr>) {
+        STDEXEC_ASSERT(__err != nullptr); // std::exception_ptr must not be null.
+        __state_->__eptr_ = static_cast<_Error&&>(__err);
+      } else if constexpr (__same_as<_Error, std::error_code>) {
+        __state_->__eptr_ = std::make_exception_ptr(std::system_error(__err));
+      } else {
+        __state_->__eptr_ = std::make_exception_ptr(static_cast<_Error&&>(__err));
       }
-
-      template <class _Error>
-      constexpr void set_error(_Error __err) noexcept {
-        if constexpr (__same_as<_Error, std::exception_ptr>) {
-          STDEXEC_ASSERT(__err != nullptr); // std::exception_ptr must not be null.
-          __state_->__eptr_ = static_cast<_Error&&>(__err);
-        } else if constexpr (__same_as<_Error, std::error_code>) {
-          __state_->__eptr_ = std::make_exception_ptr(std::system_error(__err));
+      __state_->__loop_.finish();
+    }
+
+    constexpr void set_stopped() noexcept {
+      __state_->__loop_.finish();
+    }
+
+    [[nodiscard]]
+    constexpr auto get_env() const noexcept -> __env {
+      return __env{&__state_->__loop_};
+    }
+    __state* __state_;
+    std::optional<std::tuple<_Values...>>* __values_;
+  };
+
+  template <class _CvSender>
+  using __receiver_t = __result_t<_CvSender, __q<__receiver>>;
+
+  // These are for hiding the metaprogramming in diagnostics
+  template <class _CvSender>
+  struct __sync_receiver_for {
+    using __t = __receiver_t<_CvSender>;
+  };
+  template <class _CvSender>
+  using __sync_receiver_for_t = __t<__sync_receiver_for<_CvSender>>;
+
+  template <class _CvSender>
+  struct __value_tuple_for {
+    using __t = __sync_wait_result_t<_CvSender>;
+  };
+  template <class _CvSender>
+  using __value_tuple_for_t = __t<__value_tuple_for<_CvSender>>;
+
+  template <class _CvSender>
+  struct __variant {
+    using __t = __sync_wait_with_variant_result_t<_CvSender>;
+  };
+  template <class _CvSender>
+  using __variant_for_t = __t<__variant<_CvSender>>;
+
+  struct _SENDER_HAS_TOO_MANY_SUCCESSFUL_COMPLETIONS_ { };
+  struct _USE_SYNC_WAIT_WITH_VARIANT_INSTEAD_ { };
+
+  template <class _Reason, class _CvSender, class _Env = __env>
+  using __sync_wait_error_t = __mexception<
+    _WHAT_(_INVALID_ARGUMENT_),
+    _WHERE_(_IN_ALGORITHM_, sync_wait_t),
+    _WHY_(_Reason),
+    _WITH_PRETTY_SENDER_<_CvSender>,
+    _WITH_ENVIRONMENT_(_Env),
+    _TO_FIX_THIS_ERROR_(_USE_SYNC_WAIT_WITH_VARIANT_INSTEAD_)
+  >;
+
+  template <class _CvSender, class>
+  using __too_many_successful_completions_error_t =
+    __sync_wait_error_t<_SENDER_HAS_TOO_MANY_SUCCESSFUL_COMPLETIONS_, _CvSender>;
+
+  template <class _CvSender>
+  concept __valid_sync_wait_argument = __ok<__minvoke<
+    __mtry_catch_q<__single_value_variant_sender_t, __q<__too_many_successful_completions_error_t>>,
+    _CvSender,
+    __env
+  >>;
+} // namespace STDEXEC::__sync_wait
+
+STDEXEC_P2300_NAMESPACE_BEGIN(this_thread)
+////////////////////////////////////////////////////////////////////////////
+// [execution.senders.consumers.sync_wait]
+struct sync_wait_t {
+  template <STDEXEC::sender_in<STDEXEC::__sync_wait::__env> _CvSender>
+  auto operator()(_CvSender&& __sndr) const {
+    using __domain_t =
+      STDEXEC::__completion_domain_of_t<STDEXEC::set_value_t, _CvSender, STDEXEC::__sync_wait::__env>;
+    constexpr auto __success_completion_count =
+      STDEXEC::__count_of<STDEXEC::set_value_t, _CvSender, STDEXEC::__sync_wait::__env>::value;
+
+    static_assert(
+      __success_completion_count != 0,
+      "The argument to STDEXEC::sync_wait() is a sender that cannot complete successfully. "
+      "STDEXEC::sync_wait() requires a sender that can complete successfully in exactly one "
+      "way. In other words, the sender's completion signatures must include exactly one "
+      "signature of the form `set_value_t(value-types...)`.");
+
+    static_assert(
+      __success_completion_count <= 1,
+      "The sender passed to STDEXEC::sync_wait() can complete successfully in "
+      "more than one way. Use STDEXEC::sync_wait_with_variant() instead.");
+
+    if constexpr (1 == __success_completion_count) {
+      if constexpr (STDEXEC::__same_as<__domain_t, STDEXEC::default_domain>) {
+        if constexpr (STDEXEC::sender_to<_CvSender, STDEXEC::__sync_wait::__receiver_t<_CvSender>>) {
+          using __opstate_t =
+            STDEXEC::connect_result_t<_CvSender, STDEXEC::__sync_wait::__receiver_t<_CvSender>>;
+          if constexpr (STDEXEC::operation_state<__opstate_t>) {
+            // success path, dispatch to the default domain's sync_wait
+            return STDEXEC::default_domain().apply_sender(*this, static_cast<_CvSender&&>(__sndr));
+          } else {
+            static_assert(
+              STDEXEC::operation_state<__opstate_t>,
+              "The `connect` member function of the sender passed to STDEXEC::sync_wait() "
+              "does not return an operation state. An operation state is required to have a "
+              "no-throw .start() member function.");
+          }
         } else {
-          __state_->__eptr_ = std::make_exception_ptr(static_cast<_Error&&>(__err));
+          // This shoud generate a useful error message about why the sender cannot
+          // be connected to the receiver:
+          STDEXEC::connect(
+            static_cast<_CvSender&&>(__sndr), STDEXEC::__sync_wait::__receiver_t<_CvSender>{});
+          static_assert(
+            STDEXEC::sender_to<_CvSender, STDEXEC::__sync_wait::__receiver_t<_CvSender>>,
+            STDEXEC_ERROR_SYNC_WAIT_CANNOT_CONNECT_SENDER_TO_RECEIVER);
         }
-        __state_->__loop_.finish();
-      }
-
-      constexpr void set_stopped() noexcept {
-        __state_->__loop_.finish();
-      }
-
-      [[nodiscard]]
-      constexpr auto get_env() const noexcept -> __env {
-        return __env{&__state_->__loop_};
+      } else if constexpr (!STDEXEC::__has_implementation_for<sync_wait_t, __domain_t, _CvSender>) {
+        static_assert(
+          STDEXEC::__has_implementation_for<sync_wait_t, __domain_t, _CvSender>,
+          "The sender passed to STDEXEC::sync_wait() has a domain that does not provide a "
+          "usable implementation for sync_wait().");
+      } else {
+        // success path, dispatch to the custom domain's sync_wait
+        return STDEXEC::apply_sender(__domain_t(), *this, static_cast<_CvSender&&>(__sndr));
       }
-      __state* __state_;
-      std::optional<std::tuple<_Values...>>* __values_;
-    };
-
-    template <class _CvSender>
-    using __receiver_t = __result_t<_CvSender, __q<__receiver>>;
-
-    // These are for hiding the metaprogramming in diagnostics
-    template <class _CvSender>
-    struct __sync_receiver_for {
-      using __t = __receiver_t<_CvSender>;
-    };
-    template <class _CvSender>
-    using __sync_receiver_for_t = __t<__sync_receiver_for<_CvSender>>;
-
-    template <class _CvSender>
-    struct __value_tuple_for {
-      using __t = __sync_wait_result_t<_CvSender>;
-    };
-    template <class _CvSender>
-    using __value_tuple_for_t = __t<__value_tuple_for<_CvSender>>;
-
-    template <class _CvSender>
-    struct __variant {
-      using __t = __sync_wait_with_variant_result_t<_CvSender>;
-    };
-    template <class _CvSender>
-    using __variant_for_t = __t<__variant<_CvSender>>;
-
-    struct _SENDER_HAS_TOO_MANY_SUCCESSFUL_COMPLETIONS_ { };
-    struct _USE_SYNC_WAIT_WITH_VARIANT_INSTEAD_ { };
-
-    template <class _Reason, class _CvSender, class _Env = __env>
-    using __sync_wait_error_t = __mexception<
-      _WHAT_(_INVALID_ARGUMENT_),
-      _WHERE_(_IN_ALGORITHM_, sync_wait_t),
-      _WHY_(_Reason),
-      _WITH_PRETTY_SENDER_<_CvSender>,
-      _WITH_ENVIRONMENT_(_Env),
-      _TO_FIX_THIS_ERROR_(_USE_SYNC_WAIT_WITH_VARIANT_INSTEAD_)
+    }
+  }
+
+  template <class _CvSender>
+  constexpr auto operator()(_CvSender&&) const {
+    STDEXEC::__diagnose_sender_concept_failure<
+      STDEXEC::__demangle_t<_CvSender>,
+      STDEXEC::__sync_wait::__env
+    >();
+    // dummy return type to silence follow-on errors
+    return std::optional<std::tuple<int>>{};
+  }
+
+  /// @brief Synchronously wait for the result of a sender, blocking the
+  ///         current thread.
+  ///
+  /// `sync_wait` connects and starts the given sender, and then drives a
+  ///         `run_loop` instance until the sender completes. Additional work
+  ///         can be delegated to the `run_loop` by scheduling work on the
+  ///         scheduler returned by calling `get_delegation_scheduler` on the
+  ///         receiver's environment.
+  ///
+  /// @pre The sender must have a exactly one value completion signature. That
+  ///         is, it can only complete successfully in one way, with a single
+  ///         set of values.
+  ///
+  /// @retval success Returns an engaged `std::optional` containing the result
+  ///         values in a `std::tuple`.
+  /// @retval canceled Returns an empty `std::optional`.
+  /// @retval error Throws the error.
+  ///
+  /// @throws std::rethrow_exception(error) if the error has type
+  ///         `std::exception_ptr`.
+  /// @throws std::system_error(error) if the error has type
+  ///         `std::error_code`.
+  /// @throws error otherwise
+
+  template <STDEXEC::sender_in<STDEXEC::__sync_wait::__env> _CvSender>
+  STDEXEC_CONSTEXPR_CXX23 auto apply_sender(_CvSender&& __sndr) const //
+    -> std::optional<STDEXEC::__sync_wait::__value_tuple_for_t<_CvSender>> {
+    STDEXEC::__sync_wait::__state __local_state{};
+    std::optional<STDEXEC::__sync_wait::__value_tuple_for_t<_CvSender>> __result{};
+
+    // Launch the sender with a continuation that will fill in the __result optional or set the
+    // exception_ptr in __local_state.
+    [[maybe_unused]]
+    auto __op = STDEXEC::connect(
+      static_cast<_CvSender&&>(__sndr),
+      STDEXEC::__sync_wait::__receiver_t<_CvSender>{&__local_state, &__result});
+    STDEXEC::start(__op);
+
+    // Wait for the variant to be filled in.
+    __local_state.__loop_.run();
+
+    if (__local_state.__eptr_) {
+      std::rethrow_exception(static_cast<std::exception_ptr&&>(__local_state.__eptr_));
+    }
+
+    return __result;
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////
+// [execution.senders.consumers.sync_wait_with_variant]
+struct sync_wait_with_variant_t {
+  template <STDEXEC::sender_in<STDEXEC::__sync_wait::__env> _CvSender>
+    requires STDEXEC::__callable<
+      STDEXEC::apply_sender_t,
+      STDEXEC::__completion_domain_of_t<STDEXEC::set_value_t, _CvSender, STDEXEC::__sync_wait::__env>,
+      sync_wait_with_variant_t,
+      _CvSender
+    >
+  auto operator()(_CvSender&& __sndr) const -> decltype(auto) {
+    using __result_t = STDEXEC::__call_result_t<
+      STDEXEC::apply_sender_t,
+      STDEXEC::__completion_domain_of_t<STDEXEC::set_value_t, _CvSender, STDEXEC::__sync_wait::__env>,
+      sync_wait_with_variant_t,
+      _CvSender
     >;
+    static_assert(STDEXEC::__is_instance_of<__result_t, std::optional>);
+    using __variant_t = __result_t::value_type;
+    static_assert(STDEXEC::__is_instance_of<__variant_t, std::variant>);
 
-    template <class _CvSender, class>
-    using __too_many_successful_completions_error_t =
-      __sync_wait_error_t<_SENDER_HAS_TOO_MANY_SUCCESSFUL_COMPLETIONS_, _CvSender>;
-
-    template <class _CvSender>
-    concept __valid_sync_wait_argument = __ok<__minvoke<
-      __mtry_catch_q<__single_value_variant_sender_t, __q<__too_many_successful_completions_error_t>>,
+    using _Domain = STDEXEC::__completion_domain_of_t<
+      STDEXEC::set_value_t,
       _CvSender,
-      __env
-    >>;
-
-    ////////////////////////////////////////////////////////////////////////////
-    // [execution.senders.consumers.sync_wait]
-    struct sync_wait_t {
-      template <sender_in<__env> _CvSender>
-      auto operator()(_CvSender&& __sndr) const {
-        using __domain_t = __completion_domain_of_t<set_value_t, _CvSender, __env>;
-        constexpr auto __success_completion_count =
-          __count_of<set_value_t, _CvSender, __env>::value;
-
-        static_assert(
-          __success_completion_count != 0,
-          "The argument to STDEXEC::sync_wait() is a sender that cannot complete successfully. "
-          "STDEXEC::sync_wait() requires a sender that can complete successfully in exactly one "
-          "way. In other words, the sender's completion signatures must include exactly one "
-          "signature of the form `set_value_t(value-types...)`.");
-
-        static_assert(
-          __success_completion_count <= 1,
-          "The sender passed to STDEXEC::sync_wait() can complete successfully in "
-          "more than one way. Use STDEXEC::sync_wait_with_variant() instead.");
-
-        if constexpr (1 == __success_completion_count) {
-          if constexpr (__same_as<__domain_t, default_domain>) {
-            if constexpr (sender_to<_CvSender, __receiver_t<_CvSender>>) {
-              using __opstate_t = connect_result_t<_CvSender, __receiver_t<_CvSender>>;
-              if constexpr (operation_state<__opstate_t>) {
-                // success path, dispatch to the default domain's sync_wait
-                return default_domain().apply_sender(*this, static_cast<_CvSender&&>(__sndr));
-              } else {
-                static_assert(
-                  operation_state<__opstate_t>,
-                  "The `connect` member function of the sender passed to STDEXEC::sync_wait() "
-                  "does not return an operation state. An operation state is required to have a "
-                  "no-throw .start() member function.");
-              }
-            } else {
-              // This shoud generate a useful error message about why the sender cannot
-              // be connected to the receiver:
-              connect(static_cast<_CvSender&&>(__sndr), __receiver_t<_CvSender>{});
-              static_assert(
-                sender_to<_CvSender, __receiver_t<_CvSender>>,
-                STDEXEC_ERROR_SYNC_WAIT_CANNOT_CONNECT_SENDER_TO_RECEIVER);
-            }
-          } else if constexpr (!__has_implementation_for<sync_wait_t, __domain_t, _CvSender>) {
-            static_assert(
-              __has_implementation_for<sync_wait_t, __domain_t, _CvSender>,
-              "The sender passed to STDEXEC::sync_wait() has a domain that does not provide a "
-              "usable implementation for sync_wait().");
-          } else {
-            // success path, dispatch to the custom domain's sync_wait
-            return STDEXEC::apply_sender(__domain_t(), *this, static_cast<_CvSender&&>(__sndr));
-          }
-        }
-      }
-
-      template <class _CvSender>
-      constexpr auto operator()(_CvSender&&) const {
-        STDEXEC::__diagnose_sender_concept_failure<__demangle_t<_CvSender>, __env>();
-        // dummy return type to silence follow-on errors
-        return std::optional<std::tuple<int>>{};
-      }
-
-      // clang-format off
-      /// @brief Synchronously wait for the result of a sender, blocking the
-      ///         current thread.
-      ///
-      /// `sync_wait` connects and starts the given sender, and then drives a
-      ///         `run_loop` instance until the sender completes. Additional work
-      ///         can be delegated to the `run_loop` by scheduling work on the
-      ///         scheduler returned by calling `get_delegation_scheduler` on the
-      ///         receiver's environment.
-      ///
-      /// @pre The sender must have a exactly one value completion signature. That
-      ///         is, it can only complete successfully in one way, with a single
-      ///         set of values.
-      ///
-      /// @retval success Returns an engaged `std::optional` containing the result
-      ///         values in a `std::tuple`.
-      /// @retval canceled Returns an empty `std::optional`.
-      /// @retval error Throws the error.
-      ///
-      /// @throws std::rethrow_exception(error) if the error has type
-      ///         `std::exception_ptr`.
-      /// @throws std::system_error(error) if the error has type
-      ///         `std::error_code`.
-      /// @throws error otherwise
-      // clang-format on
-
-      template <sender_in<__env> _CvSender>
-      STDEXEC_CONSTEXPR_CXX23 auto apply_sender(_CvSender&& __sndr) const //
-        -> std::optional<__value_tuple_for_t<_CvSender>> {
-        __state __local_state{};
-        std::optional<__value_tuple_for_t<_CvSender>> __result{};
-
-        // Launch the sender with a continuation that will fill in the __result optional or set the
-        // exception_ptr in __local_state.
-        [[maybe_unused]]
-        auto __op = STDEXEC::connect(
-          static_cast<_CvSender&&>(__sndr), __receiver_t<_CvSender>{&__local_state, &__result});
-        STDEXEC::start(__op);
-
-        // Wait for the variant to be filled in.
-        __local_state.__loop_.run();
-
-        if (__local_state.__eptr_) {
-          std::rethrow_exception(static_cast<std::exception_ptr&&>(__local_state.__eptr_));
-        }
-
-        return __result;
-      }
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    // [execution.senders.consumers.sync_wait_with_variant]
-    struct sync_wait_with_variant_t {
-      struct __impl;
-
-      template <sender_in<__env> _CvSender>
-        requires __callable<
-          apply_sender_t,
-          __completion_domain_of_t<set_value_t, _CvSender, __env>,
-          sync_wait_with_variant_t,
-          _CvSender
-        >
-      auto operator()(_CvSender&& __sndr) const -> decltype(auto) {
-        using __result_t = __call_result_t<
-          apply_sender_t,
-          __completion_domain_of_t<set_value_t, _CvSender, __env>,
-          sync_wait_with_variant_t,
-          _CvSender
-        >;
-        static_assert(__is_instance_of<__result_t, std::optional>);
-        using __variant_t = __result_t::value_type;
-        static_assert(__is_instance_of<__variant_t, std::variant>);
-
-        using _Domain = __completion_domain_of_t<set_value_t, _CvSender, __env>;
-        return STDEXEC::apply_sender(_Domain(), *this, static_cast<_CvSender&&>(__sndr));
-      }
-
-      template <class _CvSender>
-        requires __callable<sync_wait_t, __result_of<into_variant, _CvSender>>
-      auto apply_sender(_CvSender&& __sndr) const -> std::optional<__variant_for_t<_CvSender>> {
-        if (auto __opt_values = sync_wait_t()(into_variant(static_cast<_CvSender&&>(__sndr)))) {
-          return std::move(std::get<0>(*__opt_values));
-        }
-        return std::nullopt;
-      }
-    };
-  } // namespace __sync_wait
-
-  using __sync_wait::sync_wait_t;
-  inline constexpr sync_wait_t sync_wait{};
-
-  using __sync_wait::sync_wait_with_variant_t;
-  inline constexpr sync_wait_with_variant_t sync_wait_with_variant{};
-} // namespace STDEXEC
+      STDEXEC::__sync_wait::__env
+    >;
+    return STDEXEC::apply_sender(_Domain(), *this, static_cast<_CvSender&&>(__sndr));
+  }
+
+  template <class _CvSender>
+    requires STDEXEC::__callable<sync_wait_t, STDEXEC::__result_of<STDEXEC::into_variant, _CvSender>>
+  auto apply_sender(_CvSender&& __sndr) const
+    -> std::optional<STDEXEC::__sync_wait::__variant_for_t<_CvSender>> {
+    if (auto __opt_values = sync_wait_t()(STDEXEC::into_variant(static_cast<_CvSender&&>(__sndr)))) {
+      return std::move(std::get<0>(*__opt_values));
+    }
+    return std::nullopt;
+  }
+};
+
+inline constexpr sync_wait_t sync_wait{};
+inline constexpr sync_wait_with_variant_t sync_wait_with_variant{};
+
+STDEXEC_P2300_NAMESPACE_END(this_thread)
diff --git a/include/stdexec/stop_token.hpp b/include/stdexec/stop_token.hpp
index a0577bd98..943ce8403 100644
--- a/include/stdexec/stop_token.hpp
+++ b/include/stdexec/stop_token.hpp
@@ -31,340 +31,369 @@
 
 extern void _mm_pause();
 
-namespace STDEXEC {
-  namespace __stok {
-    inline void __pause() {
+namespace STDEXEC::__stok {
+  inline void __pause() {
 #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
-      ::_mm_pause();
+    ::_mm_pause();
 #elif defined(__i386__) || defined(__x86_64__) || defined(_M_X64)
-      asm volatile("pause");
+    asm volatile("pause");
 #elif defined(__aarch64__) || defined(__arm__)
-      asm volatile("yield");
+    asm volatile("yield");
 #elif defined(__powerpc64__)
-      asm volatile("or 27,27,27");
+    asm volatile("or 27,27,27");
 #endif
-    }
+  }
 
-    struct __inplace_stop_callback_base {
-      constexpr void __execute() noexcept {
-        this->__execute_(this);
-      }
+  struct __inplace_stop_callback_base {
+    constexpr void __execute() noexcept {
+      this->__execute_(this);
+    }
 
-     protected:
-      using __execute_fn_t = void(__inplace_stop_callback_base*) noexcept;
+   protected:
+    using __execute_fn_t = void(__inplace_stop_callback_base*) noexcept;
 
-      constexpr explicit __inplace_stop_callback_base(
-        const inplace_stop_source* __source,
-        __execute_fn_t* __execute) noexcept
-        : __source_(__source)
-        , __execute_(__execute) {
-      }
+    constexpr explicit __inplace_stop_callback_base(
+      const inplace_stop_source* __source,
+      __execute_fn_t* __execute) noexcept
+      : __source_(__source)
+      , __execute_(__execute) {
+    }
 
-      constexpr void __register_callback_() noexcept;
+    constexpr void __register_callback_() noexcept;
 
-      friend inplace_stop_source;
+    friend inplace_stop_source;
 
-      const inplace_stop_source* __source_;
-      __execute_fn_t* __execute_;
-      __inplace_stop_callback_base* __next_ = nullptr;
-      __inplace_stop_callback_base** __prev_ptr_ = nullptr;
-      bool* __removed_during_callback_ = nullptr;
-      __std::atomic<bool> __callback_completed_{false};
-    };
+    const inplace_stop_source* __source_;
+    __execute_fn_t* __execute_;
+    __inplace_stop_callback_base* __next_ = nullptr;
+    __inplace_stop_callback_base** __prev_ptr_ = nullptr;
+    bool* __removed_during_callback_ = nullptr;
+    STDEXEC::__std::atomic<bool> __callback_completed_{false};
+  };
 
-    struct __spin_wait {
-      constexpr __spin_wait() noexcept = default;
+  struct __spin_wait {
+    constexpr __spin_wait() noexcept = default;
 
-      void __wait() noexcept {
-        if (__count_++ < __yield_threshold_) {
-          __stok::__pause();
-        } else {
-          if (__count_ == 0) // true if __count_ wrapped around
-            __count_ = __yield_threshold_;
-          std::this_thread::yield();
-        }
+    void __wait() noexcept {
+      if (__count_++ < __yield_threshold_) {
+        STDEXEC::__stok::__pause();
+      } else {
+        if (__count_ == 0) // true if __count_ wrapped around
+          __count_ = __yield_threshold_;
+        std::this_thread::yield();
       }
-
-     private:
-      static constexpr uint32_t __yield_threshold_ = 20;
-      uint32_t __count_ = 0;
-    };
-  } // namespace __stok
-
-  template <class _Callback>
-  class inplace_stop_callback;
-
-  // [stopsource.inplace], class inplace_stop_source
-  class inplace_stop_source {
-   public:
-    inplace_stop_source() noexcept = default;
-    ~inplace_stop_source();
-    inplace_stop_source(inplace_stop_source&&) = delete;
-
-    constexpr auto get_token() const noexcept -> inplace_stop_token;
-
-    auto request_stop() noexcept -> bool;
-
-    auto stop_requested() const noexcept -> bool {
-      return (__state_.load(__std::memory_order_acquire) & __stop_requested_flag_) != 0;
     }
 
    private:
-    friend inplace_stop_token;
-    friend __stok::__inplace_stop_callback_base;
-    template <class>
-    friend class inplace_stop_callback;
+    static constexpr uint32_t __yield_threshold_ = 20;
+    uint32_t __count_ = 0;
+  };
 
-    auto __lock_() const noexcept -> uint8_t;
-    void __unlock_(uint8_t) const noexcept;
+  using __get_stop_token_t =
+    STDEXEC::__query<get_stop_token_t, never_stop_token{}, STDEXEC::__q1<STDEXEC::__decay_t>>;
+} // namespace STDEXEC::__stok
 
-    auto __try_lock_unless_stop_requested_(bool) const noexcept -> bool;
+STDEXEC_P2300_NAMESPACE_BEGIN()
+template <class _Callback>
+class inplace_stop_callback;
 
-    auto __try_add_callback_(__stok::__inplace_stop_callback_base*) const noexcept -> bool;
+// [stopsource.inplace], class inplace_stop_source
+class inplace_stop_source {
+ public:
+  inplace_stop_source() noexcept = default;
+  ~inplace_stop_source();
+  inplace_stop_source(inplace_stop_source&&) = delete;
 
-    void __remove_callback_(__stok::__inplace_stop_callback_base*) const noexcept;
+  constexpr auto get_token() const noexcept -> inplace_stop_token;
 
-    static constexpr uint8_t __stop_requested_flag_ = 1;
-    static constexpr uint8_t __locked_flag_ = 2;
+  auto request_stop() noexcept -> bool;
 
-    mutable __std::atomic<uint8_t> __state_{0};
-    mutable __stok::__inplace_stop_callback_base* __callbacks_ = nullptr;
-    std::thread::id __notifying_thread_;
-  };
+  auto stop_requested() const noexcept -> bool {
+    return (__state_.load(STDEXEC::__std::memory_order_acquire) & __stop_requested_flag_) != 0;
+  }
 
-  // [stoptoken.inplace], class inplace_stop_token
-  class inplace_stop_token {
-   public:
-    template <class _Fun>
-    using callback_type = inplace_stop_callback<_Fun>;
+ private:
+  friend inplace_stop_token;
+  friend STDEXEC::__stok::__inplace_stop_callback_base;
+  template <class>
+  friend class inplace_stop_callback;
 
-    constexpr inplace_stop_token() noexcept
-      : __source_(nullptr) {
-    }
+  auto __lock_() const noexcept -> uint8_t;
+  void __unlock_(uint8_t) const noexcept;
 
-    constexpr inplace_stop_token(const inplace_stop_token& __other) noexcept = default;
+  auto __try_lock_unless_stop_requested_(bool) const noexcept -> bool;
 
-    constexpr inplace_stop_token(inplace_stop_token&& __other) noexcept
-      : __source_(std::exchange(__other.__source_, {})) {
-    }
+  auto __try_add_callback_(STDEXEC::__stok::__inplace_stop_callback_base*) const noexcept -> bool;
 
-    constexpr auto
-      operator=(const inplace_stop_token& __other) noexcept -> inplace_stop_token& = default;
+  void __remove_callback_(STDEXEC::__stok::__inplace_stop_callback_base*) const noexcept;
 
-    constexpr auto operator=(inplace_stop_token&& __other) noexcept -> inplace_stop_token& {
-      __source_ = std::exchange(__other.__source_, nullptr);
-      return *this;
-    }
+  static constexpr uint8_t __stop_requested_flag_ = 1;
+  static constexpr uint8_t __locked_flag_ = 2;
 
-    [[nodiscard]]
-    constexpr auto stop_requested() const noexcept -> bool {
-      return __source_ != nullptr && __source_->stop_requested();
-    }
+  mutable STDEXEC::__std::atomic<uint8_t> __state_{0};
+  mutable STDEXEC::__stok::__inplace_stop_callback_base* __callbacks_ = nullptr;
+  std::thread::id __notifying_thread_;
+};
 
-    [[nodiscard]]
-    constexpr auto stop_possible() const noexcept -> bool {
-      return __source_ != nullptr;
-    }
+// [stoptoken.inplace], class inplace_stop_token
+class inplace_stop_token {
+ public:
+  template <class _Fun>
+  using callback_type = inplace_stop_callback<_Fun>;
 
-    constexpr void swap(inplace_stop_token& __other) noexcept {
-      std::swap(__source_, __other.__source_);
-    }
+  constexpr inplace_stop_token() noexcept
+    : __source_(nullptr) {
+  }
 
-    constexpr auto operator==(const inplace_stop_token&) const noexcept -> bool = default;
+  constexpr inplace_stop_token(const inplace_stop_token& __other) noexcept = default;
 
-   private:
-    friend inplace_stop_source;
-    template <class>
-    friend class inplace_stop_callback;
+  constexpr inplace_stop_token(inplace_stop_token&& __other) noexcept
+    : __source_(std::exchange(__other.__source_, {})) {
+  }
 
-    constexpr explicit inplace_stop_token(const inplace_stop_source* __source) noexcept
-      : __source_(__source) {
-    }
+  constexpr auto
+    operator=(const inplace_stop_token& __other) noexcept -> inplace_stop_token& = default;
 
-    const inplace_stop_source* __source_;
-  };
+  constexpr auto operator=(inplace_stop_token&& __other) noexcept -> inplace_stop_token& {
+    __source_ = std::exchange(__other.__source_, nullptr);
+    return *this;
+  }
 
-  inline constexpr auto inplace_stop_source::get_token() const noexcept -> inplace_stop_token {
-    return inplace_stop_token{this};
+  [[nodiscard]]
+  constexpr auto stop_requested() const noexcept -> bool {
+    return __source_ != nullptr && __source_->stop_requested();
   }
 
-  // [stopcallback.inplace], class template inplace_stop_callback
-  template <class _Fun>
-  class inplace_stop_callback : __stok::__inplace_stop_callback_base {
-   public:
-    template <class _Fun2>
-      requires __std::constructible_from<_Fun, _Fun2>
-    explicit inplace_stop_callback(inplace_stop_token __token, _Fun2&& __fun)
-      noexcept(__nothrow_constructible_from<_Fun, _Fun2>)
-      : __stok::__inplace_stop_callback_base(
-          __token.__source_,
-          &inplace_stop_callback::__execute_impl_)
-      , __fun_(static_cast<_Fun2&&>(__fun)) {
-      __register_callback_();
-    }
+  [[nodiscard]]
+  constexpr auto stop_possible() const noexcept -> bool {
+    return __source_ != nullptr;
+  }
 
-    constexpr ~inplace_stop_callback() {
-      if (__source_ != nullptr)
-        __source_->__remove_callback_(this);
-    }
+  constexpr void swap(inplace_stop_token& __other) noexcept {
+    std::swap(__source_, __other.__source_);
+  }
 
-   private:
-    static constexpr void __execute_impl_(__stok::__inplace_stop_callback_base* cb) noexcept {
-      std::move(static_cast<inplace_stop_callback*>(cb)->__fun_)();
-    }
+  constexpr auto operator==(const inplace_stop_token&) const noexcept -> bool = default;
 
-    STDEXEC_ATTRIBUTE(no_unique_address) _Fun __fun_;
-  };
+ private:
+  friend inplace_stop_source;
+  template <class>
+  friend class inplace_stop_callback;
 
-  namespace __stok {
-    inline constexpr void __inplace_stop_callback_base::__register_callback_() noexcept {
-      if (__source_ != nullptr) {
-        if (!__source_->__try_add_callback_(this)) {
-          __source_ = nullptr;
-          // Callback not registered because stop_requested() was true.
-          // Execute inline here.
-          __execute();
-        }
-      }
-    }
-  } // namespace __stok
+  constexpr explicit inplace_stop_token(const inplace_stop_source* __source) noexcept
+    : __source_(__source) {
+  }
+
+  const inplace_stop_source* __source_;
+};
+
+inline constexpr auto inplace_stop_source::get_token() const noexcept -> inplace_stop_token {
+  return inplace_stop_token{this};
+}
+
+// [stopcallback.inplace], class template inplace_stop_callback
+template <class _Fun>
+class inplace_stop_callback : STDEXEC::__stok::__inplace_stop_callback_base {
+ public:
+  template <class _Fun2>
+    requires STDEXEC::__std::constructible_from<_Fun, _Fun2>
+  explicit inplace_stop_callback(inplace_stop_token __token, _Fun2&& __fun)
+    noexcept(STDEXEC::__nothrow_constructible_from<_Fun, _Fun2>)
+    : STDEXEC::__stok::__inplace_stop_callback_base(
+        __token.__source_,
+        &inplace_stop_callback::__execute_impl_)
+    , __fun_(static_cast<_Fun2&&>(__fun)) {
+    __register_callback_();
+  }
+
+  constexpr ~inplace_stop_callback() {
+    if (__source_ != nullptr)
+      __source_->__remove_callback_(this);
+  }
 
-  inline inplace_stop_source::~inplace_stop_source() {
-    STDEXEC_ASSERT((__state_.load(__std::memory_order_relaxed) & __locked_flag_) == 0);
-    STDEXEC_ASSERT(__callbacks_ == nullptr);
+ private:
+  static constexpr void
+    __execute_impl_(STDEXEC::__stok::__inplace_stop_callback_base* cb) noexcept {
+    std::move(static_cast<inplace_stop_callback*>(cb)->__fun_)();
   }
 
-  inline auto inplace_stop_source::request_stop() noexcept -> bool {
-    if (!__try_lock_unless_stop_requested_(true))
-      return true;
+  STDEXEC_ATTRIBUTE(no_unique_address) _Fun __fun_;
+};
+
+inline inplace_stop_source::~inplace_stop_source() {
+  STDEXEC_ASSERT((__state_.load(STDEXEC::__std::memory_order_relaxed) & __locked_flag_) == 0);
+  STDEXEC_ASSERT(__callbacks_ == nullptr);
+}
 
-    __notifying_thread_ = std::this_thread::get_id();
+inline auto inplace_stop_source::request_stop() noexcept -> bool {
+  if (!__try_lock_unless_stop_requested_(true))
+    return true;
 
-    // We are responsible for executing callbacks.
-    while (__callbacks_ != nullptr) {
-      auto* __callbk = __callbacks_;
-      __callbk->__prev_ptr_ = nullptr;
-      __callbacks_ = __callbk->__next_;
-      if (__callbacks_ != nullptr)
-        __callbacks_->__prev_ptr_ = &__callbacks_;
+  __notifying_thread_ = std::this_thread::get_id();
 
-      __state_.store(__stop_requested_flag_, __std::memory_order_release);
+  // We are responsible for executing callbacks.
+  while (__callbacks_ != nullptr) {
+    auto* __callbk = __callbacks_;
+    __callbk->__prev_ptr_ = nullptr;
+    __callbacks_ = __callbk->__next_;
+    if (__callbacks_ != nullptr)
+      __callbacks_->__prev_ptr_ = &__callbacks_;
 
-      bool __removed_during_callback = false;
-      __callbk->__removed_during_callback_ = &__removed_during_callback;
+    __state_.store(__stop_requested_flag_, STDEXEC::__std::memory_order_release);
 
-      __callbk->__execute();
+    bool __removed_during_callback = false;
+    __callbk->__removed_during_callback_ = &__removed_during_callback;
 
-      if (!__removed_during_callback) {
-        __callbk->__removed_during_callback_ = nullptr;
-        __callbk->__callback_completed_.store(true, __std::memory_order_release);
-      }
+    __callbk->__execute();
 
-      __lock_();
+    if (!__removed_during_callback) {
+      __callbk->__removed_during_callback_ = nullptr;
+      __callbk->__callback_completed_.store(true, STDEXEC::__std::memory_order_release);
     }
 
-    __state_.store(__stop_requested_flag_, __std::memory_order_release);
-    return false;
+    __lock_();
   }
 
-  inline auto inplace_stop_source::__lock_() const noexcept -> uint8_t {
-    __stok::__spin_wait __spin;
-    auto __old_state = __state_.load(__std::memory_order_relaxed);
-    do {
-      while ((__old_state & __locked_flag_) != 0) {
+  __state_.store(__stop_requested_flag_, STDEXEC::__std::memory_order_release);
+  return false;
+}
+
+inline auto inplace_stop_source::__lock_() const noexcept -> uint8_t {
+  STDEXEC::__stok::__spin_wait __spin;
+  auto __old_state = __state_.load(STDEXEC::__std::memory_order_relaxed);
+  do {
+    while ((__old_state & __locked_flag_) != 0) {
+      __spin.__wait();
+      __old_state = __state_.load(STDEXEC::__std::memory_order_relaxed);
+    }
+  } while (!__state_.compare_exchange_weak(
+    __old_state,
+    __old_state | __locked_flag_,
+    STDEXEC::__std::memory_order_acquire,
+    STDEXEC::__std::memory_order_relaxed));
+
+  return __old_state;
+}
+
+inline void inplace_stop_source::__unlock_(uint8_t __old_state) const noexcept {
+  (void) __state_.store(__old_state, STDEXEC::__std::memory_order_release);
+}
+
+inline auto
+  inplace_stop_source::__try_lock_unless_stop_requested_(bool __set_stop_requested) const noexcept
+  -> bool {
+  STDEXEC::__stok::__spin_wait __spin;
+  auto __old_state = __state_.load(STDEXEC::__std::memory_order_relaxed);
+  do {
+    while (true) {
+      if ((__old_state & __stop_requested_flag_) != 0) {
+        // Stop already requested.
+        return false;
+      } else if (__old_state == 0) {
+        break;
+      } else {
         __spin.__wait();
-        __old_state = __state_.load(__std::memory_order_relaxed);
+        __old_state = __state_.load(STDEXEC::__std::memory_order_relaxed);
       }
-    } while (!__state_.compare_exchange_weak(
-      __old_state,
-      __old_state | __locked_flag_,
-      __std::memory_order_acquire,
-      __std::memory_order_relaxed));
-
-    return __old_state;
+    }
+  } while (!__state_.compare_exchange_weak(
+    __old_state,
+    __set_stop_requested ? (__locked_flag_ | __stop_requested_flag_) : __locked_flag_,
+    STDEXEC::__std::memory_order_acq_rel,
+    STDEXEC::__std::memory_order_relaxed));
+
+  // Lock acquired successfully
+  return true;
+}
+
+inline auto inplace_stop_source::__try_add_callback_(
+  STDEXEC::__stok::__inplace_stop_callback_base* __callbk) const noexcept -> bool {
+  if (!__try_lock_unless_stop_requested_(false)) {
+    return false;
   }
 
-  inline void inplace_stop_source::__unlock_(uint8_t __old_state) const noexcept {
-    (void) __state_.store(__old_state, __std::memory_order_release);
+  __callbk->__next_ = __callbacks_;
+  __callbk->__prev_ptr_ = &__callbacks_;
+  if (__callbacks_ != nullptr) {
+    __callbacks_->__prev_ptr_ = &__callbk->__next_;
   }
+  __callbacks_ = __callbk;
 
-  inline auto
-    inplace_stop_source::__try_lock_unless_stop_requested_(bool __set_stop_requested) const noexcept
-    -> bool {
-    __stok::__spin_wait __spin;
-    auto __old_state = __state_.load(__std::memory_order_relaxed);
-    do {
-      while (true) {
-        if ((__old_state & __stop_requested_flag_) != 0) {
-          // Stop already requested.
-          return false;
-        } else if (__old_state == 0) {
-          break;
-        } else {
-          __spin.__wait();
-          __old_state = __state_.load(__std::memory_order_relaxed);
-        }
-      }
-    } while (!__state_.compare_exchange_weak(
-      __old_state,
-      __set_stop_requested ? (__locked_flag_ | __stop_requested_flag_) : __locked_flag_,
-      __std::memory_order_acq_rel,
-      __std::memory_order_relaxed));
+  __unlock_(0);
 
-    // Lock acquired successfully
-    return true;
-  }
+  return true;
+}
 
-  inline auto inplace_stop_source::__try_add_callback_(
-    __stok::__inplace_stop_callback_base* __callbk) const noexcept -> bool {
-    if (!__try_lock_unless_stop_requested_(false)) {
-      return false;
-    }
+inline void inplace_stop_source::__remove_callback_(
+  STDEXEC::__stok::__inplace_stop_callback_base* __callbk) const noexcept {
+  auto __old_state = __lock_();
 
-    __callbk->__next_ = __callbacks_;
-    __callbk->__prev_ptr_ = &__callbacks_;
-    if (__callbacks_ != nullptr) {
-      __callbacks_->__prev_ptr_ = &__callbk->__next_;
+  if (__callbk->__prev_ptr_ != nullptr) {
+    // Callback has not been executed yet.
+    // Remove from the list.
+    *__callbk->__prev_ptr_ = __callbk->__next_;
+    if (__callbk->__next_ != nullptr) {
+      __callbk->__next_->__prev_ptr_ = __callbk->__prev_ptr_;
     }
-    __callbacks_ = __callbk;
+    __unlock_(__old_state);
+  } else {
+    auto __notifying_thread = __notifying_thread_;
+    __unlock_(__old_state);
+
+    // Callback has either already been executed or is
+    // currently executing on another thread.
+    if (std::this_thread::get_id() == __notifying_thread) {
+      if (__callbk->__removed_during_callback_ != nullptr) {
+        *__callbk->__removed_during_callback_ = true;
+      }
+    } else {
+      // Concurrently executing on another thread.
+      // Wait until the other thread finishes executing the callback.
+      STDEXEC::__stok::__spin_wait __spin;
+      while (!__callbk->__callback_completed_.load(STDEXEC::__std::memory_order_acquire)) {
+        __spin.__wait();
+      }
+    }
+  }
+}
 
-    __unlock_(0);
+struct get_stop_token_t : STDEXEC::__stok::__get_stop_token_t {
+  using STDEXEC::__stok::__get_stop_token_t::operator();
 
+  // defined in __read_env.hpp
+  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+  constexpr auto operator()() const noexcept;
+
+  template <class _Env>
+  STDEXEC_ATTRIBUTE(always_inline, host, device)
+  static constexpr void __validate() noexcept {
+    static_assert(STDEXEC::__nothrow_callable<get_stop_token_t, const _Env&>);
+    static_assert(stoppable_token<STDEXEC::__call_result_t<get_stop_token_t, const _Env&>>);
+  }
+
+  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+  static consteval auto query(forwarding_query_t) noexcept -> bool {
     return true;
   }
+};
 
-  inline void inplace_stop_source::__remove_callback_(
-    __stok::__inplace_stop_callback_base* __callbk) const noexcept {
-    auto __old_state = __lock_();
+inline constexpr get_stop_token_t get_stop_token{};
 
-    if (__callbk->__prev_ptr_ != nullptr) {
-      // Callback has not been executed yet.
-      // Remove from the list.
-      *__callbk->__prev_ptr_ = __callbk->__next_;
-      if (__callbk->__next_ != nullptr) {
-        __callbk->__next_->__prev_ptr_ = __callbk->__prev_ptr_;
-      }
-      __unlock_(__old_state);
-    } else {
-      auto __notifying_thread = __notifying_thread_;
-      __unlock_(__old_state);
-
-      // Callback has either already been executed or is
-      // currently executing on another thread.
-      if (std::this_thread::get_id() == __notifying_thread) {
-        if (__callbk->__removed_during_callback_ != nullptr) {
-          *__callbk->__removed_during_callback_ = true;
-        }
-      } else {
-        // Concurrently executing on another thread.
-        // Wait until the other thread finishes executing the callback.
-        __stok::__spin_wait __spin;
-        while (!__callbk->__callback_completed_.load(__std::memory_order_acquire)) {
-          __spin.__wait();
+STDEXEC_P2300_NAMESPACE_END()
+
+namespace STDEXEC {
+  namespace __stok {
+    inline constexpr void __inplace_stop_callback_base::__register_callback_() noexcept {
+      if (__source_ != nullptr) {
+        if (!__source_->__try_add_callback_(this)) {
+          __source_ = nullptr;
+          // Callback not registered because stop_requested() was true.
+          // Execute inline here.
+          __execute();
         }
       }
     }
-  }
+  } // namespace __stok
 
   struct __forward_stop_request {
     void operator()() const noexcept {
@@ -374,33 +403,6 @@ namespace STDEXEC {
     inplace_stop_source& __stop_source_;
   };
 
-  namespace __queries {
-    using __get_stop_token_t = __query<get_stop_token_t, never_stop_token{}, __q1<__decay_t>>;
-
-    struct get_stop_token_t : __get_stop_token_t {
-      using __get_stop_token_t::operator();
-
-      // defined in __read_env.hpp
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      constexpr auto operator()() const noexcept;
-
-      template <class _Env>
-      STDEXEC_ATTRIBUTE(always_inline, host, device)
-      static constexpr void __validate() noexcept {
-        static_assert(__nothrow_callable<get_stop_token_t, const _Env&>);
-        static_assert(stoppable_token<__call_result_t<get_stop_token_t, const _Env&>>);
-      }
-
-      STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      static consteval auto query(forwarding_query_t) noexcept -> bool {
-        return true;
-      }
-    };
-  } // namespace __queries
-
-  using __queries::get_stop_token_t;
-  inline constexpr get_stop_token_t get_stop_token{};
-
   using in_place_stop_token
     [[deprecated("in_place_stop_token has been renamed inplace_stop_token")]] = inplace_stop_token;
 
diff --git a/test/exec/async_scope/test_spawn_future.cpp b/test/exec/async_scope/test_spawn_future.cpp
index d3a022e3a..e1ca93d20 100644
--- a/test/exec/async_scope/test_spawn_future.cpp
+++ b/test/exec/async_scope/test_spawn_future.cpp
@@ -9,6 +9,8 @@ namespace ex = STDEXEC;
 using exec::async_scope;
 using ex::sync_wait;
 
+STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
+
 namespace {
   void expect_empty(exec::async_scope& scope) {
     ex::run_loop loop;
diff --git a/test/exec/test_type_async_scope.cpp b/test/exec/test_type_async_scope.cpp
index 8d3938f5d..c9364fcf4 100644
--- a/test/exec/test_type_async_scope.cpp
+++ b/test/exec/test_type_async_scope.cpp
@@ -26,6 +26,8 @@
 
 namespace ex = STDEXEC;
 
+STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
+
 namespace {
   void expect_empty(exec::async_scope& scope) {
     ex::run_loop loop;
diff --git a/test/stdexec/algos/consumers/test_sync_wait.cpp b/test/stdexec/algos/consumers/test_sync_wait.cpp
index 9f0a88241..07149f31d 100644
--- a/test/stdexec/algos/consumers/test_sync_wait.cpp
+++ b/test/stdexec/algos/consumers/test_sync_wait.cpp
@@ -262,4 +262,14 @@ namespace {
       >);
   }
 
+#if STDEXEC_NAMESPACE_IS_WITHIN_STD()
+  TEST_CASE(
+    "std::this_thread::sync_wait is available when STDEXEC is std::execution",
+    "[consumers][sync_wait]") {
+    std::optional<std::tuple<int>> res = std::this_thread::sync_wait(ex::just(49));
+    CHECK(res.has_value());
+    CHECK(std::get<0>(res.value()) == 49);
+  }
+#endif
+
 } // namespace
diff --git a/test/test_common/allocators.hpp b/test/test_common/allocators.hpp
index d375615fe..1ccd8e756 100644
--- a/test/test_common/allocators.hpp
+++ b/test/test_common/allocators.hpp
@@ -19,6 +19,8 @@
 #include <catch2/catch.hpp>
 #include <stdexec/execution.hpp>
 
+#include <new>
+
 namespace ex = STDEXEC;
 
 namespace {
@@ -45,7 +47,11 @@ namespace {
     void deallocate(T* p, std::size_t n) {
       if (bytes_ != nullptr)
         *bytes_ -= n * sizeof(T);
+#if defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 2013'09L
       ::operator delete(p, n * sizeof(T));
+#else
+      ::operator delete(p);
+#endif
     }
 
     bool operator==(const test_allocator&) const = default;