run_loop has no set_stopped completion with unstoppable token

include/exec/sequence/merge_each.hpp

@@ -772,13 +772,13 @@ namespace exec {
           // else remove
           STDEXEC::__mconst<STDEXEC::__mlist<>>::__f,
           // concat to __mlist result
-          STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__mlist>>::__f
+          STDEXEC::__mtry<STDEXEC::__mconcat<STDEXEC::__q<STDEXEC::__mlist>>>::__f
         >;
       };
 
       template <class _Sequence, class _Sender, class... _Env>
       using __nested_sequences_from_item_type_t = STDEXEC::__minvoke<
-        __mtry<__gather_sequences_t<_Sequence, _Sender, _Env...>>,
+        __gather_sequences_t<_Sequence, _Sender, _Env...>,
         STDEXEC::__completion_signatures_of_t<_Sender, _Env...>
       >;
 
@@ -1131,7 +1131,6 @@ namespace exec {
       >
     >;
 
-
     template <class _Receiver>
     struct __subscribe_fn {
       template <class _Sequence>
@@ -1206,16 +1205,17 @@ namespace exec {
         __compute::__nested_sequences_t<__child_of<_Self>, _Env...>
       >;
 
-      template <sender_expr_for<merge_each_t> _Self, class... _Env>
+      template <class _Self, class... _Env>
       static consteval auto get_completion_signatures() {
+        static_assert(sender_expr_for<_Self, merge_each_t>);
         // TODO: update this to use constant evaluation:
         using __result_t = __minvoke<
           __mtry_q<__completions_t>,
           _Self,
           __env_with_inplace_stop_token_result_t<_Env>...
         >;
         if constexpr (__ok<__result_t>) {
-          static_assert(__valid_completion_signatures<__result_t>);
+          static_assert(STDEXEC::__well_formed_completions<__result_t>);
           return __result_t();
         } else {
           return STDEXEC::__throw_compile_time_error(__result_t());

include/exec/sequence_senders.hpp

@@ -392,15 +392,15 @@ namespace exec {
     requires STDEXEC::__well_formed_sender<_Item>
   auto __check_item(_Item*) -> STDEXEC::__msuccess;
 
-  template <class _Sequence, class _Items>
-    requires STDEXEC::__merror<_Items>
-  auto __check_items(_Items*) -> _Items;
-
   struct _SEQUENCE_GET_ITEM_TYPES_RESULT_IS_NOT_WELL_FORMED_ { };
 
   template <template <class...> class _Class>
   struct _EXPECTED_A_SPECIALIZATION_OF_ { };
 
+  template <class _Sequence, class _Items>
+    requires STDEXEC::__merror<_Items>
+  auto __check_items(_Items*) -> _Items;
+
   template <class _Sequence, class _Items>
     requires(!STDEXEC::__merror<_Items>)
   auto __check_items(_Items*) -> STDEXEC::__mexception<
@@ -411,7 +411,7 @@ namespace exec {
   >;
 
   template <class _Sequence, class... _Items>
-  constexpr auto __check_items(exec::item_types<_Items...>*) -> decltype((
+  auto __check_items(exec::item_types<_Items...>*) -> decltype((
     STDEXEC::__msuccess(),
     ...,
     exec::__check_item<_Sequence>(static_cast<_Items*>(nullptr))));
@@ -442,9 +442,13 @@ namespace exec {
   auto __check_sequence(_Sequence*) -> decltype(exec::__check_items<_Sequence>(
     static_cast<__item_types_of_t<_Sequence>*>(nullptr)));
 
+  template <class _Ty>
+  concept __ok_or_dependent = STDEXEC::__ok<_Ty>
+                           || STDEXEC::__std::derived_from<_Ty, STDEXEC::dependent_sender_error>;
+
   template <class _Sequence>
   concept __well_formed_item_senders = requires(STDEXEC::__decay_t<_Sequence>* __sequence) {
-    { exec::__check_sequence(__sequence) } -> STDEXEC::__ok;
+    { exec::__check_sequence(__sequence) } -> __ok_or_dependent;
   };
 
   template <class _Sequence>

include/stdexec/__detail/__meta.hpp

@@ -146,7 +146,7 @@ namespace STDEXEC {
 
     template <class... _Ts>
     STDEXEC_ATTRIBUTE(always_inline)
-    constexpr __ignore(_Ts&&...) noexcept {
+    constexpr __ignore(_Ts &&...) noexcept {
     }
   };
 
@@ -558,10 +558,10 @@ namespace STDEXEC {
     using __f = __minvoke<_Fn, std::integral_constant<_Np, _Ns>...>;
   };
 
-  template <class _What, class... _With>
-  struct __mfor<_ERROR_<_What, _With...>> {
+  template <class... _What>
+  struct __mfor<_ERROR_<_What...>> {
     template <class _Fn>
-    using __f = _ERROR_<_What, _With...>;
+    using __f = _ERROR_<_What...>;
   };
 
   template <class _Fn, class _List>

include/stdexec/__detail/__run_loop.hpp

@@ -224,10 +224,14 @@ namespace STDEXEC {
               &__loop_->__task_count_, &__loop_->__queue_, static_cast<_Rcvr&&>(__rcvr)};
           }
 
-          template <class, class...>
+          template <class, class _RcvrEnv>
           STDEXEC_ATTRIBUTE(nodiscard, host, device)
           static consteval auto get_completion_signatures() noexcept {
-            return completion_signatures<set_value_t(), set_stopped_t()>{};
+            if constexpr (unstoppable_token<stop_token_of_t<_RcvrEnv>>) {
+              return completion_signatures<set_value_t()>{};
+            } else {
+              return completion_signatures<set_value_t(), set_stopped_t()>{};
+            }
           }
 
           STDEXEC_ATTRIBUTE(nodiscard, host, device)