diff --git a/.clangd b/.clangd
index e823bc7fd..66a926fcf 100644
--- a/.clangd
+++ b/.clangd
@@ -80,6 +80,7 @@ CompileFlags:
     - -profiler
     - -ignore-system
     - "-fconcepts-diagnostics-depth=*"
+    - "-gopt"
 Diagnostics:
   Suppress:
     - "variadic_device_fn"
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 43ad86868..f60da31af 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -74,15 +74,15 @@
             "args": "-v normal ${input:CUDA_TEST_TAGS}",
         },
         {
-            "name": "maxwell_gpu_s (cuda-gdb)",
+            "name": "maxwell_cpu_st (cuda-gdb)",
             "type": "cuda-gdb",
             "request": "launch",
             "stopAtEntry": false,
             "breakOnLaunch": false,
             "internalConsoleOptions": "openOnFirstSessionStart",
-            "program": "${command:cmake.buildDirectory}/examples/nvexec/maxwell_gpu_s",
+            "program": "${command:cmake.buildDirectory}/examples/nvexec/maxwell_cpu_st",
             "cwd": "${command:cmake.buildDirectory}",
-            "args": ["--iterations=1000", "--N=512", "--run-cuda", "--run-stdpar", "--run-stream-scheduler"],
+            "args": ["--iterations=1000", "--N=512", "--run-cpp", "--run-inline-scheduler"],
         },
     ],
     "inputs": [
diff --git a/examples/nvexec/maxwell/common.cuh b/examples/nvexec/maxwell/common.cuh
index 04d5ba7fb..b98082ab8 100644
--- a/examples/nvexec/maxwell/common.cuh
+++ b/examples/nvexec/maxwell/common.cuh
@@ -56,7 +56,6 @@ struct deleter_t {
 };
 
 template <class T>
-STDEXEC_ATTRIBUTE(host, device)
 inline auto allocate_on(bool gpu, std::size_t elements = 1) -> std::unique_ptr<T, deleter_t> {
   T *ptr{};
 
diff --git a/examples/nvexec/maxwell_cpu_mt.cu b/examples/nvexec/maxwell_cpu_mt.cu
index 9f4d9ea31..e0fe7f4ce 100644
--- a/examples/nvexec/maxwell_cpu_mt.cu
+++ b/examples/nvexec/maxwell_cpu_mt.cu
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+// This file causes clangd to crash during parsing
+#if !defined(STDEXEC_CLANGD_INVOKED)
+
 #include "maxwell/snr.cuh"
 #include "maxwell/std.cuh"
 #include "maxwell/stdpar.cuh" // IWYU pragma: keep
@@ -85,3 +88,5 @@ auto main(int argc, char *argv[]) -> int {
   }
 #endif
 }
+
+#endif // !defined(STDEXEC_CLANGD_INVOKED)
diff --git a/examples/nvexec/maxwell_cpu_st.cu b/examples/nvexec/maxwell_cpu_st.cu
index c3d2a56cf..7da9ca143 100644
--- a/examples/nvexec/maxwell_cpu_st.cu
+++ b/examples/nvexec/maxwell_cpu_st.cu
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+// This file causes clangd to crash during parsing
+#if !defined(STDEXEC_CLANGD_INVOKED)
+
 #include "maxwell/snr.cuh"
 #include "maxwell/cpp.cuh"
 
@@ -65,3 +68,5 @@ auto main(int argc, char *argv[]) -> int {
     run_cpp(dt, write_vtk, n_iterations, grid, "CPU (cpp)");
   }
 }
+
+#endif // !defined(STDEXEC_CLANGD_INVOKED)
diff --git a/examples/nvexec/maxwell_distributed.cu b/examples/nvexec/maxwell_distributed.cu
index 81f2d41af..2ec362579 100644
--- a/examples/nvexec/maxwell_distributed.cu
+++ b/examples/nvexec/maxwell_distributed.cu
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+// This file causes clangd to crash during parsing
+#if !defined(STDEXEC_CLANGD_INVOKED)
+
 #include "maxwell/snr.cuh"           // IWYU pragma: keep
 #include "nvexec/stream_context.cuh" // IWYU pragma: keep
 
@@ -512,7 +515,7 @@ auto main(int argc, char *argv[]) -> int {
   }
 
   write();
-#  else
+#  else // ^^ defined(OVERLAP) ^^ // vv !defined(OVERLAP) vv
   for (std::size_t compute_step = 0; compute_step < n_iterations; compute_step++) {
     auto compute_h =
       ex::just()
@@ -531,7 +534,7 @@ auto main(int argc, char *argv[]) -> int {
   }
 
   write();
-#  endif
+#  endif // defined(OVERLAP)
 
   MPI_Barrier(MPI_COMM_WORLD);
   const auto end = std::chrono::system_clock::now();
@@ -550,3 +553,5 @@ auto main(int argc, char *argv[]) -> int {
   MPI_Finalize();
 }
 #endif
+
+#endif // !defined(STDEXEC_CLANGD_INVOKED)
diff --git a/examples/nvexec/maxwell_gpu_m.cu b/examples/nvexec/maxwell_gpu_m.cu
index 5f9102f3b..720e42264 100644
--- a/examples/nvexec/maxwell_gpu_m.cu
+++ b/examples/nvexec/maxwell_gpu_m.cu
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+// This file causes clangd to crash during parsing
+#if !defined(STDEXEC_CLANGD_INVOKED)
+
 #include "maxwell/snr.cuh"
 
 auto main(int argc, char *argv[]) -> int {
@@ -52,3 +55,5 @@ auto main(int argc, char *argv[]) -> int {
   nvexec::multi_gpu_stream_context stream_context{};
   run_snr_on("GPU (multi-GPU)", stream_context.get_scheduler());
 }
+
+#endif // !defined(STDEXEC_CLANGD_INVOKED)
diff --git a/examples/nvexec/maxwell_gpu_s.cu b/examples/nvexec/maxwell_gpu_s.cu
index fdb76ee33..9a1ecbcd8 100644
--- a/examples/nvexec/maxwell_gpu_s.cu
+++ b/examples/nvexec/maxwell_gpu_s.cu
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+// This file causes clangd to crash during parsing
+#if !defined(STDEXEC_CLANGD_INVOKED)
+
 #include "maxwell/snr.cuh"
 #include "maxwell/stdpar.cuh" // IWYU pragma: keep
 #include "maxwell/cuda.cuh"
@@ -79,5 +82,7 @@ auto main(int argc, char *argv[]) -> int {
 
     run_stdpar(dt, write_vtk, n_iterations, grid, stdexec::par_unseq, method);
   }
-#endif
+#endif // STDEXEC_HAS_PARALLEL_ALGORITHMS()
 }
+
+#endif // !defined(STDEXEC_CLANGD_INVOKED)
diff --git a/include/exec/sequence.hpp b/include/exec/sequence.hpp
index 79cf75d91..ab5cc11ab 100644
--- a/include/exec/sequence.hpp
+++ b/include/exec/sequence.hpp
@@ -186,15 +186,15 @@ namespace exec {
         stdexec::__minvoke<stdexec::__mfold_left<void, stdexec::__q2<_fold_fn>>, Sndrs...>;
     };
 
-    template <class... Sndrs>
-    struct _sndr {
+    template <class Sndr0, class... Sndrs>
+    struct _sndr<Sndr0, Sndrs...> {
       using sender_concept = stdexec::sender_t;
 
       template <class... Env>
-      using _completions_t = stdexec::__minvoke<_completions<Env...>, Sndrs...>;
+      using _completions_t = stdexec::__minvoke<_completions<Env...>, Sndr0, Sndrs...>;
 
       template <class Self, class... Env>
-        requires(stdexec::__decay_copyable<stdexec::__copy_cvref_t<Self, Sndrs>> && ...)
+        requires stdexec::__decay_copyable<Self>
       STDEXEC_ATTRIBUTE(host, device)
       STDEXEC_EXPLICIT_THIS_BEGIN(auto get_completion_signatures)(this Self&&, Env&&...)
         -> _completions_t<Env...> {
@@ -203,17 +203,17 @@ namespace exec {
       STDEXEC_EXPLICIT_THIS_END(get_completion_signatures)
 
       template <class Self, class Rcvr>
-        requires(stdexec::__decay_copyable<stdexec::__copy_cvref_t<Self, Sndrs>> && ...)
+        requires stdexec::__decay_copyable<Self>
       STDEXEC_ATTRIBUTE(host, device)
       STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Rcvr rcvr) {
-        return _opstate<Rcvr, Sndrs...>{
+        return _opstate<Rcvr, stdexec::__copy_cvref_t<Self, Sndr0>, Sndrs...>{
           static_cast<Rcvr&&>(rcvr), static_cast<Self&&>(self)._sndrs};
       }
       STDEXEC_EXPLICIT_THIS_END(connect)
 
       STDEXEC_ATTRIBUTE(no_unique_address, maybe_unused) sequence_t _tag;
       STDEXEC_ATTRIBUTE(no_unique_address, maybe_unused) stdexec::__ignore _ignore;
-      stdexec::__tuple<Sndrs...> _sndrs;
+      stdexec::__tuple<Sndr0, Sndrs...> _sndrs;
     };
 
     template <class Sndr>
diff --git a/include/exec/sequence/merge_each.hpp b/include/exec/sequence/merge_each.hpp
index 4c926fb07..af92504d8 100644
--- a/include/exec/sequence/merge_each.hpp
+++ b/include/exec/sequence/merge_each.hpp
@@ -32,7 +32,6 @@
 #include "../../stdexec/__detail/__senders_core.hpp"
 #include "../../stdexec/__detail/__stop_token.hpp"
 #include "../../stdexec/__detail/__transform_completion_signatures.hpp"
-#include "../../stdexec/__detail/__unstoppable.hpp"
 #include "../../stdexec/__detail/__variant.hpp"
 
 #include <atomic>
@@ -240,7 +239,7 @@ namespace exec {
 
         __operation_base_interface_t* __op_;
 
-        template <std::same_as<__t> _Self, class... _Env>
+        template <class _Self, class... _Env>
         STDEXEC_EXPLICIT_THIS_BEGIN(
           auto get_completion_signatures)(this _Self&&, _Env&&...) noexcept
           -> stdexec::__mapply<
@@ -252,8 +251,9 @@ namespace exec {
           > {
           return {};
         }
+        STDEXEC_EXPLICIT_THIS_END(get_completion_signatures)
 
-        template <std::same_as<__t> _Self, receiver _ErrorReceiver>
+        template <class _Self, receiver _ErrorReceiver>
         STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this _Self&& __self, _ErrorReceiver&& __rcvr)
           noexcept(__nothrow_move_constructible<_ErrorReceiver>)
             -> __error_op_t<stdexec::__id<_ErrorReceiver>> {
@@ -607,7 +607,7 @@ namespace exec {
         _NestedValueSender __nested_value_;
         __operation_base_interface_t* __op_;
 
-        template <std::same_as<__t> _Self, class... _Env>
+        template <class _Self, class... _Env>
         STDEXEC_EXPLICIT_THIS_BEGIN(
           auto get_completion_signatures)(this _Self&&, _Env&&...) noexcept
           -> stdexec::transform_completion_signatures<
@@ -618,8 +618,9 @@ namespace exec {
           > {
           return {};
         }
+        STDEXEC_EXPLICIT_THIS_END(get_completion_signatures)
 
-        template <std::same_as<__t> _Self, receiver _NestedValueReceiver>
+        template <class _Self, receiver _NestedValueReceiver>
         STDEXEC_EXPLICIT_THIS_BEGIN(
           auto connect)(this _Self&& __self, _NestedValueReceiver&& __rcvr)
           noexcept(__nothrow_constructible_from<
@@ -1072,14 +1073,16 @@ namespace exec {
         _OperationBase* __op_;
         _NestedSequenceSender __nested_sequence_;
 
-        template <std::same_as<__t> _Self, class... _Env>
+        template <class _Self, class... _Env>
         STDEXEC_EXPLICIT_THIS_BEGIN(
           auto get_completion_signatures)(this _Self&&, _Env&&...) noexcept
           -> stdexec::completion_signatures<stdexec::set_value_t(), stdexec::set_stopped_t()> {
           return {};
         }
+        STDEXEC_EXPLICIT_THIS_END(get_completion_signatures)
 
-        template <std::same_as<__t> _Self, receiver _NextReceiver>
+
+        template <class _Self, receiver _NextReceiver>
         STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this _Self&& __self, _NextReceiver&& __rcvr)
           noexcept(__nothrow_constructible_from<
                    __next_sequence_op_t<stdexec::__id<_NextReceiver>>,
diff --git a/include/exec/when_any.hpp b/include/exec/when_any.hpp
index be924e36f..f45ff78fb 100644
--- a/include/exec/when_any.hpp
+++ b/include/exec/when_any.hpp
@@ -274,10 +274,6 @@ namespace exec {
         template <class _Self, class... _Env>
         STDEXEC_EXPLICIT_THIS_BEGIN(
           auto get_completion_signatures)(this _Self&&, const _Env&...) noexcept {
-          static_assert(__decay_copyable<_Self>);
-          static_assert(
-            (__decay_copyable<__copy_cvref_t<_Self, stdexec::__t<_SenderIds>>> && ...),
-            "All senders passed to when_any must be copyable.");
           return __mexception<
             _SENDER_TYPE_IS_NOT_COPYABLE_,
             _WITH_SENDERS_<stdexec::__t<_SenderIds>>...
diff --git a/include/nvexec/stream/continues_on.cuh b/include/nvexec/stream/continues_on.cuh
index 21e39acae..56b77fa71 100644
--- a/include/nvexec/stream/continues_on.cuh
+++ b/include/nvexec/stream/continues_on.cuh
@@ -161,19 +161,19 @@ namespace nvexec::_strm {
         : sndr_(schedule_from(static_cast<Sender&&>(sndr))) {
       }
 
-      template <__decays_to<source_sender_t> Self, receiver Receiver>
+      template <__decay_copyable Self, receiver Receiver>
       STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Receiver rcvr)
         -> connect_result_t<__copy_cvref_t<Self, schedule_from_sender_t>, Receiver> {
         return stdexec::connect(static_cast<Self&&>(self).sndr_, static_cast<Receiver&&>(rcvr));
       }
       STDEXEC_EXPLICIT_THIS_END(connect)
 
-      template <__decays_to<source_sender_t> _Self, class... _Env>
+      template <__decay_copyable _Self, class... _Env>
       STDEXEC_EXPLICIT_THIS_BEGIN(auto get_completion_signatures)(this _Self&&, _Env&&...)
         -> __completion_signatures_of_t<__copy_cvref_t<_Self, Sender>, _Env...> {
         return {};
       }
-        STDEXEC_EXPLICIT_THIS_END(get_completion_signatures)
+      STDEXEC_EXPLICIT_THIS_END(get_completion_signatures)
 
       [[nodiscard]]
       auto get_env() const noexcept -> env_of_t<const Sender&> {
diff --git a/include/stdexec/__detail/__completion_signatures.hpp b/include/stdexec/__detail/__completion_signatures.hpp
index 3e5fb4338..afbde4e16 100644
--- a/include/stdexec/__detail/__completion_signatures.hpp
+++ b/include/stdexec/__detail/__completion_signatures.hpp
@@ -124,18 +124,22 @@ namespace stdexec {
         (__declval<__undefined<__partitions<>>&>() * ... * static_cast<_Sigs*>(nullptr))));
 
     template <class _Completions>
-    using __partitions_of_t = typename _Completions::__partitioned::__t;
+    using __partitions_of_t = _Completions::__partitioned::__t;
   } // namespace __sigs
 
   ////////////////////////////////////////////////////////////////////////////////////////////////////
   // completion signatures type traits
+  template <class _Completions>
+  concept __valid_completion_signatures = __ok<_Completions>
+                                       && __sigs::__is_completion_signatures<_Completions>;
+
   template <
     class _Sigs,
     class _Tuple = __qq<__decayed_std_tuple>,
     class _Variant = __qq<__std_variant>
   >
   using __value_types_t =
-    typename __sigs::__partitions_of_t<_Sigs>::template __value_types<_Tuple, _Variant>;
+    __sigs::__partitions_of_t<_Sigs>::template __value_types<_Tuple, _Variant>;
 
   template <
     class _Sndr,
@@ -157,7 +161,7 @@ namespace stdexec {
 
   template <class _Sigs, class _Variant = __qq<__std_variant>, class _Transform = __q1<__midentity>>
   using __error_types_t =
-    typename __sigs::__partitions_of_t<_Sigs>::template __error_types<_Variant, _Transform>;
+    __sigs::__partitions_of_t<_Sigs>::template __error_types<_Variant, _Transform>;
 
   template <
     class _Sender,
@@ -174,13 +178,14 @@ namespace stdexec {
 
   template <class _Sigs, class _Variant, class _Type = set_stopped_t()>
   using __stopped_types_t =
-    typename __sigs::__partitions_of_t<_Sigs>::template __stopped_types<_Variant, _Type>;
+    __sigs::__partitions_of_t<_Sigs>::template __stopped_types<_Variant, _Type>;
 
-  template <class _Sigs>
+  template <__valid_completion_signatures _Sigs>
   inline constexpr bool __sends_stopped =
     __v<typename __sigs::__partitions_of_t<_Sigs>::__count_stopped> != 0;
 
   template <class _Sndr, class... _Env>
+    requires __valid_completion_signatures<__completion_signatures_of_t<_Sndr, _Env...>>
   inline constexpr bool sends_stopped =
     __sends_stopped<__completion_signatures_of_t<_Sndr, _Env...>>;
 
@@ -396,11 +401,6 @@ namespace stdexec {
   using __single_value_variant_sender_t =
     __value_types_t<__completion_signatures_of_t<_Sender, _Env...>, __qq<__types>, __qq<__msingle>>;
 
-
-  template <class _Completions>
-  concept __valid_completion_signatures = __same_as<__ok_t<_Completions>, __msuccess>
-                                       && __sigs::__is_completion_signatures<_Completions>;
-
   template <class _Sender, class... _Env>
   using __unrecognized_sender_error =
     __mexception<_UNRECOGNIZED_SENDER_TYPE_<>, _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>...>;
diff --git a/include/stdexec/__detail/__diagnostics.hpp b/include/stdexec/__detail/__diagnostics.hpp
index dc9e0b9ab..346310790 100644
--- a/include/stdexec/__detail/__diagnostics.hpp
+++ b/include/stdexec/__detail/__diagnostics.hpp
@@ -176,29 +176,35 @@ namespace stdexec {
     char const * what_;
   };
 
-  namespace __detail {
-    template <class _Sender>
-    struct __dependent_sender_error : dependent_sender_error {
-      constexpr __dependent_sender_error() noexcept
-        : dependent_sender_error{
-            "This sender needs to know its execution environment before it can know how it will "
-            "complete."} {
-      }
+  template <class _Sender>
+  struct __dependent_sender_error : dependent_sender_error {
+    constexpr __dependent_sender_error() noexcept
+      : dependent_sender_error{
+          "This sender needs to know its execution environment before it can know how it will "
+          "complete."} {
+    }
 
-      STDEXEC_ATTRIBUTE(host, device) auto operator+() -> __dependent_sender_error;
+    STDEXEC_ATTRIBUTE(host, device) auto operator+() -> __dependent_sender_error;
 
-      template <class Ty>
-      STDEXEC_ATTRIBUTE(host, device)
-      auto operator,(Ty&) -> __dependent_sender_error&;
+    template <class Ty>
+    STDEXEC_ATTRIBUTE(host, device)
+    auto operator,(Ty&) -> __dependent_sender_error&;
 
-      template <class... What>
-      STDEXEC_ATTRIBUTE(host, device)
-      auto operator,(stdexec::_ERROR_<What...>&) -> stdexec::_ERROR_<What...>&;
-    };
-  } // namespace __detail
+    template <class... What>
+    STDEXEC_ATTRIBUTE(host, device)
+    auto operator,(_ERROR_<What...>&) -> _ERROR_<What...>&;
 
-  template <class _Sender>
-  using __dependent_sender_error = __detail::__dependent_sender_error<__demangle_t<_Sender>>;
+    using __partitioned = __dependent_sender_error;
+
+    template <class, class>
+    using __value_types = __dependent_sender_error;
+
+    template <class, class>
+    using __error_types = __dependent_sender_error;
+
+    template <class, class>
+    using __stopped_types = __dependent_sender_error;
+  };
 
   template <class _What, class... _With>
   struct __not_a_sender {
diff --git a/include/stdexec/__detail/__let.hpp b/include/stdexec/__detail/__let.hpp
index 0028afc2b..e458d1841 100644
--- a/include/stdexec/__detail/__let.hpp
+++ b/include/stdexec/__detail/__let.hpp
@@ -537,9 +537,8 @@ namespace stdexec {
         []<class _Self, class _Env>(_Self&&, _Env&&...) noexcept {
           static_assert(sender_expr_for<_Self, __let_t<_SetTag>>);
           if constexpr (__decay_copyable<_Self>) {
-            using __result_t =
-              __completions_t<__let_t<_SetTag>, __data_of<_Self>, __child_of<_Self>, _Env>;
-            return __result_t{};
+            using __fn_t = __decay_t<__data_of<_Self>>;
+            return __completions_t<__let_t<_SetTag>, __fn_t, __child_of<_Self>, _Env>{};
           } else {
             return __mexception<_SENDER_TYPE_IS_NOT_COPYABLE_, _WITH_SENDER_<_Self>>{};
           }
@@ -552,7 +551,7 @@ namespace stdexec {
         static_assert(sender_expr_for<_Sender, __let_t<_SetTag>>);
         using _Fun = __decay_t<__data_of<_Sender>>;
         using _Child = __child_of<_Sender>;
-        using _Env2 = __env2_t<_SetTag, env_of_t<const _Child&>, env_of_t<const _Receiver&>>;
+        using _Env2 = __env2_t<_SetTag, env_of_t<_Child>, env_of_t<_Receiver>>;
         using __mk_let_state = __mbind_front_q<__let_state, _Receiver, _Fun, _SetTag, _Env2>;
 
         using __let_state_t = __gather_completions_of<
diff --git a/include/stdexec/__detail/__meta.hpp b/include/stdexec/__detail/__meta.hpp
index 43972b0ee..604b38db7 100644
--- a/include/stdexec/__detail/__meta.hpp
+++ b/include/stdexec/__detail/__meta.hpp
@@ -254,6 +254,20 @@ namespace stdexec {
   template <class... _What>
   struct _ERROR_ {
     auto operator,(__msuccess) const noexcept -> _ERROR_;
+
+    using __t = _ERROR_;
+    using __id = _ERROR_;
+
+    using __partitioned = _ERROR_;
+
+    template <class, class>
+    using __value_types = _ERROR_;
+
+    template <class, class>
+    using __error_types = _ERROR_;
+
+    template <class, class>
+    using __stopped_types = _ERROR_;
   };
 
   template <__mstring... _What>
@@ -810,19 +824,22 @@ namespace stdexec {
 
   namespace __detail {
     template <class _Ty>
-    extern __q<__midentity> __demangle_v;
+    extern __cp __demangle_v;
 
     template <class _Ty>
     using __demangle_fn = decltype(__demangle_v<_Ty>);
+
+    template <class _Ty>
+    using __demangle_t = __minvoke<__demangle_fn<_Ty>, _Ty>;
   } // namespace __detail
 
   // A utility for pretty-printing type names in diagnostics
   template <class _Ty>
-  using __demangle_t = __minvoke<__detail::__demangle_fn<_Ty>, _Ty>;
+  using __demangle_t = __copy_cvref_t<_Ty, __detail::__demangle_t<std::remove_cvref_t<_Ty>>>;
 
   namespace __detail {
     //////////////////////////////////////////////////////////////////////////////////////////
-    // _pretty_name
+    // __get_pretty_name
     template <class>
     struct __xyzzy {
       struct __plugh { };
@@ -855,8 +872,10 @@ namespace stdexec {
     }
   } // namespace __detail
 
+  ////////////////////////////////////////////////////////////////////////////////////////////
+  // __mnameof: get the pretty name of a type T as a string_view at compile time
   template <class T>
-  inline constexpr auto __mnameof = __detail::__get_pretty_name<__demangle_t<T>>();
+  inline constexpr std::string_view __mnameof = __detail::__get_pretty_name<__demangle_t<T>>();
 
   static_assert(__mnameof<int> == "int");
 
diff --git a/include/stdexec/__detail/__shared.hpp b/include/stdexec/__detail/__shared.hpp
index 8d03af742..c36412120 100644
--- a/include/stdexec/__detail/__shared.hpp
+++ b/include/stdexec/__detail/__shared.hpp
@@ -433,9 +433,10 @@ namespace stdexec::__shared {
   struct __shared_impl : __sexpr_defaults {
     static constexpr auto get_state =
       []<class _CvrefSender, class _Receiver>(_CvrefSender&& __sndr, _Receiver&) noexcept
-      -> __local_state<_CvrefSender, _Receiver> {
+      -> __local_state<_CvrefSender, _Receiver>
+      requires __decay_copyable<__data_of<_CvrefSender>>
+    {
       static_assert(sender_expr_for<_CvrefSender, _Tag>);
-      static_assert(__decay_copyable<_CvrefSender>);
       return __local_state<_CvrefSender, _Receiver>{static_cast<_CvrefSender&&>(__sndr)};
     };
 
diff --git a/include/stdexec/__detail/__transfer_just.hpp b/include/stdexec/__detail/__transfer_just.hpp
index 2e5cfc61f..7e6b5e44f 100644
--- a/include/stdexec/__detail/__transfer_just.hpp
+++ b/include/stdexec/__detail/__transfer_just.hpp
@@ -34,7 +34,7 @@ namespace stdexec {
   // [execution.senders.transfer_just]
   namespace __transfer_just {
     inline auto __make_transform_fn() {
-      return [&]<class _Scheduler, __decay_copyable... _Values>(
+      return []<class _Scheduler, __decay_copyable... _Values>(
                _Scheduler&& __sched, _Values&&... __vals) {
         return continues_on(
           just(static_cast<_Values&&>(__vals)...), static_cast<_Scheduler&&>(__sched));
@@ -42,7 +42,7 @@ namespace stdexec {
     }
 
     inline auto __transform_sender_fn() {
-      return [&]<class _Data>(__ignore, _Data&& __data) {
+      return []<class _Data>(__ignore, _Data&& __data) {
         return stdexec::__apply(__make_transform_fn(), static_cast<_Data&&>(__data));
       };
     }
@@ -57,7 +57,11 @@ namespace stdexec {
 
       template <class _Sender, class _Env>
       static auto transform_sender(set_value_t, _Sender&& __sndr, const _Env&) {
-        return __sexpr_apply(static_cast<_Sender&&>(__sndr), __transform_sender_fn());
+        if constexpr (!__decay_copyable<_Sender>) {
+          return __mexception<_SENDER_TYPE_IS_NOT_COPYABLE_, _WITH_SENDER_<_Sender>>();
+        } else {
+          return __sexpr_apply(static_cast<_Sender&&>(__sndr), __transform_sender_fn());
+        }
       }
     };
 
diff --git a/include/stdexec/__detail/__transform_sender.hpp b/include/stdexec/__detail/__transform_sender.hpp
index 1423c6e1c..058ee9ea4 100644
--- a/include/stdexec/__detail/__transform_sender.hpp
+++ b/include/stdexec/__detail/__transform_sender.hpp
@@ -45,7 +45,9 @@ namespace stdexec {
         constexpr bool __is_nothrow =
           __has_nothrow_transform_sender<__domain_t, _OpTag, _Sndr, _Env>;
 
-        if constexpr (__same_as<__result_t, _Sndr>) {
+        if constexpr (!__ok<__result_t>) {
+          return __declfn<__result_t>();
+        } else if constexpr (__same_as<__result_t, _Sndr>) {
           return __declfn<__result_t, __is_nothrow>();
         } else if constexpr (__same_as<_OpTag, start_t>) {
           return __get_declfn<__result_t, _Env, (_Nothrow && __is_nothrow)>();
diff --git a/include/stdexec/__detail/__type_traits.hpp b/include/stdexec/__detail/__type_traits.hpp
index 6b9abf29d..32c3a9348 100644
--- a/include/stdexec/__detail/__type_traits.hpp
+++ b/include/stdexec/__detail/__type_traits.hpp
@@ -60,6 +60,7 @@ namespace stdexec {
       using __f = __decay(_Ty);
     };
   } // namespace __tt
+
   template <class _Ty>
   using __decay_t = __tt::__decay_<sizeof(__tt::__wrap<_Ty> *) == ~0ul>::template __f<_Ty>;
 
diff --git a/include/stdexec/__detail/__upon_error.hpp b/include/stdexec/__detail/__upon_error.hpp
index 47f475b57..c7c2fce77 100644
--- a/include/stdexec/__detail/__upon_error.hpp
+++ b/include/stdexec/__detail/__upon_error.hpp
@@ -19,12 +19,10 @@
 
 #include "__basic_sender.hpp"
 #include "__diagnostics.hpp"
-#include "__domain.hpp"
 #include "__meta.hpp"
 #include "__senders_core.hpp"
 #include "__sender_adaptor_closure.hpp"
 #include "__transform_completion_signatures.hpp"
-#include "__transform_sender.hpp"
 #include "__senders.hpp" // IWYU pragma: keep for __well_formed_sender
 
 // include these after __execution_fwd.hpp
diff --git a/include/stdexec/__detail/__upon_stopped.hpp b/include/stdexec/__detail/__upon_stopped.hpp
index caae68094..fbd85451c 100644
--- a/include/stdexec/__detail/__upon_stopped.hpp
+++ b/include/stdexec/__detail/__upon_stopped.hpp
@@ -19,12 +19,10 @@
 
 #include "__basic_sender.hpp"
 #include "__diagnostics.hpp"
-#include "__domain.hpp"
 #include "__meta.hpp"
 #include "__senders_core.hpp"
 #include "__sender_adaptor_closure.hpp"
 #include "__transform_completion_signatures.hpp"
-#include "__transform_sender.hpp"
 #include "__senders.hpp" // IWYU pragma: keep for __well_formed_sender
 
 // include these after __execution_fwd.hpp