diff --git a/.clang-format b/.clang-format
index 87df19d0d..9028646bf 100644
--- a/.clang-format
+++ b/.clang-format
@@ -86,8 +86,8 @@ InsertTrailingCommas: None
 KeepEmptyLinesAtTheStartOfBlocks: false
 LambdaBodyIndentation: Signature
 LineEnding: LF
-MacroBlockBegin: "^STDEXEC_NAMESPACE_STD_BEGIN$"
-MacroBlockEnd: "^STDEXEC_NAMESPACE_STD_END$"
+MacroBlockBegin: "^STDEXEC_NAMESPACE_STD_BEGIN|STDEXEC_P2300_NAMESPACE_BEGIN$"
+MacroBlockEnd: "^STDEXEC_NAMESPACE_STD_END|STDEXEC_P2300_NAMESPACE_END$"
 Macros: [
   'STDEXEC_CATCH_FALLTHROUGH= ',
   'STDEXEC_EXPLICIT_THIS_BEGIN(...)=__VA_ARGS__',
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index a0b3ec9d5..ec250c127 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -34,3 +34,6 @@ aee392a046a26ae2340849fe98e38332d9537397
 # new formatting style for improved readability
 0cccd586b8d75c64b289e38f334e95846dfb4f33
 72666721b5787c1adcc100dd86c26fbbe8bda82f
+
+# inform clang-format that `STDEXEC_P2300_NAMESPACE_BEGIN()` opens a scope
+9207f741ec54cb8d5e437385a083459da69ccaa6
diff --git a/include/stdexec/__detail/__basic_sender.hpp b/include/stdexec/__detail/__basic_sender.hpp
index f8524ce56..93c4bdf17 100644
--- a/include/stdexec/__detail/__basic_sender.hpp
+++ b/include/stdexec/__detail/__basic_sender.hpp
@@ -111,7 +111,7 @@ namespace STDEXEC
         noexcept(__nothrow_decay_copyable<_CvData>)
         : __rcvr_(static_cast<_Receiver&&>(__rcvr))
         , __data_(STDEXEC::__allocator_aware_forward(static_cast<_CvData&&>(__data), __rcvr_))
-      { }
+      {}
 
       STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
       _Receiver __rcvr_;
diff --git a/include/stdexec/__detail/__execution_fwd.hpp b/include/stdexec/__detail/__execution_fwd.hpp
index e1f3d19b0..82fc4fa59 100644
--- a/include/stdexec/__detail/__execution_fwd.hpp
+++ b/include/stdexec/__detail/__execution_fwd.hpp
@@ -325,30 +325,30 @@ namespace experimental::execution
 namespace exec = experimental::execution;
 
 STDEXEC_P2300_NAMESPACE_BEGIN()
-struct forwarding_query_t;
-struct get_allocator_t;
-struct get_stop_token_t;
-
-extern forwarding_query_t const forwarding_query;
-extern get_allocator_t const    get_allocator;
-extern get_stop_token_t const   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;
+  struct forwarding_query_t;
+  struct get_allocator_t;
+  struct get_stop_token_t;
+
+  extern forwarding_query_t const forwarding_query;
+  extern get_allocator_t const    get_allocator;
+  extern get_stop_token_t const   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 sync_wait_t const              sync_wait;
-extern sync_wait_with_variant_t const sync_wait_with_variant;
+  struct sync_wait_t;
+  struct sync_wait_with_variant_t;
+  extern sync_wait_t const              sync_wait;
+  extern sync_wait_with_variant_t const sync_wait_with_variant;
 STDEXEC_P2300_NAMESPACE_END(this_thread)
 
 // NOT TO SPEC: make sync_wait et. al. available in namespace STDEXEC (possibly
diff --git a/include/stdexec/__detail/__queries.hpp b/include/stdexec/__detail/__queries.hpp
index 62df2b7b7..e96350b2d 100644
--- a/include/stdexec/__detail/__queries.hpp
+++ b/include/stdexec/__detail/__queries.hpp
@@ -134,31 +134,31 @@ namespace STDEXEC
 }  // 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();
+  //////////////////////////////////////////////////////////////////////////////////
+  // [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;
+    // 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, _Env const &>);
-    using __alloc_t = STDEXEC::__call_result_t<get_allocator_t, _Env const &>;
-    static_assert(STDEXEC::__simple_allocator<STDEXEC::__decay_t<__alloc_t>>);
-  }
+    template <class _Env>
+    STDEXEC_ATTRIBUTE(always_inline, host, device)
+    static constexpr void __validate() noexcept
+    {
+      static_assert(STDEXEC::__nothrow_callable<get_allocator_t, _Env const &>);
+      using __alloc_t = STDEXEC::__call_result_t<get_allocator_t, _Env const &>;
+      static_assert(STDEXEC::__simple_allocator<STDEXEC::__decay_t<__alloc_t>>);
+    }
 
-  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-  static consteval auto query(forwarding_query_t) noexcept -> bool
-  {
-    return true;
-  }
-};
+    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{};
+  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 1c694773a..d33c559ac 100644
--- a/include/stdexec/__detail/__query.hpp
+++ b/include/stdexec/__detail/__query.hpp
@@ -149,22 +149,22 @@ namespace STDEXEC
 }  // 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
+  struct forwarding_query_t
   {
-    if constexpr (STDEXEC::__queryable_with<_Query, forwarding_query_t>)
-    {
-      return STDEXEC::__query<forwarding_query_t>()(_Query());
-    }
-    else
+    template <class _Query>
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    consteval auto operator()(_Query) const noexcept -> bool
     {
-      return STDEXEC::__std::derived_from<_Query, forwarding_query_t>;
+      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{};
+  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 5262bf757..69836f473 100644
--- a/include/stdexec/__detail/__read_env.hpp
+++ b/include/stdexec/__detail/__read_env.hpp
@@ -178,15 +178,15 @@ namespace STDEXEC
 }  // 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_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_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/__stop_token.hpp b/include/stdexec/__detail/__stop_token.hpp
index c1339b366..53ee71137 100644
--- a/include/stdexec/__detail/__stop_token.hpp
+++ b/include/stdexec/__detail/__stop_token.hpp
@@ -26,80 +26,80 @@
 
 STDEXEC_P2300_NAMESPACE_BEGIN()
 
-template <template <class> class _Callback>
-struct __check_type_alias_exists;
+  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>
-  using __f = _Token::template callback_type<_Callback>;
-};
+  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 <>
-struct __stop_callback_for<std::stop_token>
-{
-  template <class _Callback>
-  using __f = std::stop_callback<_Callback>;
-};
+  template <>
+  inline constexpr bool __has_stop_callback_v<std::stop_token> = true;
 #endif
 
-template <class _Token, class _Callback>
-using stop_callback_for_t = STDEXEC::__mcall1<__stop_callback_for<_Token>, _Callback>;
-
-template <class _Token>
-concept stoppable_token =
-  requires(_Token const __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
+  template <class _Token>
+  struct __stop_callback_for
   {
-    constexpr explicit __callback_type(never_stop_token, STDEXEC::__ignore) noexcept {}
+    template <class _Callback>
+    using __f = _Token::template callback_type<_Callback>;
   };
- public:
-  template <class>
-  using callback_type = __callback_type;
 
-  static constexpr auto stop_requested() noexcept -> bool
+#if defined(__cpp_lib_jthread) && __cpp_lib_jthread >= 2019'11L
+  template <>
+  struct __stop_callback_for<std::stop_token>
   {
-    return false;
-  }
+    template <class _Callback>
+    using __f = std::stop_callback<_Callback>;
+  };
+#endif
 
-  static constexpr auto stop_possible() noexcept -> bool
+  template <class _Token, class _Callback>
+  using stop_callback_for_t = STDEXEC::__mcall1<__stop_callback_for<_Token>, _Callback>;
+
+  template <class _Token>
+  concept stoppable_token =
+    requires(_Token const __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
   {
-    return false;
-  }
-
-  constexpr auto operator==(never_stop_token const &) const noexcept -> bool = default;
-};
+   private:
+    struct __callback_type
+    {
+      constexpr explicit __callback_type(never_stop_token, STDEXEC::__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;
+    }
+
+    constexpr auto operator==(never_stop_token const &) const noexcept -> bool = default;
+  };
 STDEXEC_P2300_NAMESPACE_END()
 
 namespace STDEXEC
diff --git a/include/stdexec/__detail/__sync_wait.hpp b/include/stdexec/__detail/__sync_wait.hpp
index e0833343a..fb269cf87 100644
--- a/include/stdexec/__detail/__sync_wait.hpp
+++ b/include/stdexec/__detail/__sync_wait.hpp
@@ -192,185 +192,188 @@ namespace STDEXEC::__sync_wait
 }  // 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
+  ////////////////////////////////////////////////////////////////////////////
+  // [execution.senders.consumers.sync_wait]
+  struct sync_wait_t
   {
-    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)
+    template <STDEXEC::sender_in<STDEXEC::__sync_wait::__env> _CvSender>
+    auto operator()(_CvSender&& __sndr) const
     {
-      if constexpr (STDEXEC::__same_as<__domain_t, STDEXEC::default_domain>)
+      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::sender_to<_CvSender, STDEXEC::__sync_wait::__receiver_t<_CvSender>>)
+        if constexpr (STDEXEC::__same_as<__domain_t, STDEXEC::default_domain>)
         {
-          using __opstate_t =
-            STDEXEC::connect_result_t<_CvSender, STDEXEC::__sync_wait::__receiver_t<_CvSender>>;
-          if constexpr (STDEXEC::operation_state<__opstate_t>)
+          if constexpr (STDEXEC::sender_to<_CvSender,
+                                           STDEXEC::__sync_wait::__receiver_t<_CvSender>>)
           {
-            // success path, dispatch to the default domain's sync_wait
-            return STDEXEC::default_domain().apply_sender(*this, static_cast<_CvSender&&>(__sndr));
+            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
           {
-            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.");
+            // 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);
           }
         }
+        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
         {
-          // 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);
+          // success path, dispatch to the custom domain's sync_wait
+          return STDEXEC::apply_sender(__domain_t(), *this, static_cast<_CvSender&&>(__sndr));
         }
       }
-      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));
-      }
     }
-  }
 
-  template <class _CvSender>
-  constexpr auto operator()(_CvSender&&) const
-  {
-    STDEXEC::__diagnose_sender_concept_failure<_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{};
+    template <class _CvSender>
+    constexpr auto operator()(_CvSender&&) const
+    {
+      STDEXEC::__diagnose_sender_concept_failure<_CvSender, STDEXEC::__sync_wait::__env>();
+      // dummy return type to silence follow-on errors
+      return std::optional<std::tuple<int>>{};
+    }
 
-    // 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);
+    /// @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{};
 
-    // Wait for the variant to be filled in.
-    __local_state.__loop_.run();
+      // 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);
 
-    if (__local_state.__eptr_)
-    {
-      std::rethrow_exception(static_cast<std::exception_ptr&&>(__local_state.__eptr_));
-    }
+      // Wait for the variant to be filled in.
+      __local_state.__loop_.run();
 
-    return __result;
-  }
-};
+      if (__local_state.__eptr_)
+      {
+        std::rethrow_exception(static_cast<std::exception_ptr&&>(__local_state.__eptr_));
+      }
 
-////////////////////////////////////////////////////////////////////////////
-// [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,
+      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>
-  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>);
-
-    using _Domain = STDEXEC::__completion_domain_of_t<STDEXEC::set_value_t,
-                                                      _CvSender,
-                                                      STDEXEC::__sync_wait::__env>;
-    return STDEXEC::apply_sender(_Domain(), *this, static_cast<_CvSender&&>(__sndr));
-  }
+                                 _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>);
+
+      using _Domain = STDEXEC::__completion_domain_of_t<STDEXEC::set_value_t,
+                                                        _CvSender,
+                                                        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))))
+    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>>
     {
-      return std::move(std::get<0>(*__opt_values));
+      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;
     }
-    return std::nullopt;
-  }
-};
+  };
 
-inline constexpr sync_wait_t              sync_wait{};
-inline constexpr sync_wait_with_variant_t sync_wait_with_variant{};
+  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 d01cebbba..5d39e69b2 100644
--- a/include/stdexec/stop_token.hpp
+++ b/include/stdexec/stop_token.hpp
@@ -102,334 +102,334 @@ namespace STDEXEC::__stok
 }  // namespace STDEXEC::__stok
 
 STDEXEC_P2300_NAMESPACE_BEGIN()
-template <class _Callback>
-class inplace_stop_callback;
+  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
+  // [stopsource.inplace], class inplace_stop_source
+  class inplace_stop_source
   {
-    return (__state_.load(STDEXEC::__std::memory_order_acquire) & __stop_requested_flag_) != 0;
-  }
+   public:
+    inplace_stop_source() noexcept = default;
+    ~inplace_stop_source();
+    inplace_stop_source(inplace_stop_source&&) = delete;
 
- private:
-  friend inplace_stop_token;
-  friend STDEXEC::__stok::__inplace_stop_callback_base;
-  template <class>
-  friend class inplace_stop_callback;
+    constexpr auto get_token() const noexcept -> inplace_stop_token;
 
-  auto __lock_() const noexcept -> uint8_t;
-  void __unlock_(uint8_t) const noexcept;
+    auto request_stop() noexcept -> bool;
 
-  auto __try_lock_unless_stop_requested_(bool) const noexcept -> bool;
+    auto stop_requested() const noexcept -> bool
+    {
+      return (__state_.load(STDEXEC::__std::memory_order_acquire) & __stop_requested_flag_) != 0;
+    }
 
-  auto __try_add_callback_(STDEXEC::__stok::__inplace_stop_callback_base*) const noexcept -> bool;
+   private:
+    friend inplace_stop_token;
+    friend STDEXEC::__stok::__inplace_stop_callback_base;
+    template <class>
+    friend class inplace_stop_callback;
 
-  void __remove_callback_(STDEXEC::__stok::__inplace_stop_callback_base*) const noexcept;
+    auto __lock_() const noexcept -> uint8_t;
+    void __unlock_(uint8_t) const noexcept;
 
-  static constexpr uint8_t __stop_requested_flag_ = 1;
-  static constexpr uint8_t __locked_flag_         = 2;
+    auto __try_lock_unless_stop_requested_(bool) const noexcept -> bool;
 
-  mutable STDEXEC::__std::atomic<uint8_t>                __state_{0};
-  mutable STDEXEC::__stok::__inplace_stop_callback_base* __callbacks_ = nullptr;
-  std::thread::id                                        __notifying_thread_;
-};
+    auto __try_add_callback_(STDEXEC::__stok::__inplace_stop_callback_base*) const noexcept -> bool;
 
-// [stoptoken.inplace], class inplace_stop_token
-class inplace_stop_token
-{
- public:
-  template <class _Fun>
-  using callback_type = inplace_stop_callback<_Fun>;
+    void __remove_callback_(STDEXEC::__stok::__inplace_stop_callback_base*) const noexcept;
 
-  constexpr inplace_stop_token() noexcept
-    : __source_(nullptr)
-  {}
+    static constexpr uint8_t __stop_requested_flag_ = 1;
+    static constexpr uint8_t __locked_flag_         = 2;
 
-  constexpr inplace_stop_token(inplace_stop_token const & __other) noexcept = default;
+    mutable STDEXEC::__std::atomic<uint8_t>                __state_{0};
+    mutable STDEXEC::__stok::__inplace_stop_callback_base* __callbacks_ = nullptr;
+    std::thread::id                                        __notifying_thread_;
+  };
 
-  constexpr inplace_stop_token(inplace_stop_token&& __other) noexcept
-    : __source_(std::exchange(__other.__source_, {}))
-  {}
+  // [stoptoken.inplace], class inplace_stop_token
+  class inplace_stop_token
+  {
+   public:
+    template <class _Fun>
+    using callback_type = inplace_stop_callback<_Fun>;
 
-  constexpr auto
-  operator=(inplace_stop_token const & __other) noexcept -> inplace_stop_token& = default;
+    constexpr inplace_stop_token() noexcept
+      : __source_(nullptr)
+    {}
 
-  constexpr auto operator=(inplace_stop_token&& __other) noexcept -> inplace_stop_token&
-  {
-    __source_ = std::exchange(__other.__source_, nullptr);
-    return *this;
-  }
+    constexpr inplace_stop_token(inplace_stop_token const & __other) noexcept = default;
 
-  [[nodiscard]]
-  constexpr auto stop_requested() const noexcept -> bool
-  {
-    return __source_ != nullptr && __source_->stop_requested();
-  }
+    constexpr inplace_stop_token(inplace_stop_token&& __other) noexcept
+      : __source_(std::exchange(__other.__source_, {}))
+    {}
 
-  [[nodiscard]]
-  constexpr auto stop_possible() const noexcept -> bool
-  {
-    return __source_ != nullptr;
-  }
+    constexpr auto
+    operator=(inplace_stop_token const & __other) noexcept -> inplace_stop_token& = default;
 
-  constexpr void swap(inplace_stop_token& __other) noexcept
-  {
-    std::swap(__source_, __other.__source_);
-  }
+    constexpr auto operator=(inplace_stop_token&& __other) noexcept -> inplace_stop_token&
+    {
+      __source_ = std::exchange(__other.__source_, nullptr);
+      return *this;
+    }
 
-  constexpr auto operator==(inplace_stop_token const &) const noexcept -> bool = default;
+    [[nodiscard]]
+    constexpr auto stop_requested() const noexcept -> bool
+    {
+      return __source_ != nullptr && __source_->stop_requested();
+    }
 
- private:
-  friend inplace_stop_source;
-  template <class>
-  friend class inplace_stop_callback;
+    [[nodiscard]]
+    constexpr auto stop_possible() const noexcept -> bool
+    {
+      return __source_ != nullptr;
+    }
 
-  constexpr explicit inplace_stop_token(inplace_stop_source const * __source) noexcept
-    : __source_(__source)
-  {}
+    constexpr void swap(inplace_stop_token& __other) noexcept
+    {
+      std::swap(__source_, __other.__source_);
+    }
 
-  inplace_stop_source const * __source_;
-};
+    constexpr auto operator==(inplace_stop_token const &) const noexcept -> bool = default;
 
-inline constexpr auto inplace_stop_source::get_token() const noexcept -> inplace_stop_token
-{
-  return inplace_stop_token{this};
-}
+   private:
+    friend inplace_stop_source;
+    template <class>
+    friend class inplace_stop_callback;
 
-// [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 explicit inplace_stop_token(inplace_stop_source const * __source) noexcept
+      : __source_(__source)
+    {}
+
+    inplace_stop_source const * __source_;
+  };
 
-  constexpr ~inplace_stop_callback()
+  inline constexpr auto inplace_stop_source::get_token() const noexcept -> inplace_stop_token
   {
-    if (__source_ != nullptr)
-      __source_->__remove_callback_(this);
+    return inplace_stop_token{this};
   }
 
- private:
-  static constexpr void __execute_impl_(STDEXEC::__stok::__inplace_stop_callback_base* cb) noexcept
+  // [stopcallback.inplace], class template inplace_stop_callback
+  template <class _Fun>
+  class inplace_stop_callback : STDEXEC::__stok::__inplace_stop_callback_base
   {
-    std::move(static_cast<inplace_stop_callback*>(cb)->__fun_)();
-  }
+   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_();
+    }
 
-  STDEXEC_ATTRIBUTE(no_unique_address) _Fun __fun_;
-};
+    constexpr ~inplace_stop_callback()
+    {
+      if (__source_ != nullptr)
+        __source_->__remove_callback_(this);
+    }
 
-inline inplace_stop_source::~inplace_stop_source()
-{
-  STDEXEC_ASSERT((__state_.load(STDEXEC::__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_;
+  };
 
-  __notifying_thread_ = std::this_thread::get_id();
+  inline inplace_stop_source::~inplace_stop_source()
+  {
+    STDEXEC_ASSERT((__state_.load(STDEXEC::__std::memory_order_relaxed) & __locked_flag_) == 0);
+    STDEXEC_ASSERT(__callbacks_ == nullptr);
+  }
 
-  // We are responsible for executing callbacks.
-  while (__callbacks_ != nullptr)
+  inline auto inplace_stop_source::request_stop() noexcept -> bool
   {
-    auto* __callbk        = __callbacks_;
-    __callbk->__prev_ptr_ = nullptr;
-    __callbacks_          = __callbk->__next_;
-    if (__callbacks_ != nullptr)
-      __callbacks_->__prev_ptr_ = &__callbacks_;
+    if (!__try_lock_unless_stop_requested_(true))
+      return true;
 
-    __state_.store(__stop_requested_flag_, STDEXEC::__std::memory_order_release);
+    __notifying_thread_ = std::this_thread::get_id();
 
-    bool __removed_during_callback       = false;
-    __callbk->__removed_during_callback_ = &__removed_during_callback;
+    // 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_;
 
-    __callbk->__execute();
+      __state_.store(__stop_requested_flag_, STDEXEC::__std::memory_order_release);
 
-    if (!__removed_during_callback)
-    {
-      __callbk->__removed_during_callback_ = nullptr;
-      __callbk->__callback_completed_.store(true, STDEXEC::__std::memory_order_release);
-    }
+      bool __removed_during_callback       = false;
+      __callbk->__removed_during_callback_ = &__removed_during_callback;
 
-    __lock_();
-  }
+      __callbk->__execute();
 
-  __state_.store(__stop_requested_flag_, STDEXEC::__std::memory_order_release);
-  return false;
-}
+      if (!__removed_during_callback)
+      {
+        __callbk->__removed_during_callback_ = nullptr;
+        __callbk->__callback_completed_.store(true, STDEXEC::__std::memory_order_release);
+      }
 
-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);
+      __lock_();
     }
-  }
-  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);
-}
+    __state_.store(__stop_requested_flag_, STDEXEC::__std::memory_order_release);
+    return false;
+  }
 
-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
+  inline auto inplace_stop_source::__lock_() const noexcept -> uint8_t
   {
-    while (true)
+    STDEXEC::__stok::__spin_wait __spin;
+    auto                         __old_state = __state_.load(STDEXEC::__std::memory_order_relaxed);
+    do
     {
-      if ((__old_state & __stop_requested_flag_) != 0)
-      {
-        // Stop already requested.
-        return false;
-      }
-      else if (__old_state == 0)
-      {
-        break;
-      }
-      else
+      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;
   }
-  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))
+
+  inline void inplace_stop_source::__unlock_(uint8_t __old_state) const noexcept
   {
-    return false;
+    (void) __state_.store(__old_state, STDEXEC::__std::memory_order_release);
   }
 
-  __callbk->__next_     = __callbacks_;
-  __callbk->__prev_ptr_ = &__callbacks_;
-  if (__callbacks_ != nullptr)
+  inline auto inplace_stop_source::__try_lock_unless_stop_requested_(bool __set_stop_requested)
+    const noexcept -> bool
   {
-    __callbacks_->__prev_ptr_ = &__callbk->__next_;
+    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(STDEXEC::__std::memory_order_relaxed);
+        }
+      }
+    }
+    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;
   }
-  __callbacks_ = __callbk;
-
-  __unlock_(0);
-
-  return true;
-}
 
-inline void inplace_stop_source::__remove_callback_(
-  STDEXEC::__stok::__inplace_stop_callback_base* __callbk) const noexcept
-{
-  auto __old_state = __lock_();
-
-  if (__callbk->__prev_ptr_ != nullptr)
+  inline auto inplace_stop_source::__try_add_callback_(STDEXEC::__stok::__inplace_stop_callback_base
+                                                       * __callbk) const noexcept -> bool
   {
-    // Callback has not been executed yet.
-    // Remove from the list.
-    *__callbk->__prev_ptr_ = __callbk->__next_;
-    if (__callbk->__next_ != nullptr)
+    if (!__try_lock_unless_stop_requested_(false))
+    {
+      return false;
+    }
+
+    __callbk->__next_     = __callbacks_;
+    __callbk->__prev_ptr_ = &__callbacks_;
+    if (__callbacks_ != nullptr)
     {
-      __callbk->__next_->__prev_ptr_ = __callbk->__prev_ptr_;
+      __callbacks_->__prev_ptr_ = &__callbk->__next_;
     }
-    __unlock_(__old_state);
+    __callbacks_ = __callbk;
+
+    __unlock_(0);
+
+    return true;
   }
-  else
+
+  inline void inplace_stop_source::__remove_callback_(STDEXEC::__stok::__inplace_stop_callback_base
+                                                      * __callbk) const noexcept
   {
-    auto __notifying_thread = __notifying_thread_;
-    __unlock_(__old_state);
+    auto __old_state = __lock_();
 
-    // Callback has either already been executed or is
-    // currently executing on another thread.
-    if (std::this_thread::get_id() == __notifying_thread)
+    if (__callbk->__prev_ptr_ != nullptr)
     {
-      if (__callbk->__removed_during_callback_ != nullptr)
+      // Callback has not been executed yet.
+      // Remove from the list.
+      *__callbk->__prev_ptr_ = __callbk->__next_;
+      if (__callbk->__next_ != nullptr)
       {
-        *__callbk->__removed_during_callback_ = true;
+        __callbk->__next_->__prev_ptr_ = __callbk->__prev_ptr_;
       }
+      __unlock_(__old_state);
     }
     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))
+      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)
       {
-        __spin.__wait();
+        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();
+        }
       }
     }
   }
-}
 
-struct get_stop_token_t : STDEXEC::__stok::__get_stop_token_t
-{
-  using STDEXEC::__stok::__get_stop_token_t::operator();
+  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;
+    // 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, _Env const &>);
-    static_assert(stoppable_token<STDEXEC::__call_result_t<get_stop_token_t, _Env const &>>);
-  }
+    template <class _Env>
+    STDEXEC_ATTRIBUTE(always_inline, host, device)
+    static constexpr void __validate() noexcept
+    {
+      static_assert(STDEXEC::__nothrow_callable<get_stop_token_t, _Env const &>);
+      static_assert(stoppable_token<STDEXEC::__call_result_t<get_stop_token_t, _Env const &>>);
+    }
 
-  STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-  static consteval auto query(forwarding_query_t) noexcept -> bool
-  {
-    return true;
-  }
-};
+    STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+    static consteval auto query(forwarding_query_t) noexcept -> bool
+    {
+      return true;
+    }
+  };
 
-inline constexpr get_stop_token_t get_stop_token{};
+  inline constexpr get_stop_token_t get_stop_token{};
 
 STDEXEC_P2300_NAMESPACE_END()