diff --git a/.vscode/launch.json b/.vscode/launch.json
index 8316045fe..f4d90ab0d 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -85,6 +85,17 @@
             "environment": [{"CUDA_LAUNCH_BLOCKING": "1"}],
             "args": ["--iterations=1000", "--N=512", "--run-stream-scheduler"],
         },
+        {
+            "name": "(Windows) Launch",
+            "type": "cppvsdbg",
+            "request": "launch",
+            "program": "${command:cmake.launchTargetPath}",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${fileDirname}",
+            "environment": [],
+            "console": "externalTerminal"
+        },
     ],
     "inputs": [
         // These require the Tasks Shell Input extension:
diff --git a/include/exec/detail/basic_sequence.hpp b/include/exec/detail/basic_sequence.hpp
index 2c4a92b38..0357b7a0c 100644
--- a/include/exec/detail/basic_sequence.hpp
+++ b/include/exec/detail/basic_sequence.hpp
@@ -127,6 +127,6 @@ namespace STDEXEC::__detail
   extern decltype(_DescriptorFn()) __desc_of_v<exec::__seqexpr<_DescriptorFn>>;
 
   template <auto _DescriptorFn>
-  extern __declfn_t<__minvoke<decltype(_DescriptorFn()), __q<exec::__basic_sequence_sender_t>>>
+  extern __mtype<__minvoke<decltype(_DescriptorFn()), __q<exec::__basic_sequence_sender_t>>>
     __demangle_v<exec::__seqexpr<_DescriptorFn>>;
 }  // namespace STDEXEC::__detail
diff --git a/include/exec/repeat_until.hpp b/include/exec/repeat_until.hpp
index c44b36645..146750da1 100644
--- a/include/exec/repeat_until.hpp
+++ b/include/exec/repeat_until.hpp
@@ -275,11 +275,11 @@ namespace experimental::execution
         using __eptr_completion_t        = set_error_t(std::exception_ptr);
         constexpr auto __eptr_completion = (__eptr_completion_t *) nullptr;
 
-        STDEXEC_COMPLSIGS_LET(
-          __sigs,
+        auto __sigs =
           exec::transform_completion_signatures(get_completion_signatures<__child_t, _Env...>(),
                                                 __transform_values<__child_t>,
-                                                __transform_errors))
+                                                __transform_errors);
+        STDEXEC_IF_OK(__sigs)
         {
           // The repeat_until sender is a dependent sender if one of the following is
           // true:
diff --git a/include/exec/static_thread_pool.hpp b/include/exec/static_thread_pool.hpp
index 582f91b12..6673cc619 100644
--- a/include/exec/static_thread_pool.hpp
+++ b/include/exec/static_thread_pool.hpp
@@ -45,7 +45,6 @@
 #include "sequence/iterate.hpp"
 #include "sequence_senders.hpp"
 
-#include <algorithm>
 #include <compare>
 #include <condition_variable>
 #include <cstdint>
diff --git a/include/nvexec/nvtx.cuh b/include/nvexec/nvtx.cuh
index 0c5bd4de2..d0be24e8b 100644
--- a/include/nvexec/nvtx.cuh
+++ b/include/nvexec/nvtx.cuh
@@ -196,7 +196,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <nvexec::_strm::nvtx::kind Kind, class Sender>
-  extern __declfn_t<nvexec::_strm::nvtx::nvtx_sender<Kind, __demangle_t<Sender>>>
+  extern __mtype<nvexec::_strm::nvtx::nvtx_sender<Kind, __demangle_t<Sender>>>
     __demangle_v<nvexec::_strm::nvtx::nvtx_sender<Kind, Sender>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/algorithm_base.cuh b/include/nvexec/stream/algorithm_base.cuh
index c5b6a54ab..8832c1a84 100644
--- a/include/nvexec/stream/algorithm_base.cuh
+++ b/include/nvexec/stream/algorithm_base.cuh
@@ -145,7 +145,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender, class InitT, class Fun, class DerivedSender>
-  extern __declfn_t<nvexec::_strm::__algo_range_init_fun::
-                      sender<__demangle_t<Sender>, InitT, Fun, __demangle_t<DerivedSender>>>
+  extern __mtype<nvexec::_strm::__algo_range_init_fun::
+                   sender<__demangle_t<Sender>, InitT, Fun, __demangle_t<DerivedSender>>>
     __demangle_v<nvexec::_strm::__algo_range_init_fun::sender<Sender, InitT, Fun, DerivedSender>>;
 }  // namespace STDEXEC::__detail
diff --git a/include/nvexec/stream/bulk.cuh b/include/nvexec/stream/bulk.cuh
index e8b277ab2..a3a2a6ab8 100644
--- a/include/nvexec/stream/bulk.cuh
+++ b/include/nvexec/stream/bulk.cuh
@@ -440,12 +440,11 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender, class Shape, class Fun>
-  inline constexpr __declfn_t<nvexec::_strm::bulk_sender<__demangle_t<Sender>, Shape, Fun>>
+  inline constexpr __mtype<nvexec::_strm::bulk_sender<__demangle_t<Sender>, Shape, Fun>>
     __demangle_v<nvexec::_strm::bulk_sender<Sender, Shape, Fun>>{};
 
   template <class Sender, class Shape, class Fun>
-  inline constexpr __declfn_t<
-    nvexec::_strm::multi_gpu_bulk_sender<__demangle_t<Sender>, Shape, Fun>>
+  inline constexpr __mtype<nvexec::_strm::multi_gpu_bulk_sender<__demangle_t<Sender>, Shape, Fun>>
     __demangle_v<nvexec::_strm::multi_gpu_bulk_sender<Sender, Shape, Fun>>{};
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/continues_on.cuh b/include/nvexec/stream/continues_on.cuh
index a7ee8f260..b06697755 100644
--- a/include/nvexec/stream/continues_on.cuh
+++ b/include/nvexec/stream/continues_on.cuh
@@ -284,7 +284,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Scheduler, class Sender>
-  extern __declfn_t<nvexec::_strm::continues_on_sender<Scheduler, __demangle_t<Sender>>>
+  extern __mtype<nvexec::_strm::continues_on_sender<Scheduler, __demangle_t<Sender>>>
     __demangle_v<nvexec::_strm::continues_on_sender<Scheduler, Sender>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/ensure_started.cuh b/include/nvexec/stream/ensure_started.cuh
index 324842cd2..30ae50ab4 100644
--- a/include/nvexec/stream/ensure_started.cuh
+++ b/include/nvexec/stream/ensure_started.cuh
@@ -430,7 +430,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender>
-  extern __declfn_t<nvexec::_strm::ensure_started_sender<__demangle_t<Sender>>>
+  extern __mtype<nvexec::_strm::ensure_started_sender<__demangle_t<Sender>>>
     __demangle_v<nvexec::_strm::ensure_started_sender<Sender>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/launch.cuh b/include/nvexec/stream/launch.cuh
index 35b29e785..de3f79f1d 100644
--- a/include/nvexec/stream/launch.cuh
+++ b/include/nvexec/stream/launch.cuh
@@ -204,7 +204,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender, class Fun>
-  extern __declfn_t<nvexec::_strm::launch_sender<__demangle_t<Sender>, Fun>>
+  extern __mtype<nvexec::_strm::launch_sender<__demangle_t<Sender>, Fun>>
     __demangle_v<nvexec::_strm::launch_sender<Sender, Fun>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/let_xxx.cuh b/include/nvexec/stream/let_xxx.cuh
index 4d7e3b940..0ed840cb5 100644
--- a/include/nvexec/stream/let_xxx.cuh
+++ b/include/nvexec/stream/let_xxx.cuh
@@ -344,7 +344,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender, class Fun, class SetTag>
-  extern __declfn_t<nvexec::_strm::let_sender<__demangle_t<Sender>, Fun, SetTag>>
+  extern __mtype<nvexec::_strm::let_sender<__demangle_t<Sender>, Fun, SetTag>>
     __demangle_v<nvexec::_strm::let_sender<Sender, Fun, SetTag>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/reduce.cuh b/include/nvexec/stream/reduce.cuh
index 90a5c3780..b1ec38b56 100644
--- a/include/nvexec/stream/reduce.cuh
+++ b/include/nvexec/stream/reduce.cuh
@@ -165,7 +165,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender, class Init, class Fun>
-  extern __declfn_t<nvexec::_strm::reduce_::sender<__demangle_t<Sender>, Init, Fun>>
+  extern __mtype<nvexec::_strm::reduce_::sender<__demangle_t<Sender>, Init, Fun>>
     __demangle_v<nvexec::_strm::reduce_::sender<Sender, Init, Fun>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/schedule_from.cuh b/include/nvexec/stream/schedule_from.cuh
index cb979c650..8f7edee11 100644
--- a/include/nvexec/stream/schedule_from.cuh
+++ b/include/nvexec/stream/schedule_from.cuh
@@ -196,6 +196,6 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender>
-  extern __declfn_t<nvexec::_strm::schedule_from_sender<__demangle_t<Sender>>>
+  extern __mtype<nvexec::_strm::schedule_from_sender<__demangle_t<Sender>>>
     __demangle_v<nvexec::_strm::schedule_from_sender<Sender>>;
 }  // namespace STDEXEC::__detail
diff --git a/include/nvexec/stream/split.cuh b/include/nvexec/stream/split.cuh
index 7488cbb39..d461e3ff1 100644
--- a/include/nvexec/stream/split.cuh
+++ b/include/nvexec/stream/split.cuh
@@ -412,7 +412,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender>
-  extern __declfn_t<nvexec::_strm::split_sender<__demangle_t<Sender>>>
+  extern __mtype<nvexec::_strm::split_sender<__demangle_t<Sender>>>
     __demangle_v<nvexec::_strm::split_sender<Sender>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/then.cuh b/include/nvexec/stream/then.cuh
index 9d8f0171c..44e3a53b7 100644
--- a/include/nvexec/stream/then.cuh
+++ b/include/nvexec/stream/then.cuh
@@ -228,7 +228,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender, class Fun>
-  extern __declfn_t<nvexec::_strm::then_sender<__demangle_t<Sender>, Fun>>
+  extern __mtype<nvexec::_strm::then_sender<__demangle_t<Sender>, Fun>>
     __demangle_v<nvexec::_strm::then_sender<Sender, Fun>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/upon_error.cuh b/include/nvexec/stream/upon_error.cuh
index 4f0904f1a..38350b9ff 100644
--- a/include/nvexec/stream/upon_error.cuh
+++ b/include/nvexec/stream/upon_error.cuh
@@ -216,7 +216,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender, class Fun>
-  extern __declfn_t<nvexec::_strm::upon_error_sender<__demangle_t<Sender>, Fun>>
+  extern __mtype<nvexec::_strm::upon_error_sender<__demangle_t<Sender>, Fun>>
     __demangle_v<nvexec::_strm::upon_error_sender<Sender, Fun>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/upon_stopped.cuh b/include/nvexec/stream/upon_stopped.cuh
index f18e4a120..cb7668c59 100644
--- a/include/nvexec/stream/upon_stopped.cuh
+++ b/include/nvexec/stream/upon_stopped.cuh
@@ -207,7 +207,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class Sender, class Fun>
-  extern __declfn_t<nvexec::_strm::upon_stopped_sender<__demangle_t<Sender>, Fun>>
+  extern __mtype<nvexec::_strm::upon_stopped_sender<__demangle_t<Sender>, Fun>>
     __demangle_v<nvexec::_strm::upon_stopped_sender<Sender, Fun>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/nvexec/stream/when_all.cuh b/include/nvexec/stream/when_all.cuh
index a367a9653..efa005e18 100644
--- a/include/nvexec/stream/when_all.cuh
+++ b/include/nvexec/stream/when_all.cuh
@@ -576,7 +576,7 @@ namespace nvexec = nv::execution;
 namespace STDEXEC::__detail
 {
   template <class WhenAllTag, class Scheduler, class... Senders>
-  extern __declfn_t<nvexec::_strm::when_all_sender<WhenAllTag, Scheduler, __demangle_t<Senders>...>>
+  extern __mtype<nvexec::_strm::when_all_sender<WhenAllTag, Scheduler, __demangle_t<Senders>...>>
     __demangle_v<nvexec::_strm::when_all_sender<WhenAllTag, Scheduler, Senders...>>;
 }  // namespace STDEXEC::__detail
 
diff --git a/include/stdexec/__detail/__basic_sender.hpp b/include/stdexec/__detail/__basic_sender.hpp
index 1f987463a..44fdf8a6b 100644
--- a/include/stdexec/__detail/__basic_sender.hpp
+++ b/include/stdexec/__detail/__basic_sender.hpp
@@ -456,7 +456,7 @@ namespace STDEXEC
     using __basic_sender_t = __basic_sender<_Tag, _Data, __demangle_t<_Child>...>::type;
 
     template <auto _Descriptor>
-    extern __declfn_t<__minvoke<decltype(_Descriptor()), __q<__basic_sender_t>>>
+    extern __mtype<__minvoke<decltype(_Descriptor()), __q<__basic_sender_t>>>
       __demangle_v<__sexpr<_Descriptor>>;
   }  // namespace __detail
 }  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__completion_info.hpp b/include/stdexec/__detail/__completion_info.hpp
new file mode 100644
index 000000000..0512af80b
--- /dev/null
+++ b/include/stdexec/__detail/__completion_info.hpp
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2026 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *   https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "__execution_fwd.hpp"
+
+// IWYU pragma: begin_keep
+#include "__completion_behavior.hpp"
+#include "__completion_signatures.hpp"
+#include "__meta.hpp"
+#include "__static_vector.hpp"
+#include "__typeinfo.hpp"
+
+#include "../functional.hpp"
+
+#include <algorithm>
+#include <array>
+#include <compare>
+// IWYU pragma: end_keep
+
+namespace STDEXEC
+{
+  template <class _Sig>
+  constexpr _Sig *__signature = nullptr;
+
+  struct __completion_info
+  {
+    using __behavior_t = __completion_behavior::__behavior;
+
+    STDEXEC::__disposition __disposition = __invalid_disposition;
+    __type_index           __signature   = __mtypeid<void>;
+    __type_index           __domain      = __mtypeid<void>;
+    __behavior_t           __behavior    = __completion_behavior::__unknown;
+
+    __completion_info() = default;
+
+    template <__completion_tag _Tag, class... _Args>
+    constexpr __completion_info(_Tag (*)(_Args...),
+                                __type_index __domain   = __mtypeid<void>,
+                                __behavior_t __behavior = __completion_behavior::__unknown) noexcept
+      : __disposition(_Tag::__disposition)
+      , __signature(__mtypeid<_Tag(_Args...)>)
+      , __domain(__domain)
+      , __behavior(__behavior)
+    {}
+
+    template <class _Sender, class... _Env>
+    constexpr auto __populate() noexcept -> __completion_info &
+    {
+      switch (__disposition)
+      {
+      case __disposition::__value:
+        __domain   = __mtypeid<__completion_domain_t<set_value_t, env_of_t<_Sender>, _Env...>>;
+        __behavior = STDEXEC::__get_completion_behavior<set_value_t, _Sender, _Env...>();
+        break;
+      case __disposition::__error:
+        __domain   = __mtypeid<__completion_domain_t<set_error_t, env_of_t<_Sender>, _Env...>>;
+        __behavior = STDEXEC::__get_completion_behavior<set_error_t, _Sender, _Env...>();
+        break;
+      case __disposition::__stopped:
+        __domain   = __mtypeid<__completion_domain_t<set_stopped_t, env_of_t<_Sender>, _Env...>>;
+        __behavior = STDEXEC::__get_completion_behavior<set_stopped_t, _Sender, _Env...>();
+        break;
+      }
+      return *this;
+    }
+
+    [[nodiscard]]
+    constexpr auto operator<=>(__completion_info const &) const noexcept  //
+      -> std::strong_ordering = default;
+  };
+
+  namespace __cmplsigs
+  {
+    template <auto _GetComplInfo>
+    constexpr auto __completion_info_from_v = []() noexcept
+    {
+      auto __cmpl_info = _GetComplInfo();
+      STDEXEC_IF_OK(__cmpl_info)
+      {
+        constexpr auto __size = _GetComplInfo().size();
+        auto           __arr  = __static_vector<__completion_info, __size>();
+        std::ranges::sort(__cmpl_info);
+        auto const __end = std::ranges::unique_copy(__cmpl_info, __arr.begin()).out;
+        __arr.resize(__end - __arr.begin());
+        return __arr;
+      }
+    }();
+
+    template <class _GetComplInfo>
+    consteval auto __completion_info_from(_GetComplInfo) noexcept -> auto const &
+    {
+      return __completion_info_from_v<(_GetComplInfo())>;
+    }
+
+    template <auto _GetComplInfo>
+    constexpr auto __completion_sigs_from_v = []() noexcept
+    {
+      constexpr auto __completions = __completion_info_from_v<_GetComplInfo>;
+      STDEXEC_IF_OK(__completions)
+      {
+        auto __signatures = __static_vector<__type_index, __completions.size()>();
+        __signatures.resize(__completions.size());
+        std::ranges::transform(__completions,
+                               __signatures.begin(),
+                               &__completion_info::__signature);
+        std::ranges::sort(__signatures);
+        auto const __end = std::ranges::unique(__signatures).begin();
+        __signatures.erase(__end, __signatures.end());
+        return __signatures;
+      }
+    }();
+
+    template <class _GetComplInfo>
+    consteval auto __completion_sigs_from(_GetComplInfo) noexcept
+    {
+      constexpr auto __sigs = __completion_sigs_from_v<(_GetComplInfo())>;
+      STDEXEC_IF_OK(__sigs)
+      {
+        constexpr auto __fn = [=]<std::size_t... _Is>(__indices<_Is...>)
+        {
+          return completion_signatures<__msplice<__sigs[_Is]>...>();
+        };
+        return __fn(__make_indices<__sigs.size()>());
+      }
+    }
+
+    template <class... _Sigs>
+    [[nodiscard]]
+    consteval auto __to_array(completion_signatures<_Sigs...>) noexcept
+    {
+      using __array_t = __static_vector<__completion_info, sizeof...(_Sigs)>;
+      auto __compls   = __array_t{__completion_info(__signature<_Sigs>)...};
+      std::ranges::sort(__compls);
+      return __compls;
+    }
+  }  // namespace __cmplsigs
+}  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__completion_signatures.hpp b/include/stdexec/__detail/__completion_signatures.hpp
index 2d6fd54b9..1a864218f 100644
--- a/include/stdexec/__detail/__completion_signatures.hpp
+++ b/include/stdexec/__detail/__completion_signatures.hpp
@@ -541,38 +541,15 @@ namespace STDEXEC
       __cmplsigs::__partitions_of_t<_Sigs>::__count_stopped::value;
   }  // namespace __detail
 
-  // Below is the definition of the STDEXEC_COMPLSIGS_LET portability macro. It
-  // is used to check that an expression's type is a valid completion_signature
-  // specialization.
-  //
-  // USAGE:
-  //
-  //   STDEXEC_COMPLSIGS_LET(__cs, <expression>)
-  //   {
-  //     // __cs is guaranteed to be a specialization of completion_signatures.
-  //   }
-  //
-  // When constexpr exceptions are available (C++26), the macro simply expands to
-  // the moral equivalent of:
-  //
-  //   // With constexpr exceptions:
-  //   auto __cs = <expression>; // throws if __cs is not a completion_signatures
-  //
-  // When constexpr exceptions are not available, the macro expands to:
-  //
-  //   // Without constexpr exceptions:
-  //   if constexpr (auto __cs = <expression>; !__valid_completion_signatures<decltype(__cs)>)
-  //   {
-  //     return __cs;
-  //   }
-  //   else
+  // Below is the definition of the STDEXEC_IF_OK portability macro. It is used to check
+  // that an expression's type is not an __mexception type.
 
 #if STDEXEC_NO_STDCPP_CONSTEXPR_EXCEPTIONS()
 
-#  define STDEXEC_COMPLSIGS_LET(_ID, ...)                                                          \
-    if constexpr ([[maybe_unused]] auto _ID = __VA_ARGS__;                                         \
-                  !STDEXEC::__valid_completion_signatures<decltype(_ID)>) {                        \
-      return _ID;                                                                                  \
+#  define STDEXEC_IF_OK(_ID)                        \
+    if constexpr (STDEXEC::__merror<decltype(_ID)>) \
+    {                                               \
+      return _ID;                                   \
     } else
 
   template <class, class _Sndr>
@@ -591,9 +568,7 @@ namespace STDEXEC
 
 #else  // ^^^ no constexpr exceptions ^^^ / vvv constexpr exceptions vvv
 
-#  define STDEXEC_COMPLSIGS_LET(_ID, ...)                                                          \
-    if constexpr ([[maybe_unused]] auto _ID = __VA_ARGS__; false) {                                \
-    } else
+#  define STDEXEC_IF_OK(_ID)
 
   template <class _Result, class _Sndr>
   [[noreturn, nodiscard]]
diff --git a/include/stdexec/__detail/__concepts.hpp b/include/stdexec/__detail/__concepts.hpp
index f4de37fb1..21e235857 100644
--- a/include/stdexec/__detail/__concepts.hpp
+++ b/include/stdexec/__detail/__concepts.hpp
@@ -252,6 +252,16 @@ namespace STDEXEC
 
   }  // namespace __std
 
+  template <class _Ty, class... _As>
+  concept __initializable_from = requires(__declfn_t<_As &&>... __as) {
+    { _Ty{__as()...} };
+  };
+
+  template <class _Ty, class... _As>
+  concept __nothrow_initializable_from = requires(__declfn_t<_As &&>... __as) {
+    { _Ty{__as()...} } noexcept;
+  };
+
   template <class _Ty>
   concept __movable_value = __std::move_constructible<__decay_t<_Ty>>
                          && __std::constructible_from<__decay_t<_Ty>, _Ty>;
diff --git a/include/stdexec/__detail/__continues_on.hpp b/include/stdexec/__detail/__continues_on.hpp
index b87c400f8..c14fbec02 100644
--- a/include/stdexec/__detail/__continues_on.hpp
+++ b/include/stdexec/__detail/__continues_on.hpp
@@ -318,8 +318,9 @@ namespace STDEXEC
       template <class _Child, class... _Env>
       static consteval auto __get_child_completions()
       {
-        STDEXEC_COMPLSIGS_LET(__child_completions,
-                              STDEXEC::get_completion_signatures<_Child, __fwd_env_t<_Env>...>())
+        auto __child_completions =
+          STDEXEC::get_completion_signatures<_Child, __fwd_env_t<_Env>...>();
+        STDEXEC_IF_OK(__child_completions)
         {
           // continues_on has the completions of the child sender, but with value and
           // error result types decayed.
@@ -334,8 +335,9 @@ namespace STDEXEC
       static consteval auto __get_scheduler_completions()
       {
         using __sndr_t = schedule_result_t<_Scheduler>;
-        STDEXEC_COMPLSIGS_LET(__sched_completions,
-                              STDEXEC::get_completion_signatures<__sndr_t, __fwd_env_t<_Env>...>())
+        auto __sched_completions =
+          STDEXEC::get_completion_signatures<__sndr_t, __fwd_env_t<_Env>...>();
+        STDEXEC_IF_OK(__sched_completions)
         {
           // The scheduler contributes only error and stopped completions; we ignore value
           // completions here
diff --git a/include/stdexec/__detail/__cpo.hpp b/include/stdexec/__detail/__cpo.hpp
deleted file mode 100644
index bbe2ae8b4..000000000
--- a/include/stdexec/__detail/__cpo.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2024 NVIDIA Corporation
- *
- * Licensed under the Apache License Version 2.0 with LLVM Exceptions
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *   https://llvm.org/LICENSE.txt
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include "__config.hpp"
-#include "__execution_fwd.hpp"
-
-#if STDEXEC_MSVC()
-#  pragma deprecated(STDEXEC_CUSTOM)
-#  pragma deprecated(STDEXEC_MEMFN_DECL)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// To hook a customization point like STDEXEC::get_env, first bring the names
-/// in STDEXEC::tags into scope:
-///
-/// @code
-/// using namespace STDEXEC::tags;
-/// @endcode
-///
-/// Then define a member function like this:
-///
-/// @code
-/// STDEXEC_MEMFN_DECL(auto get_env)(this const MySender& self) {
-///   return ...;
-/// }
-/// @endcode
-#define STDEXEC_MEMFN_DECL_IMPL(...)                                                               \
-  friend STDEXEC_PP_EVAL(                                                                          \
-    STDEXEC_MEMFN_DECL_TAG_INVOKE, STDEXEC_MEMFN_DECL_WHICH(__VA_ARGS__), __VA_ARGS__)
-
-#define STDEXEC_MEMFN_DECL_WHICH(_A1, ...)                                                         \
-  STDEXEC_PP_CAT(STDEXEC_MEMFN_DECL_WHICH_, STDEXEC_PP_FRONT(__VA_OPT__(1, ) 0))(_A1, __VA_ARGS__)
-#define STDEXEC_MEMFN_DECL_WHICH_0(_A1, ...)                                                       \
-  STDEXEC_PP_CHECK(STDEXEC_MEMFN_DECL_PROBE_##_A1), STDEXEC_PP_CHECK(_A1##_STDEXEC_MEMFN_DECL_PROBE)
-#define STDEXEC_MEMFN_DECL_WHICH_1(_A1, ...)                                                       \
-  0, STDEXEC_PP_CHECK(STDEXEC_PP_CAT(STDEXEC_PP_BACK(__VA_ARGS__), _STDEXEC_MEMFN_DECL_PROBE))
-
-#define STDEXEC_MEMFN_DECL_TAG_INVOKE(_WHICH, _QUERY, ...)                                         \
-  STDEXEC_MEMFN_DECL_RETURN_ ## _WHICH(__VA_ARGS__)                                                \
-  __tag_invoke(STDEXEC_MEMFN_DECL_TAG_ ## _WHICH ## _QUERY(__VA_ARGS__)
-
-#define STDEXEC_MEMFN_DECL_ARGS(...)                                                               \
-  STDEXEC_PP_CAT(STDEXEC_EAT_THIS_, __VA_ARGS__))
-
-#define STDEXEC_MEMFN_DECL_QUERY(_SELF, _TAG, ...)                                                 \
-  _TAG, STDEXEC_PP_CAT(STDEXEC_EAT_THIS_, _SELF) __VA_OPT__(, __VA_ARGS__))
-
-#define STDEXEC_EAT_THIS_this
-#define STDEXEC_EAT_AUTO_auto
-#define STDEXEC_EAT_VOID_void
-
-#define query_STDEXEC_MEMFN_DECL_PROBE   STDEXEC_PP_PROBE(~, 1)
-#define STDEXEC_MEMFN_DECL_PROBE_auto    STDEXEC_PP_PROBE(~, 1)
-#define STDEXEC_MEMFN_DECL_PROBE_void    STDEXEC_PP_PROBE(~, 2)
-
-#define STDEXEC_MEMFN_DECL_RETURN_0(...) ::STDEXEC::__arg_type_t<void(__VA_ARGS__())>
-#define STDEXEC_MEMFN_DECL_RETURN_1(...) auto
-#define STDEXEC_MEMFN_DECL_RETURN_2(...) void
-
-#define STDEXEC_MEMFN_DECL_TAG_00(...)                                                             \
-  const ::STDEXEC::__tag_type_t<__VA_ARGS__##_t::*>&, STDEXEC_MEMFN_DECL_ARGS
-#define STDEXEC_MEMFN_DECL_TAG_10(...)                                                             \
-  const STDEXEC_EAT_AUTO_##__VA_ARGS__##_t&, STDEXEC_MEMFN_DECL_ARGS
-#define STDEXEC_MEMFN_DECL_TAG_20(...)                                                             \
-  const STDEXEC_EAT_VOID_##__VA_ARGS__##_t&, STDEXEC_MEMFN_DECL_ARGS
-#define STDEXEC_MEMFN_DECL_TAG_01(...) STDEXEC_MEMFN_DECL_QUERY
-#define STDEXEC_MEMFN_DECL_TAG_11(...) STDEXEC_MEMFN_DECL_QUERY
-#define STDEXEC_MEMFN_DECL_TAG_21(...) STDEXEC_MEMFN_DECL_QUERY
-
-#define STDEXEC_MEMFN_FRIEND(_TAG)                                                                 \
-  using STDEXEC_PP_CAT(_TAG, _t) = STDEXEC_PP_CAT(STDEXEC::_TAG, _t)
-
-#if STDEXEC_GCC() || (STDEXEC_CLANG() && STDEXEC_CLANG_VERSION < 1400)
-#  define STDEXEC_CUSTOM                                                                           \
-    _Pragma("GCC warning \"STDEXEC_CUSTOM is deprecated.\"") STDEXEC_MEMFN_DECL_IMPL
-#  define STDEXEC_MEMFN_DECL                                                                       \
-    _Pragma("GCC warning \"STDEXEC_MEMFN_DECL is deprecated.\"") STDEXEC_MEMFN_DECL_IMPL
-#else
-#  define STDEXEC_CUSTOM     STDEXEC_MEMFN_DECL_IMPL
-#  define STDEXEC_MEMFN_DECL STDEXEC_MEMFN_DECL_IMPL
-#endif
-
-#if STDEXEC_CLANG() && STDEXEC_CLANG_VERSION >= 1400
-#  pragma clang deprecated(STDEXEC_CUSTOM)
-#  pragma clang deprecated(STDEXEC_MEMFN_DECL)
-#endif
-
-namespace STDEXEC
-{
-  template <class>
-  struct __arg_type;
-
-  template <class _Arg>
-  struct __arg_type<void(_Arg (*)())>
-  {
-    using type = _Arg;
-  };
-
-  template <class _Fn>
-  using __arg_type_t = __arg_type<_Fn>::type;
-
-  template <class>
-  struct __tag_type;
-
-  template <class _Ret, class _Tag>
-  struct __tag_type<_Ret _Tag::*>
-  {
-    using type = _Tag;
-  };
-
-  template <class _Fn>
-  using __tag_type_t = __tag_type<_Fn>::type;
-
-  namespace tags
-  {
-    using STDEXEC::set_value_t;
-    using STDEXEC::set_error_t;
-    using STDEXEC::set_stopped_t;
-    using STDEXEC::connect_t;
-    using STDEXEC::start_t;
-    using STDEXEC::get_env_t;
-    using STDEXEC::get_completion_signatures_t;
-  }  // namespace tags
-}  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__diagnostics.hpp b/include/stdexec/__detail/__diagnostics.hpp
index 485a67625..fe2f67bf6 100644
--- a/include/stdexec/__detail/__diagnostics.hpp
+++ b/include/stdexec/__detail/__diagnostics.hpp
@@ -267,15 +267,22 @@ namespace STDEXEC
                                "complete."}
     {}
 
-    STDEXEC_ATTRIBUTE(host, device) constexpr auto operator+() const -> _ERROR_;
+    STDEXEC_ATTRIBUTE(host, device)
+    constexpr auto operator+() const -> _ERROR_;
 
     template <class _Ty>
     STDEXEC_ATTRIBUTE(host, device)
-    constexpr auto operator,(_Ty const &) const -> _ERROR_;
+    constexpr auto operator,(_Ty const &) const -> _ERROR_
+    {
+      return *this;
+    }
 
     template <class... Other>
     STDEXEC_ATTRIBUTE(host, device)
-    constexpr auto operator,(const _ERROR_<Other...> &) const -> _ERROR_<Other...>;
+    constexpr auto operator,(const _ERROR_<Other...> &__other) const -> _ERROR_<Other...>
+    {
+      return __other;
+    }
   };
 
   // By making __dependent_sender_error_t an alias for _ERROR_<...>, we ensure that
diff --git a/include/stdexec/__detail/__domain.hpp b/include/stdexec/__detail/__domain.hpp
index 2d49145c5..096671ccc 100644
--- a/include/stdexec/__detail/__domain.hpp
+++ b/include/stdexec/__detail/__domain.hpp
@@ -18,10 +18,8 @@
 #include "__execution_fwd.hpp"
 
 #include "__completion_behavior.hpp"
-#include "__completion_signatures_of.hpp"
 #include "__concepts.hpp"
 #include "__config.hpp"
-#include "__execution_fwd.hpp"
 #include "__meta.hpp"
 #include "__sender_introspection.hpp"
 #include "__utility.hpp"
@@ -171,12 +169,6 @@ namespace STDEXEC
   }  // namespace __detail
 
   ////////////////////////////////////////////////////////////////////////////////////////////////
-  template <class _Tag, class _Attrs, class... _Env>
-  using __completion_domain_t = __call_result_or_t<get_completion_domain_t<_Tag>,
-                                                   indeterminate_domain<>,
-                                                   _Attrs,
-                                                   _Env const &...>;
-
   template <class _Tag, sender _Sender, class... _Env>
     requires __sends<_Tag, _Sender, _Env...>
   using __completion_domain_of_t = __completion_domain_t<_Tag, env_of_t<_Sender>, _Env const &...>;
diff --git a/include/stdexec/__detail/__execution_fwd.hpp b/include/stdexec/__detail/__execution_fwd.hpp
index 38e8408c7..031b5a5a0 100644
--- a/include/stdexec/__detail/__execution_fwd.hpp
+++ b/include/stdexec/__detail/__execution_fwd.hpp
@@ -74,6 +74,15 @@ namespace STDEXEC
   extern set_error_t const   set_error;
   extern set_stopped_t const set_stopped;
 
+  enum class __disposition
+  {
+    __value,
+    __error,
+    __stopped
+  };
+
+  constexpr auto __invalid_disposition = static_cast<__disposition>(3);  // invalid value
+
   template <class _Tag>
   concept __completion_tag = __one_of<_Tag, set_value_t, set_error_t, set_stopped_t>;
 
@@ -135,6 +144,12 @@ namespace STDEXEC
   extern get_domain_t const                   get_domain;
   extern get_await_completion_adaptor_t const get_await_completion_adaptor;
 
+  template <class _Tag, class _Attrs, class... _Env>
+  using __completion_domain_t = __call_result_or_t<get_completion_domain_t<_Tag>,
+                                                   indeterminate_domain<>,
+                                                   _Attrs,
+                                                   _Env const &...>;
+
   template <class _Env>
   concept __is_debug_env = __callable<__debug_env_t, _Env>;
 
@@ -184,17 +199,20 @@ namespace STDEXEC
 #if STDEXEC_NO_STDCPP_CONSTEXPR_EXCEPTIONS()
 
   template <class... _What, class... _Values>
+  [[nodiscard]]
   consteval auto __throw_compile_time_error(_Values...) -> __mexception<_What...>;
 
 #else  // ^^^ no constexpr exceptions ^^^ / vvv constexpr exceptions vvv
 
   // C++26, https://wg21.link/p3068
   template <class _What, class... _More, class... _Values>
+  [[noreturn, nodiscard]]
   consteval auto __throw_compile_time_error(_Values...) -> completion_signatures<>;
 
 #endif  // ^^^ constexpr exceptions ^^^
 
   template <class... _What>
+  [[nodiscard]]
   consteval auto __throw_compile_time_error(__mexception<_What...>);
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/stdexec/__detail/__finally.hpp b/include/stdexec/__detail/__finally.hpp
index 45d06d572..433781399 100644
--- a/include/stdexec/__detail/__finally.hpp
+++ b/include/stdexec/__detail/__finally.hpp
@@ -307,13 +307,13 @@ namespace STDEXEC
     template <class _CvInitialSender, class _CvFinalSender, class... _Env>
     consteval auto __get_completion_signatures()
     {
-      STDEXEC_COMPLSIGS_LET(__initial_completions,
-                            get_completion_signatures<_CvInitialSender, _Env...>())
+      auto __initial_completions = get_completion_signatures<_CvInitialSender, _Env...>();
+      STDEXEC_IF_OK(__initial_completions)
       {
         using __initial_completions_t = decltype(__initial_completions);
-        STDEXEC_COMPLSIGS_LET(
-          __final_completions,
-          get_completion_signatures<_CvFinalSender, __mk_final_env_t<_CvInitialSender, _Env>...>())
+        auto __final_completions =
+          get_completion_signatures<_CvFinalSender, __mk_final_env_t<_CvInitialSender, _Env>...>();
+        STDEXEC_IF_OK(__final_completions)
         {
           if constexpr (__never_sends<set_value_t,
                                       _CvFinalSender,
diff --git a/include/stdexec/__detail/__get_completion_signatures.hpp b/include/stdexec/__detail/__get_completion_signatures.hpp
index 05100a7d9..a08aef357 100644
--- a/include/stdexec/__detail/__get_completion_signatures.hpp
+++ b/include/stdexec/__detail/__get_completion_signatures.hpp
@@ -19,6 +19,7 @@
 
 // include these after __execution_fwd.hpp
 #include "__awaitable.hpp"
+#include "__completion_info.hpp"
 #include "__completion_signatures.hpp"  // IWYU pragma: export
 #include "__connect_awaitable.hpp"
 #include "__diagnostics.hpp"
@@ -27,6 +28,8 @@
 #include "__tag_invoke.hpp"
 #include "__tuple.hpp"  // IWYU pragma: keep for __tuple
 
+#include <algorithm>
+
 namespace STDEXEC
 {
   namespace __detail
@@ -381,4 +384,16 @@ namespace STDEXEC
   template <class _Tag, class _Sender, class... _Env>
   using __count_of =
     __msize_t<__detail::__count_of<_Tag, __completion_signatures_of_t<_Sender, _Env...>>>;
+
+  template <class _Sender, class... _Env>
+  consteval auto __get_completion_info()
+  {
+    auto __cmplsigs = STDEXEC::get_completion_signatures<_Sender, _Env...>();
+    STDEXEC_IF_OK(__cmplsigs)
+    {
+      auto __cmplinfo = STDEXEC::__cmplsigs::__to_array(__cmplsigs);
+      std::ranges::for_each(__cmplinfo, &__completion_info::__populate<_Sender, _Env...>);
+      return __cmplinfo;
+    }
+  }
 }  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__let.hpp b/include/stdexec/__detail/__let.hpp
index b59096f80..c0c00b034 100644
--- a/include/stdexec/__detail/__let.hpp
+++ b/include/stdexec/__detail/__let.hpp
@@ -19,6 +19,7 @@
 
 // include these after __execution_fwd.hpp
 #include "__basic_sender.hpp"
+#include "__completion_info.hpp"
 #include "__diagnostics.hpp"
 #include "__domain.hpp"
 #include "__env.hpp"
@@ -27,7 +28,6 @@
 #include "__sender_adaptor_closure.hpp"
 #include "__senders.hpp"
 #include "__submit.hpp"
-#include "__transform_completion_signatures.hpp"
 #include "__utility.hpp"
 #include "__variant.hpp"
 
@@ -106,6 +106,12 @@ namespace STDEXEC
       __fn_t<_WITH_ENVIRONMENT_, _JoinEnv2>...,
       __mapply_q<_NESTED_ERROR_, __try_completion_signatures_of_t<_Sender, _JoinEnv2...>>>;
 
+    template <class _LetTag, class... _Args>
+    using __not_decay_copyable_error_t =
+      __mexception<_WHAT_(_SENDER_RESULTS_ARE_NOT_DECAY_COPYABLE_),
+                   _WHERE_(_IN_ALGORITHM_, _LetTag),
+                   _WITH_ARGUMENTS_(_Args...)>;
+
     template <class _Sender, class... _JoinEnv2>
     concept __potentially_valid_sender_in = sender_in<_Sender, _JoinEnv2...>
                                          || (sender<_Sender> && (sizeof...(_JoinEnv2) == 0));
@@ -132,7 +138,8 @@ namespace STDEXEC
       using __rcvr2_t = __receiver_archetype<_Env2>;
 
       template <class... _Ts>
-      using __f = __mbool<__nothrow_decay_copyable<_Ts...>
+      using __f = __mbool<__nothrow_decay_copyable<_Ts...>                 //
+                          && __nothrow_invocable<_Fn, __decay_t<_Ts>&...>  //
                           && __nothrow_connectable<__sndr2_t<_Ts...>, __rcvr2_t>>;
     };
 
@@ -514,111 +521,143 @@ namespace STDEXEC
     struct __impls : __sexpr_defaults
     {
      private:
-      using __set_t = __t<_LetTag>;
-      template <class _Sender>
-      using __fn_t = __decay_t<__data_of<_Sender>>;
+      using __set_t      = __t<_LetTag>;
+      using __eptr_sig_t = set_error_t(std::exception_ptr);
+
+      template <class _CvSender>
+      using __fn_t = __decay_t<__data_of<_CvSender>>;
+
+      template <class _CvSender, class _Env>
+      using __env2_t = __let::__result_env_t<__set_t, _CvSender, _Env>;
 
-      template <class _Sender, class _Receiver>
+      template <class _CvSender, class _Env>
+      using __rcvr2_t = __receiver_archetype<__env2_t<_CvSender, _Env>>;
+
+      template <class _CvSender, class _Receiver>
       using __opstate_t = __gather_completions_of_t<
-        __t<_LetTag>,
-        __child_of<_Sender>,
+        __set_t,
+        __child_of<_CvSender>,
         __fwd_env_t<env_of_t<_Receiver>>,
         __q<__decayed_tuple>,
-        __mbind_front_q<__opstate, __t<_LetTag>, __child_of<_Sender>, __fn_t<_Sender>, _Receiver>>;
+        __mbind_front_q<__opstate, __set_t, __child_of<_CvSender>, __fn_t<_CvSender>, _Receiver>>;
 
-      template <class... _Args>
-      using __not_decay_copyable_error_t =
-        __mexception<_WHAT_(_SENDER_RESULTS_ARE_NOT_DECAY_COPYABLE_),
-                     _WHERE_(_IN_ALGORITHM_, _LetTag),
-                     _WITH_ARGUMENTS_(_Args...)>;
+      template <class _Fun, class _Child, class... _Env>
+      static constexpr auto __transform_cmplsig =                        //
+        []<class... _As>(__set_t (*)(_As...), __completion_info __info)  //
+        -> decltype(auto)
+      {
+        if constexpr (!__decay_copyable<_As...>)
+        {
+          using __what_t = __not_decay_copyable_error_t<_LetTag, _As...>;
+          return STDEXEC::__throw_compile_time_error(__what_t());
+        }
+        else if constexpr (!__invocable<_Fun, __decay_t<_As>&...>)
+        {
+          using __what_t = __callable_error_t<_LetTag, _Fun, __decay_t<_As>&...>;
+          return STDEXEC::__throw_compile_time_error(__what_t());
+        }
+        else if constexpr (!__potentially_valid_sender_in<
+                             __invoke_result_t<_Fun, __decay_t<_As>&...>,
+                             __env2_t<_Child, _Env>...>)
+        {
+          using __sndr_t = __invoke_result_t<_Fun, __decay_t<_As>&...>;
+          using __what_t = __bad_result_sender<__sndr_t, _LetTag, __env2_t<_Child, _Env>...>;
+          return STDEXEC::__throw_compile_time_error(__what_t());
+        }
+        else
+        {
+          using __sndr2_t = __invoke_result_t<_Fun, __decay_t<_As>&...>;
+          auto __cmpls    = STDEXEC::__get_completion_info<__sndr2_t, __env2_t<_Child, _Env>...>();
+          STDEXEC_IF_OK(__cmpls)
+          {
+            if constexpr (!__nothrow_decay_copyable<_As...>
+                          || !__nothrow_invocable<_Fun, __decay_t<_As>&...>
+                          || (!__nothrow_connectable<__sndr2_t, __rcvr2_t<_Child, _Env>> || ...))
+            {
+              __completion_info const __eptr_info(__signature<__eptr_sig_t>,
+                                                  __info.__domain,
+                                                  __info.__behavior);
+              return __cmpls + STDEXEC::__make_static_vector(__eptr_info);
+            }
+            else
+            {
+              return __cmpls;
+            }
+          }
+        }
+      };
 
-     public:
-      static constexpr auto __get_attrs =
-        []<class _Child>(__ignore, __ignore, _Child const & __child) noexcept -> decltype(auto)
+      template <__completion_info _Info>
+      static constexpr auto __maybe_transform_cmplsig = [](auto __transform) -> decltype(auto)
       {
-        // TODO(ericniebler): this needs a proper implementation
-        return __fwd_env(STDEXEC::get_env(__child));
+        if constexpr (_Info.__disposition != __set_t::__disposition)
+          return STDEXEC::__make_static_vector(_Info);
+        else
+          return __transform(__signature<__msplice<_Info.__signature>>, _Info);
       };
 
-      template <class _CvSndr, class... _Env>
-      static consteval auto __get_completion_signatures()
+      //! @tparam _Info A `__static_vector` of `__completion_info` objects representing
+      //! the completions of the predecessor sender.
+      template <auto _Info, auto _Transform>
+      static constexpr auto __get_cmpl_info_i = []<std::size_t... _Is>(__indices<_Is...>)
       {
-        static_assert(__sender_for<_CvSndr, _LetTag>);
-        using __fn_t        = __impls::__fn_t<_CvSndr>;
-        using __child_t     = __child_of<_CvSndr>;
-        auto __completions  = STDEXEC::get_completion_signatures<__child_t, _Env...>();
-        auto __transform_fn = []<class... _Args>()
+        return []
         {
-          if constexpr (!__invocable<__fn_t, __decay_t<_Args>&...>)
-          {
-            using __what_t = __callable_error_t<_LetTag, __fn_t, __decay_t<_Args>&...>;
-            return STDEXEC::__throw_compile_time_error(__what_t());
-          }
-          else if constexpr (!__decay_copyable<_Args...>)
-          {
-            using __what_t = __not_decay_copyable_error_t<_Args...>;
-            return STDEXEC::__throw_compile_time_error(__what_t());
-          }
-          else if constexpr (!__potentially_valid_sender_in<
-                               __invoke_result_t<__fn_t, __decay_t<_Args>&...>,
-                               __result_env_t<__set_t, __child_t, _Env>...>)
-          {
-            using __sndr_t = __invoke_result_t<__fn_t, __decay_t<_Args>&...>;
-            using __what_t =
-              __bad_result_sender<__sndr_t, _LetTag, __result_env_t<__set_t, __child_t, _Env>...>;
-            return STDEXEC::__throw_compile_time_error(__what_t());
-          }
-          else
+          __static_vector<__completion_info, 0> __result;
+          // NB: this fold uses an overloaded addition operator that propagates
+          // __mexception objects when constexpr exceptions are not available.
+          return (__maybe_transform_cmplsig<_Info[_Is]>(_Transform) + ... + __result);
+        };
+      };
+
+      template <class _Fun, class _Child, class... _Env>
+      struct __get_cmpl_info
+      {
+        constexpr auto operator()() const
+        {
+          constexpr auto __transform   = __transform_cmplsig<_Fun, _Child, _Env...>;
+          constexpr auto __get_sig     = &__completion_info::__signature;
+          constexpr auto __eptr_sig_id = __mtypeid<__eptr_sig_t>;
+          constexpr auto __cmpls       = STDEXEC::__get_completion_info<_Child, _Env...>();
+
+          STDEXEC_IF_OK(__cmpls)
           {
-            using __sndr_t    = __invoke_result_t<__fn_t, __decay_t<_Args>&...>;
-            using __nothrow_t = __mbool<__nothrow_invocable<__fn_t, __decay_t<_Args>&...>
-                                        && __nothrow_decay_copyable<_Args...>>;
-
-            STDEXEC_COMPLSIGS_LET(
-              __sigs,
-              STDEXEC::__concat_completion_signatures(
-                STDEXEC::get_completion_signatures<__sndr_t,
-                                                   __result_env_t<__set_t, __child_t, _Env>...>(),
-                __eptr_completion_unless_t<__nothrow_t>()))
+            constexpr auto __idx        = __make_indices<__cmpls.size()>();
+            constexpr auto __get_cmpls2 = __get_cmpl_info_i<__cmpls, __transform>(__idx);
+            constexpr auto __cmpls2     = __cmplsigs::__completion_info_from(__get_cmpls2);
+
+            STDEXEC_IF_OK(__cmpls2)
             {
-              if constexpr (__sigs.template __contains<set_error_t(std::exception_ptr)>())
-              {
-                return __sigs;
-              }
-              else if constexpr (sizeof...(_Env) == 0)
-              {
-                return STDEXEC::__dependent_sender<__sndr_t>();
-              }
+              if constexpr (std::ranges::find(__cmpls2, __eptr_sig_id, __get_sig) == __cmpls2.end()
+                            && sizeof...(_Env) == 0)
+                return STDEXEC::__dependent_sender<_Child>();
               else
-              {
-                using __env_t     = __mfront<__result_env_t<__set_t, __child_t, _Env>...>;
-                using __rcvr_t    = __receiver_archetype<__env_t>;
-                using __nothrow_t = __mbool<__nothrow_connectable<__sndr_t, __rcvr_t>>;
-                using __eptr_t    = __eptr_completion_unless_t<__nothrow_t>;
-
-                return STDEXEC::__concat_completion_signatures(__sigs, __eptr_t());
-              }
+                return __cmpls2;
             }
           }
-        };
+        }
+      };
 
-        if constexpr (!__decay_copyable<_CvSndr>)
-        {
+     public:
+      static constexpr auto __get_attrs =
+        []<class _Child>(__ignore, __ignore, _Child const & __child) noexcept -> decltype(auto)
+      {
+        // TODO(ericniebler): this needs a proper implementation
+        return __fwd_env(STDEXEC::get_env(__child));
+      };
+
+      template <class _CvSender, class... _Env>
+      static consteval auto __get_completion_signatures()
+      {
+        static_assert(__sender_for<_CvSender, _LetTag>);
+        constexpr auto __get_cmpl_info =
+          __impls::__get_cmpl_info<__fn_t<_CvSender>, __child_of<_CvSender>, _Env...>();
+
+        if constexpr (!__decay_copyable<_CvSender>)
           return STDEXEC::__throw_compile_time_error<_SENDER_TYPE_IS_NOT_DECAY_COPYABLE_,
-                                                     _WITH_PRETTY_SENDER_<_CvSndr>>();
-        }
-        else if constexpr (__same_as<_LetTag, let_value_t>)
-        {
-          return STDEXEC::__transform_completion_signatures(__completions, __transform_fn);
-        }
-        else if constexpr (__same_as<_LetTag, let_error_t>)
-        {
-          return STDEXEC::__transform_completion_signatures(__completions, {}, __transform_fn);
-        }
+                                                     _WITH_PRETTY_SENDER_<_CvSender>>();
         else
-        {
-          return STDEXEC::__transform_completion_signatures(__completions, {}, {}, __transform_fn);
-        }
+          return __cmplsigs::__completion_sigs_from(__get_cmpl_info);
       }
 
       static constexpr auto __connect =
diff --git a/include/stdexec/__detail/__meta.hpp b/include/stdexec/__detail/__meta.hpp
index e57538cab..5d87d5218 100644
--- a/include/stdexec/__detail/__meta.hpp
+++ b/include/stdexec/__detail/__meta.hpp
@@ -18,18 +18,18 @@
 #include "__concepts.hpp"
 #include "__config.hpp"
 #include "__type_traits.hpp"
+#include "__typeinfo.hpp"
 
+#include <algorithm>
+#include <array>
 #include <cassert>
 #include <cstddef>
-#include <source_location>  // IWYU pragma: keep for std::source_location::current
-#include <string_view>
 #include <type_traits>
 
 namespace STDEXEC
 {
-  //! Convenience metafunction getting the dependant type `__t` out of `_Tp`.
+  //! Convenience metafunction getting the dependent type `__t` out of `_Tp`.
   //! That is, `typename _Tp::__t`.
-  //! See MAINTAINERS.md#class-template-parameters for details.
   template <class _Tp>
   using __t = _Tp::__t;
 
@@ -39,24 +39,16 @@ namespace STDEXEC
   template <class _Ret, class... _Args>
   using __fn_ptr_t = _Ret (*)(_Args...);
 
-  template <class _Ty>
-  struct __mtype
-  {
-    using __t = _Ty;
-  };
-
   template <class...>
   concept __mnever = false;
 
-  namespace __detail
-  {
-    // NB: This variable template is partially specialized for __type_index in __typeinfo.hpp:
-    template <auto _Value>
-    extern __fn_ptr_t<decltype(_Value)> __mtypeof_v;
-  }  // namespace __detail
-
+#if STDEXEC_GCC() && STDEXEC_GCC_VERSION < 1300
+  template <auto _Value>
+  using __mtypeof = std::remove_const_t<decltype(_Value)>;
+#else
   template <auto _Value>
-  using __mtypeof = decltype(__detail::__mtypeof_v<_Value>());
+  using __mtypeof = decltype(_Value);
+#endif
 
   template <class...>
   struct __mlist;
@@ -203,7 +195,10 @@ namespace STDEXEC
     constexpr auto operator+() const -> _ERROR_;
 
     STDEXEC_ATTRIBUTE(host, device)
-    constexpr auto operator,(__ignore) const -> _ERROR_;
+    constexpr auto operator,(__ignore) const -> _ERROR_
+    {
+      return *this;
+    }
   };
 
   template <class... _What>
@@ -301,46 +296,6 @@ namespace STDEXEC
     using __f = __mfind_error<_Args...>;
   };
 
-#if STDEXEC_EDG()
-  // Most compilers memoize alias template specializations, but
-  // nvc++ does not. So we memoize the type computations by
-  // indirecting through a class template specialization.
-  template <template <class...> class _Fn, class... _Args>
-  using __minvoke_q__ = __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;
-
-  template <template <class...> class _Fn, class... _Args>
-  struct __minvoke_q_
-  {};
-
-  template <template <class...> class _Fn, class... _Args>
-    requires __typename<__minvoke_q__<_Fn, _Args...>>
-  struct __minvoke_q_<_Fn, _Args...>
-  {
-    using __t = __minvoke_q__<_Fn, _Args...>;
-  };
-
-  template <template <class...> class _Fn, class... _Args>
-  using __minvoke_q = __t<__minvoke_q_<_Fn, _Args...>>;
-
-  template <class _Fn, class... _Args>
-  using __minvoke__ = __i<_Ok<_Fn, _Args...>>::template __f<_Fn, _Args...>;
-
-  template <class _Fn, class... _Args>
-  struct __minvoke_
-  {};
-
-  template <class _Fn, class... _Args>
-    requires __typename<__minvoke__<_Fn, _Args...>>
-  struct __minvoke_<_Fn, _Args...>
-  {
-    using __t = __minvoke__<_Fn, _Args...>;
-  };
-
-  template <class _Fn, class... _Args>
-  using __minvoke = __t<__minvoke_<_Fn, _Args...>>;
-
-#else
-
   template <template <class...> class _Fn, class... _Args>
   using __minvoke_q = __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;
 
@@ -350,8 +305,6 @@ namespace STDEXEC
   template <class _Fn, class... _Args>
   using __minvoke = __i<_Ok<_Fn, _Args...>>::template __f<_Fn, _Args...>;
 
-#endif
-
   template <template <class...> class _Fn>
   struct __qq
   {
@@ -866,80 +819,6 @@ namespace STDEXEC
     using __f = __mfront<_As..., _Default>;
   };
 
-  namespace __detail
-  {
-    template <class _Ty>
-    extern __declfn_t<_Ty> __demangle_v;
-
-    template <class _Ty>
-    extern __declfn_t<_Ty &> __demangle_v<_Ty &>;
-
-    template <class _Ty>
-    extern __declfn_t<_Ty &&> __demangle_v<_Ty &&>;
-
-    template <class _Ty>
-    extern __declfn_t<_Ty const &> __demangle_v<_Ty const &>;
-
-    template <class _Ty>
-    using __demangle_t = decltype(__demangle_v<_Ty>());
-  }  // namespace __detail
-
-  // A utility for pretty-printing type names in diagnostics
-  template <class _Ty>
-  using __demangle_t = __copy_cvref_t<_Ty, __detail::__demangle_t<std::remove_cvref_t<_Ty>>>;
-
-  namespace __detail
-  {
-    //////////////////////////////////////////////////////////////////////////////////////////
-    // __get_pretty_name
-    template <class>
-    struct __xyzzy
-    {
-      struct __plugh
-      {};
-    };
-
-    inline constexpr char __type_name_prefix[] = "__xyzzy<";
-    inline constexpr char __type_name_suffix[] = ">::__plugh";
-
-    [[nodiscard]]
-    consteval std::string_view __find_pretty_name(std::string_view __sv) noexcept
-    {
-      auto const __beg_pos = __sv.find(__type_name_prefix);
-      auto const __end_pos = __sv.rfind(__type_name_suffix);
-
-      auto const __start = __beg_pos + sizeof(__type_name_prefix) - 1;
-      auto const __len   = __end_pos - __start;
-
-      return __sv.substr(__start, __len);
-    }
-
-    template <class _Ty>
-    [[nodiscard]]
-    consteval std::string_view __get_pretty_name_helper() noexcept
-    {
-#if STDEXEC_EDG()
-      return __detail::__find_pretty_name(std::string_view{STDEXEC_PRETTY_FUNCTION()});
-#else
-      return __detail::__find_pretty_name(std::source_location::current().function_name());
-#endif
-    }
-
-    template <class _Ty>
-    [[nodiscard]]
-    consteval std::string_view __get_pretty_name() noexcept
-    {
-      return __detail::__get_pretty_name_helper<typename __xyzzy<_Ty>::__plugh>();
-    }
-  }  // namespace __detail
-
-  ////////////////////////////////////////////////////////////////////////////////////////////
-  // __mnameof: get the pretty name of a type _Ty as a string_view at compile time
-  template <class _Ty>
-  inline constexpr std::string_view __mnameof = __detail::__get_pretty_name<__demangle_t<_Ty>>();
-
-  static_assert(__mnameof<void> == "void");
-
   template <class _List1, class _List2>
   struct __mzip_with2_ : __mzip_with2_<__mapply_q<__mlist, _List1>, __mapply_q<__mlist, _List2>>
   {};
@@ -1111,4 +990,31 @@ namespace STDEXEC
     using __f = __mapply<_Continuation, __mmake_set<_Ts...>>;
 #endif
   };
+
+  namespace __detail
+  {
+    template <std::size_t _Ny>
+    consteval auto __msort_impl(std::array<__type_index, _Ny> __arr) noexcept
+    {
+      std::ranges::sort(__arr);
+      return __arr;
+    }
+
+    template <class _Continuation, auto _Ids, class = __make_indices<_Ids.size()>>
+    struct __msort_apply;
+
+    template <class _Continuation, auto _Ids, std::size_t... _Is>
+    struct __msort_apply<_Continuation, _Ids, __indices<_Is...>>
+    {
+      using __t = __minvoke<_Continuation, __msplice<_Ids[_Is]>...>;
+    };
+  }  // namespace __detail
+
+  template <class _Continuation = __q<__mlist>>
+  struct __msort
+  {
+    template <class... _Ts>
+    using __f = __detail::__msort_apply<_Continuation,
+                                        __detail::__msort_impl(std::array{__mtypeid<_Ts>...})>::__t;
+  };
 }  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__receivers.hpp b/include/stdexec/__detail/__receivers.hpp
index d67dd8ff5..5650273b9 100644
--- a/include/stdexec/__detail/__receivers.hpp
+++ b/include/stdexec/__detail/__receivers.hpp
@@ -28,13 +28,6 @@
 
 namespace STDEXEC
 {
-  enum class __disposition
-  {
-    __value,
-    __error,
-    __stopped
-  };
-
   namespace __detail
   {
     template <__disposition _Disposition>
diff --git a/include/stdexec/__detail/__sequence.hpp b/include/stdexec/__detail/__sequence.hpp
index ff9c37a5e..9ba8081a7 100644
--- a/include/stdexec/__detail/__sequence.hpp
+++ b/include/stdexec/__detail/__sequence.hpp
@@ -499,7 +499,7 @@ namespace STDEXEC
   namespace __detail
   {
     template <class... _Senders>
-    extern __declfn_t<__seq::__sndr<__demangle_t<_Senders>...>>
+    extern __mtype<__seq::__sndr<__demangle_t<_Senders>...>>
       __demangle_v<__seq::__sndr<_Senders...>>;
   }  // namespace __detail
 }  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__static_vector.hpp b/include/stdexec/__detail/__static_vector.hpp
new file mode 100644
index 000000000..97484332e
--- /dev/null
+++ b/include/stdexec/__detail/__static_vector.hpp
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2026 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *   https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "__execution_fwd.hpp"
+
+#include "__concepts.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <initializer_list>
+
+namespace STDEXEC
+{
+  template <class _Tp, std::size_t _Capacity>
+  struct __static_vector;
+
+  namespace __detail
+  {
+    struct __static_vector_base
+    {
+      template <class... _What, class _Tp, std::size_t _Capacity>
+      [[nodiscard]]
+      friend constexpr auto operator+(__mexception<_What...>,                            //
+                                      __static_vector<_Tp, _Capacity> const &) noexcept  //
+        -> __mexception<_What...>
+      {
+        return {};
+      }
+
+      template <class... _What, class _Tp, std::size_t _Capacity>
+      [[nodiscard]]
+      friend constexpr auto operator+(__static_vector<_Tp, _Capacity> const &,  //
+                                      __mexception<_What...>) noexcept          //
+        -> __mexception<_What...>
+      {
+        return {};
+      }
+
+      template <class _Ty, std::size_t _Capacity0, std::size_t _Capacity1>
+      [[nodiscard]]
+      friend constexpr auto operator+(__static_vector<_Ty, _Capacity0> const &__lhs,  //
+                                      __static_vector<_Ty, _Capacity1> const &__rhs)
+        noexcept(__nothrow_copy_constructible<_Ty>) -> __static_vector<_Ty, _Capacity0 + _Capacity1>
+      {
+        __static_vector<_Ty, _Capacity0 + _Capacity1> __result;
+        std::copy(__lhs.begin(), __lhs.end(), __result.begin());
+        std::copy(__rhs.begin(), __rhs.end(), __result.begin() + __lhs.size());
+        __result.resize(__lhs.size() + __rhs.size());
+        return __result;
+      }
+    };
+  }  // namespace __detail
+
+  template <class _Tp, std::size_t _Capacity>
+  struct __static_vector : __detail::__static_vector_base
+  {
+    using value_type     = _Tp;
+    using iterator       = value_type *;
+    using const_iterator = value_type const *;
+
+    __static_vector() = default;
+
+    constexpr __static_vector(std::initializer_list<value_type> __init)
+      noexcept(__nothrow_copy_constructible<value_type>)
+    {
+      auto const __count = (std::min) (__init.size(), _Capacity);
+      auto const __end   = std::ranges::copy_n(__init.begin(), __count, __data_).out;
+      __size_            = __end - __data_;
+    }
+
+    [[nodiscard]]
+    constexpr auto operator[](std::size_t __i) noexcept -> value_type &
+    {
+      return __data_[__i];
+    }
+
+    [[nodiscard]]
+    constexpr auto operator[](std::size_t __i) const noexcept -> value_type const &
+    {
+      return __data_[__i];
+    }
+
+    [[nodiscard]]
+    constexpr auto begin() noexcept -> iterator
+    {
+      return __data_;
+    }
+
+    [[nodiscard]]
+    constexpr auto begin() const noexcept -> const_iterator
+    {
+      return __data_;
+    }
+
+    [[nodiscard]]
+    constexpr auto end() noexcept -> iterator
+    {
+      return __data_ + __size_;
+    }
+
+    [[nodiscard]]
+    constexpr auto end() const noexcept -> const_iterator
+    {
+      return __data_ + __size_;
+    }
+
+    [[nodiscard]]
+    constexpr auto size() const noexcept -> std::size_t
+    {
+      return __size_;
+    }
+
+    [[nodiscard]]
+    static constexpr auto capacity() noexcept -> std::size_t
+    {
+      return _Capacity;
+    }
+
+    constexpr void resize(std::size_t __new_size) noexcept
+    {
+      __size_ = __new_size;
+    }
+
+    constexpr auto erase(const_iterator __first, const_iterator __last) noexcept -> iterator
+    {
+      std::move(const_cast<iterator>(__last), end(), const_cast<iterator>(__first));
+      resize(size() - (__last - __first));
+      return end();
+    }
+
+    std::size_t __size_ = 0;
+    value_type  __data_[_Capacity];
+  };
+
+  // Specialization of __static_vector for zero capacity that doesn't require default
+  // constructibility of _Tp.
+  template <class _Tp>
+  struct __static_vector<_Tp, 0> : __detail::__static_vector_base
+  {
+    using value_type     = _Tp;
+    using iterator       = value_type *;
+    using const_iterator = value_type const *;
+
+    __static_vector() = default;
+
+    [[nodiscard]]
+    constexpr auto begin() noexcept -> iterator
+    {
+      return nullptr;
+    }
+
+    [[nodiscard]]
+    constexpr auto begin() const noexcept -> const_iterator
+    {
+      return nullptr;
+    }
+
+    [[nodiscard]]
+    constexpr auto end() noexcept -> iterator
+    {
+      return nullptr;
+    }
+
+    [[nodiscard]]
+    constexpr auto end() const noexcept -> const_iterator
+    {
+      return nullptr;
+    }
+
+    [[nodiscard]]
+    static constexpr auto size() noexcept -> std::size_t
+    {
+      return 0;
+    }
+
+    [[nodiscard]]
+    static constexpr auto capacity() noexcept -> std::size_t
+    {
+      return 0;
+    }
+  };
+
+  template <class _First, __same_as<_First>... _Rest>
+  STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
+  __static_vector(_First, _Rest...) -> __static_vector<_First, 1 + sizeof...(_Rest)>;
+
+  template <class _First, __same_as<_First>... _Rest>
+  constexpr auto __make_static_vector(_First __first, _Rest... __rest) noexcept
+  {
+    return __static_vector<_First, 1 + sizeof...(_Rest)>{__first, __rest...};
+  }
+}  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__stopped_as_optional.hpp b/include/stdexec/__detail/__stopped_as_optional.hpp
index 43e4f49b4..13a488420 100644
--- a/include/stdexec/__detail/__stopped_as_optional.hpp
+++ b/include/stdexec/__detail/__stopped_as_optional.hpp
@@ -66,8 +66,9 @@ namespace STDEXEC
       static constexpr auto __get_completion_signatures()
       {
         static_assert(__sender_for<_Self, stopped_as_optional_t>);
-        STDEXEC_COMPLSIGS_LET(__completions,
-                              STDEXEC::get_completion_signatures<__child_of<_Self>, _Env...>())
+        auto __completions = STDEXEC::get_completion_signatures<__child_of<_Self>, _Env...>();
+
+        STDEXEC_IF_OK(__completions)
         {
           using _Completions = decltype(__completions);
           if constexpr (__single_value_sender<__child_of<_Self>, _Env...>)
diff --git a/include/stdexec/__detail/__transform_completion_signatures.hpp b/include/stdexec/__detail/__transform_completion_signatures.hpp
index a61b441ff..98b6d34c5 100644
--- a/include/stdexec/__detail/__transform_completion_signatures.hpp
+++ b/include/stdexec/__detail/__transform_completion_signatures.hpp
@@ -575,9 +575,11 @@ namespace STDEXEC
                                                    _StoppedFn __stopped_fn = {},
                                                    _ExtraSigs              = {})
   {
-    STDEXEC_COMPLSIGS_LET(__completions, _Completions{})
+    auto __completions = _Completions{};
+    STDEXEC_IF_OK(__completions)
     {
-      STDEXEC_COMPLSIGS_LET(__extra_sigs, _ExtraSigs{})
+      auto __extra_sigs = _ExtraSigs{};
+      STDEXEC_IF_OK(__extra_sigs)
       {
         __cmplsigs::__transform_one __tfx1{__value_fn, __error_fn, __stopped_fn};
         return __concat_completion_signatures(__completions.__apply(
diff --git a/include/stdexec/__detail/__typeinfo.hpp b/include/stdexec/__detail/__typeinfo.hpp
index 9fa81172c..483de8292 100644
--- a/include/stdexec/__detail/__typeinfo.hpp
+++ b/include/stdexec/__detail/__typeinfo.hpp
@@ -17,9 +17,9 @@
 #pragma once
 
 #include "__config.hpp"
-#include "__meta.hpp"
 
 #include <compare>
+#include <source_location>
 #include <string_view>
 #include <typeinfo>
 
@@ -27,10 +27,90 @@ STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-private-field")
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// __type_info, __mtypeid, and __mtypeof
+// __type_info, __mtypeid, and __msplice
 
 namespace STDEXEC
 {
+  template <class _Ty>
+  struct __mtype
+  {
+    using __t = _Ty;
+  };
+
+  namespace __detail
+  {
+    template <class _Ty>
+    extern __mtype<_Ty> __demangle_v;
+  }  // namespace __detail
+
+  // A utility for pretty-printing type names in diagnostics
+  template <class _Ty>
+  using __demangle_t = decltype(__detail::__demangle_v<_Ty>)::__t;
+
+  namespace __detail
+  {
+    template <class _Ty>
+    extern __mtype<__demangle_t<_Ty> &> __demangle_v<_Ty &>;
+
+    template <class _Ty>
+    extern __mtype<__demangle_t<_Ty> &&> __demangle_v<_Ty &&>;
+
+    template <class _Ty>
+    extern __mtype<__demangle_t<_Ty> const &> __demangle_v<_Ty const &>;
+  }  // namespace __detail
+
+  namespace __detail
+  {
+    //////////////////////////////////////////////////////////////////////////////////////////
+    // __get_pretty_name
+    template <class>
+    struct __xyzzy
+    {
+      struct __plugh
+      {};
+    };
+
+    inline constexpr char __type_name_prefix[] = "__xyzzy<";
+    inline constexpr char __type_name_suffix[] = ">::__plugh";
+
+    [[nodiscard]]
+    consteval std::string_view __find_pretty_name(std::string_view __sv) noexcept
+    {
+      auto const __beg_pos = __sv.find(__type_name_prefix);
+      auto const __end_pos = __sv.rfind(__type_name_suffix);
+
+      auto const __start = __beg_pos + sizeof(__type_name_prefix) - 1;
+      auto const __len   = __end_pos - __start;
+
+      return __sv.substr(__start, __len);
+    }
+
+    template <class _Ty>
+    [[nodiscard]]
+    consteval std::string_view __get_pretty_name_helper() noexcept
+    {
+#if STDEXEC_EDG()
+      return __detail::__find_pretty_name(std::string_view{STDEXEC_PRETTY_FUNCTION()});
+#else
+      return __detail::__find_pretty_name(std::source_location::current().function_name());
+#endif
+    }
+
+    template <class _Ty>
+    [[nodiscard]]
+    consteval std::string_view __get_pretty_name() noexcept
+    {
+      return __detail::__get_pretty_name_helper<typename __xyzzy<_Ty>::__plugh>();
+    }
+  }  // namespace __detail
+
+  ////////////////////////////////////////////////////////////////////////////////////////////
+  // __mnameof: get the pretty name of a type _Ty as a string_view at compile time
+  template <class _Ty>
+  inline constexpr std::string_view __mnameof = __detail::__get_pretty_name<__demangle_t<_Ty>>();
+
+  static_assert(__mnameof<void> == "void");
+
   //////////////////////////////////////////////////////////////////////////////////////////
   // __type_info
   struct __type_info
@@ -97,8 +177,10 @@ namespace STDEXEC
   // __type_index
   struct __type_index
   {
-    constexpr __type_index(__type_info const &info) noexcept
-      : __info_(&info)
+    __type_index() = default;
+
+    constexpr __type_index(__type_info const &__info) noexcept
+      : __info_(&__info)
     {}
 
     [[nodiscard]]
@@ -108,15 +190,15 @@ namespace STDEXEC
     }
 
     [[nodiscard]]
-    constexpr bool operator==(__type_index const &other) const noexcept
+    constexpr bool operator==(__type_index const &__other) const noexcept
     {
-      return *__info_ == *other.__info_;
+      return *__info_ == *__other.__info_;
     }
 
     [[nodiscard]]
-    constexpr std::strong_ordering operator<=>(__type_index const &other) const noexcept
+    constexpr std::strong_ordering operator<=>(__type_index const &__other) const noexcept
     {
-      return *__info_ <=> *other.__info_;
+      return *__info_ <=> *__other.__info_;
     }
 
 #if !STDEXEC_NO_STDCPP_TYPEID()
@@ -133,7 +215,7 @@ namespace STDEXEC
     }
 #endif
 
-    __type_info const *__info_;
+    __type_info const *__info_ = &__detail::__mtypeid_v<void>;
   };
 
   namespace __detail
@@ -164,19 +246,33 @@ namespace STDEXEC
 
     STDEXEC_PRAGMA_POP()
 
-    // This specialization is what makes __mtypeof< Id > return the type associated with Id.
-    template <auto _Index>
-      requires __same_as<decltype(_Index) const, __type_index const>
-    extern __fn_t<__t<decltype(__typeid_lookup(__detail::__mtypeid_key<_Index>()))>>
-      *__mtypeof_v<_Index>;
+#if STDEXEC_MSVC()
+    template <auto _Id>
+    struct __msplice_helper : decltype(__typeid_lookup(__mtypeid_key<_Id>())){};
+#else
+    // Cache the result of the lookup:
+    template <auto _Id>
+    extern decltype(__typeid_lookup(__mtypeid_key<_Id>())) __msplice_v;
+#endif
   }  // namespace __detail
 
   // For a given type, return a __type_index object
   template <class _Ty>
   inline constexpr __type_index __mtypeid = __detail::__mtypeid_value<_Ty>::__id;
 
+#if STDEXEC_MSVC()
+  template <__type_index _Id>
+  using __msplice = __detail::__msplice_helper<_Id>::__t;
+#elif STDEXEC_GCC() && STDEXEC_GCC_VERSION < 1300
+  template <auto _Id>
+  using __msplice = decltype(__detail::__msplice_v<_Id>)::__t;
+#else
+  template <__type_index _Id>
+  using __msplice = decltype(__detail::__msplice_v<_Id>)::__t;
+#endif
+
   // Sanity check:
-  static_assert(STDEXEC_IS_SAME(void, __mtypeof<__mtypeid<void>>));
+  static_assert(STDEXEC_IS_SAME(void, __msplice<__mtypeid<void>>));
 }  // namespace STDEXEC
 
 STDEXEC_PRAGMA_POP()
diff --git a/include/stdexec/__detail/__utility.hpp b/include/stdexec/__detail/__utility.hpp
index 1526fe9ec..89c9cf2f7 100644
--- a/include/stdexec/__detail/__utility.hpp
+++ b/include/stdexec/__detail/__utility.hpp
@@ -65,21 +65,18 @@ namespace STDEXEC
 
   struct __move_only
   {
-    __move_only() = default;
-
+    __move_only()                                          = default;
     __move_only(__move_only&&) noexcept                    = default;
+    __move_only(__move_only const &)                       = delete;
     auto operator=(__move_only&&) noexcept -> __move_only& = default;
-
-    __move_only(__move_only const &)                    = delete;
-    auto operator=(__move_only const &) -> __move_only& = delete;
+    auto operator=(__move_only const &) -> __move_only&    = delete;
   };
 
   template <class _Fun, class... _As>
   using __call_result_t = decltype(__declval<_Fun>()(__declval<_As>()...));
 
   template <class _Fun, class _Default, class... _As>
-  using __call_result_or_t =
-    __mcall<__mtry_catch_q<__call_result_t, __mconst<_Default>>, _Fun, _As...>;
+  using __call_result_or_t = __minvoke_or_q<__call_result_t, _Default, _Fun, _As...>;
 
 // BUGBUG TODO file this bug with nvc++
 #if STDEXEC_EDG()
diff --git a/include/stdexec/execution.hpp b/include/stdexec/execution.hpp
index 5f30676a1..9f5f6a4da 100644
--- a/include/stdexec/execution.hpp
+++ b/include/stdexec/execution.hpp
@@ -27,7 +27,6 @@
 #include "__detail/__connect_awaitable.hpp"
 #include "__detail/__continues_on.hpp"
 #include "__detail/__counting_scopes.hpp"
-#include "__detail/__cpo.hpp"
 #include "__detail/__debug.hpp"
 #include "__detail/__domain.hpp"
 #include "__detail/__env.hpp"
diff --git a/include/stdexec/functional.hpp b/include/stdexec/functional.hpp
index 09d0e8ed6..1c8b86e9d 100644
--- a/include/stdexec/functional.hpp
+++ b/include/stdexec/functional.hpp
@@ -267,12 +267,12 @@ namespace STDEXEC
   struct __construct_from
   {
     template <class... _As>
-      requires __std::constructible_from<_Ty, _As...>
+      requires __initializable_from<_Ty, _As...>
     STDEXEC_ATTRIBUTE(host, device, always_inline)
-    constexpr auto operator()(_As &&...__as) const noexcept(  //
-      __nothrow_constructible_from<_Ty, _As...>) -> _Ty
+    constexpr auto
+    operator()(_As &&...__as) const noexcept(__nothrow_initializable_from<_Ty, _As...>) -> _Ty
     {
-      return _Ty(static_cast<_As &&>(__as)...);
+      return _Ty{static_cast<_As &&>(__as)...};
     }
   };
 
@@ -363,8 +363,7 @@ namespace STDEXEC
   constexpr auto __bind_back(_Fn &&__fn, _BoundArgs... __bound_args)
     noexcept(__nothrow_move_constructible<_BoundArgs...> && __nothrow_decay_copyable<_Fn>)
   {
-    return __back_binder<__decay_t<_Fn>, _BoundArgs...>{static_cast<_Fn &&>(__fn),
-                                                        static_cast<_BoundArgs &&>(
-                                                          __bound_args)...};
+    using __binder_t = __back_binder<__decay_t<_Fn>, _BoundArgs...>;
+    return __binder_t{static_cast<_Fn &&>(__fn), static_cast<_BoundArgs &&>(__bound_args)...};
   };
 }  // namespace STDEXEC
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index e14a0469d..006e1d6f2 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -18,7 +18,7 @@ check_compiler_flag(CXX -Wno-c2y-extensions HAVE_C2Y_EXTENSIONS_WARNING)
 
 function(add_compile_diagnostics TARGET)
     if(CMAKE_CXX_COMPILER_ID STREQUAL Clang OR CMAKE_CXX_COMPILER_ID STREQUAL GNU)
-        target_compile_options(${TARGET} PRIVATE -Wall -Wextra -Wpedantic -Werror $<$<BOOL:${HAVE_C2Y_EXTENSIONS_WARNING}>:-Wno-c2y-extensions>)
+        target_compile_options(${TARGET} PRIVATE -Wall -Wextra -Wpedantic -Werror -Wfatal-errors $<$<BOOL:${HAVE_C2Y_EXTENSIONS_WARNING}>:-Wno-c2y-extensions>)
     endif()
 endfunction()
 
diff --git a/test/stdexec/algos/adaptors/test_into_variant.cpp b/test/stdexec/algos/adaptors/test_into_variant.cpp
index 6b20df485..6fa1d5bd9 100644
--- a/test/stdexec/algos/adaptors/test_into_variant.cpp
+++ b/test/stdexec/algos/adaptors/test_into_variant.cpp
@@ -26,7 +26,6 @@ namespace ex = STDEXEC;
 
 namespace
 {
-
   TEST_CASE("into_variant returns a sender", "[adaptors][into_variant]")
   {
     auto snd = ex::into_variant(ex::just(11));
@@ -78,8 +77,10 @@ namespace
     check_val_types<ex::__mset<pack<int>, pack<std::string>>>(std::move(in_snd));
 
     ex::sender auto snd = std::move(in_snd) | ex::into_variant();
-    wait_for_value(std::move(snd),
-                   std::variant<std::tuple<int>, std::tuple<std::string>>{std::make_tuple(13)});
+
+    using variant_t =
+      ex::__minvoke<ex::__msort<ex::__qq<std::variant>>, std::tuple<int>, std::tuple<std::string>>;
+    wait_for_value(std::move(snd), variant_t{std::make_tuple(13)});
   }
 
   TEST_CASE("into_variant can be used with just_error", "[adaptors][into_variant]")
@@ -124,7 +125,9 @@ namespace
     check_val_types<ex::__mset<pack<std::variant<std::tuple<int, double>>>>>(ex::just(3, 0.1415)
                                                                              | ex::into_variant());
 
-    check_val_types<ex::__mset<pack<std::variant<std::tuple<int>, std::tuple<std::string>>>>>(
+    using variant_t =
+      ex::__minvoke<ex::__msort<ex::__qq<std::variant>>, std::tuple<int>, std::tuple<std::string>>;
+    check_val_types<ex::__mset<pack<variant_t>>>(
       fallible_just{13}
       | ex::let_error([](std::exception_ptr) { return ex::just(std::string{"err"}); })
       // sender here can send either `int` or `std::string`
diff --git a/test/stdexec/algos/consumers/test_sync_wait.cpp b/test/stdexec/algos/consumers/test_sync_wait.cpp
index 3ef5e1d2e..8d054bd8a 100644
--- a/test/stdexec/algos/consumers/test_sync_wait.cpp
+++ b/test/stdexec/algos/consumers/test_sync_wait.cpp
@@ -157,11 +157,12 @@ namespace
     check_val_types<ex::__mset<pack<int>, pack<std::string>>>(std::move(snd));
     static_assert(std::invocable<ex::sync_wait_with_variant_t, decltype(snd)>);
 
-    std::optional<std::tuple<std::variant<std::tuple<int>, std::tuple<std::string>>>> res =
-      ex::sync_wait_with_variant(std::move(snd));
+    using variant_t =
+      ex::__minvoke<ex::__msort<ex::__qq<std::variant>>, std::tuple<int>, std::tuple<std::string>>;
+    std::optional<variant_t> res = ex::sync_wait_with_variant(std::move(snd));
 
     CHECK(res.has_value());
-    CHECK_TUPLE(std::get<0>(std::get<0>(res.value())) == std::make_tuple(13));
+    CHECK(std::get<0>(std::get<std::tuple<int>>(res.value())) == 13);
   }
 
   TEST_CASE("sync_wait_with_variant accepts single-value senders",
@@ -171,10 +172,10 @@ namespace
     check_val_types<ex::__mset<pack<int>>>(snd);
     static_assert(std::invocable<ex::sync_wait_with_variant_t, decltype(snd)>);
 
-    std::optional<std::tuple<std::variant<std::tuple<int>>>> res = ex::sync_wait_with_variant(snd);
+    std::optional<std::variant<std::tuple<int>>> res = ex::sync_wait_with_variant(snd);
 
     CHECK(res.has_value());
-    CHECK_TUPLE(std::get<0>(std::get<0>(res.value())) == std::make_tuple(13));
+    CHECK(std::get<0>(std::get<std::tuple<int>>(res.value())) == 13);
   }
 
   TEST_CASE("sync_wait works if signaled from a different thread", "[consumers][sync_wait]")