diff --git a/include/sdbusplus/async/stdexec/__detail/__env.hpp b/include/sdbusplus/async/stdexec/__detail/__env.hpp
index 229de70..3c0ff09 100644
--- a/include/sdbusplus/async/stdexec/__detail/__env.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__env.hpp
@@ -325,230 +325,23 @@
     __call_result_t<query_or_t, _Tag, _Queryable, _Default>;
 
 /////////////////////////////////////////////////////////////////////////////
-// env_of
 namespace __env
 {
-template <class _Descriptor>
-struct __prop;
-
-template <class _Value, class... _Tags>
-struct __prop<_Value(_Tags...)>
-{
-    using __t = __prop;
-    using __id = __prop;
-    _Value __value_;
-
-    template <__one_of<_Tags...> _Key>
-    friend auto tag_invoke(_Key, const __prop& __self) //
-        noexcept(__nothrow_decay_copyable<_Value>) -> _Value
-    {
-        return __self.__value_;
-    }
-};
-
-template <class... _Tags>
-struct __prop<void(_Tags...)>
-{
-    using __t = __prop;
-    using __id = __prop;
-
-    template <__one_of<_Tags...> _Key, class _Self>
-        requires(std::is_base_of_v<__prop, __decay_t<_Self>>)
-    friend auto tag_invoke(_Key, _Self&&) noexcept = delete;
-};
-
-struct __mkprop_t
-{
-    template <class _Value, class _Tag, class... _Tags>
-    auto operator()(_Value&& __value, _Tag, _Tags...) const
-        noexcept(__nothrow_decay_copyable<_Value>)
-            -> __prop<__decay_t<_Value>(_Tag, _Tags...)>
-    {
-        return {(_Value&&)__value};
-    }
-
-    template <class _Tag>
-    auto operator()(_Tag) const -> __prop<void(_Tag)>
-    {
-        return {};
-    }
-};
-
-template <__nothrow_move_constructible _Fun>
-struct __env_fn
-{
-    using __t = __env_fn;
-    using __id = __env_fn;
-    STDEXEC_ATTRIBUTE((no_unique_address)) _Fun __fun_;
-
-    template <class _Tag>
-        requires __callable<const _Fun&, _Tag>
-    friend auto tag_invoke(_Tag, const __env_fn& __self) //
-        noexcept(__nothrow_callable<const _Fun&, _Tag>)
-            -> __call_result_t<const _Fun&, _Tag>
-    {
-        return __self.__fun_(_Tag());
-    }
-};
-
-template <class _Fun>
-__env_fn(_Fun) -> __env_fn<_Fun>;
-
-template <class _Env>
-struct __env_fwd
-{
-    static_assert(__nothrow_move_constructible<_Env>);
-    using __t = __env_fwd;
-    using __id = __env_fwd;
-    STDEXEC_ATTRIBUTE((no_unique_address)) _Env __env_;
-
-    template <__forwarding_query _Tag>
-        requires tag_invocable<_Tag, const _Env&>
-    friend auto tag_invoke(_Tag, const __env_fwd& __self) //
-        noexcept(nothrow_tag_invocable<_Tag, const _Env&>)
-            -> tag_invoke_result_t<_Tag, const _Env&>
-    {
-        return _Tag()(__self.__env_);
-    }
-};
-
-template <class _Env>
-__env_fwd(_Env&&) -> __env_fwd<_Env>;
-
-template <class _Env, class _Base = empty_env>
-struct __joined_env : __env_fwd<_Base>
-{
-    static_assert(__nothrow_move_constructible<_Env>);
-    using __t = __joined_env;
-    using __id = __joined_env;
-    STDEXEC_ATTRIBUTE((no_unique_address)) _Env __env_;
-
-    const _Base& base() const noexcept
-    {
-        return this->__env_fwd<_Base>::__env_;
-    }
-
-    template <class _Tag>
-        requires tag_invocable<_Tag, const _Env&>
-    friend auto tag_invoke(_Tag, const __joined_env& __self) //
-        noexcept(nothrow_tag_invocable<_Tag, const _Env&>)
-            -> tag_invoke_result_t<_Tag, const _Env&>
-    {
-        return _Tag()(__self.__env_);
-    }
-};
-
-template <class _Tag, class _Base>
-struct __joined_env<__prop<void(_Tag)>, _Base> : __env_fwd<_Base>
-{
-    using __t = __joined_env;
-    using __id = __joined_env;
-    STDEXEC_ATTRIBUTE((no_unique_address)) __prop<void(_Tag)> __env_;
-
-    friend void tag_invoke(_Tag, const __joined_env&) noexcept = delete;
-};
-
-struct __join_env_t
-{
-    template <class _Env>
-    _Env operator()(_Env&& __env) const noexcept
-    {
-        return (_Env&&)__env;
-    }
-
-    template <class _Env, class _Base>
-    decltype(auto) operator()(_Env&& __env, _Base&& __base) const noexcept
-    {
-        using __env_t = __decay_t<_Env>;
-        using __base_t = __decay_t<_Base>;
-        if constexpr (__same_as<__env_t, empty_env>)
-        {
-            return _Base((_Base&&)__base);
-        }
-        else if constexpr (__same_as<__base_t, empty_env>)
-        {
-            return _Env((_Env&&)__env);
-        }
-        else
-        {
-            return __joined_env<_Env, _Base>{{(_Base&&)__base}, (_Env&&)__env};
-        }
-    }
-
-    template <class _Env0, class _Env1, class _Env2, class... _Envs>
-    decltype(auto) operator()(_Env0&& __env0, _Env1&& __env1, _Env2&& __env2,
-                              _Envs&&... __envs) const noexcept
-    {
-        const auto& __join_env = *this;
-        return __join_env(
-            (_Env0&&)__env0,
-            __join_env((_Env1&&)__env1,
-                       __join_env((_Env2&&)__env2, (_Envs&&)__envs...)));
-    }
-};
-
-template <class... _Envs>
-using __env_join_t = __call_result_t<__join_env_t, _Envs...>;
-
-// To be kept in sync with the promise type used in __connect_awaitable
-template <class _Env>
-struct __env_promise
-{
-    template <class _Ty>
-    _Ty&& await_transform(_Ty&& __value) noexcept
-    {
-        return (_Ty&&)__value;
-    }
-
-    template <class _Ty>
-        requires tag_invocable<as_awaitable_t, _Ty, __env_promise&>
-    auto await_transform(_Ty&& __value) //
-        noexcept(nothrow_tag_invocable<as_awaitable_t, _Ty, __env_promise&>)
-            -> tag_invoke_result_t<as_awaitable_t, _Ty, __env_promise&>
-    {
-        return tag_invoke(as_awaitable, (_Ty&&)__value, *this);
-    }
-
-    template <same_as<get_env_t> _Tag>
-    friend auto tag_invoke(_Tag, const __env_promise&) noexcept -> const _Env&
-    {
-        std::terminate();
-    }
-};
-
-// For making an environment from key/value pairs and optionally
-// another environment.
-struct __make_env_t
-{
-    template <__nothrow_move_constructible _Base,
-              __nothrow_move_constructible _Env>
-    auto operator()(_Base&& __base, _Env&& __env) const noexcept
-        -> __env_join_t<_Env, _Base>
-    {
-        return __join_env_t()((_Env&&)__env, (_Base&&)__base);
-    }
-
-    template <__nothrow_move_constructible _Env>
-    _Env operator()(_Env&& __env) const noexcept
-    {
-        return (_Env&&)__env;
-    }
-};
-
-// For getting an evaluation environment from a receiver
+// For getting an execution environment from a receiver,
+// or the attributes from a sender.
 struct get_env_t
 {
     template <class _EnvProvider>
         requires tag_invocable<get_env_t, const _EnvProvider&>
     STDEXEC_ATTRIBUTE((always_inline)) //
         constexpr auto
-        operator()(const _EnvProvider& __with_env) const noexcept
+        operator()(const _EnvProvider& __env_provider) const noexcept
         -> tag_invoke_result_t<get_env_t, const _EnvProvider&>
     {
         static_assert(
             queryable<tag_invoke_result_t<get_env_t, const _EnvProvider&>>);
         static_assert(nothrow_tag_invocable<get_env_t, const _EnvProvider&>);
-        return tag_invoke(*this, __with_env);
+        return tag_invoke(*this, __env_provider);
     }
 
     template <class _EnvProvider>
@@ -557,28 +350,259 @@
         return {};
     }
 };
+
+// To be kept in sync with the promise type used in __connect_awaitable
+template <class _Env>
+struct __promise
+{
+    template <class _Ty>
+    _Ty&& await_transform(_Ty&& __value) noexcept
+    {
+        return (_Ty&&)__value;
+    }
+
+    template <class _Ty>
+        requires tag_invocable<as_awaitable_t, _Ty, __promise&>
+    auto await_transform(_Ty&& __value) //
+        noexcept(nothrow_tag_invocable<as_awaitable_t, _Ty, __promise&>)
+            -> tag_invoke_result_t<as_awaitable_t, _Ty, __promise&>
+    {
+        return tag_invoke(as_awaitable, (_Ty&&)__value, *this);
+    }
+
+    template <same_as<get_env_t> _Tag>
+    friend auto tag_invoke(_Tag, const __promise&) noexcept -> const _Env&
+    {
+        std::terminate();
+    }
+};
+
+template <class _Value, class _Tag, class... _Tags>
+struct __with
+{
+    using __t = __with;
+    using __id = __with;
+    _Value __value_;
+
+    constexpr __with(_Value __value) noexcept(
+        __nothrow_decay_copyable<_Value>) :
+        __value_((_Value&&)__value)
+    {}
+
+    constexpr explicit __with(_Value __value, _Tag, _Tags...) noexcept(
+        __nothrow_decay_copyable<_Value>) :
+        __value_((_Value&&)__value)
+    {}
+
+    template <__one_of<_Tag, _Tags...> _Key>
+    friend auto tag_invoke(_Key, const __with& __self) //
+        noexcept(__nothrow_decay_copyable<_Value>) -> _Value
+    {
+        return __self.__value_;
+    }
+};
+
+template <class _Value, class _Tag, class... _Tags>
+__with(_Value, _Tag, _Tags...) -> __with<_Value, _Tag, _Tags...>;
+
+template <class _Tag, class... _Tags>
+struct __without
+{
+    using __t = __without;
+    using __id = __without;
+
+    __without() = default;
+
+    constexpr explicit __without(_Tag, _Tags...) noexcept {}
+};
+
+template <class _Env>
+struct __fwd
+{
+    static_assert(__nothrow_move_constructible<_Env>);
+    using __t = __fwd;
+    using __id = __fwd;
+    STDEXEC_ATTRIBUTE((no_unique_address)) _Env __env_;
+
+    template <__forwarding_query _Tag>
+        requires tag_invocable<_Tag, const _Env&>
+    friend auto tag_invoke(_Tag, const __fwd& __self) //
+        noexcept(nothrow_tag_invocable<_Tag, const _Env&>)
+            -> tag_invoke_result_t<_Tag, const _Env&>
+    {
+        return _Tag()(__self.__env_);
+    }
+};
+
+template <class _Env>
+__fwd(_Env&&) -> __fwd<_Env>;
+
+template <class _Second, class _First>
+struct __joined : _Second
+{
+    static_assert(__nothrow_move_constructible<_First>);
+    static_assert(__nothrow_move_constructible<_Second>);
+    using __t = __joined;
+    using __id = __joined;
+
+    STDEXEC_ATTRIBUTE((no_unique_address)) _First __env_;
+
+    template <class _Tag>
+        requires tag_invocable<_Tag, const _First&>
+    friend auto tag_invoke(_Tag, const __joined& __self) //
+        noexcept(nothrow_tag_invocable<_Tag, const _First&>)
+            -> tag_invoke_result_t<_Tag, const _First&>
+    {
+        return _Tag()(__self.__env_);
+    }
+};
+
+template <class _Second, class _Tag, class... _Tags>
+struct __joined<_Second, __without<_Tag, _Tags...>> :
+    _Second,
+    __without<_Tag, _Tags...>
+{
+    using __t = __joined;
+    using __id = __joined;
+
+    template <__one_of<_Tag, _Tags...> _Key, class _Self>
+        requires(std::is_base_of_v<__joined, __decay_t<_Self>>)
+    friend auto tag_invoke(_Key, _Self&&) noexcept = delete;
+};
+
+template <class _Second, class _First>
+__joined(_Second&&, _First&&) -> __joined<_Second, _First>;
+
+template <__nothrow_move_constructible _Fun>
+struct __from
+{
+    using __t = __from;
+    using __id = __from;
+    STDEXEC_ATTRIBUTE((no_unique_address)) _Fun __fun_;
+
+    template <class _Tag>
+        requires __callable<const _Fun&, _Tag>
+    friend auto tag_invoke(_Tag, const __from& __self) //
+        noexcept(__nothrow_callable<const _Fun&, _Tag>)
+            -> __call_result_t<const _Fun&, _Tag>
+    {
+        return __self.__fun_(_Tag());
+    }
+};
+
+template <class _Fun>
+__from(_Fun) -> __from<_Fun>;
+
+struct __fwd_fn
+{
+    template <class Env>
+    auto operator()(Env&& env) const
+    {
+        return __fwd{(Env&&)env};
+    }
+
+    empty_env operator()(empty_env) const
+    {
+        return {};
+    }
+
+    template <class _Tag, class... _Tags>
+    __without<_Tag, _Tags...> operator()(__without<_Tag, _Tags...>) const
+    {
+        return {};
+    }
+};
+
+struct __join_fn
+{
+    empty_env operator()() const
+    {
+        return {};
+    }
+
+    template <class _Env>
+    _Env operator()(_Env&& __env) const
+    {
+        return (_Env&&)__env;
+    }
+
+    empty_env operator()(empty_env) const
+    {
+        return {};
+    }
+
+    template <class _Tag, class... _Tags>
+    empty_env operator()(__without<_Tag, _Tags...>) const
+    {
+        return {};
+    }
+
+    template <class _Env>
+    _Env operator()(_Env&& __env, empty_env) const
+    {
+        return (_Env&&)__env;
+    }
+
+    template <class _Env, class _Tag, class... _Tags>
+    _Env operator()(_Env&& __env, __without<_Tag, _Tags...>) const
+    {
+        return (_Env&&)__env;
+    }
+
+    empty_env operator()(empty_env, empty_env) const
+    {
+        return {};
+    }
+
+    template <class _Tag, class... _Tags>
+    empty_env operator()(empty_env, __without<_Tag, _Tags...>) const
+    {
+        return {};
+    }
+
+    template <class _Tag, class... _Tags>
+    empty_env operator()(__without<_Tag, _Tags...>, empty_env) const
+    {
+        return {};
+    }
+
+    template <class _Tag, class... _Tags, class _Tag2, class... _Tags2>
+    empty_env operator()(__without<_Tag, _Tags...>,
+                         __without<_Tag2, _Tags2...>) const
+    {
+        return {};
+    }
+
+    template <class... Rest>
+    decltype(auto) operator()(empty_env, Rest&&... rest) const
+    {
+        return __fwd_fn()(__join_fn()((Rest&&)rest...));
+    }
+
+    template <class _Tag, class... _Tags, class... Rest>
+    decltype(auto) operator()(__without<_Tag, _Tags...>, Rest&&... rest) const
+    {
+        return __joined{__fwd_fn()(__join_fn()((Rest&&)rest...)),
+                        __without<_Tag, _Tags...>()};
+    }
+
+    template <class First, class... Rest>
+    decltype(auto) operator()(First&& first, Rest&&... rest) const
+    {
+        return __joined{__fwd_fn()(__join_fn()((Rest&&)rest...)),
+                        (First&&)first};
+    }
+};
+
+inline constexpr __join_fn __join{};
+
+template <class... _Envs>
+using __join_t = __result_of<__join, _Envs...>;
 } // namespace __env
 
 using __env::empty_env;
-using __empty_env
-    [[deprecated("Please use stdexec::empty_env now.")]] = empty_env;
-
-using __env::__env_promise;
-
-inline constexpr __env::__make_env_t __make_env{};
-inline constexpr __env::__join_env_t __join_env{};
-inline constexpr __env::get_env_t get_env{};
-
-// for making an environment from a single key/value pair
-inline constexpr __env::__mkprop_t __mkprop{};
-
-template <class _Tag, class _Value = void>
-using __with = __env::__prop<_Value(_Tag)>;
-
-template <class... _Ts>
-using __make_env_t = __call_result_t<__env::__make_env_t, _Ts...>;
-
-using __default_env = empty_env;
+using __env::get_env_t;
+inline constexpr get_env_t get_env{};
 
 template <class _EnvProvider>
 concept environment_provider = //
diff --git a/include/sdbusplus/async/stdexec/__detail/__meta.hpp b/include/sdbusplus/async/stdexec/__detail/__meta.hpp
index 8ddc0de..2a4c33b 100644
--- a/include/sdbusplus/async/stdexec/__detail/__meta.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__meta.hpp
@@ -170,29 +170,58 @@
     const char __what_[_Len];
 };
 
+STDEXEC_PRAGMA_PUSH()
+STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals")
+
 #if STDEXEC_NVHPC() && (__EDG_VERSION__ < 604)
 // Use a non-standard extension for older nvc++ releases
 template <__mchar _Char, _Char... _Str>
-constexpr __mstring<sizeof...(_Str)> operator""__csz() noexcept
+[[deprecated("Use _mstr instead")]] constexpr __mstring<sizeof...(_Str)>
+    operator""__csz() noexcept
+{
+    return {_Str...};
+}
+
+// Use a non-standard extension for older nvc++ releases
+template <__mchar _Char, _Char... _Str>
+constexpr __mstring<sizeof...(_Str)> operator""_mstr() noexcept
 {
     return {_Str...};
 }
 #elif STDEXEC_NVHPC() && (__EDG_VERSION__ < 605)
 // This is to work around an unfiled (by me) EDG bug that fixed in build 605
 template <__mstring _Str>
-constexpr const __mtypeof<_Str> operator""__csz() noexcept
+[[deprecated("Use _mstr instead")]] constexpr const __mtypeof<_Str>
+    operator""__csz() noexcept
+{
+    return _Str;
+}
+
+// This is to work around an unfiled (by me) EDG bug that fixed in build 605
+template <__mstring _Str>
+constexpr const __mtypeof<_Str> operator""_mstr() noexcept
 {
     return _Str;
 }
 #else
 // Use a standard user-defined string literal template
 template <__mstring _Str>
-constexpr __mtypeof<_Str> operator""__csz() noexcept
+[[deprecated("Use _mstr instead")]] constexpr __mtypeof<_Str>
+    operator""__csz() noexcept
+{
+    return _Str;
+}
+
+// Use a standard user-defined string literal template
+template <__mstring _Str>
+constexpr __mtypeof<_Str> operator""_mstr() noexcept
 {
     return _Str;
 }
 #endif
 
+STDEXEC_PRAGMA_POP()
+
 using __msuccess = int;
 
 template <class _What, class... _With>
@@ -415,7 +444,7 @@
 };
 
 inline constexpr __mstring __mbad_substitution =
-    "The specified meta-function could not be evaluated with the types provided."__csz;
+    "The specified meta-function could not be evaluated with the types provided."_mstr;
 
 template <__mstring _Diagnostic = __mbad_substitution>
 struct _BAD_SUBSTITUTION_
@@ -798,20 +827,6 @@
 template <const auto& _Fun, class... _As>
 using __result_of = __call_result_t<decltype(_Fun), _As...>;
 
-#if STDEXEC_CLANG() && (__clang_major__ < 13)
-template <class _Ty>
-constexpr auto __hide_ = [] { return (__mtype<_Ty>(*)())0; };
-#else
-template <class _Ty>
-extern decltype([] { return (__mtype<_Ty>(*)())0; }) __hide_;
-#endif
-
-template <class _Ty>
-using __hide = decltype(__hide_<_Ty>);
-
-template <class _Id>
-using __unhide = __t<__call_result_t<__call_result_t<_Id>>>;
-
 // For working around clang's lack of support for CWG#2369:
 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#2369
 struct __qcall_result
diff --git a/include/sdbusplus/async/stdexec/any_sender_of.hpp b/include/sdbusplus/async/stdexec/any_sender_of.hpp
index 5336954..42f5302 100644
--- a/include/sdbusplus/async/stdexec/any_sender_of.hpp
+++ b/include/sdbusplus/async/stdexec/any_sender_of.hpp
@@ -966,7 +966,7 @@
 
 template <class _Env>
 using __env_t =
-    __make_env_t<_Env, __with<get_stop_token_t, in_place_stop_token>>;
+    __env::__join_t<__env::__with<in_place_stop_token, get_stop_token_t>, _Env>;
 
 template <class _ReceiverId>
 struct __stoppable_receiver
@@ -1020,9 +1020,10 @@
         friend __env_t<env_of_t<_Receiver>>
             tag_invoke(_GetEnv, const _Self& __self) noexcept
         {
-            return __make_env(get_env(__self.__op_->__rcvr_),
-                              __mkprop(__self.__op_->__stop_source_.get_token(),
-                                       get_stop_token));
+            return __env::__join(
+                __env::__with(__self.__op_->__stop_source_.get_token(),
+                              get_stop_token),
+                get_env(__self.__op_->__rcvr_));
         }
     };
 };
diff --git a/include/sdbusplus/async/stdexec/async_scope.hpp b/include/sdbusplus/async/stdexec/async_scope.hpp
index 8c2483f..1669953 100644
--- a/include/sdbusplus/async/stdexec/async_scope.hpp
+++ b/include/sdbusplus/async/stdexec/async_scope.hpp
@@ -254,6 +254,7 @@
 struct __nest_sender
 {
     using _Constrained = stdexec::__t<_ConstrainedId>;
+
     struct __t
     {
         using __id = __nest_sender;
@@ -751,9 +752,8 @@
 // async_scope::spawn implementation
 template <class _Env>
 using __spawn_env_t =
-    __result_of<__join_env, _Env,
-                __env::__prop<in_place_stop_token(get_stop_token_t)>,
-                __env::__prop<__inln::__scheduler(get_scheduler_t)>>;
+    __env::__join_t<_Env, __env::__with<in_place_stop_token, get_stop_token_t>,
+                    __env::__with<__inln::__scheduler, get_scheduler_t>>;
 
 template <class _EnvId>
 struct __spawn_op_base
@@ -783,9 +783,9 @@
         // BUGBUG NOT TO SPEC spawn shouldn't accept senders that can fail.
         template <same_as<set_error_t> _Tag>
         [[noreturn]] friend void tag_invoke(_Tag, __t&&,
-                                            const std::exception_ptr&) noexcept
+                                            std::exception_ptr __eptr) noexcept
         {
-            std::terminate();
+            std::rethrow_exception(std::move(__eptr));
         }
 
         friend const __spawn_env_t<_Env>& tag_invoke(get_env_t,
@@ -810,10 +810,11 @@
         template <__decays_to<_Sender> _Sndr>
         __t(_Sndr&& __sndr, _Env __env, const __impl* __scope) :
             __spawn_op_base<_EnvId>{
-                __join_env((_Env&&)__env,
-                           __mkprop(__scope->__stop_source_.get_token(),
-                                    get_stop_token),
-                           __mkprop(__inln::__scheduler{}, get_scheduler)),
+                __env::__join(
+                    (_Env&&)__env,
+                    __env::__with(__scope->__stop_source_.get_token(),
+                                  get_stop_token),
+                    __env::__with(__inln::__scheduler{}, get_scheduler)),
                 [](__spawn_op_base<_EnvId>* __op) {
             delete static_cast<__t*>(__op);
         }},
diff --git a/include/sdbusplus/async/stdexec/commit.info b/include/sdbusplus/async/stdexec/commit.info
index 6788e94..96d8212 100644
--- a/include/sdbusplus/async/stdexec/commit.info
+++ b/include/sdbusplus/async/stdexec/commit.info
@@ -1 +1 @@
-98f1f7a18dba497859b7705ce60d31e0ba3d204d
+ad16d4a45053f7d16f037e08b51c11c0cb305ecc
diff --git a/include/sdbusplus/async/stdexec/concepts.hpp b/include/sdbusplus/async/stdexec/concepts.hpp
index a5ebe4a..17f5467 100644
--- a/include/sdbusplus/async/stdexec/concepts.hpp
+++ b/include/sdbusplus/async/stdexec/concepts.hpp
@@ -84,6 +84,10 @@
 
 // Avoid using libstdc++'s object concepts because they instantiate a
 // lot of templates.
+#if STDEXEC_HAS_BUILTIN(__is_nothrow_destructible)
+template <class _Ty>
+concept destructible = __is_nothrow_destructible(_Ty);
+#else
 template <class _Ty>
 inline constexpr bool __destructible_ = //
     requires {
@@ -100,6 +104,7 @@
 
 template <class T>
 concept destructible = __destructible_<T>;
+#endif
 
 #if STDEXEC_HAS_BUILTIN(__is_constructible)
 template <class _Ty, class... _As>
diff --git a/include/sdbusplus/async/stdexec/env.hpp b/include/sdbusplus/async/stdexec/env.hpp
index c77176f..30f1a70 100644
--- a/include/sdbusplus/async/stdexec/env.hpp
+++ b/include/sdbusplus/async/stdexec/env.hpp
@@ -23,33 +23,63 @@
 namespace exec
 {
 template <class _Tag, class _Value = void>
-using with_t = stdexec::__with<_Tag, _Value>;
+using with_t = stdexec::__if_c<stdexec::same_as<_Value, void>,
+                               stdexec::__env::__without<_Tag>,
+                               stdexec::__env::__with<_Value, _Tag>>;
 
 namespace __detail
 {
 struct __with_t
 {
     template <class _Tag, class _Value>
-    with_t<_Tag, stdexec::__decay_t<_Value>> operator()(_Tag,
-                                                        _Value&& __val) const
+    auto operator()(_Tag, _Value&& __val) const
     {
-        return stdexec::__mkprop((_Value&&)__val, _Tag());
+        return stdexec::__env::__with((_Value&&)__val, _Tag());
     }
 
     template <class _Tag>
-    with_t<_Tag> operator()(_Tag) const
+    [[deprecated("use exec::without(Tag) instead")]] auto operator()(_Tag) const
     {
-        return stdexec::__mkprop(_Tag());
+        return stdexec::__env::__without(_Tag());
+    }
+};
+
+struct __without_t
+{
+    template <class _Tag>
+    auto operator()(_Tag) const
+    {
+        return stdexec::__env::__without(_Tag());
+    }
+};
+
+// For making an environment from key/value pairs and optionally
+// another environment.
+struct __make_env_t
+{
+    template <stdexec::__nothrow_move_constructible _Base,
+              stdexec::__nothrow_move_constructible _Env>
+    auto operator()(_Base&& __base, _Env&& __env) const noexcept
+        -> stdexec::__env::__join_t<_Env, _Base>
+    {
+        return stdexec::__env::__join((_Env&&)__env, (_Base&&)__base);
+    }
+
+    template <stdexec::__nothrow_move_constructible _Env>
+    _Env operator()(_Env&& __env) const noexcept
+    {
+        return (_Env&&)__env;
     }
 };
 } // namespace __detail
 
 inline constexpr __detail::__with_t with{};
+inline constexpr __detail::__without_t without{};
 
-inline constexpr stdexec::__env::__make_env_t make_env{};
+inline constexpr __detail::__make_env_t make_env{};
 
 template <class... _Ts>
-using make_env_t = stdexec::__make_env_t<_Ts...>;
+using make_env_t = stdexec::__result_of<make_env, _Ts...>;
 
 namespace __read_with_default
 {
diff --git a/include/sdbusplus/async/stdexec/execution.hpp b/include/sdbusplus/async/stdexec/execution.hpp
index 87abcd9..cceb182 100644
--- a/include/sdbusplus/async/stdexec/execution.hpp
+++ b/include/sdbusplus/async/stdexec/execution.hpp
@@ -154,7 +154,7 @@
 {
 inline constexpr __mstring __unrecognized_sender_type_diagnostic =
     "The given type cannot be used as a sender with the given environment "
-    "because the attempt to compute the completion signatures failed."__csz;
+    "because the attempt to compute the completion signatures failed."_mstr;
 
 template <__mstring _Diagnostic = __unrecognized_sender_type_diagnostic>
 struct _UNRECOGNIZED_SENDER_TYPE_;
@@ -293,7 +293,7 @@
     __mbool<!__valid_completion_signatures<_Completions>>;
 
 template <__mstring _Msg =
-              "Expected an instance of template completion_signatures<>"__csz>
+              "Expected an instance of template completion_signatures<>"_mstr>
 struct _INVALID_COMPLETION_SIGNATURES_TYPE_
 {
     template <class... _Completions>
@@ -406,7 +406,8 @@
         -> tag_invoke_result_t<__is_debug_env_t, const _Env&>;
 };
 template <class _Env>
-using __debug_env_t = __make_env_t<_Env, __with<__is_debug_env_t, bool>>;
+using __debug_env_t =
+    __env::__join_t<__env::__with<bool, __is_debug_env_t>, _Env>;
 
 template <class _Env>
 concept __is_debug_env = tag_invocable<__debug::__is_debug_env_t, _Env>;
@@ -590,7 +591,7 @@
 {
     if constexpr (!__is_debug_env<_Env>)
     {
-        if (sizeof(_Sender) == ~0)
+        if (sizeof(_Sender) == ~0u)
         { // never true
             using _Receiver =
                 __debug_receiver<__cvref_id<_Sender>, _Env, _Sigs>;
@@ -890,9 +891,9 @@
             using _Result = __member_alias_t<_Sender, _Env>;
             return (_Result(*)()) nullptr;
         }
-        else if constexpr (__awaitable<_Sender, __env_promise<_Env>>)
+        else if constexpr (__awaitable<_Sender, __env::__promise<_Env>>)
         {
-            using _Result = __await_result_t<_Sender, __env_promise<_Env>>;
+            using _Result = __await_result_t<_Sender, __env::__promise<_Env>>;
             return (completion_signatures<
                     // set_value_t() or set_value_t(T)
                     __minvoke<__remove<void, __qf<set_value_t>>, _Result>,
@@ -919,7 +920,7 @@
 
     // NOT TO SPEC: if we're unable to compute the completion signatures,
     // return an error type instead of SFINAE.
-    template <class _Sender, class _Env = __default_env>
+    template <class _Sender, class _Env = empty_env>
     constexpr auto operator()(_Sender&&, const _Env&) const noexcept
         -> decltype(__impl<_Sender, _Env>()())
     {
@@ -944,7 +945,7 @@
 concept __enable_sender =                     //
     derived_from<typename _Sender::sender_concept, sender_t> ||
     requires { typename _Sender::is_sender; } // NOT TO SPEC back compat
-    || __awaitable<_Sender, __env_promise<empty_env>>;
+    || __awaitable<_Sender, __env::__promise<empty_env>>;
 } // namespace __detail
 
 template <class _Sender>
@@ -1045,7 +1046,7 @@
 
 template <                               //
     class _Sender,                       //
-    class _Env = __default_env,          //
+    class _Env = empty_env,              //
     class _Tuple = __q<__decayed_tuple>, //
     class _Variant = __q<__variant>>
 using __try_value_types_of_t =           //
@@ -1053,20 +1054,20 @@
 
 template <                               //
     class _Sender,                       //
-    class _Env = __default_env,          //
+    class _Env = empty_env,              //
     class _Tuple = __q<__decayed_tuple>, //
     class _Variant = __q<__variant>>
     requires sender_in<_Sender, _Env>
 using __value_types_of_t = //
     __msuccess_or_t<__try_value_types_of_t<_Sender, _Env, _Tuple, _Variant>>;
 
-template <class _Sender, class _Env = __default_env,
+template <class _Sender, class _Env = empty_env,
           class _Variant = __q<__variant>>
 using __try_error_types_of_t =
     __gather_completions_for<set_error_t, _Sender, _Env, __q<__midentity>,
                              _Variant>;
 
-template <class _Sender, class _Env = __default_env,
+template <class _Sender, class _Env = empty_env,
           class _Variant = __q<__variant>>
     requires sender_in<_Sender, _Env>
 using __error_types_of_t =
@@ -1074,50 +1075,50 @@
 
 template <                                              //
     class _Sender,                                      //
-    class _Env = __default_env,                         //
+    class _Env = empty_env,                             //
     template <class...> class _Tuple = __decayed_tuple, //
     template <class...> class _Variant = __variant>
     requires sender_in<_Sender, _Env>
 using value_types_of_t =
     __value_types_of_t<_Sender, _Env, __q<_Tuple>, __q<_Variant>>;
 
-template <class _Sender, class _Env = __default_env,
+template <class _Sender, class _Env = empty_env,
           template <class...> class _Variant = __variant>
     requires sender_in<_Sender, _Env>
 using error_types_of_t = __error_types_of_t<_Sender, _Env, __q<_Variant>>;
 
-template <class _Tag, class _Sender, class _Env = __default_env>
+template <class _Tag, class _Sender, class _Env = empty_env>
 using __try_count_of = //
     __compl_sigs::__maybe_for_all_sigs<
         __completion_signatures_of_t<_Sender, _Env>, __q<__mfront>,
         __mcount<_Tag>>;
 
-template <class _Tag, class _Sender, class _Env = __default_env>
+template <class _Tag, class _Sender, class _Env = empty_env>
     requires sender_in<_Sender, _Env>
 using __count_of = __msuccess_or_t<__try_count_of<_Tag, _Sender, _Env>>;
 
-template <class _Tag, class _Sender, class _Env = __default_env>
+template <class _Tag, class _Sender, class _Env = empty_env>
     requires __mvalid<__count_of, _Tag, _Sender, _Env>
 inline constexpr bool __sends = (__v<__count_of<_Tag, _Sender, _Env>> != 0);
 
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
     requires __mvalid<__count_of, set_stopped_t, _Sender, _Env>
 inline constexpr bool sends_stopped = __sends<set_stopped_t, _Sender, _Env>;
 
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
 using __single_sender_value_t =
     __value_types_of_t<_Sender, _Env, __msingle_or<void>, __q<__msingle>>;
 
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
 using __single_value_variant_sender_t =
     value_types_of_t<_Sender, _Env, __types, __msingle>;
 
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
 concept __single_typed_sender =
     sender_in<_Sender, _Env> &&
     __mvalid<__single_sender_value_t, _Sender, _Env>;
 
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
 concept __single_value_variant_sender =
     sender_in<_Sender, _Env> &&
     __mvalid<__single_value_variant_sender_t, _Sender, _Env>;
@@ -1125,7 +1126,7 @@
 template <class... Errs>
 using __nofail = __mbool<sizeof...(Errs) == 0>;
 
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
 concept __nofail_sender = sender_in<_Sender, _Env> &&
                           (__v<error_types_of_t<_Sender, _Env, __nofail>>);
 
@@ -1171,7 +1172,7 @@
 
 template <                                                      //
     class _Sender,                                              //
-    class _Env = __default_env,                                 //
+    class _Env = empty_env,                                     //
     class _Sigs = completion_signatures<>,                      //
     class _SetValue = __q<__default_set_value>,                 //
     class _SetError = __q<__default_set_error>,                 //
@@ -1202,7 +1203,7 @@
 //
 //  template <
 //    sender Sndr,
-//    class Env = __default_env,
+//    class Env = empty_env,
 //    class AddlSigs = completion_signatures<>,
 //    template <class...> class SetValue = __default_set_value,
 //    template <class> class SetError = __default_set_error,
@@ -1250,7 +1251,7 @@
 //  SendsStopped>` is an alias for an empty struct
 template <                                                                   //
     class _Sender,                                                           //
-    class _Env = __default_env,                                              //
+    class _Env = empty_env,                                                  //
     __valid_completion_signatures _Sigs = completion_signatures<>,           //
     template <class...> class _SetValue = __compl_sigs::__default_set_value, //
     template <class> class _SetError = __compl_sigs::__default_set_error,    //
@@ -1749,7 +1750,7 @@
 template <class _Sig>
 using __tag_of_sig_t = decltype(stdexec::__tag_of_sig_((_Sig*)nullptr));
 
-template <class _Sender, class _SetSig, class _Env = __default_env>
+template <class _Sender, class _SetSig, class _Env = empty_env>
 concept sender_of =
     sender_in<_Sender, _Env> &&
     same_as<__types<_SetSig>, __gather_completions_for<
@@ -2271,10 +2272,11 @@
 struct __sexpr_impl<__inln::__schedule_t> : __sexpr_defaults
 {
     static constexpr auto get_attrs = //
-        [](__ignore) noexcept -> __env::__prop<__inln::__scheduler(
-                                  get_completion_scheduler_t<set_value_t>)> {
-        return __mkprop(__inln::__scheduler{},
-                        get_completion_scheduler<set_value_t>);
+        [](__ignore) noexcept
+        -> __env::__with<__inln::__scheduler,
+                         get_completion_scheduler_t<set_value_t>> {
+        return __env::__with(__inln::__scheduler{},
+                             get_completion_scheduler<set_value_t>);
     };
 
     static constexpr auto get_completion_signatures = //
@@ -2919,7 +2921,7 @@
 {};
 
 inline constexpr __mstring __not_callable_diag =
-    "The specified function is not callable with the arguments provided."__csz;
+    "The specified function is not callable with the arguments provided."_mstr;
 
 template <__mstring _Context, __mstring _Diagnostic = __not_callable_diag>
 struct _NOT_CALLABLE_
@@ -2958,7 +2960,7 @@
 namespace __then
 {
 inline constexpr __mstring __then_context =
-    "In stdexec::then(Sender, Function)..."__csz;
+    "In stdexec::then(Sender, Function)..."_mstr;
 using __on_not_callable = __callable_error<__then_context>;
 
 template <class _Fun, class _CvrefSender, class _Env>
@@ -3041,7 +3043,7 @@
 namespace __upon_error
 {
 inline constexpr __mstring __upon_error_context =
-    "In stdexec::upon_error(Sender, Function)..."__csz;
+    "In stdexec::upon_error(Sender, Function)..."_mstr;
 using __on_not_callable = __callable_error<__upon_error_context>;
 
 template <class _Fun, class _CvrefSender, class _Env>
@@ -3122,7 +3124,7 @@
 namespace __upon_stopped
 {
 inline constexpr __mstring __upon_stopped_context =
-    "In stdexec::upon_stopped(Sender, Function)..."__csz;
+    "In stdexec::upon_stopped(Sender, Function)..."_mstr;
 using __on_not_callable = __callable_error<__upon_stopped_context>;
 
 template <class _Fun, class _CvrefSender, class _Env>
@@ -3205,7 +3207,7 @@
 namespace __bulk
 {
 inline constexpr __mstring __bulk_context =
-    "In stdexec::bulk(Sender, Shape, Function)..."__csz;
+    "In stdexec::bulk(Sender, Shape, Function)..."_mstr;
 using __on_not_callable = __callable_error<__bulk_context>;
 
 template <class _Shape, class _Fun>
@@ -3358,9 +3360,9 @@
 namespace __shared
 {
 template <class _BaseEnv>
-using __env_t =            //
-    __make_env_t<_BaseEnv, // BUGBUG NOT TO SPEC
-                 __with<get_stop_token_t, in_place_stop_token>>;
+using __env_t =                //
+    __env::__join_t<__env::__with<in_place_stop_token, get_stop_token_t>,
+                    _BaseEnv>; // BUGBUG NOT TO SPEC
 
 struct __on_stop_request
 {
@@ -3546,8 +3548,9 @@
     connect_result_t<_CvrefSender, __receiver_t> __op_state2_;
 
     explicit __shared_state(_CvrefSender&& __sndr, _Env __env) :
-        __env_(__make_env((_Env&&)__env, __mkprop(__stop_source_.get_token(),
-                                                  get_stop_token))),
+        __env_(__env::__join(
+            __env::__with(__stop_source_.get_token(), get_stop_token),
+            (_Env&&)__env)),
         __op_state2_(connect((_CvrefSender&&)__sndr, __receiver_t{this}))
     {}
 
@@ -3906,9 +3909,8 @@
     struct __t : receiver_adaptor<__t>
     {
         using __id = __receiver_with;
-        using __env_t =
-            __env::__env_join_t<__result_of<_EnvFns, _Operation*>...,
-                                env_of_t<_Receiver>>;
+        using __env_t = __env::__join_t<__result_of<_EnvFns, _Operation*>...,
+                                        env_of_t<_Receiver>>;
 
         _Operation* __op_state_;
 
@@ -3919,8 +3921,8 @@
 
         __env_t get_env() const noexcept
         {
-            return __join_env(_EnvFns(__op_state_)...,
-                              stdexec::get_env(__op_state_->*_ReceiverPtr));
+            return __env::__join(_EnvFns(__op_state_)...,
+                                 stdexec::get_env(__op_state_->*_ReceiverPtr));
         }
     };
 };
@@ -3973,8 +3975,9 @@
     template <same_as<get_env_t> _Tag>
     friend auto tag_invoke(_Tag, const __receiver_with_sched& __self) noexcept
     {
-        return __join_env(__mkprop(__self.__sched_, get_scheduler),
-                          __mkprop(get_domain), get_env(__self.__rcvr_));
+        return __env::__join(__env::__with(__self.__sched_, get_scheduler),
+                             __env::__without(get_domain),
+                             get_env(__self.__rcvr_));
     }
 };
 
@@ -3987,8 +3990,8 @@
 template <class _Env, class _Scheduler>
 using __result_env_t =
     __if_c<__unknown_context<_Scheduler>, _Env,
-           __env::__env_join_t<__env::__prop<_Scheduler(get_scheduler_t)>,
-                               __env::__prop<void(get_domain_t)>, _Env>>;
+           __env::__join_t<__env::__with<_Scheduler, get_scheduler_t>,
+                           __env::__without<get_domain_t>, _Env>>;
 
 template <class _Tp>
 using __decay_ref = __decay_t<_Tp>&;
@@ -4004,7 +4007,7 @@
     using __t = __mexception<
         _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_<
             __in_which_let_msg<_Set>,
-            "The function must return a valid sender for the current environment"__csz>,
+            "The function must return a valid sender for the current environment"_mstr>,
         _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>>;
 };
 template <class _Sender, class _Env, class _Set>
@@ -4014,7 +4017,7 @@
 using __bad_result_sender = __mexception<
     _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_<
         __in_which_let_msg<_Set>,
-        "The function must return a valid sender for the current environment"__csz>,
+        "The function must return a valid sender for the current environment"_mstr>,
     _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>>;
 #endif
 
@@ -4094,7 +4097,7 @@
 using __no_common_domain_t = //
     _NO_COMMON_DOMAIN_<
         __in_which_let_msg<_Set>,
-        "The senders returned by Function do not all share a common domain"__csz>;
+        "The senders returned by Function do not all share a common domain"_mstr>;
 
 template <class _Set>
 using __try_common_domain_fn = //
@@ -4131,10 +4134,11 @@
             }
             else
             {
-                return __join_env(__mkprop(get_completion_scheduler<_Set>(
-                                               stdexec::get_env(__child)),
-                                           get_scheduler),
-                                  __mkprop(get_domain), __env);
+                return __env::__join(
+                    __env::__with(get_completion_scheduler<_Set>(
+                                      stdexec::get_env(__child)),
+                                  get_scheduler),
+                    __env::__without(get_domain), __env);
             }
         }
         STDEXEC_UNREACHABLE();
@@ -4160,10 +4164,15 @@
             {
                 return _Domain();
             }
+            else if constexpr (same_as<_Domain, dependent_domain>)
+            {
+                using _Domain2 = __late_domain_of_t<_Child, _Env>;
+                return __make_sexpr<__let_t<_Set, _Domain2>>((_Fun&&)__fun,
+                                                             (_Child&&)__child);
+            }
             else
             {
-                static_assert(
-                    __none_of<_Domain, __none_such, dependent_domain>);
+                static_assert(!same_as<_Domain, __none_such>);
                 return __make_sexpr<__let_t<_Set, _Domain>>((_Fun&&)__fun,
                                                             (_Child&&)__child);
             }
@@ -4257,8 +4266,8 @@
 {
     static constexpr auto get_attrs = //
         []<class _Child>(__ignore, const _Child& __child) noexcept {
-        return __join_env(__mkprop(_Domain(), get_domain),
-                          stdexec::get_env(__child));
+        return __env::__join(__env::__with(_Domain(), get_domain),
+                             stdexec::get_env(__child));
     };
 
     static constexpr auto get_completion_signatures = //
@@ -4759,9 +4768,9 @@
 struct __environ
 {
     struct __t :
-        __env::__prop<stdexec::__t<_SchedulerId>(
-            get_completion_scheduler_t<set_value_t>,
-            get_completion_scheduler_t<set_stopped_t>)>
+        __env::__with<stdexec::__t<_SchedulerId>,
+                      get_completion_scheduler_t<set_value_t>,
+                      get_completion_scheduler_t<set_stopped_t>>
     {
         using __id = __environ;
 
@@ -4873,7 +4882,7 @@
     static constexpr auto get_attrs = //
         []<class _Data, class _Child>(const _Data& __data,
                                       const _Child& __child) noexcept {
-        return __join_env(__data, stdexec::get_env(__child));
+        return __env::__join(__data, stdexec::get_env(__child));
     };
 
     static constexpr auto get_completion_signatures = //
@@ -5002,7 +5011,7 @@
         []<class _Data, class _Child>(
             const _Data& __data,
             const _Child& __child) noexcept -> decltype(auto) {
-        return __join_env(__data, stdexec::get_env(__child));
+        return __env::__join(__data, stdexec::get_env(__child));
     };
 };
 } // namespace __transfer
@@ -5071,7 +5080,7 @@
     return []<class _Scheduler>(const _Scheduler& __sched,
                                 const auto&...) noexcept {
         using _Env = __t<__schedule_from::__environ<__id<_Scheduler>>>;
-        return _Env{{__sched}};
+        return _Env{__sched};
     };
 }
 
@@ -5100,7 +5109,7 @@
     template <sender _Sender, class... _Envs>
     auto operator()(_Sender&& __sndr, _Envs... __envs) const
     {
-        return __make_sexpr<__write_t>(__join_env(std::move(__envs)...),
+        return __make_sexpr<__write_t>(__env::__join(std::move(__envs)...),
                                        (_Sender&&)__sndr);
     }
 
@@ -5116,7 +5125,7 @@
     static auto __transform_env_fn(_Env&& __env) noexcept
     {
         return [&](__ignore, const auto& __state, __ignore) noexcept {
-            return __join_env(__state, (_Env&&)__env);
+            return __env::__join(__state, (_Env&&)__env);
         };
     }
 
@@ -5131,14 +5140,14 @@
 {
     static constexpr auto get_env = //
         [](__ignore, const auto& __state, const auto& __rcvr) noexcept {
-        return __join_env(__state, stdexec::get_env(__rcvr));
+        return __env::__join(__state, stdexec::get_env(__rcvr));
     };
 
     static constexpr auto get_completion_signatures = //
         []<class _Self, class _Env>(_Self&&, _Env&&) noexcept
         -> stdexec::__completion_signatures_of_t<
             __child_of<_Self>,
-            __env::__env_join_t<const __decay_t<__data_of<_Self>>&, _Env>> {
+            __env::__join_t<const __decay_t<__data_of<_Self>>&, _Env>> {
         static_assert(sender_expr_for<_Self, __write_t>);
         return {};
     };
@@ -5158,8 +5167,8 @@
 STDEXEC_ATTRIBUTE((always_inline))
 auto __mkenv_sched(_Scheduler __sched)
 {
-    auto __env = __join_env(__mkprop(__sched, get_scheduler),
-                            __mkprop(get_domain));
+    auto __env = __env::__join(__env::__with(__sched, get_scheduler),
+                               __env::__without(get_domain));
 
     struct __env_t : decltype(__env)
     {};
@@ -5207,7 +5216,8 @@
     static auto __transform_env_fn(_Env&& __env) noexcept
     {
         return [&](__ignore, auto __sched, __ignore) noexcept {
-            return __join_env(__detail::__mkenv_sched(__sched), (_Env&&)__env);
+            return __env::__join(__detail::__mkenv_sched(__sched),
+                                 (_Env&&)__env);
         };
     }
 
@@ -5347,8 +5357,9 @@
 template <class _Env>
 auto __mkenv(_Env&& __env, in_place_stop_source& __stop_source) noexcept
 {
-    return __join_env(__mkprop(__stop_source.get_token(), get_stop_token),
-                      (_Env&&)__env);
+    return __env::__join(
+        __env::__with(__stop_source.get_token(), get_stop_token),
+        (_Env&&)__env);
 }
 
 template <class _Env>
@@ -5364,10 +5375,10 @@
                                  __mconst<int>, __msingle_or<void>>;
 
 template <
-    __mstring _Context = "In stdexec::when_all()..."__csz,
+    __mstring _Context = "In stdexec::when_all()..."_mstr,
     __mstring _Diagnostic =
         "The given sender can complete successfully in more that one way. "
-        "Use stdexec::when_all_with_variant() instead."__csz>
+        "Use stdexec::when_all_with_variant() instead."_mstr>
 struct _INVALID_WHEN_ALL_ARGUMENT_;
 
 template <class _Sender, class _Env>
@@ -5596,7 +5607,7 @@
         }
         else
         {
-            return __mkprop(_Domain(), get_domain);
+            return __env::__with(_Domain(), get_domain);
         }
         STDEXEC_UNREACHABLE();
     };
@@ -5769,7 +5780,7 @@
         }
         else
         {
-            return __mkprop(_Domain(), get_domain);
+            return __env::__with(_Domain(), get_domain);
         }
         STDEXEC_UNREACHABLE();
     };
@@ -5913,7 +5924,7 @@
     __nothrow_callable<_Tag, env_of_t<stdexec::__t<_ReceiverId>>>;
 
 inline constexpr __mstring __query_failed_diag =
-    "The current execution environment doesn't have a value for the given query."__csz;
+    "The current execution environment doesn't have a value for the given query."_mstr;
 
 template <class _Tag>
 struct _WITH_QUERY_;
@@ -5921,7 +5932,7 @@
 template <class _Tag, class _Env>
 using __query_failed_error = //
     __mexception<            //
-        _NOT_CALLABLE_<"In stdexec::read()..."__csz, __query_failed_diag>,
+        _NOT_CALLABLE_<"In stdexec::read()..."_mstr, __query_failed_diag>,
         _WITH_QUERY_<_Tag>, _WITH_ENVIRONMENT_<_Env>>;
 
 template <class _Tag, class _Env>
@@ -6079,11 +6090,11 @@
 namespace __on_v2
 {
 inline constexpr __mstring __on_context =
-    "In stdexec::on(Scheduler, Sender)..."__csz;
+    "In stdexec::on(Scheduler, Sender)..."_mstr;
 inline constexpr __mstring __no_scheduler_diag =
-    "stdexec::on() requires a scheduler to transition back to."__csz;
+    "stdexec::on() requires a scheduler to transition back to."_mstr;
 inline constexpr __mstring __no_scheduler_details =
-    "The provided environment lacks a value for the get_scheduler() query."__csz;
+    "The provided environment lacks a value for the get_scheduler() query."_mstr;
 
 template <__mstring _Context = __on_context,
           __mstring _Diagnostic = __no_scheduler_diag,
@@ -6133,7 +6144,8 @@
     static auto __transform_env_fn(_Env&& __env) noexcept
     {
         return [&](__ignore, auto __sched, __ignore) noexcept {
-            return __join_env(__detail::__mkenv_sched(__sched), (_Env&&)__env);
+            return __env::__join(__detail::__mkenv_sched(__sched),
+                                 (_Env&&)__env);
         };
     }
 
@@ -6234,18 +6246,15 @@
 {
 inline auto __make_env(run_loop& __loop) noexcept
 {
-    return __env::__env_fn{
-        [&](__one_of<get_scheduler_t,
-                     get_delegatee_scheduler_t> auto) noexcept {
-        return __loop.get_scheduler();
-    }};
+    return __env::__with(__loop.get_scheduler(), get_scheduler,
+                         get_delegatee_scheduler);
 }
 
 struct __env : __result_of<__make_env, run_loop&>
 {
     __env();
 
-    __env(run_loop& __loop) noexcept :
+    explicit __env(run_loop& __loop) noexcept :
         __result_of<__make_env, run_loop&>{__sync_wait::__make_env(__loop)}
     {}
 };
@@ -6361,10 +6370,10 @@
 using __variant_for_t = __t<__variant_for<_Sender>>;
 
 inline constexpr __mstring __sync_wait_context_diag = //
-    "In stdexec::sync_wait()..."__csz;
+    "In stdexec::sync_wait()..."_mstr;
 inline constexpr __mstring __too_many_successful_completions_diag =
     "The argument to stdexec::sync_wait() is a sender that can complete successfully in more "
-    "than one way. Use stdexec::sync_wait_with_variant() instead."__csz;
+    "than one way. Use stdexec::sync_wait_with_variant() instead."_mstr;
 
 template <__mstring _Context, __mstring _Diagnostic>
 struct _INVALID_ARGUMENT_TO_SYNC_WAIT_;
@@ -6404,7 +6413,7 @@
         else
         {
             constexpr __mstring __diag =
-                "The stdexec::sender_in<Sender, Environment> concept check has failed."__csz;
+                "The stdexec::sender_in<Sender, Environment> concept check has failed."_mstr;
             return __sync_wait_error<__diag, _Sender>();
         }
     }
@@ -6417,12 +6426,12 @@
     {
         constexpr __mstring __diag =
             "Failed to connect the given sender to sync_wait's internal receiver. "
-            "The stdexec::connect(Sender, Receiver) expression is ill-formed."__csz;
+            "The stdexec::connect(Sender, Receiver) expression is ill-formed."_mstr;
         return __sync_wait_error<__diag, _Sender>();
     }
     else
     {
-        constexpr __mstring __diag = "Unknown concept check failure."__csz;
+        constexpr __mstring __diag = "Unknown concept check failure."_mstr;
         return __sync_wait_error<__diag, _Sender>();
     }
     STDEXEC_UNREACHABLE();
@@ -6555,7 +6564,7 @@
     {}
 };
 
-template <auto _Reason = "You cannot pipe one sender into another."__csz>
+template <auto _Reason = "You cannot pipe one sender into another."_mstr>
 struct _CANNOT_PIPE_INTO_A_SENDER_
 {};
 
diff --git a/include/sdbusplus/async/stdexec/sequence_senders.hpp b/include/sdbusplus/async/stdexec/sequence_senders.hpp
index 2f7b7e0..c579998 100644
--- a/include/sdbusplus/async/stdexec/sequence_senders.hpp
+++ b/include/sdbusplus/async/stdexec/sequence_senders.hpp
@@ -228,7 +228,7 @@
         }
     }
 
-    template <class _Sender, class _Env = __default_env>
+    template <class _Sender, class _Env = empty_env>
     constexpr auto operator()(_Sender&&, const _Env&) const noexcept
         -> decltype(__impl<_Sender, _Env>()())
     {
diff --git a/include/sdbusplus/async/stdexec/task.hpp b/include/sdbusplus/async/stdexec/task.hpp
index 56ad9aa..4eeb9ab 100644
--- a/include/sdbusplus/async/stdexec/task.hpp
+++ b/include/sdbusplus/async/stdexec/task.hpp
@@ -367,7 +367,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 // basic_task
 template <class _Ty, class _Context = default_task_context<_Ty>>
-class basic_task
+class [[nodiscard]] basic_task
 {
     struct __promise;