diff --git a/MAINTAINERS.md b/MAINTAINERS.md
index 8ff1f41f1..bb716031a 100644
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@@ -49,9 +49,29 @@ stdexec should follow.
     the `include/exec` directory, export them with
     `STDEXEC_MODULE_EXPORT_AUTHORING`.
 
-* The first non-comment, non-blank line in a test file should be
-  `#include <catch2/catch_all.hpp>` so as not to break the modules build.
-  If compile-time behavior needs to differ between modularized and
-  traditional builds, the next inclusion should be
-  `#include <stdexec/__detail/__config.hpp>` so that `STDEXEC_USE_MODULES()`
-  is defined and can be checked.
+* In tests, the include order should be:
+  ```c++
+  /* Copyright... */
+
+  // Catch2 must come before any potential import statements
+  #include <catch2/catch_all.hpp>
+
+  // Pull in all the macros in __config.hpp and either include all of
+  // stdexec's headers, or import stdexec, as appropriate
+  #include <stdexec/execution.hpp>
+
+  // other non-std headers, like anything in <exec/...> or in the test
+  // utility library
+  #include <exec/function.hpp>
+  #include <test_common/receivers.hpp>
+
+  // if the test has direct dependencies on std, the declarations thereof
+  // must come last, either as import std, or the usual includes. This has
+  // to come last because current compilers support including std headers
+  // *before* import std, but not *after*.
+  #if STDEXEC_USE_MODULES()
+  import std;
+  #else
+  #  include <algorithm>
+  #endif
+  ```
diff --git a/include/exec/any_sender_of.hpp b/include/exec/any_sender_of.hpp
index 47d6518b8..d39901304 100644
--- a/include/exec/any_sender_of.hpp
+++ b/include/exec/any_sender_of.hpp
@@ -15,14 +15,21 @@
  */
 #pragma once
 
-#include "../stdexec/__detail/__any.hpp"
-#include "../stdexec/__detail/__concepts.hpp"
-#include "../stdexec/__detail/__receiver_ref.hpp"
-#include "../stdexec/__detail/__receivers.hpp"
+#include "../stdexec/__detail/__config.hpp"
 
+#include "../stdexec/__detail/__receiver_ref.hpp"
 #include "env.hpp"
 
-#include <utility>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include "../stdexec/__detail/__any.hpp"
+#  include "../stdexec/__detail/__concepts.hpp"
+#  include "../stdexec/__detail/__receivers.hpp"
+
+#  include <utility>
+#endif
 
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Woverloaded-virtual")
diff --git a/include/exec/asio/as_default_on.hpp b/include/exec/asio/as_default_on.hpp
index 040bf2eae..d2d3c5a1a 100644
--- a/include/exec/asio/as_default_on.hpp
+++ b/include/exec/asio/as_default_on.hpp
@@ -20,10 +20,16 @@
 
 #include <exec/asio/asio_config.hpp>
 
+#include "../../stdexec/__detail/__config.hpp"
+
 #include "executor_with_default.hpp"
 
-#include <type_traits>
-#include <utility>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <type_traits>
+#  include <utility>
+#endif
 
 namespace experimental::execution::asio
 {
diff --git a/include/exec/asio/completion_token.hpp b/include/exec/asio/completion_token.hpp
index f8ad7b2cb..a1401dead 100644
--- a/include/exec/asio/completion_token.hpp
+++ b/include/exec/asio/completion_token.hpp
@@ -20,25 +20,33 @@
 
 #include <exec/asio/asio_config.hpp>
 
-#include "../../stdexec/__detail/__execution_fwd.hpp"
-
-#include "../../stdexec/__detail/__completion_signatures_of.hpp"
-#include "../../stdexec/__detail/__env.hpp"
-#include "../../stdexec/__detail/__queries.hpp"
-#include "../../stdexec/__detail/__receivers.hpp"
-#include "../../stdexec/__detail/__type_traits.hpp"
-#include "../../stdexec/stop_token.hpp"
-#include "as_default_on.hpp"
-
-#include <concepts>
-#include <exception>
-#include <functional>
-#include <mutex>
-#include <optional>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <version>
+#include "../../stdexec/__detail/__config.hpp"
+
+#  include "as_default_on.hpp"
+
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include "../../stdexec/__detail/__execution_fwd.hpp"
+
+#  include "../../stdexec/__detail/__completion_signatures_of.hpp"
+#  include "../../stdexec/__detail/__env.hpp"
+#  include "../../stdexec/__detail/__queries.hpp"
+#  include "../../stdexec/__detail/__receivers.hpp"
+#  include "../../stdexec/__detail/__type_traits.hpp"
+#  include "../../stdexec/stop_token.hpp"
+
+#  include <concepts>
+#  include <exception>
+#  include <functional>
+#  include <mutex>
+#  include <optional>
+#  include <tuple>
+#  include <type_traits>
+#  include <utility>
+#  include <version>
+#endif
 
 namespace experimental::execution::asio
 {
diff --git a/include/exec/asio/noexcept_boost_throw.hpp b/include/exec/asio/noexcept_boost_throw.hpp
index a829a59c4..f4014825a 100644
--- a/include/exec/asio/noexcept_boost_throw.hpp
+++ b/include/exec/asio/noexcept_boost_throw.hpp
@@ -27,8 +27,12 @@
 #  include <boost/asio/thread_pool.hpp>
 #  include <boost/throw_exception.hpp>
 
-#  include <cstdlib>
-#  include <exception>
+#  if STDEXEC_USE_MODULES()
+import std;
+#  else
+#    include <cstdlib>
+#    include <exception>
+#  endif
 
 namespace boost
 {
diff --git a/include/exec/asio/use_sender.hpp b/include/exec/asio/use_sender.hpp
index 760b7b8d4..46195a6fa 100644
--- a/include/exec/asio/use_sender.hpp
+++ b/include/exec/asio/use_sender.hpp
@@ -20,22 +20,29 @@
 
 #include <exec/asio/asio_config.hpp>
 
-#include "../../stdexec/__detail/__execution_fwd.hpp"
-
-#include "../../stdexec/__detail/__completion_signatures_of.hpp"
-#include "../../stdexec/__detail/__receivers.hpp"
-#include "../../stdexec/__detail/__senders.hpp"
-#include "../../stdexec/__detail/__transform_completion_signatures.hpp"
-#include "../../stdexec/__detail/__type_traits.hpp"
+#include "../../stdexec/__detail/__config.hpp"
 
 #include "as_default_on.hpp"
 #include "completion_token.hpp"
 
-#include <concepts>
-#include <exception>
-#include <system_error>
-#include <type_traits>
-#include <utility>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include "../../stdexec/__detail/__execution_fwd.hpp"
+
+#  include "../../stdexec/__detail/__completion_signatures_of.hpp"
+#  include "../../stdexec/__detail/__receivers.hpp"
+#  include "../../stdexec/__detail/__senders.hpp"
+#  include "../../stdexec/__detail/__transform_completion_signatures.hpp"
+#  include "../../stdexec/__detail/__type_traits.hpp"
+
+#  include <concepts>
+#  include <exception>
+#  include <system_error>
+#  include <type_traits>
+#  include <utility>
+#endif
 
 namespace experimental::execution::asio
 {
@@ -71,7 +78,7 @@ namespace experimental::execution::asio
         : r_(static_cast<T&&>(t))
       {}
 
-      using receiver_concept = ::STDEXEC::receiver_t;
+      using receiver_concept = ::STDEXEC::receiver_tag;
 
       constexpr void set_stopped() && noexcept
         requires ::STDEXEC::receiver_of<
diff --git a/include/exec/async_scope.hpp b/include/exec/async_scope.hpp
index 0ade14061..819e16277 100644
--- a/include/exec/async_scope.hpp
+++ b/include/exec/async_scope.hpp
@@ -130,7 +130,7 @@ namespace experimental::execution
 
       template <__decays_to<__when_empty_sender> _Self, class... _Env>
       static consteval auto get_completion_signatures()
-        -> __completion_signatures_of_t<__copy_cvref_t<_Self, _Constrained>, __env_t<_Env>...>
+        -> completion_signatures_of_t<__copy_cvref_t<_Self, _Constrained>, __env_t<_Env>...>
       {
         return {};
       }
@@ -256,7 +256,7 @@ namespace experimental::execution
 
       template <__decays_to<__nest_sender> _Self, class... _Env>
       static consteval auto get_completion_signatures()
-        -> __completion_signatures_of_t<__copy_cvref_t<_Self, _Constrained>, __env_t<_Env>...>
+        -> completion_signatures_of_t<__copy_cvref_t<_Self, _Constrained>, __env_t<_Env>...>
       {
         return {};
       }
diff --git a/include/exec/detail/basic_sequence.hpp b/include/exec/detail/basic_sequence.hpp
index 0357b7a0c..118a08b27 100644
--- a/include/exec/detail/basic_sequence.hpp
+++ b/include/exec/detail/basic_sequence.hpp
@@ -16,10 +16,16 @@
  */
 #pragma once
 
-#include "../../stdexec/__detail/__basic_sender.hpp"
 #include "../../stdexec/__detail/__config.hpp"
-#include "../../stdexec/__detail/__meta.hpp"
 
+#if STDEXEC_USE_MODULES()
+import stdexec;
+#else
+#  include "../../stdexec/__detail/__basic_sender.hpp"
+#  include "../../stdexec/__detail/__meta.hpp"
+#endif
+
+#include "../../stdexec/__detail/__basic_sender_macros.hpp"
 #include "../sequence_senders.hpp"
 
 namespace experimental::execution
diff --git a/include/exec/env.hpp b/include/exec/env.hpp
index c7544a9f8..faab71b08 100644
--- a/include/exec/env.hpp
+++ b/include/exec/env.hpp
@@ -15,7 +15,13 @@
  */
 #pragma once
 
-#include "../stdexec/execution.hpp"
+#include "../stdexec/__detail/__config.hpp"
+
+#if STDEXEC_USE_MODULES()
+import stdexec;
+#else
+#  include "../stdexec/execution.hpp"
+#endif
 
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_EDG(1302)
@@ -229,7 +235,7 @@ namespace experimental::execution
 
       template <__decays_to<__sender> _Self, class... _Env>
       static consteval auto get_completion_signatures()
-        -> __completion_signatures_of_t<__copy_cvref_t<_Self, _Sender>, _Env...>
+        -> completion_signatures_of_t<__copy_cvref_t<_Self, _Sender>, _Env...>
       {
         return {};
       }
diff --git a/include/exec/sender_for.hpp b/include/exec/sender_for.hpp
index 5c87e2466..02a86570f 100644
--- a/include/exec/sender_for.hpp
+++ b/include/exec/sender_for.hpp
@@ -15,7 +15,13 @@
  */
 #pragma once
 
-#include "../stdexec/__detail/__sender_introspection.hpp"
+#include "../stdexec/__detail/__config.hpp"
+
+#if STDEXEC_USE_MODULES()
+import stdexec;
+#else
+#  include "../stdexec/__detail/__sender_introspection.hpp"
+#endif
 
 namespace experimental::execution
 {
diff --git a/include/exec/sequence/iterate.hpp b/include/exec/sequence/iterate.hpp
index 30e5ce1db..b847431a7 100644
--- a/include/exec/sequence/iterate.hpp
+++ b/include/exec/sequence/iterate.hpp
@@ -18,15 +18,24 @@
 
 #include "../../stdexec/__detail/__config.hpp"
 
-#include "../../stdexec/__detail/__concepts.hpp"
-#include "../../stdexec/__detail/__connect.hpp"
-#include "../../stdexec/__detail/__env.hpp"
-#include "../../stdexec/__detail/__execution_fwd.hpp"
-#include "../../stdexec/__detail/__operation_states.hpp"
-#include "../../stdexec/__detail/__optional.hpp"
-#include "../../stdexec/__detail/__receivers.hpp"
-#include "../../stdexec/__detail/__schedulers.hpp"
-#include "../../stdexec/__detail/__sender_concepts.hpp"
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include "../../stdexec/__detail/__execution_fwd.hpp"
+
+#  include "../../stdexec/__detail/__concepts.hpp"
+#  include "../../stdexec/__detail/__connect.hpp"
+#  include "../../stdexec/__detail/__env.hpp"
+#  include "../../stdexec/__detail/__operation_states.hpp"
+#  include "../../stdexec/__detail/__optional.hpp"
+#  include "../../stdexec/__detail/__receivers.hpp"
+#  include "../../stdexec/__detail/__schedulers.hpp"
+#  include "../../stdexec/__detail/__sender_concepts.hpp"
+
+#  include <exception>
+#  include <ranges>
+#endif
 
 #include "../detail/basic_sequence.hpp"
 #include "../sender_for.hpp"
@@ -34,9 +43,6 @@
 #include "../sequence_senders.hpp"
 #include "../trampoline_scheduler.hpp"
 
-#include <exception>
-#include <ranges>
-
 namespace experimental::execution
 {
   namespace __iterate
diff --git a/include/exec/sequence_senders.hpp b/include/exec/sequence_senders.hpp
index 8cd61ca1d..668fc0cc1 100644
--- a/include/exec/sequence_senders.hpp
+++ b/include/exec/sequence_senders.hpp
@@ -16,24 +16,31 @@
  */
 #pragma once
 
-#include "../stdexec/__detail/__execution_fwd.hpp"
-
-#include "../stdexec/__detail/__completion_signatures.hpp"
-#include "../stdexec/__detail/__concepts.hpp"
-#include "../stdexec/__detail/__connect.hpp"
-#include "../stdexec/__detail/__debug.hpp"
-#include "../stdexec/__detail/__diagnostics.hpp"
-#include "../stdexec/__detail/__env.hpp"
-#include "../stdexec/__detail/__just.hpp"
-#include "../stdexec/__detail/__meta.hpp"
-#include "../stdexec/__detail/__receivers.hpp"
-#include "../stdexec/__detail/__senders.hpp"
-#include "../stdexec/__detail/__stop_token.hpp"
-#include "../stdexec/__detail/__tag_invoke.hpp"
-#include "../stdexec/__detail/__transform_sender.hpp"
-#include "../stdexec/__detail/__type_traits.hpp"
-#include "../stdexec/__detail/__utility.hpp"
-#include "../stdexec/stop_token.hpp"
+#include "../stdexec/__detail/__config.hpp"
+
+#if STDEXEC_USE_MODULES()
+import stdexec;
+#  include "../stdexec/__detail/__diagnostic_macros.hpp"
+#else
+#  include "../stdexec/__detail/__execution_fwd.hpp"
+
+#  include "../stdexec/__detail/__completion_signatures.hpp"
+#  include "../stdexec/__detail/__concepts.hpp"
+#  include "../stdexec/__detail/__connect.hpp"
+#  include "../stdexec/__detail/__debug.hpp"
+#  include "../stdexec/__detail/__diagnostics.hpp"
+#  include "../stdexec/__detail/__env.hpp"
+#  include "../stdexec/__detail/__just.hpp"
+#  include "../stdexec/__detail/__meta.hpp"
+#  include "../stdexec/__detail/__receivers.hpp"
+#  include "../stdexec/__detail/__senders.hpp"
+#  include "../stdexec/__detail/__stop_token.hpp"
+#  include "../stdexec/__detail/__tag_invoke.hpp"
+#  include "../stdexec/__detail/__transform_sender.hpp"
+#  include "../stdexec/__detail/__type_traits.hpp"
+#  include "../stdexec/__detail/__utility.hpp"
+#  include "../stdexec/stop_token.hpp"
+#endif
 
 #include "completion_signatures.hpp"
 
diff --git a/include/exec/static_thread_pool.hpp b/include/exec/static_thread_pool.hpp
index ae664af8c..feb70674e 100644
--- a/include/exec/static_thread_pool.hpp
+++ b/include/exec/static_thread_pool.hpp
@@ -17,24 +17,43 @@
  */
 #pragma once
 
-#include "../stdexec/__detail/__atomic.hpp"
-#include "../stdexec/__detail/__bulk.hpp"
-#include "../stdexec/__detail/__completion_signatures.hpp"
-#include "../stdexec/__detail/__concepts.hpp"
 #include "../stdexec/__detail/__config.hpp"
-#include "../stdexec/__detail/__domain.hpp"
-#include "../stdexec/__detail/__execution_fwd.hpp"
-#include "../stdexec/__detail/__execution_legacy.hpp"
-#include "../stdexec/__detail/__get_completion_signatures.hpp"
-#include "../stdexec/__detail/__intrusive_queue.hpp"
-#include "../stdexec/__detail/__manual_lifetime.hpp"
-#include "../stdexec/__detail/__meta.hpp"
-#include "../stdexec/__detail/__optional.hpp"
-#include "../stdexec/__detail/__receivers.hpp"
-#include "../stdexec/__detail/__transform_completion_signatures.hpp"
-#include "../stdexec/__detail/__tuple.hpp"
-#include "../stdexec/__detail/__type_traits.hpp"
-#include "../stdexec/__detail/__variant.hpp"
+
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include "../stdexec/__detail/__atomic.hpp"
+#  include "../stdexec/__detail/__bulk.hpp"
+#  include "../stdexec/__detail/__completion_signatures.hpp"
+#  include "../stdexec/__detail/__concepts.hpp"
+#  include "../stdexec/__detail/__config.hpp"
+#  include "../stdexec/__detail/__domain.hpp"
+#  include "../stdexec/__detail/__execution_fwd.hpp"
+#  include "../stdexec/__detail/__execution_legacy.hpp"
+#  include "../stdexec/__detail/__get_completion_signatures.hpp"
+#  include "../stdexec/__detail/__intrusive_queue.hpp"
+#  include "../stdexec/__detail/__manual_lifetime.hpp"
+#  include "../stdexec/__detail/__meta.hpp"
+#  include "../stdexec/__detail/__optional.hpp"
+#  include "../stdexec/__detail/__receivers.hpp"
+#  include "../stdexec/__detail/__transform_completion_signatures.hpp"
+#  include "../stdexec/__detail/__tuple.hpp"
+#  include "../stdexec/__detail/__type_traits.hpp"
+#  include "../stdexec/__detail/__variant.hpp"
+
+#  include <compare>
+#  include <condition_variable>
+#  include <cstdint>
+#  include <exception>
+#  include <limits>
+#  include <mutex>
+#  include <random>
+#  include <span>
+#  include <thread>
+#  include <type_traits>
+#  include <vector>
+#endif
 
 #include "detail/atomic_intrusive_queue.hpp"
 #include "detail/bwos_lifo_queue.hpp"
@@ -45,18 +64,6 @@
 #include "sequence/iterate.hpp"
 #include "sequence_senders.hpp"
 
-#include <compare>
-#include <condition_variable>
-#include <cstdint>
-#include <exception>
-#include <limits>
-#include <mutex>
-#include <random>
-#include <span>
-#include <thread>
-#include <type_traits>
-#include <vector>
-
 namespace experimental::execution
 {
   struct bwos_params
diff --git a/include/exec/thread_pool_base.hpp b/include/exec/thread_pool_base.hpp
index 9cc3b1e44..f2d8211d2 100644
--- a/include/exec/thread_pool_base.hpp
+++ b/include/exec/thread_pool_base.hpp
@@ -17,27 +17,34 @@
  */
 #pragma once
 
-#include "../stdexec/__detail/__execution_fwd.hpp"
-
-#include "../stdexec/__detail/__connect.hpp"
-#include "../stdexec/__detail/__env.hpp"
-#include "../stdexec/__detail/__meta.hpp"
-#include "../stdexec/__detail/__operation_states.hpp"
-#include "../stdexec/__detail/__receivers.hpp"
-#include "../stdexec/__detail/__schedulers.hpp"
-#include "../stdexec/__detail/__transform_completion_signatures.hpp"
-#include "../stdexec/__detail/__type_traits.hpp"
+#include "../stdexec/__detail/__config.hpp"
 
 #include "sender_for.hpp"
 #include "static_thread_pool.hpp"
 
-#include <atomic>
-#include <concepts>
-#include <cstdint>
-#include <exception>
-#include <tuple>
-#include <utility>
-#include <variant>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include "../stdexec/__detail/__execution_fwd.hpp"
+
+#  include "../stdexec/__detail/__connect.hpp"
+#  include "../stdexec/__detail/__env.hpp"
+#  include "../stdexec/__detail/__meta.hpp"
+#  include "../stdexec/__detail/__operation_states.hpp"
+#  include "../stdexec/__detail/__receivers.hpp"
+#  include "../stdexec/__detail/__schedulers.hpp"
+#  include "../stdexec/__detail/__transform_completion_signatures.hpp"
+#  include "../stdexec/__detail/__type_traits.hpp"
+
+#  include <atomic>
+#  include <concepts>
+#  include <cstdint>
+#  include <exception>
+#  include <tuple>
+#  include <utility>
+#  include <variant>
+#endif
 
 namespace experimental::execution
 {
diff --git a/include/stdexec/__detail/__affine.hpp b/include/stdexec/__detail/__affine.hpp
index d0e6ac1cf..2306561ec 100644
--- a/include/stdexec/__detail/__affine.hpp
+++ b/include/stdexec/__detail/__affine.hpp
@@ -15,14 +15,22 @@
  */
 #pragma once
 
-#include "__basic_sender.hpp"
-#include "__completion_behavior.hpp"
-#include "__finally.hpp"
-#include "__schedulers.hpp"
-#include "__senders.hpp"
-#include "__unstoppable.hpp"
+#include "__config.hpp"
 
-#include "__prologue.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__basic_sender.hpp"
+#  include "__completion_behavior.hpp"
+#  include "__finally.hpp"
+#  include "__schedulers.hpp"
+#  include "__senders.hpp"
+#  include "__unstoppable.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -179,4 +187,5 @@ namespace STDEXEC
   };
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__any.hpp b/include/stdexec/__detail/__any.hpp
index 014cb9462..849233c6a 100644
--- a/include/stdexec/__detail/__any.hpp
+++ b/include/stdexec/__detail/__any.hpp
@@ -50,6 +50,10 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Warray-bounds")
 
 // NOLINTBEGIN(moderize-use-override)
 
+STDEXEC_MODULE_EXPORT_AUTHORING
+namespace STDEXEC::__any
+{}
+
 namespace STDEXEC::__any
 {
 
@@ -165,25 +169,31 @@ namespace STDEXEC::__any
   template <template <class> class _Interface>
   struct __any_ptr_base;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <template <class> class _Interface>
   struct __any_ptr;
 
   template <template <class> class _Interface>
   struct __any_cptr;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <template <class> class... _BaseInterfaces>
   struct __extends;
 
   // semiregular interfaces
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Base>
   struct __imovable;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Base>
   struct __icopyable;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Base>
   struct __iequality_comparable;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Base>
   struct __isemiregular;
 
@@ -192,6 +202,7 @@ namespace STDEXEC::__any
   template <template <class> class _Interface>
   using __bases_of = _Interface<__iroot>::__bases_type;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <template <class> class _Interface,
             class _Base,
             class _BaseInterfaces   = __extends<>,
@@ -292,18 +303,23 @@ namespace STDEXEC::__any
     };
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   [[maybe_unused]]
   inline constexpr auto __value = __access::__value_t{};
   [[maybe_unused]]
   inline constexpr auto __empty = __access::__empty_t{};
+  STDEXEC_MODULE_EXPORT_AUTHORING
   [[maybe_unused]]
   inline constexpr auto __reset = __access::__reset_t{};
+  STDEXEC_MODULE_EXPORT_AUTHORING
   [[maybe_unused]]
   inline constexpr auto __type = __access::__type_t{};
   [[maybe_unused]]
   inline constexpr auto __data = __access::__data_t{};
+  STDEXEC_MODULE_EXPORT_AUTHORING
   [[maybe_unused]]
   inline constexpr auto __addressof = __access::__addressof_t{};
+  STDEXEC_MODULE_EXPORT_AUTHORING
   [[maybe_unused]]
   inline constexpr auto __caddressof = __access::__caddressof_t{};
 
@@ -313,12 +329,14 @@ namespace STDEXEC::__any
 
   //////////////////////////////////////////////////////////////////////////////////////////
   // __extension_of
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Interface, template <class> class _BaseInterface>
   concept __extension_of = requires(_Interface const &__arg) {
     STDEXEC::__any::__interface_cast<_BaseInterface>(__arg);
   };
 
   //////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT_AUTHORING
   enum class __box_kind
   {
     __abstract,
@@ -403,6 +421,7 @@ namespace STDEXEC::__any
   //! derived from
   //! @c __iabstract<_Base>. @c __iabstract<_Derived> is an alias for @c
   //! Derived<Base<__iroot>>.
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <template <class> class _Interface, class _BaseInterfaces = __bases_of<_Interface>>
   using __iabstract = _Interface<__mcall1<_BaseInterfaces, __iroot>>;
 
@@ -1779,6 +1798,7 @@ namespace STDEXEC::__any
   struct __any_cast_t : __basic_cast_t<_Value, __any_dynamic_cast_t>
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Value>
   constexpr __any_cast_t<_Value> __any_cast{};
 
@@ -1788,6 +1808,7 @@ namespace STDEXEC::__any
   struct __any_static_cast_t : __basic_cast_t<_Value, __any_static_cast_impl_t>
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Value>
   constexpr __any_static_cast_t<_Value> __any_static_cast{};
 
diff --git a/include/stdexec/__detail/__any_allocator.hpp b/include/stdexec/__detail/__any_allocator.hpp
index a72bd483a..a93cf0947 100644
--- a/include/stdexec/__detail/__any_allocator.hpp
+++ b/include/stdexec/__detail/__any_allocator.hpp
@@ -16,14 +16,22 @@
 
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__any.hpp"
-#include "__concepts.hpp"
-#include "__memory.hpp"
-#include "__typeinfo.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__any.hpp"
+#  include "__concepts.hpp"
+#  include "__memory.hpp"
+#  include "__typeinfo.hpp"
+
+#  include "__prologue.hpp"
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Warray-bounds")
 
@@ -125,4 +133,5 @@ namespace STDEXEC
   __any_allocator(std::allocator<void>) -> __any_allocator<std::byte>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__associate.hpp b/include/stdexec/__detail/__associate.hpp
index 6a9d92779..d34506c8f 100644
--- a/include/stdexec/__detail/__associate.hpp
+++ b/include/stdexec/__detail/__associate.hpp
@@ -156,6 +156,7 @@ namespace STDEXEC
     __associate_data(_Token, _Sender&&) -> __associate_data<_Token, _Sender>;
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
+    STDEXEC_MODULE_EXPORT
     struct associate_t
     {
       template <sender _Sender, scope_token _Token>
@@ -285,11 +286,13 @@ namespace STDEXEC
     };
   }  // namespace __associate
 
+  STDEXEC_MODULE_EXPORT
   using __associate::associate_t;
 
   /// @brief The associate sender adaptor, which associates a sender with the
   ///        async scope referred to by the given token
   /// @hideinitializer
+  STDEXEC_MODULE_EXPORT
   inline constexpr associate_t associate{};
 
   template <>
diff --git a/include/stdexec/__detail/__atomic.hpp b/include/stdexec/__detail/__atomic.hpp
index 28578a770..006014206 100644
--- a/include/stdexec/__detail/__atomic.hpp
+++ b/include/stdexec/__detail/__atomic.hpp
@@ -65,16 +65,27 @@ namespace STDEXEC::__std
 
 #  else  // ^^^ STDEXEC_HAS_CUDA_STD_ATOMIC() / vvv !STDEXEC_HAS_CUDA_STD_ATOMIC()
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::atomic;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::atomic_flag;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::atomic_ptrdiff_t;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::memory_order;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::memory_order_relaxed;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::memory_order_acquire;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::memory_order_release;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::memory_order_acq_rel;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::memory_order_seq_cst;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::atomic_thread_fence;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using std::atomic_signal_fence;
 
 #    if __cpp_lib_atomic_ref >= 201806L
@@ -91,6 +102,7 @@ namespace STDEXEC::__std
 
   // clang-12 does not know about std::atomic_ref yet
   // Here we implement only what we need
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <integral _Ty>
   class atomic_ref
   {
@@ -134,9 +146,11 @@ namespace STDEXEC::__std
   }
 
 #  if __cpp_lib_atomic_shared_ptr >= 201711L && !STDEXEC_HAS_CUDA_STD_ATOMIC()
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty>
   using __atomic_shared_ptr = std::atomic<std::shared_ptr<_Ty>>;
 #  else
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <typename _Ty>
   struct __atomic_shared_ptr
   {
diff --git a/include/stdexec/__detail/__atomic_intrusive_queue.hpp b/include/stdexec/__detail/__atomic_intrusive_queue.hpp
index 4114e4b93..610706ef0 100644
--- a/include/stdexec/__detail/__atomic_intrusive_queue.hpp
+++ b/include/stdexec/__detail/__atomic_intrusive_queue.hpp
@@ -17,13 +17,21 @@
 
 #include "__config.hpp"
 
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
 //
-#include "__atomic.hpp"
-#include "__intrusive_queue.hpp"
+#  include "__atomic.hpp"
+#  include "__intrusive_queue.hpp"
 
-#include <cassert>
+#  if !STDEXEC_USE_MODULES()
+#    include <cassert>
+#  endif
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -81,4 +89,5 @@ namespace STDEXEC
 
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__awaitable.hpp b/include/stdexec/__detail/__awaitable.hpp
index 717889cbc..7b5775f4d 100644
--- a/include/stdexec/__detail/__awaitable.hpp
+++ b/include/stdexec/__detail/__awaitable.hpp
@@ -15,21 +15,30 @@
  */
 #pragma once
 
-#include "../functional.hpp"
-#include "__concepts.hpp"
 #include "__config.hpp"
-#include "__meta.hpp"
 
-#include "__prologue.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "../functional.hpp"
+#  include "__concepts.hpp"
+#  include "__config.hpp"
+#  include "__meta.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
-#if !STDEXEC_NO_STDCPP_COROUTINES()
+#  if !STDEXEC_NO_STDCPP_COROUTINES()
   // Define some concepts and utilities for working with awaitables
   template <class _Tp>
   concept __await_suspend_result = __one_of<_Tp, void, bool>
                                 || __is_instance_of<_Tp, __std::coroutine_handle>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Awaiter, class... _Promise>
   concept __awaiter = requires(_Awaiter &__awaiter, __std::coroutine_handle<_Promise...> __h) {
     __awaiter.await_ready() ? 1 : 0;
@@ -74,6 +83,7 @@ namespace STDEXEC
   template <class _Awaitable>
   using __awaiter_of_t = decltype(STDEXEC::__get_awaiter(__declval<_Awaitable>()));
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Awaitable, class... _Promise>
   concept __awaitable = requires(_Awaitable &&__awaitable, _Promise &...__promise) {
     {
@@ -85,6 +95,7 @@ namespace STDEXEC
   template <class _Tp>
   constexpr auto __as_lvalue(_Tp &&) -> _Tp &;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Awaitable, class... _Promise>
   struct __await_result
   {
@@ -95,20 +106,24 @@ namespace STDEXEC
                            .await_resume());
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Awaitable, class... _Promise>
     requires __awaitable<_Awaitable, _Promise...>
   using __await_result_t = __t<__await_result<_Awaitable, _Promise...>>;
 
-#else
+#  else
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Awaitable, class... _Promise>
   concept __awaitable = false;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Awaitable, class... _Promise>
     requires __awaitable<_Awaitable, _Promise...>
   using __await_result_t = void;
 
-#endif
+#  endif
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__basic_sender.hpp b/include/stdexec/__detail/__basic_sender.hpp
index 960e2dc30..49933cf5c 100644
--- a/include/stdexec/__detail/__basic_sender.hpp
+++ b/include/stdexec/__detail/__basic_sender.hpp
@@ -25,6 +25,7 @@ import stdexec;
 
 #  include "__execution_fwd.hpp"
 
+#  include "__basic_sender_macros.hpp"
 #  include "__completion_signatures_of.hpp"
 #  include "__concepts.hpp"
 #  include "__connect.hpp"
@@ -51,21 +52,12 @@ namespace STDEXEC
   /////////////////////////////////////////////////////////////////////////////
   // Generic __sender type
 
-#  if STDEXEC_EDG()
-#    define STDEXEC_SEXPR_DESCRIPTOR_FN(_Descriptor)                                               \
-    ([]<class _Desc = _Descriptor>(_Desc __desc = {}) { return __desc; })
-#    define STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child)                                          \
-    STDEXEC::__descriptor_fn<_Tag, _Data, _Child>()
-#  else  // ^^^ EDG ^^^ / vvv !EDG vvv
-#    define STDEXEC_SEXPR_DESCRIPTOR_FN(_Descriptor) ([] { return _Descriptor(); })
-#    define STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child)                                          \
-    STDEXEC::__descriptor_fn_v<STDEXEC::__desc<_Tag, _Data, _Child>>
-#  endif
-
 #  if defined(STDEXEC_DEMANGLE_SENDER_NAMES)
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Descriptor>
   inline constexpr auto __descriptor_fn_v = _Descriptor{};
 #  else
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Descriptor, auto _DescriptorFn = STDEXEC_SEXPR_DESCRIPTOR_FN(_Descriptor)>
   inline constexpr auto __descriptor_fn_v = _DescriptorFn;
 #  endif
@@ -76,6 +68,7 @@ namespace STDEXEC
     return __descriptor_fn_v<__desc<_Tag, _Data, _Child...>>;
   }
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag>
   struct __sexpr_impl;
 
@@ -157,6 +150,7 @@ namespace STDEXEC
     concept __connectable_to =
       __applicable<__connect_t<_Sexpr>, _Sexpr, __state_type_t<_Sexpr, _Receiver>&>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     struct __defaults
     {
       static constexpr auto __get_attrs =  //
@@ -238,6 +232,7 @@ namespace STDEXEC
     };
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __sexpr_defaults = __detail::__defaults;
 
   template <class _Tag, class _State, std::size_t _Idx>
@@ -342,6 +337,7 @@ namespace STDEXEC
 
   //! A dummy type used only for diagnostic purposes.
   //! See `__sexpr` for the implementation of P2300's _`basic-sender`_.
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag, class _Data, class... _Child>
   struct __basic_sender
   {
@@ -351,8 +347,10 @@ namespace STDEXEC
     };
   };
 
+#  if !STDEXEC_USE_MODULES()
   namespace
   {
+#  endif
     //! A struct template to aid in creating senders. This struct resembles P2300's
     //! [_`basic-sender`_](https://eel.is/c++draft/exec#snd.expos-24), but is not an exact
     //! implementation. Note: The struct named `__basic_sender` is just a dummy type and
@@ -448,7 +446,9 @@ namespace STDEXEC
     template <class _Tag, class _Data, class... _Child>
     STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
     __sexpr(_Tag, _Data, _Child...) -> __sexpr<STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child...)>;
+#  if !STDEXEC_USE_MODULES()
   }  // anonymous namespace
+#  endif
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
   // __make_sexpr
@@ -470,6 +470,7 @@ namespace STDEXEC
     };
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag>
   inline constexpr __detail::__make_sexpr_t<_Tag> __make_sexpr{};
 
diff --git a/include/stdexec/__detail/__basic_sender_macros.hpp b/include/stdexec/__detail/__basic_sender_macros.hpp
new file mode 100644
index 000000000..31990cd49
--- /dev/null
+++ b/include/stdexec/__detail/__basic_sender_macros.hpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2021-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"
+
+#if STDEXEC_EDG()
+#  define STDEXEC_SEXPR_DESCRIPTOR_FN(_Descriptor)                                               \
+    ([]<class _Desc = _Descriptor>(_Desc __desc = {}) { return __desc; })
+#  define STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child)                                          \
+    STDEXEC::__descriptor_fn<_Tag, _Data, _Child>()
+#else  // ^^^ EDG ^^^ / vvv !EDG vvv
+#  define STDEXEC_SEXPR_DESCRIPTOR_FN(_Descriptor) ([] { return _Descriptor(); })
+#  define STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child)                                          \
+    STDEXEC::__descriptor_fn_v<STDEXEC::__desc<_Tag, _Data, _Child>>
+#endif
diff --git a/include/stdexec/__detail/__bulk.hpp b/include/stdexec/__detail/__bulk.hpp
index 0da2eeb30..63f87dcea 100644
--- a/include/stdexec/__detail/__bulk.hpp
+++ b/include/stdexec/__detail/__bulk.hpp
@@ -15,19 +15,27 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__basic_sender.hpp"
-#include "__completion_signatures_of.hpp"
-#include "__diagnostics.hpp"
-#include "__execution_legacy.hpp"  // IWYU pragma: export
-#include "__meta.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"  // IWYU pragma: keep for __well_formed_sender
-#include "__transform_completion_signatures.hpp"
+#  include "__basic_sender.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__diagnostics.hpp"
+#  include "__execution_legacy.hpp"  // IWYU pragma: export
+#  include "__meta.hpp"
+#  include "__sender_adaptor_closure.hpp"
+#  include "__senders.hpp"  // IWYU pragma: keep for __well_formed_sender
+#  include "__transform_completion_signatures.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
 
@@ -224,6 +232,7 @@ namespace STDEXEC
       }
     };
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Fun>
     struct __as_bulk_chunked_fn
     {
@@ -577,4 +586,5 @@ namespace STDEXEC
   {};
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__completion_behavior.hpp b/include/stdexec/__detail/__completion_behavior.hpp
index 63ec51330..126b0c482 100644
--- a/include/stdexec/__detail/__completion_behavior.hpp
+++ b/include/stdexec/__detail/__completion_behavior.hpp
@@ -41,6 +41,7 @@ namespace STDEXEC
 {
   //////////////////////////////////////////////////////////////////////////////////////////
   // __get_completion_behavior
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __completion_behavior
   {
     //private:
@@ -204,10 +205,12 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag, class _Attrs, class... _Env>
   inline constexpr auto __completion_behavior_of_v =
     __call_result_t<__get_completion_behavior_t<_Tag>, _Attrs const &, _Env const &...>{};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag, class _Attrs, class... _Env>
   concept __completes_inline = (__completion_behavior_of_v<_Tag, _Attrs, _Env...>.value
                                 == __completion_behavior::__inline_completion);
diff --git a/include/stdexec/__detail/__completion_signatures.hpp b/include/stdexec/__detail/__completion_signatures.hpp
index 6a59e33a7..d1f537385 100644
--- a/include/stdexec/__detail/__completion_signatures.hpp
+++ b/include/stdexec/__detail/__completion_signatures.hpp
@@ -45,6 +45,7 @@ namespace STDEXEC
   // completion_signatures
   namespace __cmplsigs
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Sig>
     inline constexpr bool __is_compl_sig = false;
     template <class... _Args>
@@ -55,6 +56,7 @@ namespace STDEXEC
     inline constexpr bool __is_compl_sig<set_stopped_t()> = true;
   }  // namespace __cmplsigs
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sig>
   concept __completion_signature = __cmplsigs::__is_compl_sig<_Sig>;
 
@@ -83,6 +85,7 @@ namespace STDEXEC
     using __normalize_completions_t = decltype(__cmplsigs::__normalize_completions(
       static_cast<_Completions*>(nullptr)));
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Sig>
     using __normalize_sig_t = decltype(__cmplsigs::__normalize_sig(static_cast<_Sig*>(nullptr)));
   }  // namespace __cmplsigs
@@ -207,6 +210,7 @@ namespace STDEXEC
 
   ////////////////////////////////////////////////////////////////////////////////////////////////////
   // completion signatures type traits
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sigs,
             class _Tuple   = __qq<__decayed_std_tuple>,
             class _Variant = __qq<__std_variant>>
@@ -235,12 +239,14 @@ namespace STDEXEC
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   // concat_completion_signatures
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Sigs>
   using __concat_completion_signatures_t =
     __mcall<__mconcat<__munique<__qq<completion_signatures>>>, _Sigs...>;
 
   namespace __detail
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     struct __concat_completion_signatures_fn
     {
       template <STDEXEC::__valid_completion_signatures... Sigs>
@@ -443,13 +449,16 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __eptr_completion_t = completion_signatures<set_error_t(std::exception_ptr)>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _NoExcept>
   using __eptr_completion_unless_t = __if<_NoExcept, completion_signatures<>, __eptr_completion_t>;
 
 #  if STDEXEC_NO_STDCPP_CONSTEXPR_EXCEPTIONS()
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class, class... _What, class... _Values>
   [[nodiscard]]
   consteval auto __throw_compile_time_error_r(_Values...) -> __mexception<_What...>
@@ -467,6 +476,7 @@ namespace STDEXEC
 #  else  // ^^^ no constexpr exceptions ^^^ / vvv constexpr exceptions vvv
 
   // C++26, https://wg21.link/p3068
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Return, class _What, class... _More, class... _Values>
   [[noreturn, nodiscard]]
   consteval auto __throw_compile_time_error_r([[maybe_unused]] _Values... __values) -> _Return
@@ -538,6 +548,7 @@ namespace STDEXEC
     };
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _WantedTag, class _Sigs, class _Tuple, class _Variant>
   using __gather_completions_t =
     __detail::__gather_sigs_fn<_WantedTag>::template __f<_Sigs, _Tuple, _Variant>;
@@ -570,6 +581,7 @@ namespace STDEXEC
       return _ID;                                   \
     } else
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class, class _Sndr>
   [[nodiscard]]
   consteval auto __throw_dependent_sender_error_r() noexcept -> __dependent_sender_error_t<_Sndr>
@@ -588,6 +600,7 @@ namespace STDEXEC
 
 #    define STDEXEC_IF_OK(_ID)
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Result, class _Sndr>
   [[noreturn, nodiscard]]
   consteval auto __throw_dependent_sender_error_r() -> _Result
diff --git a/include/stdexec/__detail/__completion_signatures_of.hpp b/include/stdexec/__detail/__completion_signatures_of.hpp
index c09b281c8..f1205fe88 100644
--- a/include/stdexec/__detail/__completion_signatures_of.hpp
+++ b/include/stdexec/__detail/__completion_signatures_of.hpp
@@ -15,18 +15,26 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__debug.hpp"  // IWYU pragma: keep for STDEXEC::__debug_sender
-#include "__get_completion_signatures.hpp"
-#include "__sender_concepts.hpp"  // IWYU pragma: export
+#  include "__debug.hpp"  // IWYU pragma: keep for STDEXEC::__debug_sender
+#  include "__get_completion_signatures.hpp"
+#  include "__sender_concepts.hpp"  // IWYU pragma: export
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
-#if STDEXEC_ENABLE_EXTRA_TYPE_CHECKING()
+#  if STDEXEC_ENABLE_EXTRA_TYPE_CHECKING()
   // __checked_completion_signatures is for catching logic bugs in a sender's metadata. If sender<S>
   // and sender_in<S, Ctx> are both true, then they had better report the same metadata. This
   // completion signatures wrapper enforces that at compile time.
@@ -38,16 +46,19 @@ namespace STDEXEC
     return __completions_t{};
   }
 
+  STDEXEC_MODULE_EXPORT
   template <class _CvSender, class... _Env>
     requires sender_in<_CvSender, _Env...>
   using completion_signatures_of_t =
     decltype(STDEXEC::__checked_completion_signatures(__declval<_CvSender>(),
                                                       __declval<_Env>()...));
-#else
+#  else
+  STDEXEC_MODULE_EXPORT
   template <class _CvSender, class... _Env>
     requires sender_in<_CvSender, _Env...>
   using completion_signatures_of_t = __completion_signatures_of_t<_CvSender, _Env...>;
-#endif
+#  endif
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__concepts.hpp b/include/stdexec/__detail/__concepts.hpp
index 6bcebcf82..9a989357b 100644
--- a/include/stdexec/__detail/__concepts.hpp
+++ b/include/stdexec/__detail/__concepts.hpp
@@ -45,17 +45,20 @@ import stdexec;
 namespace STDEXEC
 {
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Fun, class... _As>
   concept __callable = requires(_Fun &&__fun, _As &&...__as) {
     static_cast<_Fun &&>(__fun)(static_cast<_As &&>(__as)...);
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Fun, class... _As>
   concept __nothrow_callable = __callable<_Fun, _As...> && requires(_Fun &&__fun, _As &&...__as) {
     { static_cast<_Fun &&>(__fun)(static_cast<_As &&>(__as)...) } noexcept;
   };
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT_META
   template <class...>
   struct __mlist;
 
@@ -65,16 +68,20 @@ namespace STDEXEC
   };
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ap, class _Bp>
   concept __same_as = STDEXEC_IS_SAME(_Ap, _Bp);
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ap, class _Bp>
   concept __not_same_as = !STDEXEC_IS_SAME(_Ap, _Bp);
 
   // Handy concepts
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class _Up>
   concept __decays_to = __same_as<__decay_t<_Ty>, _Up>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class _Up>
   concept __not_decays_to = !__decays_to<_Ty, _Up>;
 
@@ -87,12 +94,14 @@ namespace STDEXEC
   template <class _Cp>
   concept __class = __true<int _Cp::*> && (!__same_as<_Cp const, _Cp>);
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class... _As>
   concept __one_of = (__same_as<_Ty, _As> || ...);
 
   template <class _Ty, class... _Us>
   concept __all_of = (__same_as<_Ty, _Us> && ...);
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class... _Us>
   concept __none_of = (__not_same_as<_Ty, _Us> && ...);
 
@@ -102,6 +111,7 @@ namespace STDEXEC
   template <class... _As, template <class...> class _Ty>
   constexpr bool __is_instance_of_<_Ty<_As...>, _Ty> = true;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ay, template <class...> class _Ty>
   concept __is_instance_of = __is_instance_of_<_Ay, _Ty>;
 
@@ -129,13 +139,16 @@ namespace STDEXEC
 
     // Make sure we're using a same_as concept that doesn't instantiate a class template
     // (i.e., std::is_same)
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Ap, class _Bp>
     concept same_as = __same_as<_Ap, _Bp> && __same_as<_Bp, _Ap>;
 
 #  if !STDEXEC_NO_STDCPP_CONCEPTS_HEADER()
 
     using std::integral;
+    STDEXEC_MODULE_EXPORT_AUTHORING
     using std::derived_from;
+    STDEXEC_MODULE_EXPORT_AUTHORING
     using std::convertible_to;
     using std::equality_comparable;
 
@@ -144,10 +157,12 @@ namespace STDEXEC
     template <class T>
     concept integral = std::is_integral_v<T>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Ap, class _Bp>
     concept derived_from = STDEXEC_IS_BASE_OF(_Bp, _Ap)
                         && STDEXEC_IS_CONVERTIBLE_TO(_Ap const volatile *, _Bp const volatile *);
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _From, class _To>
     concept convertible_to = STDEXEC_IS_CONVERTIBLE_TO(_From, _To)
                           && requires(__declfn_t<_From> __fun) { static_cast<_To>(__fun()); };
@@ -198,6 +213,7 @@ namespace STDEXEC
     template <class _Ty, class... _As>
     concept constructible_from = destructible<_Ty> && STDEXEC_IS_CONSTRUCTIBLE(_Ty, _As...);
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Ty>
     concept default_initializable = constructible_from<_Ty> && requires { _Ty{}; }
                                  && requires { ::new _Ty; };
@@ -289,6 +305,7 @@ namespace STDEXEC
     { _Ty{__as()...} } noexcept;
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty>
   concept __movable_value = __std::move_constructible<__decay_t<_Ty>>
                          && __std::constructible_from<__decay_t<_Ty>, _Ty>;
@@ -299,19 +316,23 @@ namespace STDEXEC
                                       { __decay_t<_Ty>(__decay_t<_Ty>(__t())) } noexcept;
                                     };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class... _As>
   concept __nothrow_constructible_from = __std::constructible_from<_Ty, _As...>
                                       && STDEXEC_IS_NOTHROW_CONSTRUCTIBLE(_Ty, _As...);
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Ts>
   concept __nothrow_move_constructible = (__nothrow_constructible_from<_Ts, _Ts> && ...);
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Ts>
   concept __nothrow_copy_constructible = (__nothrow_constructible_from<_Ts, _Ts const &> && ...);
 
   template <class _Ty, class _A>
   concept __assignable_from = STDEXEC_IS_ASSIGNABLE(_Ty, _A);
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class _A>
   concept __nothrow_assignable_from = STDEXEC_IS_NOTHROW_ASSIGNABLE(_Ty, _A);
 
@@ -327,22 +348,26 @@ namespace STDEXEC
   template <class... _Ts>
   concept __nothrow_copy_assignable = (__nothrow_assignable_from<_Ts, _Ts const &> && ...);
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Ts>
   concept __decay_copyable = (__std::constructible_from<__decay_t<_Ts>, _Ts> && ...);
 
   template <class... _Ts>
   using __decay_copyable_t = __mbool<__decay_copyable<_Ts...>>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Ts>
   concept __nothrow_decay_copyable = (__nothrow_constructible_from<__decay_t<_Ts>, _Ts> && ...);
 
   template <class... _Ts>
   using __nothrow_decay_copyable_t = __mbool<__nothrow_decay_copyable<_Ts...>>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class _Up>
   concept __decays_to_derived_from = __std::derived_from<__decay_t<_Ty>, _Up>;
 
   // See [allocator.requirements.general]/p99 (https://eel.is/c++draft/allocator.requirements.general#99)
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Alloc>
   concept __simple_allocator =  //
     requires(_Alloc __alloc, std::size_t __count) {
diff --git a/include/stdexec/__detail/__config.hpp b/include/stdexec/__detail/__config.hpp
index 5aad8b496..6ce45c5e3 100644
--- a/include/stdexec/__detail/__config.hpp
+++ b/include/stdexec/__detail/__config.hpp
@@ -38,15 +38,15 @@
 
 #include "__preprocessor.hpp"
 
+#if __has_include(<version>)
+#  include <version>
+#else
+#  include <ciso646>  // For stdlib feature-test macros when <version> is not available
+#endif
+
 #if STDEXEC_USE_MODULES()
 import std;
 #else
-#  if __has_include(<version>)
-#    include <version>
-#  else
-#    include <ciso646>  // For stdlib feature-test macros when <version> is not available
-#  endif
-
 #  include <cassert>
 #  include <cstdlib>
 #  include <type_traits>  // IWYU pragma: keep
@@ -925,7 +925,7 @@ namespace STDEXEC
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-#if !defined(STDEXEC_DEMANGLE_SENDER_NAMES) && STDEXEC_MSVC()
+#if !defined(STDEXEC_DEMANGLE_SENDER_NAMES) && (STDEXEC_MSVC() || STDEXEC_USE_MODULES())
 #  define STDEXEC_DEMANGLE_SENDER_NAMES
 #endif
 
@@ -957,4 +957,15 @@ namespace STDEXEC
 #  define STDEXEC_MODULE_EXPORT
 #endif
 
-STDEXEC_MODULE_EXPORT namespace STDEXEC {}
+// Placeholder until stdexec.meta / stdexec.authoring exist as separate
+// modules; these currently just export into stdexec itself. See #2139
+// (https://github.com/NVIDIA/stdexec/issues/2139)
+#define STDEXEC_MODULE_EXPORT_META      STDEXEC_MODULE_EXPORT
+#define STDEXEC_MODULE_EXPORT_AUTHORING STDEXEC_MODULE_EXPORT
+
+STDEXEC_MODULE_EXPORT
+namespace STDEXEC
+{
+  namespace parallel_scheduler_replacement
+  {}
+}  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__connect.hpp b/include/stdexec/__detail/__connect.hpp
index 9fcde6b5d..d9b4c5d68 100644
--- a/include/stdexec/__detail/__connect.hpp
+++ b/include/stdexec/__detail/__connect.hpp
@@ -15,16 +15,24 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__completion_signatures_of.hpp"
-#include "__connect_awaitable.hpp"
-#include "__tag_invoke.hpp"
-#include "__transform_sender.hpp"
-#include "__type_traits.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__connect_awaitable.hpp"
+#  include "__tag_invoke.hpp"
+#  include "__transform_sender.hpp"
+#  include "__type_traits.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -56,9 +64,9 @@ namespace STDEXEC
                               || __with_co_await<_Sender, _Receiver>
                               || __with_legacy_tag_invoke<_Sender, _Receiver>;
 
-#if !STDEXEC_MSVC()
+#  if !STDEXEC_MSVC()
 
-#  define STDEXEC_CONNECT_DECLFN_FOR(_EXPR) __declfn_t<decltype(_EXPR), noexcept(_EXPR)>
+#    define STDEXEC_CONNECT_DECLFN_FOR(_EXPR) __declfn_t<decltype(_EXPR), noexcept(_EXPR)>
 
     // A variable template whose type is a function pointer such that the
     // return type and noexcept-ness depend on whether _Sender can be connected
@@ -131,11 +139,11 @@ namespace STDEXEC
                _Receiver,
                __nothrow_callable<transform_sender_t, _Sender, env_of_t<_Receiver>>>);
 
-#  undef STDEXEC_CONNECT_DECLFN_FOR
+#    undef STDEXEC_CONNECT_DECLFN_FOR
 
-#else  // ^^^ !STDEXEC_MSVC() ^^^ / vvv STDEXEC_MSVC() vvv
+#  else  // ^^^ !STDEXEC_MSVC() ^^^ / vvv STDEXEC_MSVC() vvv
 
-#  define STDEXEC_CONNECT_DECLFN_FOR(_EXPR) __declfn<decltype(_EXPR), noexcept(_EXPR)>()
+#    define STDEXEC_CONNECT_DECLFN_FOR(_EXPR) __declfn<decltype(_EXPR), noexcept(_EXPR)>()
 
     template <bool _NothrowTransform>
     struct __connect_declfn;
@@ -212,9 +220,9 @@ namespace STDEXEC
                  template __get<transform_sender_result_t<_Sender, env_of_t<_Receiver>>,
                                 _Receiver>());
 
-#  undef STDEXEC_CONNECT_DECLFN_FOR
+#    undef STDEXEC_CONNECT_DECLFN_FOR
 
-#endif  // STDEXEC_MSVC()
+#  endif  // STDEXEC_MSVC()
   }  // namespace __connect
 
   template <class _Sender, class _Receiver>
@@ -365,10 +373,12 @@ namespace STDEXEC
   //! @hideinitializer
   inline constexpr connect_t connect{};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class _Receiver>
   concept __nothrow_connectable = sender_to<_Sender, _Receiver>
                                && __nothrow_callable<connect_t, _Sender, _Receiver>;
 
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__continues_on.hpp b/include/stdexec/__detail/__continues_on.hpp
index d9fb2866b..a13a712d2 100644
--- a/include/stdexec/__detail/__continues_on.hpp
+++ b/include/stdexec/__detail/__continues_on.hpp
@@ -15,24 +15,32 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__basic_sender.hpp"
-#include "__concepts.hpp"
-#include "__env.hpp"
-#include "__meta.hpp"
-#include "__operation_states.hpp"
-#include "__schedule_from.hpp"
-#include "__schedulers.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
-#include "__storage.hpp"
-#include "__transform_completion_signatures.hpp"
-#include "__tuple.hpp"
-#include "__utility.hpp"
-
-#include "__prologue.hpp"
+#  include "__basic_sender.hpp"
+#  include "__concepts.hpp"
+#  include "__env.hpp"
+#  include "__meta.hpp"
+#  include "__operation_states.hpp"
+#  include "__schedule_from.hpp"
+#  include "__schedulers.hpp"
+#  include "__sender_adaptor_closure.hpp"
+#  include "__senders.hpp"
+#  include "__storage.hpp"
+#  include "__transform_completion_signatures.hpp"
+#  include "__tuple.hpp"
+#  include "__utility.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -527,4 +535,5 @@ namespace STDEXEC
   {};
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__counting_scopes.hpp b/include/stdexec/__detail/__counting_scopes.hpp
index 70768a13d..dc1651b84 100644
--- a/include/stdexec/__detail/__counting_scopes.hpp
+++ b/include/stdexec/__detail/__counting_scopes.hpp
@@ -725,6 +725,7 @@ namespace STDEXEC
 
   /////////////////////////////////////////////////////////////////////////////
   // [exec.scope.simple.counting]
+  STDEXEC_MODULE_EXPORT
   class simple_counting_scope : private __counting_scopes::__base_scope
   {
    public:
@@ -800,6 +801,7 @@ namespace STDEXEC
 
   /////////////////////////////////////////////////////////////////////////////
   // [exec.scope.counting]
+  STDEXEC_MODULE_EXPORT
   class counting_scope : private __counting_scopes::__base_scope
   {
    public:
diff --git a/include/stdexec/__detail/__debug.hpp b/include/stdexec/__detail/__debug.hpp
index d69f79939..2e69146e8 100644
--- a/include/stdexec/__detail/__debug.hpp
+++ b/include/stdexec/__detail/__debug.hpp
@@ -67,6 +67,7 @@ namespace STDEXEC
     struct _SIGNAL_SENT_BY_SENDER_
     {};
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Warning>
     [[deprecated("The sender claims to send a particular set of completions,"
                  " but in actual fact it completes with a result that is not"
@@ -75,9 +76,11 @@ namespace STDEXEC
       void _ATTENTION_() noexcept
     {}
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Env>
     using __env_t = env<prop<__debug_env_t, bool>, _Env>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _CvSender, class _Env, class... _Sigs>
     struct __receiver
     {
@@ -131,6 +134,7 @@ namespace STDEXEC
                    __mbind_front_q<__receiver, _CvSender, _Env>>,
       _Sigs>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     struct __opstate
     {
       constexpr void start() & noexcept {}
diff --git a/include/stdexec/__detail/__deprecations.hpp b/include/stdexec/__detail/__deprecations.hpp
index 9bd9a9ea0..75ddcb630 100644
--- a/include/stdexec/__detail/__deprecations.hpp
+++ b/include/stdexec/__detail/__deprecations.hpp
@@ -57,7 +57,9 @@ namespace STDEXEC
   [[deprecated("affine_on has been renamed affine")]]
   inline constexpr affine_t const & affine_on = affine;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using transfer_just_t [[deprecated]] = __transfer_just_t;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   [[deprecated]]
   inline constexpr __transfer_just_t const & transfer_just = __transfer_just;
 
diff --git a/include/stdexec/__detail/__diagnostic_macros.hpp b/include/stdexec/__detail/__diagnostic_macros.hpp
new file mode 100644
index 000000000..dcf57299a
--- /dev/null
+++ b/include/stdexec/__detail/__diagnostic_macros.hpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2021-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
+
+// ensure consumers have STDEXEC and STDEXEC_PP_STRINGIZE
+#include "__config.hpp"
+#include "__preprocessor.hpp"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_ENABLE_SENDER_IS_FALSE                                                     \
+  "\n"                                                                                             \
+  "\n"                                                                                             \
+  "The given type is not a sender because " STDEXEC_PP_STRINGIZE(STDEXEC) "::enable_sender<Sender>"\
+  "is false. Either:\n"                                                                            \
+  "\n"                                                                                             \
+  "1. Give the type a nested '::sender_concept' type that is an alias for '"                       \
+  STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag',\n"                                                 \
+  "   as in:\n"                                                                                    \
+  "\n"                                                                                             \
+  "     class MySender\n"                                                                          \
+  "     {\n"                                                                                       \
+  "     public:\n"                                                                                 \
+  "       using sender_concept = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"                 \
+  "       ...\n"                                                                                   \
+  "     };\n"                                                                                      \
+  "\n"                                                                                             \
+  "   or,\n"                                                                                       \
+  "\n"                                                                                             \
+  "2. Specialize the '" STDEXEC_PP_STRINGIZE(STDEXEC) "::enable_sender' boolean trait for this "   \
+  "type to true, as follows:\n"                                                                    \
+  "\n"                                                                                             \
+  "     class MySender\n"                                                                          \
+  "     {\n"                                                                                       \
+  "       ...\n"                                                                                   \
+  "     };\n"                                                                                      \
+  "\n"                                                                                             \
+  "     template <>\n"                                                                             \
+  "     inline constexpr bool " STDEXEC_PP_STRINGIZE(STDEXEC) "::enable_sender<MySender> = true;\n"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_CANNOT_COMPUTE_COMPLETION_SIGNATURES                                       \
+  "\n"                                                                                             \
+  "\n"                                                                                             \
+  "The sender type was not able to report its completion signatures when asked.\n"                 \
+  "This is either because it lacks the necessary member function, or because the\n"                \
+  "member function was ill-formed.\n"                                                              \
+  "\n"                                                                                             \
+  "A sender can declare its completion signatures in one of two ways:\n"                           \
+  "\n"                                                                                             \
+  "1. By defining a nested type alias named 'completion_signatures' that is a\n"                   \
+  "  specialization of '" STDEXEC_PP_STRINGIZE(STDEXEC) "::completion_signatures<...>', "          \
+  "as follows:\n"                                                                                  \
+  "\n"                                                                                             \
+  "     class MySender\n"                                                                          \
+  "     {\n"                                                                                       \
+  "     public:\n"                                                                                 \
+  "       using sender_concept        = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"          \
+  "       using completion_signatures = " STDEXEC_PP_STRINGIZE(STDEXEC)                            \
+  "::completion_signatures<\n"                                                                     \
+  "         // This sender can complete successfully with an int and a float...\n"                 \
+  "         " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_value_t(int, float),\n"                         \
+  "         // ... or in error with an exception_ptr\n"                                            \
+  "         " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_error_t(std::exception_ptr)>;\n"                \
+  "       ...\n"                                                                                   \
+  "     };\n"                                                                                      \
+  "\n"                                                                                             \
+  "   or,\n"                                                                                       \
+  "\n"                                                                                             \
+  "2. By defining a member function named 'get_completion_signatures' that returns\n"              \
+  "   a specialization of '" STDEXEC_PP_STRINGIZE(STDEXEC) "::completion_signatures<...>', as "    \
+  "follows:\n"                                                                                     \
+  "\n"                                                                                             \
+  "     class MySender\n"                                                                          \
+  "     {\n"                                                                                       \
+  "     public:\n"                                                                                 \
+  "       using sender_concept        = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"          \
+  "\n"                                                                                             \
+  "       template <class Self, class... Env>\n"                                                   \
+  "       static consteval auto get_completion_signatures() -> " STDEXEC_PP_STRINGIZE(STDEXEC)     \
+  "::completion_signatures<\n"                                                                     \
+  "         // This sender can complete successfully with an int and a float...\n"                 \
+  "         " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_value_t(int, float),\n"                         \
+  "         // ... or in error with a std::exception_ptr.\n"                                       \
+  "         " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_error_t(std::exception_ptr)>\n"                 \
+  "       {\n"                                                                                     \
+  "        return {};\n"                                                                           \
+  "       }\n"                                                                                     \
+  "       ...\n"                                                                                   \
+  "     };\n"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_RETURNED_AN_ERROR                                \
+  "\n"                                                                                             \
+  "\n"                                                                                             \
+  "Trying to compute the sender's completion signatures resulted in an error. See\n"               \
+  "the rest of the compiler diagnostic for clues. Look for the string \"_ERROR_\".\n"
+
+#define STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_HAS_INVALID_RETURN_TYPE                          \
+  "\n"                                                                                             \
+  "\n"                                                                                             \
+  "The member function 'get_completion_signatures' of the sender returned an\n"                    \
+  "invalid type.\n"                                                                                \
+  "\n"                                                                                             \
+  "A sender's 'get_completion_signatures' function must return a specialization of\n"              \
+  "'" STDEXEC_PP_STRINGIZE(STDEXEC) "::completion_signatures<...>', as follows:\n"                 \
+  "\n"                                                                                             \
+  "  class MySender\n"                                                                             \
+  "  {\n"                                                                                          \
+  "  public:\n"                                                                                    \
+  "    using sender_concept = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"                    \
+  "\n"                                                                                             \
+  "    template <class Self, class... Env>\n"                                                      \
+  "    static consteval auto get_completion_signatures() -> " STDEXEC_PP_STRINGIZE(STDEXEC)        \
+  "::completion_signatures<\n"                                                                     \
+  "      // This sender can complete successfully with an int and a float...\n"                    \
+  "      " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_value_t(int, float),\n"                            \
+  "      // ... or in error with a std::exception_ptr.\n"                                          \
+  "      " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_error_t(std::exception_ptr)>\n"                    \
+  "    {\n"                                                                                        \
+  "      return {};\n"                                                                             \
+  "    }\n"                                                                                        \
+  "    ...\n"                                                                                      \
+  "  };\n"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_CANNOT_CONNECT_SENDER_TO_RECEIVER                                          \
+  "\n"                                                                                             \
+  "A sender must provide a 'connect' member function that takes a receiver as an\n"                \
+  "argument and returns an object whose type satisfies '" STDEXEC_PP_STRINGIZE(STDEXEC)            \
+  "::operation_state',\n"                                                                          \
+  "as shown below:\n"                                                                              \
+  "\n"                                                                                             \
+  "  class MySender\n"                                                                             \
+  "  {\n"                                                                                          \
+  "  public:\n"                                                                                    \
+  "    using sender_concept        = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"             \
+  "    using completion_signatures = " STDEXEC_PP_STRINGIZE(STDEXEC) "::completion_signatures<"    \
+  STDEXEC_PP_STRINGIZE(STDEXEC) "::set_value_t()>;\n"                                              \
+  "\n"                                                                                             \
+  "    template <class Receiver>\n"                                                                \
+  "    struct MyOpState\n"                                                                         \
+  "    {\n"                                                                                        \
+  "      using operation_state_concept = " STDEXEC_PP_STRINGIZE(STDEXEC) "::operation_state_tag;\n"\
+  "\n"                                                                                             \
+  "      void start() noexcept\n"                                                                  \
+  "      {\n"                                                                                      \
+  "        // Start the operation, which will eventually complete and send its\n"                  \
+  "        // result to rcvr_;\n"                                                                  \
+  "      }\n"                                                                                      \
+  "\n"                                                                                             \
+  "      Receiver rcvr_;\n"                                                                        \
+  "    };\n"                                                                                       \
+  "\n"                                                                                             \
+  "    template <" STDEXEC_PP_STRINGIZE(STDEXEC) "::receiver Receiver>\n"                          \
+  "    auto connect(Receiver rcvr) -> MyOpState<Receiver>\n"                                       \
+  "    {\n"                                                                                        \
+  "      return MyOpState<Receiver>{std::move(rcvr)};\n"                                           \
+  "    }\n"                                                                                        \
+  "\n"                                                                                             \
+  "    ...\n"                                                                                      \
+  "  };\n"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_SYNC_WAIT_CANNOT_CONNECT_SENDER_TO_RECEIVER                                \
+  "\n"                                                                                             \
+  "\n"                                                                                             \
+  "The sender passed to '" STDEXEC_PP_STRINGIZE(STDEXEC) "::sync_wait()' does not have a "         \
+  "'connect'\n"                                                                                    \
+  "member function that accepts sync_wait's receiver.\n"                                           \
+  STDEXEC_ERROR_CANNOT_CONNECT_SENDER_TO_RECEIVER
diff --git a/include/stdexec/__detail/__diagnostics.hpp b/include/stdexec/__detail/__diagnostics.hpp
index 6f24c56ba..3f38055e8 100644
--- a/include/stdexec/__detail/__diagnostics.hpp
+++ b/include/stdexec/__detail/__diagnostics.hpp
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "__config.hpp"
+#include "__diagnostic_macros.hpp"
 
 #if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
@@ -39,15 +40,19 @@ namespace STDEXEC
   struct sender_tag;
   struct scheduler_tag;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _WHAT_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _WHERE_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _WHY_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _IN_ALGORITHM_
   {};
 
@@ -61,24 +66,29 @@ namespace STDEXEC
   struct _WITH_SENDERS_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender>
   using _WITH_PRETTY_SENDER_ = _WITH_SENDER_<__demangle_t<_Sender>>;
 
   template <class... _Senders>
   using _WITH_PRETTY_SENDERS_ = _WITH_SENDERS_<__demangle_t<_Senders>...>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _WITH_ENVIRONMENT_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty>
   struct _WITH_TYPE_;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _WITH_RECEIVER_
   {};
 
   template <class _Sig>
   struct _UNHANDLED_COMPLETION_SIGNAL_;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sig>
   struct _WITH_COMPLETION_SIGNATURE_;
 
@@ -91,15 +101,18 @@ namespace STDEXEC
   struct _WITH_ARGUMENTS_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _WITH_QUERY_
   {};
 
   struct _WITH_SCHEDULER_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _TO_FIX_THIS_ERROR_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct _SENDER_TYPE_IS_NOT_DECAY_COPYABLE_
   {};
 
@@ -192,6 +205,7 @@ namespace STDEXEC
 
 #  endif  // __cpp_lib_constexpr_exceptions >= 202502L
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __compile_time_error : __exception
   {};
 
@@ -279,6 +293,7 @@ namespace STDEXEC
   template <class _Sender>
   using __dependent_sender_error_t = _ERROR_<dependent_sender_error, _WITH_PRETTY_SENDER_<_Sender>>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _What>
   struct __not_a_sender
   {
@@ -305,168 +320,5 @@ namespace STDEXEC
   };
 }  // namespace STDEXEC
 
-////////////////////////////////////////////////////////////////////////////////
-#  define STDEXEC_ERROR_ENABLE_SENDER_IS_FALSE                                                     \
-  "\n"                                                                                             \
-  "\n"                                                                                             \
-  "The given type is not a sender because " STDEXEC_PP_STRINGIZE(STDEXEC) "::enable_sender<Sender>"\
-  "is false. Either:\n"                                                                            \
-  "\n"                                                                                             \
-  "1. Give the type a nested '::sender_concept' type that is an alias for '"                       \
-  STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag',\n"                                                 \
-  "   as in:\n"                                                                                    \
-  "\n"                                                                                             \
-  "     class MySender\n"                                                                          \
-  "     {\n"                                                                                       \
-  "     public:\n"                                                                                 \
-  "       using sender_concept = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"                 \
-  "       ...\n"                                                                                   \
-  "     };\n"                                                                                      \
-  "\n"                                                                                             \
-  "   or,\n"                                                                                       \
-  "\n"                                                                                             \
-  "2. Specialize the '" STDEXEC_PP_STRINGIZE(STDEXEC) "::enable_sender' boolean trait for this "   \
-  "type to true, as follows:\n"                                                                    \
-  "\n"                                                                                             \
-  "     class MySender\n"                                                                          \
-  "     {\n"                                                                                       \
-  "       ...\n"                                                                                   \
-  "     };\n"                                                                                      \
-  "\n"                                                                                             \
-  "     template <>\n"                                                                             \
-  "     inline constexpr bool " STDEXEC_PP_STRINGIZE(STDEXEC) "::enable_sender<MySender> = true;\n"
-
-////////////////////////////////////////////////////////////////////////////////
-#  define STDEXEC_ERROR_CANNOT_COMPUTE_COMPLETION_SIGNATURES                                       \
-  "\n"                                                                                             \
-  "\n"                                                                                             \
-  "The sender type was not able to report its completion signatures when asked.\n"                 \
-  "This is either because it lacks the necessary member function, or because the\n"                \
-  "member function was ill-formed.\n"                                                              \
-  "\n"                                                                                             \
-  "A sender can declare its completion signatures in one of two ways:\n"                           \
-  "\n"                                                                                             \
-  "1. By defining a nested type alias named 'completion_signatures' that is a\n"                   \
-  "  specialization of '" STDEXEC_PP_STRINGIZE(STDEXEC) "::completion_signatures<...>', "          \
-  "as follows:\n"                                                                                  \
-  "\n"                                                                                             \
-  "     class MySender\n"                                                                          \
-  "     {\n"                                                                                       \
-  "     public:\n"                                                                                 \
-  "       using sender_concept        = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"          \
-  "       using completion_signatures = " STDEXEC_PP_STRINGIZE(STDEXEC)                            \
-  "::completion_signatures<\n"                                                                     \
-  "         // This sender can complete successfully with an int and a float...\n"                 \
-  "         " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_value_t(int, float),\n"                         \
-  "         // ... or in error with an exception_ptr\n"                                            \
-  "         " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_error_t(std::exception_ptr)>;\n"                \
-  "       ...\n"                                                                                   \
-  "     };\n"                                                                                      \
-  "\n"                                                                                             \
-  "   or,\n"                                                                                       \
-  "\n"                                                                                             \
-  "2. By defining a member function named 'get_completion_signatures' that returns\n"              \
-  "   a specialization of '" STDEXEC_PP_STRINGIZE(STDEXEC) "::completion_signatures<...>', as "    \
-  "follows:\n"                                                                                     \
-  "\n"                                                                                             \
-  "     class MySender\n"                                                                          \
-  "     {\n"                                                                                       \
-  "     public:\n"                                                                                 \
-  "       using sender_concept        = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"          \
-  "\n"                                                                                             \
-  "       template <class Self, class... Env>\n"                                                   \
-  "       static consteval auto get_completion_signatures() -> " STDEXEC_PP_STRINGIZE(STDEXEC)     \
-  "::completion_signatures<\n"                                                                     \
-  "         // This sender can complete successfully with an int and a float...\n"                 \
-  "         " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_value_t(int, float),\n"                         \
-  "         // ... or in error with a std::exception_ptr.\n"                                       \
-  "         " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_error_t(std::exception_ptr)>\n"                 \
-  "       {\n"                                                                                     \
-  "        return {};\n"                                                                           \
-  "       }\n"                                                                                     \
-  "       ...\n"                                                                                   \
-  "     };\n"
-
-////////////////////////////////////////////////////////////////////////////////
-#  define STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_RETURNED_AN_ERROR                                \
-  "\n"                                                                                             \
-  "\n"                                                                                             \
-  "Trying to compute the sender's completion signatures resulted in an error. See\n"               \
-  "the rest of the compiler diagnostic for clues. Look for the string \"_ERROR_\".\n"
-
-#  define STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_HAS_INVALID_RETURN_TYPE                          \
-  "\n"                                                                                             \
-  "\n"                                                                                             \
-  "The member function 'get_completion_signatures' of the sender returned an\n"                    \
-  "invalid type.\n"                                                                                \
-  "\n"                                                                                             \
-  "A sender's 'get_completion_signatures' function must return a specialization of\n"              \
-  "'" STDEXEC_PP_STRINGIZE(STDEXEC) "::completion_signatures<...>', as follows:\n"                 \
-  "\n"                                                                                             \
-  "  class MySender\n"                                                                             \
-  "  {\n"                                                                                          \
-  "  public:\n"                                                                                    \
-  "    using sender_concept = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"                    \
-  "\n"                                                                                             \
-  "    template <class Self, class... Env>\n"                                                      \
-  "    static consteval auto get_completion_signatures() -> " STDEXEC_PP_STRINGIZE(STDEXEC)        \
-  "::completion_signatures<\n"                                                                     \
-  "      // This sender can complete successfully with an int and a float...\n"                    \
-  "      " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_value_t(int, float),\n"                            \
-  "      // ... or in error with a std::exception_ptr.\n"                                          \
-  "      " STDEXEC_PP_STRINGIZE(STDEXEC) "::set_error_t(std::exception_ptr)>\n"                    \
-  "    {\n"                                                                                        \
-  "      return {};\n"                                                                             \
-  "    }\n"                                                                                        \
-  "    ...\n"                                                                                      \
-  "  };\n"
-
-////////////////////////////////////////////////////////////////////////////////
-#  define STDEXEC_ERROR_CANNOT_CONNECT_SENDER_TO_RECEIVER                                          \
-  "\n"                                                                                             \
-  "A sender must provide a 'connect' member function that takes a receiver as an\n"                \
-  "argument and returns an object whose type satisfies '" STDEXEC_PP_STRINGIZE(STDEXEC)            \
-  "::operation_state',\n"                                                                          \
-  "as shown below:\n"                                                                              \
-  "\n"                                                                                             \
-  "  class MySender\n"                                                                             \
-  "  {\n"                                                                                          \
-  "  public:\n"                                                                                    \
-  "    using sender_concept        = " STDEXEC_PP_STRINGIZE(STDEXEC) "::sender_tag;\n"             \
-  "    using completion_signatures = " STDEXEC_PP_STRINGIZE(STDEXEC) "::completion_signatures<"    \
-  STDEXEC_PP_STRINGIZE(STDEXEC) "::set_value_t()>;\n"                                              \
-  "\n"                                                                                             \
-  "    template <class Receiver>\n"                                                                \
-  "    struct MyOpState\n"                                                                         \
-  "    {\n"                                                                                        \
-  "      using operation_state_concept = " STDEXEC_PP_STRINGIZE(STDEXEC) "::operation_state_tag;\n"\
-  "\n"                                                                                             \
-  "      void start() noexcept\n"                                                                  \
-  "      {\n"                                                                                      \
-  "        // Start the operation, which will eventually complete and send its\n"                  \
-  "        // result to rcvr_;\n"                                                                  \
-  "      }\n"                                                                                      \
-  "\n"                                                                                             \
-  "      Receiver rcvr_;\n"                                                                        \
-  "    };\n"                                                                                       \
-  "\n"                                                                                             \
-  "    template <" STDEXEC_PP_STRINGIZE(STDEXEC) "::receiver Receiver>\n"                          \
-  "    auto connect(Receiver rcvr) -> MyOpState<Receiver>\n"                                       \
-  "    {\n"                                                                                        \
-  "      return MyOpState<Receiver>{std::move(rcvr)};\n"                                           \
-  "    }\n"                                                                                        \
-  "\n"                                                                                             \
-  "    ...\n"                                                                                      \
-  "  };\n"
-
-////////////////////////////////////////////////////////////////////////////////
-#  define STDEXEC_ERROR_SYNC_WAIT_CANNOT_CONNECT_SENDER_TO_RECEIVER                                \
-  "\n"                                                                                             \
-  "\n"                                                                                             \
-  "The sender passed to '" STDEXEC_PP_STRINGIZE(STDEXEC) "::sync_wait()' does not have a "         \
-  "'connect'\n"                                                                                    \
-  "member function that accepts sync_wait's receiver.\n"                                           \
-  STDEXEC_ERROR_CANNOT_CONNECT_SENDER_TO_RECEIVER
-
 #  include "__epilogue.hpp"
 #endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__domain.hpp b/include/stdexec/__detail/__domain.hpp
index 539b9055c..e2a441675 100644
--- a/include/stdexec/__detail/__domain.hpp
+++ b/include/stdexec/__detail/__domain.hpp
@@ -180,10 +180,12 @@ namespace STDEXEC
   }  // namespace __detail
 
   ////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT_AUTHORING
   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 &...>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Domains>
   using __common_domain_t = decltype(__detail::__common_domain_fn<_Domains...>());
 
@@ -407,6 +409,7 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag, class _Sender, class... _Env>
   concept __has_completion_domain_for =
     __sends<_Tag, _Sender, _Env...>
diff --git a/include/stdexec/__detail/__env.hpp b/include/stdexec/__detail/__env.hpp
index ecf5fcfe2..a3102eb52 100644
--- a/include/stdexec/__detail/__env.hpp
+++ b/include/stdexec/__detail/__env.hpp
@@ -100,6 +100,7 @@ namespace STDEXEC
       }
     };
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Env>
     using __fwd_env_t = __call_result_t<__fwd_fn, _Env>;
 
@@ -132,8 +133,10 @@ namespace STDEXEC
       }
     };
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     inline constexpr __join_fn __join{};
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _First, class... _Second>
     using __join_env_t = __result_of<__join, _First, _Second...>;
 
@@ -146,6 +149,7 @@ namespace STDEXEC
       }
     };
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     struct __root_env
     {
       STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
@@ -167,14 +171,19 @@ namespace STDEXEC
     };
   }  // namespace __env
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __env::__join_env_t;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __env::__fwd_env_t;
   using __env::__root_t;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __env::__root_env;
 
-  inline constexpr __env::__fwd_fn         __fwd_env{};
+  inline constexpr __env::__fwd_fn __fwd_env{};
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr __env::__as_root_env_fn __as_root_env{};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Env>
   using __as_root_env_t = __result_of<__as_root_env, _Env>;
 
diff --git a/include/stdexec/__detail/__execution_fwd.hpp b/include/stdexec/__detail/__execution_fwd.hpp
index acb1af7fc..ed7add631 100644
--- a/include/stdexec/__detail/__execution_fwd.hpp
+++ b/include/stdexec/__detail/__execution_fwd.hpp
@@ -56,6 +56,7 @@ namespace STDEXEC
     };
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Ts>
   using __std_variant = __minvoke_if_c<sizeof...(_Ts) == 0,
                                        __mconst<__detail::__not_a_variant>,
@@ -66,22 +67,31 @@ namespace STDEXEC
   using __nullable_std_variant =
     __mcall<__munique<__mbind_front<__qq<std::variant>, std::monostate>>, __decay_t<_Ts>...>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Ts>
   using __decayed_std_tuple = std::tuple<__decay_t<_Ts>...>;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct default_domain;
 
+  STDEXEC_MODULE_EXPORT
   template <class...>
   struct indeterminate_domain;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct set_value_t;
+  STDEXEC_MODULE_EXPORT
   struct set_error_t;
+  STDEXEC_MODULE_EXPORT
   struct set_stopped_t;
 
-  extern set_value_t const   set_value;
-  extern set_error_t const   set_error;
+  STDEXEC_MODULE_EXPORT
+  extern set_value_t const set_value;
+  STDEXEC_MODULE_EXPORT
+  extern set_error_t const set_error;
+  STDEXEC_MODULE_EXPORT
   extern set_stopped_t const set_stopped;
 
   enum class __disposition
@@ -93,9 +103,11 @@ namespace STDEXEC
 
   constexpr auto __invalid_disposition = static_cast<__disposition>(3);  // invalid value
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag>
   concept __completion_tag = __one_of<_Tag, set_value_t, set_error_t, set_stopped_t>;
 
+  STDEXEC_MODULE_EXPORT
   template <class _Sender>
   extern bool const enable_receiver;
 
@@ -105,20 +117,26 @@ namespace STDEXEC
     struct cprop;
   }  // namespace __env
 
+  STDEXEC_MODULE_EXPORT
   template <class _Query, class _Value>
   struct prop;
 
+  STDEXEC_MODULE_EXPORT
   template <class... _Envs>
   struct env;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct get_env_t;
+  STDEXEC_MODULE_EXPORT
   extern get_env_t const get_env;
 
+  STDEXEC_MODULE_EXPORT
   template <class _EnvProvider>
   using env_of_t = __call_result_t<get_env_t, _EnvProvider>;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   enum class forward_progress_guarantee
   {
     concurrent,
@@ -127,31 +145,48 @@ namespace STDEXEC
   };
 
   struct __execute_may_block_caller_t;
+  STDEXEC_MODULE_EXPORT
   struct get_forward_progress_guarantee_t;
+  STDEXEC_MODULE_EXPORT
   struct get_scheduler_t;
+  STDEXEC_MODULE_EXPORT
   struct get_start_scheduler_t;
+  STDEXEC_MODULE_EXPORT
   struct get_delegation_scheduler_t;
+  STDEXEC_MODULE_EXPORT
   template <__completion_tag _CPO>
   struct get_completion_scheduler_t;
+  STDEXEC_MODULE_EXPORT
   template <class _CPO = void>
   struct get_completion_domain_t;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <__completion_tag _CPO>
   struct __get_completion_behavior_t;
+  STDEXEC_MODULE_EXPORT
   struct get_domain_t;
+  STDEXEC_MODULE_EXPORT
   struct get_await_completion_adaptor_t;
 
   struct __debug_env_t;
 
-  extern __execute_may_block_caller_t const     __execute_may_block_caller;
+  extern __execute_may_block_caller_t const __execute_may_block_caller;
+  STDEXEC_MODULE_EXPORT
   extern get_forward_progress_guarantee_t const get_forward_progress_guarantee;
-  extern get_scheduler_t const                  get_scheduler;
-  extern get_start_scheduler_t const            get_start_scheduler;
-  extern get_delegation_scheduler_t const       get_delegation_scheduler;
+  STDEXEC_MODULE_EXPORT
+  extern get_scheduler_t const get_scheduler;
+  STDEXEC_MODULE_EXPORT
+  extern get_start_scheduler_t const get_start_scheduler;
+  STDEXEC_MODULE_EXPORT
+  extern get_delegation_scheduler_t const get_delegation_scheduler;
+  STDEXEC_MODULE_EXPORT
   template <__completion_tag _CPO>
   extern get_completion_scheduler_t<_CPO> const get_completion_scheduler;
+  STDEXEC_MODULE_EXPORT
   template <class _CPO = void>
-  extern get_completion_domain_t<_CPO> const  get_completion_domain;
-  extern get_domain_t const                   get_domain;
+  extern get_completion_domain_t<_CPO> const get_completion_domain;
+  STDEXEC_MODULE_EXPORT
+  extern get_domain_t const get_domain;
+  STDEXEC_MODULE_EXPORT
   extern get_await_completion_adaptor_t const get_await_completion_adaptor;
 
   template <class _Tag, class _Attrs, class... _Env>
@@ -160,6 +195,7 @@ namespace STDEXEC
                                                    _Attrs,
                                                    _Env const &...>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Env>
   concept __is_debug_env = __callable<__debug_env_t, _Env>;
 
@@ -171,9 +207,13 @@ namespace STDEXEC
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
   // concept tag types:
+  STDEXEC_MODULE_EXPORT
   struct sender_tag;
+  STDEXEC_MODULE_EXPORT
   struct operation_state_tag;
+  STDEXEC_MODULE_EXPORT
   struct scheduler_tag;
+  STDEXEC_MODULE_EXPORT
   struct receiver_tag;
 
   // concept tag aliases for backwards compatibility:
@@ -190,6 +230,7 @@ namespace STDEXEC
   using __domain_of_t = __decay_t<__call_result_t<get_domain_t, _Env>>;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   template <class... _Sigs>
   struct completion_signatures;
 
@@ -197,17 +238,21 @@ namespace STDEXEC
   concept __valid_completion_signatures = __ok<_Completions>
                                        && __is_instance_of<_Completions, completion_signatures>;
 
+  STDEXEC_MODULE_EXPORT
   struct dependent_sender_error;
 
   namespace __cmplsigs
   {
+    STDEXEC_MODULE_EXPORT
     struct get_completion_signatures_t;
   }  // namespace __cmplsigs
 
+  STDEXEC_MODULE_EXPORT
   using __cmplsigs::get_completion_signatures_t;
 
 #  if STDEXEC_NO_STDCPP_CONSTEXPR_EXCEPTIONS()
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _What, class... _Values>
   [[nodiscard]]
   consteval auto __throw_compile_time_error(_Values...) -> __mexception<_What...>;
@@ -226,123 +271,185 @@ namespace STDEXEC
   consteval auto __throw_compile_time_error(__mexception<_What...>);
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct connect_t;
+  STDEXEC_MODULE_EXPORT
   extern connect_t const connect;
 
+  STDEXEC_MODULE_EXPORT
   template <class _Sender, class _Receiver>
   using connect_result_t = __call_result_t<connect_t, _Sender, _Receiver>;
 
+  STDEXEC_MODULE_EXPORT
   template <class _Sender>
   extern bool const enable_sender;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct start_t;
+  STDEXEC_MODULE_EXPORT
   extern start_t const start;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct schedule_t;
+  STDEXEC_MODULE_EXPORT
   extern schedule_t const schedule;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct as_awaitable_t;
+  STDEXEC_MODULE_EXPORT
   extern as_awaitable_t const as_awaitable;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct transform_sender_t;
+  STDEXEC_MODULE_EXPORT
   extern transform_sender_t const transform_sender;
 
+  STDEXEC_MODULE_EXPORT
   template <class _Sender, class... _Env>
   using transform_sender_result_t = __call_result_t<transform_sender_t, _Sender, _Env...>;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct starts_on_t;
+  STDEXEC_MODULE_EXPORT
   extern starts_on_t const starts_on;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct schedule_from_t;
+  STDEXEC_MODULE_EXPORT
   extern schedule_from_t const schedule_from;
 
+  STDEXEC_MODULE_EXPORT
   struct continues_on_t;
+  STDEXEC_MODULE_EXPORT
   extern continues_on_t const continues_on;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct bulk_t;
+  STDEXEC_MODULE_EXPORT
   struct bulk_chunked_t;
+  STDEXEC_MODULE_EXPORT
   struct bulk_unchunked_t;
 
-  extern bulk_t const           bulk;
-  extern bulk_chunked_t const   bulk_chunked;
+  STDEXEC_MODULE_EXPORT
+  extern bulk_t const bulk;
+  STDEXEC_MODULE_EXPORT
+  extern bulk_chunked_t const bulk_chunked;
+  STDEXEC_MODULE_EXPORT
   extern bulk_unchunked_t const bulk_unchunked;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
-  STDEXEC_MODULE_EXPORT struct just_t;
+  STDEXEC_MODULE_EXPORT
+  struct just_t;
+  STDEXEC_MODULE_EXPORT
   extern just_t const just;
 
+  STDEXEC_MODULE_EXPORT
   struct just_error_t;
+  STDEXEC_MODULE_EXPORT
   extern just_error_t const just_error;
 
+  STDEXEC_MODULE_EXPORT
   struct just_stopped_t;
+  STDEXEC_MODULE_EXPORT
   extern just_stopped_t const just_stopped;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct then_t;
+  STDEXEC_MODULE_EXPORT
   extern then_t const then;
 
+  STDEXEC_MODULE_EXPORT
   struct upon_error_t;
+  STDEXEC_MODULE_EXPORT
   extern upon_error_t const upon_error;
 
+  STDEXEC_MODULE_EXPORT
   struct upon_stopped_t;
+  STDEXEC_MODULE_EXPORT
   extern upon_stopped_t const upon_stopped;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct let_value_t;
+  STDEXEC_MODULE_EXPORT
   extern let_value_t const let_value;
 
+  STDEXEC_MODULE_EXPORT
   struct let_error_t;
+  STDEXEC_MODULE_EXPORT
   extern let_error_t const let_error;
 
+  STDEXEC_MODULE_EXPORT
   struct let_stopped_t;
+  STDEXEC_MODULE_EXPORT
   extern let_stopped_t const let_stopped;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct when_all_t;
+  STDEXEC_MODULE_EXPORT
   extern when_all_t const when_all;
 
+  STDEXEC_MODULE_EXPORT
   struct when_all_with_variant_t;
+  STDEXEC_MODULE_EXPORT
   extern when_all_with_variant_t const when_all_with_variant;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
   struct __read_env_t;
+  STDEXEC_MODULE_EXPORT
   extern __read_env_t const read_env;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __write_env_t;
+  STDEXEC_MODULE_EXPORT
   extern __write_env_t const write_env;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct into_variant_t;
+  STDEXEC_MODULE_EXPORT
   extern into_variant_t const into_variant;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct on_t;
+  STDEXEC_MODULE_EXPORT
   extern on_t const on;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct affine_t;
+  STDEXEC_MODULE_EXPORT
   extern affine_t const affine;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   struct stopped_as_error_t;
+  STDEXEC_MODULE_EXPORT
   extern stopped_as_error_t const stopped_as_error;
 
+  STDEXEC_MODULE_EXPORT
   struct stopped_as_optional_t;
+  STDEXEC_MODULE_EXPORT
   extern stopped_as_optional_t const stopped_as_optional;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT
   template <__class _Derived>
   struct sender_adaptor_closure;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
   // deprecated interfaces (see __deprecations.hpp):
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __transfer_just_t;
   extern __transfer_just_t const __transfer_just;
 }  // namespace STDEXEC
@@ -364,29 +471,44 @@ namespace experimental::execution
 namespace exec = experimental::execution;
 
 STDEXEC_P2300_NAMESPACE_BEGIN()
+  STDEXEC_MODULE_EXPORT
   struct forwarding_query_t;
+  STDEXEC_MODULE_EXPORT
   struct get_allocator_t;
+  STDEXEC_MODULE_EXPORT
   struct get_stop_token_t;
 
+  STDEXEC_MODULE_EXPORT
   extern forwarding_query_t const forwarding_query;
-  extern get_allocator_t const    get_allocator;
-  extern get_stop_token_t const   get_stop_token;
+  STDEXEC_MODULE_EXPORT
+  extern get_allocator_t const get_allocator;
+  STDEXEC_MODULE_EXPORT
+  extern get_stop_token_t const get_stop_token;
 
+  STDEXEC_MODULE_EXPORT
   template <class _Env>
   using stop_token_of_t = STDEXEC::__decay_t<STDEXEC::__call_result_t<get_stop_token_t, _Env>>;
 
+  STDEXEC_MODULE_EXPORT
   struct never_stop_token;
+  STDEXEC_MODULE_EXPORT
   class inplace_stop_source;
+  STDEXEC_MODULE_EXPORT
   class inplace_stop_token;
+  STDEXEC_MODULE_EXPORT
   template <class _Fn>
   class inplace_stop_callback;
 STDEXEC_P2300_NAMESPACE_END()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 STDEXEC_P2300_NAMESPACE_BEGIN(this_thread)
+  STDEXEC_MODULE_EXPORT
   struct sync_wait_t;
+  STDEXEC_MODULE_EXPORT
   struct sync_wait_with_variant_t;
-  extern sync_wait_t const              sync_wait;
+  STDEXEC_MODULE_EXPORT
+  extern sync_wait_t const sync_wait;
+  STDEXEC_MODULE_EXPORT
   extern sync_wait_with_variant_t const sync_wait_with_variant;
 STDEXEC_P2300_NAMESPACE_END(this_thread)
 
diff --git a/include/stdexec/__detail/__execution_legacy.hpp b/include/stdexec/__detail/__execution_legacy.hpp
index cff627017..d7fe252dd 100644
--- a/include/stdexec/__detail/__execution_legacy.hpp
+++ b/include/stdexec/__detail/__execution_legacy.hpp
@@ -44,19 +44,26 @@ namespace STDEXEC
     using std::is_execution_policy;
   }  // namespace __policy
 
+  STDEXEC_MODULE_EXPORT
   using namespace __policy;
 
 #else
 
+  STDEXEC_MODULE_EXPORT
   struct sequenced_policy
   {};
+  STDEXEC_MODULE_EXPORT
   struct parallel_policy
   {};
+  STDEXEC_MODULE_EXPORT
   struct parallel_unsequenced_policy
   {};
 
-  inline constexpr sequenced_policy            seq{};
-  inline constexpr parallel_policy             par{};
+  STDEXEC_MODULE_EXPORT
+  inline constexpr sequenced_policy seq{};
+  STDEXEC_MODULE_EXPORT
+  inline constexpr parallel_policy par{};
+  STDEXEC_MODULE_EXPORT
   inline constexpr parallel_unsequenced_policy par_unseq{};
 
   template <typename>
@@ -92,6 +99,7 @@ namespace STDEXEC
   struct unsequenced_policy
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr unsequenced_policy unseq{};
 
   template <>
diff --git a/include/stdexec/__detail/__finally.hpp b/include/stdexec/__detail/__finally.hpp
index 994bcb2c4..18d6f648a 100644
--- a/include/stdexec/__detail/__finally.hpp
+++ b/include/stdexec/__detail/__finally.hpp
@@ -16,20 +16,28 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after execution_fwd.hpp
-#include "__basic_sender.hpp"
-#include "__optional.hpp"
-#include "__schedulers.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
-#include "__storage.hpp"
-#include "__transform_completion_signatures.hpp"
-#include "__tuple.hpp"
-#include "__utility.hpp"
-
-#include "__prologue.hpp"
+#  include "__basic_sender.hpp"
+#  include "__optional.hpp"
+#  include "__schedulers.hpp"
+#  include "__sender_adaptor_closure.hpp"
+#  include "__senders.hpp"
+#  include "__storage.hpp"
+#  include "__transform_completion_signatures.hpp"
+#  include "__tuple.hpp"
+#  include "__utility.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -42,6 +50,7 @@ namespace STDEXEC
   struct _THE_FINAL_SENDER_MUST_BE_A_SENDER_OF_VOID_;
   struct _INVALID_ARGUMENT_TO_THE_FINALLY_ALGORITHM_;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __finally_t
   {
     template <sender _Initial, sender _Final>
@@ -69,6 +78,7 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr __finally_t __finally_{};
 
   namespace __final
@@ -388,4 +398,5 @@ namespace STDEXEC
   };
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__get_completion_signatures.hpp b/include/stdexec/__detail/__get_completion_signatures.hpp
index 2b0ecda65..933b5bb30 100644
--- a/include/stdexec/__detail/__get_completion_signatures.hpp
+++ b/include/stdexec/__detail/__get_completion_signatures.hpp
@@ -46,6 +46,7 @@ namespace STDEXEC
 {
   namespace __detail
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Env>
     struct __promise : __connect_await::__with_await_transform<__promise<_Env>>
     {
@@ -157,6 +158,7 @@ namespace STDEXEC
     concept __with_legacy_non_dependent_tag_invoke =
       (sizeof...(_Env) == 0) && __tag_invocable<get_completion_signatures_t, _Sender, env<>>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Sender>
     concept __with_legacy_member_alias = requires {
       typename STDEXEC_REMOVE_REFERENCE(_Sender)::completion_signatures;
@@ -353,6 +355,7 @@ namespace STDEXEC
   //! @see stdexec::completion_signatures_of_t — convenience type alias around this
   //! @see stdexec::sender_in               — the concept built on top of this
   //! @see stdexec::transform_sender        — domain-customization run before signature computation
+  STDEXEC_MODULE_EXPORT
   template <class _Sender>
   consteval auto get_completion_signatures()
   {
@@ -372,6 +375,7 @@ namespace STDEXEC
   //!          connected to a receiver with environment @c _Env.
   //!
   //! See @ref get_completion_signatures() for the full description.
+  STDEXEC_MODULE_EXPORT
   template <class _Sender, class _Env>
     requires __has_get_completion_signatures<_Sender, _Env>
   consteval auto get_completion_signatures()
@@ -382,6 +386,7 @@ namespace STDEXEC
   }
 
   // Legacy interface:
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class... _Env>
     requires(sizeof...(_Env) <= 1)
   constexpr auto get_completion_signatures(_Sender &&, _Env const &...) noexcept
@@ -392,6 +397,7 @@ namespace STDEXEC
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   // An minimally constrained alias for the result of get_completion_signatures:
 #  if STDEXEC_GCC()
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class... _Env>
     requires enable_sender<__decay_t<_Sender>>
             && __constant<STDEXEC::get_completion_signatures<_Sender, _Env...>()>
@@ -408,6 +414,7 @@ namespace STDEXEC
                              STDEXEC::get_completion_signatures<_Sender, _Env...>()>::value_type;
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class... _Env>
     requires enable_sender<__decay_t<_Sender>>
             && __minvocable_q<__detail::__cmplsigs_of_t, _Sender, _Env...>
@@ -421,6 +428,7 @@ namespace STDEXEC
   // get_completion_signatures in an integral_constant like we do for EDG. So we skip
   // checking the requirement.
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class... _Env>
     requires enable_sender<__decay_t<_Sender>>
   using __completion_signatures_of_t =
@@ -428,6 +436,7 @@ namespace STDEXEC
 
 #  else
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class... _Env>
     requires enable_sender<__decay_t<_Sender>>
   using __completion_signatures_of_t =
@@ -479,6 +488,7 @@ namespace STDEXEC
                            _Tuple,
                            _Variant>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender,
             class _Env     = env<>,
             class _Tuple   = __qq<__decayed_std_tuple>,
@@ -486,6 +496,7 @@ namespace STDEXEC
   using __value_types_of_t =
     __value_types_t<__completion_signatures_of_t<_Sender, _Env>, _Tuple, _Variant>;
 
+  STDEXEC_MODULE_EXPORT
   template <class _Sender,
             class _Env                         = env<>,
             template <class...> class _Tuple   = __decayed_std_tuple,
@@ -493,6 +504,7 @@ namespace STDEXEC
   using value_types_of_t =
     __value_types_t<__completion_signatures_of_t<_Sender, _Env>, __q<_Tuple>, __q<_Variant>>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender,
             class _Env       = env<>,
             class _Variant   = __qq<__std_variant>,
@@ -500,15 +512,18 @@ namespace STDEXEC
   using __error_types_of_t =
     __error_types_t<__completion_signatures_of_t<_Sender, _Env>, _Variant, _Transform>;
 
+  STDEXEC_MODULE_EXPORT
   template <class _Sender, class _Env = env<>, template <class...> class _Variant = __std_variant>
   using error_types_of_t =
     __error_types_t<__completion_signatures_of_t<_Sender, _Env>, __q<_Variant>>;
 
+  STDEXEC_MODULE_EXPORT
   template <class _Sender, class... _Env>
     requires __valid_completion_signatures<__completion_signatures_of_t<_Sender, _Env...>>
   inline constexpr bool sends_stopped =
     __sends_stopped<__completion_signatures_of_t<_Sender, _Env...>>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag, class _Sender, class... _Env>
   using __count_of =
     __msize_t<__detail::__count_of<_Tag, __completion_signatures_of_t<_Sender, _Env...>>>;
diff --git a/include/stdexec/__detail/__inline_scheduler.hpp b/include/stdexec/__detail/__inline_scheduler.hpp
index fd2176a5e..d25338215 100644
--- a/include/stdexec/__detail/__inline_scheduler.hpp
+++ b/include/stdexec/__detail/__inline_scheduler.hpp
@@ -15,13 +15,21 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__completion_behavior.hpp"
-#include "__receivers.hpp"
-#include "__schedulers.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__completion_behavior.hpp"
+#  include "__receivers.hpp"
+#  include "__schedulers.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -35,7 +43,7 @@ namespace STDEXEC
     constexpr auto operator==(__inline_attrs const &) const noexcept -> bool = default;
   };
 
-  struct inline_scheduler : __inline_attrs
+  STDEXEC_MODULE_EXPORT struct inline_scheduler : __inline_attrs
   {
    private:
     template <class _Receiver>
@@ -88,4 +96,5 @@ namespace STDEXEC
   static_assert(__completes_inline<set_value_t, env_of_t<schedule_result_t<inline_scheduler>>>);
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__intrusive_queue.hpp b/include/stdexec/__detail/__intrusive_queue.hpp
index 0a7b942f0..12f5ad95c 100644
--- a/include/stdexec/__detail/__intrusive_queue.hpp
+++ b/include/stdexec/__detail/__intrusive_queue.hpp
@@ -36,6 +36,7 @@ namespace STDEXEC
 {
   namespace __queue
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <auto _Next>
     class __intrusive_queue;
 
@@ -302,6 +303,7 @@ namespace STDEXEC
     };
   }  // namespace __queue
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __queue::__intrusive_queue;
 
 }  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__intrusive_slist.hpp b/include/stdexec/__detail/__intrusive_slist.hpp
index d3e5dc63d..5ee76c2de 100644
--- a/include/stdexec/__detail/__intrusive_slist.hpp
+++ b/include/stdexec/__detail/__intrusive_slist.hpp
@@ -36,6 +36,7 @@ namespace STDEXEC
 {
   namespace __slist
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <auto _Next>
     class __intrusive_slist;
 
@@ -178,6 +179,7 @@ namespace STDEXEC
     };
   }  // namespace __slist
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __slist::__intrusive_slist;
 
 }  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__just.hpp b/include/stdexec/__detail/__just.hpp
index 6b067a0ae..56df53290 100644
--- a/include/stdexec/__detail/__just.hpp
+++ b/include/stdexec/__detail/__just.hpp
@@ -15,17 +15,25 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__basic_sender.hpp"
-#include "__completion_behavior.hpp"
-#include "__completion_signatures.hpp"
-#include "__meta.hpp"
-#include "__receivers.hpp"
-#include "__sender_introspection.hpp"
-#include "__type_traits.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__basic_sender.hpp"
+#  include "__completion_behavior.hpp"
+#  include "__completion_signatures.hpp"
+#  include "__meta.hpp"
+#  include "__receivers.hpp"
+#  include "__sender_introspection.hpp"
+#  include "__type_traits.hpp"
+
+#  include "__prologue.hpp"
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
 
@@ -145,7 +153,7 @@ namespace STDEXEC
   //! @see stdexec::just_error    — synchronously complete with an error
   //! @see stdexec::just_stopped  — synchronously complete with stopped
   //! @see stdexec::read_env      — synchronously complete with a value read from the environment
-  STDEXEC_MODULE_EXPORT struct just_t
+  struct just_t
   {
     using __tag_t = set_value_t;
 
@@ -318,4 +326,5 @@ namespace STDEXEC
   inline constexpr just_stopped_t just_stopped{};
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__manual_lifetime.hpp b/include/stdexec/__detail/__manual_lifetime.hpp
index 729632256..21d565d51 100644
--- a/include/stdexec/__detail/__manual_lifetime.hpp
+++ b/include/stdexec/__detail/__manual_lifetime.hpp
@@ -38,6 +38,7 @@ namespace STDEXEC
 {
   //! Holds storage for a `_Ty`, but allows clients to `__construct(...)`, `__destry()`,
   //! and `__get()` the `_Ty` without regard for usual lifetime rules.
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty>
   class __manual_lifetime
   {
diff --git a/include/stdexec/__detail/__memory.hpp b/include/stdexec/__detail/__memory.hpp
index 448b0ddf4..36d9602ed 100644
--- a/include/stdexec/__detail/__memory.hpp
+++ b/include/stdexec/__detail/__memory.hpp
@@ -78,6 +78,7 @@ namespace STDEXEC
   /////////////////////////////////////////////////////////////////////////////////////////
   // __rebind_allocator: Rebinds an allocator to a different type, unless the allocator is
   // already bound to the correct type, in which case it is returned as-is.
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class _Alloc>
   [[nodiscard]]
   constexpr auto __rebind_allocator(_Alloc const &__alloc) noexcept
diff --git a/include/stdexec/__detail/__meta.hpp b/include/stdexec/__detail/__meta.hpp
index 38fbfb0aa..3f2d17ee2 100644
--- a/include/stdexec/__detail/__meta.hpp
+++ b/include/stdexec/__detail/__meta.hpp
@@ -50,6 +50,7 @@ namespace STDEXEC
   template <class _Ret, class... _Args>
   using __fn_ptr_t = _Ret (*)(_Args...);
 
+  STDEXEC_MODULE_EXPORT_META
   template <class...>
   concept __mnever = false;
 
@@ -61,12 +62,14 @@ namespace STDEXEC
   using __mtypeof = decltype(_Value);
 #  endif
 
+  STDEXEC_MODULE_EXPORT_META
   template <class...>
   struct __mlist;
 
   template <class... _Ts>
   using __mlist_ptr = __mlist<_Ts...> *;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Tp>
   using __midentity = _Tp;
 
@@ -99,6 +102,7 @@ namespace STDEXEC
   template <class _Tp, class _Up>
   using __msecond = _Up;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class...>
   struct __undefined;
 
@@ -168,6 +172,7 @@ namespace STDEXEC
   template <class... _Ts>
   using __indices_for = __make_indices<sizeof...(_Ts)>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __ignore
   {
     constexpr __ignore() = default;
@@ -178,12 +183,14 @@ namespace STDEXEC
     {}
   };
 
+  STDEXEC_MODULE_EXPORT_META
   using __msuccess = int;
 
   template <class _What, class... _With>
   struct _WARNING_
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _What>
   struct _ERROR_
   {
@@ -215,9 +222,11 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <class... _What>
   using __mexception = _ERROR_<_What...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class>
   extern __msuccess __ok_v;
 
@@ -230,18 +239,23 @@ namespace STDEXEC
   template <class _Ty>
   using __ok_t = decltype(__ok_v<_Ty>);
 
+  STDEXEC_MODULE_EXPORT_META
   template <class... _Ts>
   using __mfind_error = decltype((__ok_t<_Ts>(), ..., __msuccess()));
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Arg>
   concept __ok = STDEXEC_IS_SAME(__ok_t<_Arg>, __msuccess);
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Arg>
   concept __merror = !STDEXEC_IS_SAME(__ok_t<_Arg>, __msuccess);
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Fn, class... _Args>
   using __mcall = _Fn::template __f<_Args...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Fn, class _Arg>
   using __mcall1 = _Fn::template __f<_Arg>;
 
@@ -316,9 +330,11 @@ namespace STDEXEC
   //! Metafunction invocation
   //! Given a metafunction, `_Fn`, and args.
   //! We expect `_Fn::__f` to be type alias template "implementing" the metafunction `_Fn`.
+  STDEXEC_MODULE_EXPORT_META
   template <class _Fn, class... _Args>
   using __minvoke = __i<_Ok<_Fn, _Args...>>::template __f<_Fn, _Args...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <template <class...> class _Fn>
   struct __qq
   {
@@ -326,6 +342,7 @@ namespace STDEXEC
     using __f = _Fn<_Args...>;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <template <class> class _Fn>
   struct __q1
   {
@@ -350,6 +367,7 @@ namespace STDEXEC
   //!
   //! This design lets us report type errors briefly at the library boundary, even if the
   //! actual error happens deep inside a meta-program.
+  STDEXEC_MODULE_EXPORT_META
   template <template <class...> class _Fn>
   struct __q
   {
@@ -371,6 +389,7 @@ namespace STDEXEC
     using __f = _Error;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <template <class...> class _Fn, class... _Front>
   struct __mbind_front_q
   {
@@ -378,9 +397,11 @@ namespace STDEXEC
     using __f = __minvoke_q<_Fn, _Front..., _Args...>;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Fn, class... _Front>
   using __mbind_front = __mbind_front_q<_Fn::template __f, _Front...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <template <class...> class _Fn, class... _Back>
   struct __mbind_back_q
   {
@@ -391,6 +412,7 @@ namespace STDEXEC
   template <class _Fn, class... _Back>
   using __mbind_back = __mbind_back_q<_Fn::template __f, _Back...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <template <class...> class _Tp, class... _Args>
   concept __minvocable_q = requires { typename __minvoke_q<_Tp, _Args...>; };
 
@@ -462,15 +484,18 @@ namespace STDEXEC
   template <class _Pred, class _Then, class _Else>
   using __if = __minvoke_q<__detail::__if_t, _Pred, _Then, _Else>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <bool _Pred, class _Then, class _Else>
   using __if_c = __minvoke<__detail::__if_<_Pred>, _Then, _Else>;
 
   template <class _Pred, class _Then, class _Else, class... _Args>
   using __minvoke_if = __minvoke<__if<_Pred, _Then, _Else>, _Args...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <bool _Pred, class _Then, class _Else, class... _Args>
   using __minvoke_if_c = __minvoke<__if_c<_Pred, _Then, _Else>, _Args...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Tp>
   struct __mconst
   {
@@ -492,9 +517,11 @@ namespace STDEXEC
     using __f = __minvoke_if_c<__minvocable<_Try, _Args...>, _Try, _Catch, _Args...>;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Fn, class _Default>
   using __mwith_default = __mtry_catch<_Fn, __mconst<_Default>>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <template <class...> class _Fn, class _Default>
   using __mwith_default_q = __mtry_catch_q<_Fn, __mconst<_Default>>;
 
@@ -504,6 +531,7 @@ namespace STDEXEC
   template <template <class...> class _Fn, class _Default, class... _Args>
   using __minvoke_or_q = __minvoke<__mwith_default_q<_Fn, _Default>, _Args...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Fn, class _Continuation = __q<__mlist>>
   struct __mtransform
   {
@@ -594,6 +622,7 @@ namespace STDEXEC
     using __f = _ERROR_<_What...>;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Fn, class _List>
   using __mapply = __mcall1<__mfor<_List>, _Fn>;
 
@@ -657,6 +686,7 @@ namespace STDEXEC
     using __f = __mapply<_Continuation, __mconcat_result_t<__mlist<>, _Args...>>;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   struct __msize
   {
     template <class... _Ts>
@@ -683,6 +713,7 @@ namespace STDEXEC
     using __f = __msize_t<(bool(__minvoke<_Fn, _Ts>::value) + ... + 0)>;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Tp>
   struct __mcontains
   {
@@ -697,6 +728,7 @@ namespace STDEXEC
     using __f = __mapply<__mbind_back<_Continuation, _Item>, _List>;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <class...>
   struct __mcompose
   {};
@@ -749,6 +781,7 @@ namespace STDEXEC
                           __if<__minvoke<_Pred, _Args>, __mlist<>, __mlist<_Args>>...>;
   };
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Return>
   struct __qf
   {
@@ -819,6 +852,7 @@ namespace STDEXEC
     using __mfront_ = _Ty;
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT_META
   template <class... _As>
   using __mfront = __minvoke_q<__detail::__mfront_, _As...>;
 
@@ -903,6 +937,7 @@ namespace STDEXEC
 
   template <class... _Booleans>
   using __mand_t = __mbool<(_Booleans::value && ...)>;
+  STDEXEC_MODULE_EXPORT_META
   template <class... _Booleans>
   using __mand = __minvoke_q<__mand_t, _Booleans...>;
 
@@ -940,6 +975,7 @@ namespace STDEXEC
   template <class _Set, class... _Ty>
   concept __mset_contains = (STDEXEC_IS_BASE_OF(__mtype<_Ty>, _Set) && ...);
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Set, class... _Ty>
   using __mset_contains_t = __mbool<__mset_contains<_Set, _Ty...>>;
 
@@ -985,18 +1021,22 @@ namespace STDEXEC
     };
   }  // namespace __set
 
+  STDEXEC_MODULE_EXPORT_META
   template <class... _Ts>
   using __mset = __set::__inherit<_Ts...>;
 
   template <class _Set, class... _Ts>
   using __mset_insert = decltype(+(__declval<_Set &>() % ... % __declval<__mtype<_Ts> &>()));
 
+  STDEXEC_MODULE_EXPORT_META
   template <class... _Ts>
   using __mmake_set = __mset_insert<__mset<>, _Ts...>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Set1, class _Set2>
   concept __mset_eq = __mapply<__set::__eq<_Set1>, _Set2>::value;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Continuation = __q<__mlist>>
   struct __munique
   {
@@ -1028,6 +1068,7 @@ namespace STDEXEC
     };
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT_META
   template <class _Continuation = __q<__mlist>>
   struct __msort
   {
diff --git a/include/stdexec/__detail/__on.hpp b/include/stdexec/__detail/__on.hpp
index 164844e2f..2ceac051d 100644
--- a/include/stdexec/__detail/__on.hpp
+++ b/include/stdexec/__detail/__on.hpp
@@ -15,24 +15,32 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__basic_sender.hpp"
-#include "__completion_signatures_of.hpp"
-#include "__continues_on.hpp"
-#include "__diagnostics.hpp"
-#include "__env.hpp"
-#include "__inline_scheduler.hpp"
-#include "__meta.hpp"
-#include "__schedulers.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__sender_introspection.hpp"
-#include "__sender_ref.hpp"
-#include "__starts_on.hpp"
-#include "__utility.hpp"
-
-#include "__prologue.hpp"
+#  include "__basic_sender.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__continues_on.hpp"
+#  include "__diagnostics.hpp"
+#  include "__env.hpp"
+#  include "__inline_scheduler.hpp"
+#  include "__meta.hpp"
+#  include "__schedulers.hpp"
+#  include "__sender_adaptor_closure.hpp"
+#  include "__sender_introspection.hpp"
+#  include "__sender_ref.hpp"
+#  include "__starts_on.hpp"
+#  include "__utility.hpp"
+
+#  include "__prologue.hpp"
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
 
@@ -399,4 +407,5 @@ namespace STDEXEC
   };
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__operation_states.hpp b/include/stdexec/__detail/__operation_states.hpp
index e91bdfb78..597204d3c 100644
--- a/include/stdexec/__detail/__operation_states.hpp
+++ b/include/stdexec/__detail/__operation_states.hpp
@@ -209,7 +209,7 @@ namespace STDEXEC
   //! @see stdexec::connect              — the customization point that produces operation states
   //! @see stdexec::start                — the customization point this concept depends on
   //! @see stdexec::operation_state_tag  — the tag type that opts a class into this concept
-  template <class _Op>
+  STDEXEC_MODULE_EXPORT template <class _Op>
   concept operation_state = __std::destructible<_Op> && std::is_object_v<_Op>
                          && requires(_Op &__op) { STDEXEC::start(__op); };
 }  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__optional.hpp b/include/stdexec/__detail/__optional.hpp
index ec6eb0fdc..bcdc39312 100644
--- a/include/stdexec/__detail/__optional.hpp
+++ b/include/stdexec/__detail/__optional.hpp
@@ -63,6 +63,7 @@ namespace STDEXEC
     } __nullopt{};
 
     // A simplified version of std::optional for better compile times
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Tp>
     struct __optional
     {
@@ -261,6 +262,7 @@ namespace STDEXEC
     };
   }  // namespace __opt
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __opt::__optional;
   using __opt::__bad_optional_access;
   using __opt::__nullopt;
diff --git a/include/stdexec/__detail/__parallel_scheduler.hpp b/include/stdexec/__detail/__parallel_scheduler.hpp
index 6c904a166..16dcce7ef 100644
--- a/include/stdexec/__detail/__parallel_scheduler.hpp
+++ b/include/stdexec/__detail/__parallel_scheduler.hpp
@@ -88,6 +88,7 @@ namespace STDEXEC
     using __sender_data_t = decltype(STDEXEC::sync_wait(std::declval<_Sender>()).value());
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT
   class parallel_scheduler;
   class __parallel_sender;
 
@@ -95,6 +96,7 @@ namespace STDEXEC
   class __parallel_bulk_sender;
 
   /// Returns a scheduler that can add work to the underlying execution context.
+  STDEXEC_MODULE_EXPORT
   auto get_parallel_scheduler() -> parallel_scheduler;
 
   /// Concept that matches `bulk_chunked` and `bulk_unchunked` senders.
diff --git a/include/stdexec/__detail/__parallel_scheduler_backend.hpp b/include/stdexec/__detail/__parallel_scheduler_backend.hpp
index c362cddda..da06a1e2a 100644
--- a/include/stdexec/__detail/__parallel_scheduler_backend.hpp
+++ b/include/stdexec/__detail/__parallel_scheduler_backend.hpp
@@ -51,6 +51,7 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Warray-bounds")
 
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT
   class task_scheduler;
 
   namespace parallel_scheduler_replacement
diff --git a/include/stdexec/__detail/__parallel_scheduler_default_impl.hpp b/include/stdexec/__detail/__parallel_scheduler_default_impl.hpp
index 724e98a88..fdedcdb1d 100644
--- a/include/stdexec/__detail/__parallel_scheduler_default_impl.hpp
+++ b/include/stdexec/__detail/__parallel_scheduler_default_impl.hpp
@@ -15,32 +15,43 @@
  */
 #pragma once
 
-#include "__atomic.hpp"
-#include "__bulk.hpp"
-#include "__operation_states.hpp"
-#include "__parallel_scheduler_backend.hpp"
-#include "__parallel_scheduler_replacement_api.hpp"
-#include "__schedulers.hpp"
-#include "__senders.hpp"
-#include "__utility.hpp"
-
-#if STDEXEC_ENABLE_LIBDISPATCH
-#  include "../../exec/libdispatch_queue.hpp"  // IWYU pragma: keep
-#elif STDEXEC_ENABLE_WINDOWS_THREAD_POOL
-#  include "../../exec/windows/windows_thread_pool.hpp"  // IWYU pragma: keep
-#else
-#  include "../../exec/static_thread_pool.hpp"  // IWYU pragma: keep
-#endif
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include <concepts>
-#include <cstddef>
-#include <exception>
-#include <memory>
-#include <span>
-#include <thread>
-#include <utility>
+import stdexec;
 
-#include "__prologue.hpp"
+#else
+
+#  include "__atomic.hpp"
+#  include "__bulk.hpp"
+#  include "__operation_states.hpp"
+#  include "__parallel_scheduler_backend.hpp"
+#  include "__parallel_scheduler_replacement_api.hpp"
+#  include "__schedulers.hpp"
+#  include "__senders.hpp"
+#  include "__utility.hpp"
+
+// TODO: maybe these belong in the GMF?
+#  if STDEXEC_ENABLE_LIBDISPATCH
+#    include "../../exec/libdispatch_queue.hpp"  // IWYU pragma: keep
+#  elif STDEXEC_ENABLE_WINDOWS_THREAD_POOL
+#    include "../../exec/windows/windows_thread_pool.hpp"  // IWYU pragma: keep
+#  else
+#    include "../../exec/static_thread_pool.hpp"  // IWYU pragma: keep
+#  endif
+
+#  if !STDEXEC_USE_MODULES()
+#    include <concepts>
+#    include <cstddef>
+#    include <exception>
+#    include <memory>
+#    include <span>
+#    include <thread>
+#    include <utility>
+#  endif
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC::__parallel_scheduler_default_impl
 {
@@ -388,13 +399,13 @@ namespace STDEXEC::__parallel_scheduler_default_impl
     }
   };
 
-#if STDEXEC_ENABLE_LIBDISPATCH
+#  if STDEXEC_ENABLE_LIBDISPATCH
   using __parallel_scheduler_backend_impl = __generic_impl<exec::libdispatch_queue>;
-#elif STDEXEC_ENABLE_WINDOWS_THREAD_POOL
+#  elif STDEXEC_ENABLE_WINDOWS_THREAD_POOL
   using __parallel_scheduler_backend_impl = __generic_impl<exec::windows_thread_pool>;
-#else
+#  else
   using __parallel_scheduler_backend_impl = __generic_impl<exec::static_thread_pool>;
-#endif
+#  endif
 
   /// The singleton to hold the `parallel_scheduler_backend` instance.
   inline constinit __instance_data<parallel_scheduler_replacement::parallel_scheduler_backend,
@@ -403,4 +414,5 @@ namespace STDEXEC::__parallel_scheduler_default_impl
 
 }  // namespace STDEXEC::__parallel_scheduler_default_impl
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__parallel_scheduler_default_impl_entry.hpp b/include/stdexec/__detail/__parallel_scheduler_default_impl_entry.hpp
index 2291d33ed..76db893a9 100644
--- a/include/stdexec/__detail/__parallel_scheduler_default_impl_entry.hpp
+++ b/include/stdexec/__detail/__parallel_scheduler_default_impl_entry.hpp
@@ -16,28 +16,35 @@
  */
 #pragma once
 
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
 // This file assumes STDEXEC_PARALLEL_SCHEDULER_INLINE is defined before including it. But
 // clang-tidy and doxygen don't know that, so we need to include the header that defines
 // it when clang-tidy and doxygen are invoked.
-#if defined(STDEXEC_CLANG_TIDY_INVOKED) || defined(STDEXEC_DOXYGEN_INVOKED)
-#  include "__parallel_scheduler.hpp"  // IWYU pragma: keep
-#endif
+#  if defined(STDEXEC_CLANG_TIDY_INVOKED) || defined(STDEXEC_DOXYGEN_INVOKED)
+#    include "__parallel_scheduler.hpp"  // IWYU pragma: keep
+#  endif
 
-#if !defined(STDEXEC_PARALLEL_SCHEDULER_INLINE)
-#  error "STDEXEC_PARALLEL_SCHEDULER_INLINE must be defined before including this header"
-#endif
+#  if !defined(STDEXEC_PARALLEL_SCHEDULER_INLINE)
+#    error "STDEXEC_PARALLEL_SCHEDULER_INLINE must be defined before including this header"
+#  endif
 
-#include "__parallel_scheduler_default_impl.hpp"  // IWYU pragma: keep
+#  include "__parallel_scheduler_default_impl.hpp"  // IWYU pragma: keep
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
-namespace STDEXEC::parallel_scheduler_replacement
+STDEXEC_MODULE_EXPORT namespace STDEXEC::parallel_scheduler_replacement
 {
-
   /// Get the backend for the parallel scheduler.
   /// Users might replace this function.
-  STDEXEC_PARALLEL_SCHEDULER_INLINE auto
-  query_parallel_scheduler_backend() -> std::shared_ptr<parallel_scheduler_backend>
+  STDEXEC_MODULE_EXPORT STDEXEC_PARALLEL_SCHEDULER_INLINE auto query_parallel_scheduler_backend()
+    -> std::shared_ptr<parallel_scheduler_backend>
   {
     return STDEXEC::__parallel_scheduler_default_impl::__parallel_scheduler_backend_singleton
       .__get_current_instance();
@@ -46,7 +53,7 @@ namespace STDEXEC::parallel_scheduler_replacement
   /// Set a factory for the parallel scheduler backend.
   /// Can be used to replace the parallel scheduler at runtime.
   /// NOT TO SPEC
-  extern STDEXEC_PARALLEL_SCHEDULER_INLINE  //
+  STDEXEC_MODULE_EXPORT extern STDEXEC_PARALLEL_SCHEDULER_INLINE  //
     auto set_parallel_scheduler_backend(__parallel_scheduler_backend_factory_t __new_factory)
       -> __parallel_scheduler_backend_factory_t
   {
@@ -55,4 +62,5 @@ namespace STDEXEC::parallel_scheduler_replacement
   }
 }  // namespace STDEXEC::parallel_scheduler_replacement
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__queries.hpp b/include/stdexec/__detail/__queries.hpp
index 7a0b3117c..fde5fbc8e 100644
--- a/include/stdexec/__detail/__queries.hpp
+++ b/include/stdexec/__detail/__queries.hpp
@@ -15,15 +15,22 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__completion_behavior.hpp"
-#include "__concepts.hpp"
-#include "__config.hpp"
-#include "__query.hpp"
+#  include "__completion_behavior.hpp"
+#  include "__concepts.hpp"
+#  include "__query.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -77,7 +84,7 @@ namespace STDEXEC
   STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __sync_attrs(_Sender const &) -> __sync_attrs<_Sender>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
 
 STDEXEC_P2300_NAMESPACE_BEGIN()
   //////////////////////////////////////////////////////////////////////////////////
@@ -108,3 +115,4 @@ STDEXEC_P2300_NAMESPACE_BEGIN()
 
   inline constexpr get_allocator_t get_allocator{};
 STDEXEC_P2300_NAMESPACE_END()
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__query.hpp b/include/stdexec/__detail/__query.hpp
index dafeb37dc..7d16c18a2 100644
--- a/include/stdexec/__detail/__query.hpp
+++ b/include/stdexec/__detail/__query.hpp
@@ -68,6 +68,7 @@ namespace STDEXEC
   template <class _Query, class _Env, class... _Args>
   concept __has_validation = requires { _Query::template __validate<_Env, _Args...>(); };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Query, auto _Default = __no_default, class _Transform = __q1<__midentity>>
   struct __query  // NOLINT(bugprone-crtp-constructor-accessibility)
     : __query<_Query, __no_default, _Transform>
@@ -122,12 +123,15 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Env, class _Query, class... _Args>
   concept __queryable_with = __callable<__query<_Query>, _Env &, _Args...>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Env, class _Query, class... _Args>
   concept __nothrow_queryable_with = __nothrow_callable<__query<_Query>, _Env &, _Args...>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Env, class _Query, class... _Args>
   using __query_result_t = __call_result_t<__query<_Query>, _Env &, _Args...>;
 
@@ -145,6 +149,7 @@ namespace STDEXEC
   template <class _Tp>
   concept __is_bool_constant = requires { typename __mbool<_Tp::value>; };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag>
   concept __forwarding_query = forwarding_query(_Tag{});
 
diff --git a/include/stdexec/__detail/__receiver_adaptor.hpp b/include/stdexec/__detail/__receiver_adaptor.hpp
index f49033c8f..b670170fa 100644
--- a/include/stdexec/__detail/__receiver_adaptor.hpp
+++ b/include/stdexec/__detail/__receiver_adaptor.hpp
@@ -15,13 +15,21 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__concepts.hpp"
-#include "__receivers.hpp"
-#include "__type_traits.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__concepts.hpp"
+#  include "__receivers.hpp"
+#  include "__type_traits.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -84,7 +92,7 @@ namespace STDEXEC
 // don't shadow type aliases of the same name in base classes. :-O
 // On mingw gcc, 'bool(type::existing_member_function)' evaluates to true,
 // but 'int(type::existing_member_function)' is an error (as desired).
-#define STDEXEC_DISPATCH_MEMBER(_TAG)                                                              \
+#  define STDEXEC_DISPATCH_MEMBER(_TAG)                                                            \
   template <class _Self, class... _Ts>                                                             \
   STDEXEC_ATTRIBUTE(host, device, always_inline)                                                   \
   static auto __call_##_TAG(_Self&& __self, _Ts&&... __ts) noexcept                                \
@@ -92,22 +100,22 @@ namespace STDEXEC
     static_assert(noexcept((static_cast<_Self&&>(__self))._TAG(static_cast<_Ts&&>(__ts)...)));     \
     return static_cast<_Self&&>(__self)._TAG(static_cast<_Ts&&>(__ts)...);                         \
   } /**/
-#define STDEXEC_CALL_MEMBER(_TAG, ...) __call_##_TAG(__VA_ARGS__)
+#  define STDEXEC_CALL_MEMBER(_TAG, ...) __call_##_TAG(__VA_ARGS__)
 
-#if STDEXEC_CLANG()
+#  if STDEXEC_CLANG()
 // Only clang gets this right.
-#  define STDEXEC_MISSING_MEMBER(_Dp, _TAG) requires { typename _Dp::_TAG; }
-#  define STDEXEC_DEFINE_MEMBER(_TAG)       STDEXEC_DISPATCH_MEMBER(_TAG) using _TAG = void
-#else
-#  define STDEXEC_MISSING_MEMBER(_Dp, _TAG) (__missing_##_TAG<_Dp>())
-#  define STDEXEC_DEFINE_MEMBER(_TAG)                                                              \
+#    define STDEXEC_MISSING_MEMBER(_Dp, _TAG) requires { typename _Dp::_TAG; }
+#    define STDEXEC_DEFINE_MEMBER(_TAG)       STDEXEC_DISPATCH_MEMBER(_TAG) using _TAG = void
+#  else
+#    define STDEXEC_MISSING_MEMBER(_Dp, _TAG) (__missing_##_TAG<_Dp>())
+#    define STDEXEC_DEFINE_MEMBER(_TAG)                                                            \
     template <class _Dp>                                                                           \
     static constexpr bool __missing_##_TAG() noexcept {                                            \
       return requires { requires bool(int(_Dp::_TAG)); };                                          \
     }                                                                                              \
     STDEXEC_DISPATCH_MEMBER(_TAG)                                                                  \
     static constexpr int _TAG = 1 /**/
-#endif
+#  endif
 
   template <__class _Derived, class _Base = __adaptors::__not_a_receiver>
   struct __receiver_adaptor
@@ -185,4 +193,5 @@ namespace STDEXEC
   = __receiver_adaptor<_Derived, _Base>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__receivers.hpp b/include/stdexec/__detail/__receivers.hpp
index 13b6bc26c..f65761c1d 100644
--- a/include/stdexec/__detail/__receivers.hpp
+++ b/include/stdexec/__detail/__receivers.hpp
@@ -383,7 +383,7 @@ namespace STDEXEC
   //! @see stdexec::set_value
   //! @see stdexec::set_error
   //! @see stdexec::set_stopped
-  template <class _Receiver>
+  STDEXEC_MODULE_EXPORT template <class _Receiver>
   concept receiver = __detail::__enable_receiver<__decay_t<_Receiver>>
                   && __environment_provider<__cref_t<_Receiver>>
                   && __nothrow_move_constructible<__decay_t<_Receiver>>
@@ -434,7 +434,7 @@ namespace STDEXEC
   //! @see stdexec::receiver              — without the signature check
   //! @see stdexec::sender_to             — the sender-side mirror of this concept
   //! @see stdexec::completion_signatures — the signature pack this concept consumes
-  template <class _Receiver, class _Completions>
+  STDEXEC_MODULE_EXPORT template <class _Receiver, class _Completions>
   concept receiver_of = receiver<_Receiver> && requires(_Completions *__completions) {
     { __detail::__try_completions<_Receiver>(__completions) } -> __ok;
   };
@@ -505,6 +505,7 @@ namespace STDEXEC
     constexpr void set_stopped() noexcept {}
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Env>
   struct __receiver_archetype : __receiver_archetype_base
   {
diff --git a/include/stdexec/__detail/__run_loop.hpp b/include/stdexec/__detail/__run_loop.hpp
index 6875755de..cf806ab10 100644
--- a/include/stdexec/__detail/__run_loop.hpp
+++ b/include/stdexec/__detail/__run_loop.hpp
@@ -352,6 +352,7 @@ namespace STDEXEC
 
   // A run_loop with an empty environment. This is a struct instead of a type alias to give
   // it a simpler type name that is easier to read in diagnostics.
+  STDEXEC_MODULE_EXPORT
   struct run_loop : __run_loop::__basic_run_loop<run_loop, env<>>
   {
     run_loop() = default;
diff --git a/include/stdexec/__detail/__schedule_from.hpp b/include/stdexec/__detail/__schedule_from.hpp
index 242425946..1f4d2a758 100644
--- a/include/stdexec/__detail/__schedule_from.hpp
+++ b/include/stdexec/__detail/__schedule_from.hpp
@@ -15,15 +15,23 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__basic_sender.hpp"
-#include "__completion_signatures_of.hpp"
-#include "__queries.hpp"
-#include "__sender_introspection.hpp"
+#  include "__basic_sender.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__queries.hpp"
+#  include "__sender_introspection.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -58,4 +66,5 @@ namespace STDEXEC
   };
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__schedulers.hpp b/include/stdexec/__detail/__schedulers.hpp
index d019455da..7b3051d63 100644
--- a/include/stdexec/__detail/__schedulers.hpp
+++ b/include/stdexec/__detail/__schedulers.hpp
@@ -15,20 +15,28 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
-
-// include these after __execution_fwd.hpp
-#include "__completion_signatures_of.hpp"  // IWYU pragma: keep for the sender concept
-#include "__concepts.hpp"
 #include "__config.hpp"
-#include "__domain.hpp"
-#include "__env.hpp"
-#include "__query.hpp"
-#include "__sender_concepts.hpp"
-#include "__type_traits.hpp"
-#include "__utility.hpp"
 
-#include "__prologue.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+// include these after __execution_fwd.hpp
+#  include "__completion_signatures_of.hpp"  // IWYU pragma: keep for the sender concept
+#  include "__concepts.hpp"
+#  include "__config.hpp"
+#  include "__domain.hpp"
+#  include "__env.hpp"
+#  include "__query.hpp"
+#  include "__sender_concepts.hpp"
+#  include "__type_traits.hpp"
+#  include "__utility.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -203,12 +211,14 @@ namespace STDEXEC
   //! @see stdexec::starts_on      — adaptor that runs a sender on a scheduler
   //! @see stdexec::continues_on   — adaptor that transfers to a scheduler mid-pipeline
   //! @see stdexec::schedule_result_t — the sender type returned by @c schedule(s)
+  STDEXEC_MODULE_EXPORT
   template <class _Scheduler>
   concept scheduler = __callable<schedule_t, _Scheduler>  //
                    && __std::equality_comparable<__decay_t<_Scheduler>>
                    && __std::copy_constructible<__decay_t<_Scheduler>>
                    && __nothrow_move_constructible<__decay_t<_Scheduler>>;
 
+  STDEXEC_MODULE_EXPORT
   template <scheduler _Scheduler>
   using schedule_result_t = __call_result_t<schedule_t, _Scheduler>;
 
@@ -509,10 +519,10 @@ namespace STDEXEC
   inline constexpr get_start_scheduler_t            get_start_scheduler{};
   inline constexpr get_delegation_scheduler_t       get_delegation_scheduler{};
 
-#if !STDEXEC_GCC() || defined(__OPTIMIZE_SIZE__)
+#  if !STDEXEC_GCC() || defined(__OPTIMIZE_SIZE__)
   template <__completion_tag _Query>
   inline constexpr get_completion_scheduler_t<_Query> get_completion_scheduler{};
-#else
+#  else
   template <>
   inline constexpr get_completion_scheduler_t<set_value_t> get_completion_scheduler<set_value_t>{};
   template <>
@@ -520,7 +530,7 @@ namespace STDEXEC
   template <>
   inline constexpr get_completion_scheduler_t<set_stopped_t>
     get_completion_scheduler<set_stopped_t>{};
-#endif
+#  endif
 
   template <class _Tag, sender _Sender, class... _Env>
     requires __sends<_Tag, _Sender, _Env...>
@@ -689,13 +699,16 @@ namespace STDEXEC
                                 && __infallible_sender<__result_of<schedule, _Scheduler>, _Env...>;
 
   // Deprecated interfaces
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using get_delegatee_scheduler_t
     [[deprecated("get_delegatee_scheduler_t has been renamed "
                  "get_delegation_scheduler_t")]] = get_delegation_scheduler_t;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr auto &get_delegatee_scheduler [[deprecated("get_delegatee_scheduler has been "
                                                               "renamed get_delegation_scheduler")]]
   = get_delegation_scheduler;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__scope.hpp b/include/stdexec/__detail/__scope.hpp
index cb4299ca6..85170736e 100644
--- a/include/stdexec/__detail/__scope.hpp
+++ b/include/stdexec/__detail/__scope.hpp
@@ -33,6 +33,7 @@ import stdexec;
 
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Fn, class... _Ts>
   struct __scope_guard;
 
diff --git a/include/stdexec/__detail/__scope_concepts.hpp b/include/stdexec/__detail/__scope_concepts.hpp
index 5fb86a33c..f3e8afc08 100644
--- a/include/stdexec/__detail/__scope_concepts.hpp
+++ b/include/stdexec/__detail/__scope_concepts.hpp
@@ -75,6 +75,7 @@ namespace STDEXEC
   //! @see stdexec::scope_token
   //! @see stdexec::spawn
   //! @see stdexec::spawn_future
+  STDEXEC_MODULE_EXPORT
   template <class _Assoc>
   concept scope_association = __std::movable<_Assoc> && __nothrow_move_constructible<_Assoc>
                            && __nothrow_move_assignable<_Assoc>
@@ -86,6 +87,7 @@ namespace STDEXEC
 
   namespace __scope_concepts
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     struct __test_sender
     {
       using sender_concept = STDEXEC::sender_tag;
@@ -142,6 +144,7 @@ namespace STDEXEC
   //! @see stdexec::scope_association  — the return type of @c try_associate
   //! @see stdexec::spawn              — fire-and-forget into a scope
   //! @see stdexec::spawn_future       — spawn into a scope and observe via a sender
+  STDEXEC_MODULE_EXPORT
   template <class _Token>
   concept scope_token = __std::copyable<_Token> && requires(_Token const __token) {
     { __token.try_associate() } -> scope_association;
diff --git a/include/stdexec/__detail/__sender_adaptor_closure.hpp b/include/stdexec/__detail/__sender_adaptor_closure.hpp
index b7f2c37ba..e7710213a 100644
--- a/include/stdexec/__detail/__sender_adaptor_closure.hpp
+++ b/include/stdexec/__detail/__sender_adaptor_closure.hpp
@@ -15,14 +15,22 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__completion_signatures_of.hpp"
-#include "__concepts.hpp"
-#include "__tuple.hpp"
-#include "__type_traits.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__completion_signatures_of.hpp"
+#  include "__concepts.hpp"
+#  include "__tuple.hpp"
+#  include "__type_traits.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -83,10 +91,12 @@ namespace STDEXEC
     };
   }  // namespace __clsur
 
+  STDEXEC_MODULE_EXPORT
   template <__class _Dp>
   struct sender_adaptor_closure : __clsur::__sender_adaptor_closure_base
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Fn, class... _As>
   struct __closure : sender_adaptor_closure<__closure<_Fn, _As...>>
   {
@@ -127,4 +137,5 @@ namespace STDEXEC
   STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __closure(_Fn, _As...) -> __closure<_Fn, _As...>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__sender_concepts.hpp b/include/stdexec/__detail/__sender_concepts.hpp
index 065e60987..dce02f951 100644
--- a/include/stdexec/__detail/__sender_concepts.hpp
+++ b/include/stdexec/__detail/__sender_concepts.hpp
@@ -15,19 +15,27 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__awaitable.hpp"
-#include "__concepts.hpp"
-#include "__diagnostics.hpp"
-#include "__env.hpp"
-#include "__get_completion_signatures.hpp"
-#include "__meta.hpp"
-#include "__receivers.hpp"
-#include "__type_traits.hpp"
+#  include "__awaitable.hpp"
+#  include "__concepts.hpp"
+#  include "__diagnostics.hpp"
+#  include "__env.hpp"
+#  include "__get_completion_signatures.hpp"
+#  include "__meta.hpp"
+#  include "__receivers.hpp"
+#  include "__type_traits.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -120,21 +128,21 @@ namespace STDEXEC
   //! @see stdexec::sender_to    — sender plus a specific receiver, with compatible signatures
   //! @see stdexec::sender_tag   — the tag type that opts a class into this concept
   //! @see stdexec::enable_sender — alternative opt-in path
-  template <class _Sender>
+  STDEXEC_MODULE_EXPORT template <class _Sender>
   concept sender = enable_sender<__decay_t<_Sender>>          //
                 && __environment_provider<__cref_t<_Sender>>  //
                 && __std::move_constructible<__decay_t<_Sender>>
                 && __std::constructible_from<__decay_t<_Sender>, _Sender>;
 
-#if STDEXEC_GCC() && STDEXEC_GCC_VERSION < 1300
+#  if STDEXEC_GCC() && STDEXEC_GCC_VERSION < 1300
   template <auto _Completions>
   inline constexpr bool __constant_completion_signatures_v =
     __valid_completion_signatures<std::remove_const_t<decltype(_Completions)>>;
-#else
+#  else
   template <auto _Completions>
   inline constexpr bool __constant_completion_signatures_v =
     __valid_completion_signatures<decltype(_Completions)>;
-#endif
+#  endif
 
   //! @brief A @c sender whose *completion signatures* can be computed in a
   //!        given environment.
@@ -166,12 +174,13 @@ namespace STDEXEC
   //! @see stdexec::sender                    — the base concept
   //! @see stdexec::sender_to                 — adds a specific receiver
   //! @see stdexec::get_completion_signatures — the customization point this concept depends on
-  template <class _Sender, class... _Env>
+  STDEXEC_MODULE_EXPORT template <class _Sender, class... _Env>
   concept sender_in =
     (sizeof...(_Env) <= 1)  //
     && sender<_Sender>      //
     && __constant_completion_signatures_v<STDEXEC::get_completion_signatures<_Sender, _Env...>()>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Receiver, class _Sender>
   concept __receiver_from =
     receiver_of<_Receiver, __completion_signatures_of_t<_Sender, env_of_t<_Receiver>>>;
@@ -199,7 +208,7 @@ namespace STDEXEC
   //! @see stdexec::sender_in     — without the receiver-compatibility check
   //! @see stdexec::receiver_of   — the receiver-side mirror of this concept
   //! @see stdexec::connect       — the operation @c sender_to validates
-  template <class _Sender, class _Receiver>
+  STDEXEC_MODULE_EXPORT template <class _Sender, class _Receiver>
   concept sender_to = __sender_to<_Sender, _Receiver>  //
                    && requires(_Sender &&__sndr, _Receiver &&__rcvr) {
                         connect(static_cast<_Sender &&>(__sndr), static_cast<_Receiver &&>(__rcvr));
@@ -231,6 +240,7 @@ namespace STDEXEC
   //! @see stdexec::sender                    — the base concept (no environment required)
   //! @see stdexec::sender_in                 — sender with a concrete environment
   //! @see stdexec::get_completion_signatures — the CPO that throws @c dependent_sender_error
+  STDEXEC_MODULE_EXPORT
   template <class _Sender>
   concept dependent_sender = sender<_Sender> && __is_dependent_sender<_Sender>;
 
@@ -309,17 +319,18 @@ namespace STDEXEC
           static_assert(__valid_completion_signatures<_Completions>,
                         STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_HAS_INVALID_RETURN_TYPE);
         }
-#if STDEXEC_MSVC() || STDEXEC_NVHPC()
+#  if STDEXEC_MSVC() || STDEXEC_NVHPC()
         // MSVC and NVHPC need more encouragement to print the type of the
         // error.
         _Completions __what = 0;
-#endif
+#  endif
       }
     }
   }  // namespace __detail
 
   // Used to report a meaningful error message when the sender_in<Sndr, Env>
   // concept check fails.
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class... _Env>
   constexpr auto __diagnose_sender_concept_failure() noexcept
   {
@@ -329,4 +340,5 @@ namespace STDEXEC
   }
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__sender_introspection.hpp b/include/stdexec/__detail/__sender_introspection.hpp
index ab88c5ad8..28829a32d 100644
--- a/include/stdexec/__detail/__sender_introspection.hpp
+++ b/include/stdexec/__detail/__sender_introspection.hpp
@@ -40,13 +40,19 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Wc++26-extensions")
 
 namespace STDEXEC
 {
+#  if STDEXEC_USE_MODULES()
+  template <auto _Descriptor>
+  struct __sexpr;
+#  else
   namespace
   {
     template <auto _Descriptor>
     struct __sexpr;
   }  // namespace
+#  endif
 
   // A type that describes a sender's metadata
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tag, class _Data, class... _Child>
   struct __desc
   {
@@ -226,13 +232,16 @@ namespace STDEXEC
     template <class _Sender>
     using __desc_of_t = __call_result_t<__structured_apply, __get_desc, _Sender>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Sender>
     extern __undefined<_Sender> &__desc_of_v;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Sender>
       requires(__structured_binding_size_v<_Sender> >= 2)
     extern __desc_of_t<_Sender> __desc_of_v<_Sender>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <auto _Descriptor>
     extern decltype(_Descriptor()) __desc_of_v<__sexpr<_Descriptor>>;
   }  // namespace __detail
@@ -245,10 +254,12 @@ namespace STDEXEC
 
   // NOT TO SPEC: in the specification, the tparam of tag_of_t is constrained with the
   // sender concept
+  STDEXEC_MODULE_EXPORT
   template <class _Sender>
     requires enable_sender<__decay_t<_Sender>>
   using tag_of_t = __desc_of_t<_Sender>::__tag;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender>
   using __data_of = __copy_cvref_t<_Sender, typename __desc_of_t<_Sender>::__data>;
 
@@ -262,6 +273,7 @@ namespace STDEXEC
   template <std::size_t _Ny, class _Sender>
   using __nth_child_of_c = __nth_child_of<__msize_t<_Ny>, _Sender>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender>
   using __child_of = __children_of<_Sender, __qq<__mfront>>;
 
@@ -277,6 +289,7 @@ namespace STDEXEC
   template <auto _Descriptor>
   struct __mfor<__sexpr<_Descriptor> const &> : decltype(_Descriptor()){};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class... _Tag>
   concept __sender_for = sender<_Sender> && __minvocable_q<tag_of_t, _Sender>
                       && (__std::same_as<tag_of_t<_Sender>, _Tag> && ...);
diff --git a/include/stdexec/__detail/__sender_ref.hpp b/include/stdexec/__detail/__sender_ref.hpp
index 6aad681ed..a21b3d820 100644
--- a/include/stdexec/__detail/__sender_ref.hpp
+++ b/include/stdexec/__detail/__sender_ref.hpp
@@ -15,14 +15,22 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__connect.hpp"
-#include "__env.hpp"
-#include "__get_completion_signatures.hpp"
+#  include "__connect.hpp"
+#  include "__env.hpp"
+#  include "__get_completion_signatures.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -89,4 +97,5 @@ namespace STDEXEC
   STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __sender_ref(_Sender&) -> __sender_ref<_Sender>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__senders.hpp b/include/stdexec/__detail/__senders.hpp
index 4cac52f9e..fd6a5ef97 100644
--- a/include/stdexec/__detail/__senders.hpp
+++ b/include/stdexec/__detail/__senders.hpp
@@ -15,14 +15,22 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__completion_signatures.hpp"  // IWYU pragma: export
-#include "__connect.hpp"                // IWYU pragma: export
-#include "__sender_concepts.hpp"        // IWYU pragma: export
+#  include "__completion_signatures.hpp"  // IWYU pragma: export
+#  include "__connect.hpp"                // IWYU pragma: export
+#  include "__sender_concepts.hpp"        // IWYU pragma: export
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -44,10 +52,11 @@ namespace STDEXEC
     using __nofail_t = _Error;
   }  // namespace __detail
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sig>
   using __signature_tag_t = decltype(__detail::__signature_tag_v<_Sig>);
 
-  template <class _Sender, class _SetSig, class... _Env>
+  STDEXEC_MODULE_EXPORT template <class _Sender, class _SetSig, class... _Env>
   concept sender_of =
     sender_in<_Sender, _Env...>
     && __same_as<__mlist<_SetSig>,
@@ -61,6 +70,7 @@ namespace STDEXEC
 
   /////////////////////////////////////////////////////////////////////////////
   // early sender type-checking
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender>
   concept __well_formed_sender = sender_in<_Sender> || dependent_sender<_Sender>;
 
@@ -69,4 +79,5 @@ namespace STDEXEC
   {}
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__sequence.hpp b/include/stdexec/__detail/__sequence.hpp
index b41f3a8ba..611ee3af6 100644
--- a/include/stdexec/__detail/__sequence.hpp
+++ b/include/stdexec/__detail/__sequence.hpp
@@ -15,18 +15,26 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__basic_sender.hpp"
-#include "__connect.hpp"
-#include "__just.hpp"
-#include "__schedulers.hpp"
-#include "__senders.hpp"
-#include "__transform_completion_signatures.hpp"
-#include "__variant.hpp"
+#  include "__basic_sender.hpp"
+#  include "__connect.hpp"
+#  include "__just.hpp"
+#  include "__schedulers.hpp"
+#  include "__senders.hpp"
+#  include "__transform_completion_signatures.hpp"
+#  include "__variant.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 STDEXEC_PRAGMA_IGNORE_EDG(expr_has_no_effect)
 STDEXEC_PRAGMA_IGNORE_EDG(type_qualifiers_ignored_on_reference)
@@ -35,6 +43,7 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-value")
 
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __sequence_t;
   struct _ALL_SENDERS_BUT_THE_LAST_MUST_BE_SENDERS_OF_VOID_;
 
@@ -505,4 +514,5 @@ namespace STDEXEC
   }  // namespace __detail
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__spawn.hpp b/include/stdexec/__detail/__spawn.hpp
index a6944d661..068210418 100644
--- a/include/stdexec/__detail/__spawn.hpp
+++ b/include/stdexec/__detail/__spawn.hpp
@@ -199,6 +199,7 @@ namespace STDEXEC
   //!                                when the spawned work completes
   //! @see exec::start_detached    — scope-less fire-and-forget (extension)
   //! @see stdexec::sync_wait      — top-level synchronous wait that returns the result
+  STDEXEC_MODULE_EXPORT
   struct spawn_t
   {
    private:
@@ -312,6 +313,7 @@ namespace STDEXEC
   //! description, scope semantics, and a usage example.
   //!
   //! @hideinitializer
+  STDEXEC_MODULE_EXPORT
   inline constexpr spawn_t spawn{};
 }  // namespace STDEXEC
 
diff --git a/include/stdexec/__detail/__spawn_future.hpp b/include/stdexec/__detail/__spawn_future.hpp
index 624025cbe..fd740061d 100644
--- a/include/stdexec/__detail/__spawn_future.hpp
+++ b/include/stdexec/__detail/__spawn_future.hpp
@@ -122,6 +122,7 @@ namespace STDEXEC
       stop_token_of_t<_Env>,
       __future_stop_callback>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Env, class... _Sigs>
     using __future_completions_t =
       __future_completions<__stop_callback_is_nothrow_constructible<_Env>
@@ -786,6 +787,7 @@ namespace STDEXEC
   //! @see exec::start_detached    — scope-less fire-and-forget (extension)
   //! @see stdexec::sync_wait      — top-level synchronous wait that returns the result
   //! @see stdexec::when_all       — combine multiple senders concurrently (lazy)
+  STDEXEC_MODULE_EXPORT
   struct spawn_future_t
   {
     //! @brief Spawn @c __sndr into the scope identified by @c __tkn,
@@ -885,6 +887,7 @@ namespace STDEXEC
   //! semantics, and a usage example.
   //!
   //! @hideinitializer
+  STDEXEC_MODULE_EXPORT
   inline constexpr spawn_future_t spawn_future{};
 
   template <>
diff --git a/include/stdexec/__detail/__spin_loop_pause.hpp b/include/stdexec/__detail/__spin_loop_pause.hpp
index ed095c157..58d79a5db 100644
--- a/include/stdexec/__detail/__spin_loop_pause.hpp
+++ b/include/stdexec/__detail/__spin_loop_pause.hpp
@@ -16,46 +16,57 @@
  */
 #pragma once
 
-#include "../../stdexec/__detail/__config.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
 
 // The below code for spin_loop_pause is taken from https://github.com/max0x7ba/atomic_queue/blob/master/include/atomic_queue/defs.h
 // Copyright (c) 2019 Maxim Egorushkin. MIT License.
 
-#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
-#  if STDEXEC_MSVC_HEADERS()
-#    include <intrin.h>
-#  endif
+#  if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+#    if STDEXEC_MSVC_HEADERS()
+// TODO: does this go in the CMF in stdexec.cppm when building for modules?
+#      include <intrin.h>
+#    endif
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT_AUTHORING
   STDEXEC_ATTRIBUTE(always_inline) static void __spin_loop_pause() noexcept
   {
-#  if STDEXEC_MSVC_HEADERS()
+#    if STDEXEC_MSVC_HEADERS()
     _mm_pause();
-#  else
+#    else
     __builtin_ia32_pause();
-#  endif
+#    endif
   }
 }  // namespace STDEXEC
-#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM64)
+#  elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM64)
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT_AUTHORING
   STDEXEC_ATTRIBUTE(always_inline) inline void __spin_loop_pause() noexcept
   {
-#  if (defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__)           \
-       || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__)         \
-       || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)         \
-       || defined(__ARM_ARCH_8A__) || defined(__aarch64__))
+#    if (defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__)         \
+         || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__)       \
+         || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)       \
+         || defined(__ARM_ARCH_8A__) || defined(__aarch64__))
     asm volatile("yield" ::: "memory");
-#  elif defined(_M_ARM64)
+#    elif defined(_M_ARM64)
     __yield();
-#  else
+#    else
     asm volatile("nop" ::: "memory");
-#  endif
+#    endif
   }
 }  // namespace STDEXEC
-#else
+#  else
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT_AUTHORING
   STDEXEC_ATTRIBUTE(always_inline) static void __spin_loop_pause() noexcept {}
 }  // namespace STDEXEC
-#endif
+#  endif
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__starts_on.hpp b/include/stdexec/__detail/__starts_on.hpp
index f37affa40..21ccbd259 100644
--- a/include/stdexec/__detail/__starts_on.hpp
+++ b/include/stdexec/__detail/__starts_on.hpp
@@ -15,21 +15,29 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__completion_signatures_of.hpp"
-#include "__concepts.hpp"
-#include "__diagnostics.hpp"
-#include "__domain.hpp"
-#include "__env.hpp"
-#include "__just.hpp"
-#include "__schedulers.hpp"
-#include "__senders.hpp"
-#include "__sequence.hpp"
-#include "__utility.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__concepts.hpp"
+#  include "__diagnostics.hpp"
+#  include "__domain.hpp"
+#  include "__env.hpp"
+#  include "__just.hpp"
+#  include "__schedulers.hpp"
+#  include "__senders.hpp"
+#  include "__sequence.hpp"
+#  include "__utility.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -260,4 +268,5 @@ namespace STDEXEC
   };
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__stop_token.hpp b/include/stdexec/__detail/__stop_token.hpp
index e8af1fb7a..1b9443945 100644
--- a/include/stdexec/__detail/__stop_token.hpp
+++ b/include/stdexec/__detail/__stop_token.hpp
@@ -75,10 +75,10 @@ STDEXEC_P2300_NAMESPACE_BEGIN()
   };
 #  endif
 
-  template <class _Token, class _Callback>
+  STDEXEC_MODULE_EXPORT template <class _Token, class _Callback>
   using stop_callback_for_t = STDEXEC::__mcall1<__stop_callback_for<_Token>, _Callback>;
 
-  template <class _Token>
+  STDEXEC_MODULE_EXPORT template <class _Token>
   concept stoppable_token =
     requires(_Token const __token) {
       requires __has_stop_callback_v<_Token>;
@@ -88,7 +88,7 @@ STDEXEC_P2300_NAMESPACE_BEGIN()
     } && STDEXEC::__std::copyable<_Token>  //
     && STDEXEC::__std::equality_comparable<_Token>;
 
-  template <class _Token>
+  STDEXEC_MODULE_EXPORT template <class _Token>
   concept unstoppable_token =
     stoppable_token<_Token> //
     && requires {
@@ -97,7 +97,7 @@ STDEXEC_P2300_NAMESPACE_BEGIN()
     && (!_Token::stop_possible());
 
   // [stoptoken.never], class never_stop_token
-  struct never_stop_token
+  STDEXEC_MODULE_EXPORT struct never_stop_token
   {
    private:
     struct __callback_type
diff --git a/include/stdexec/__detail/__stop_when.hpp b/include/stdexec/__detail/__stop_when.hpp
index 3c9fc99f6..f4be5d282 100644
--- a/include/stdexec/__detail/__stop_when.hpp
+++ b/include/stdexec/__detail/__stop_when.hpp
@@ -208,6 +208,7 @@ namespace STDEXEC
   ///        into its child sender such that the sender responds to stop
   ///        requests from both the given stop token and the receiver's token
   /// @hideinitializer
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr __stop_when_t __stop_when{};
 
   template <>
diff --git a/include/stdexec/__detail/__stopped_as_error.hpp b/include/stdexec/__detail/__stopped_as_error.hpp
index 337f80035..ba549820e 100644
--- a/include/stdexec/__detail/__stopped_as_error.hpp
+++ b/include/stdexec/__detail/__stopped_as_error.hpp
@@ -15,16 +15,24 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__concepts.hpp"
-#include "__just.hpp"
-#include "__let.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
+#  include "__concepts.hpp"
+#  include "__just.hpp"
+#  include "__let.hpp"
+#  include "__sender_adaptor_closure.hpp"
+#  include "__senders.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -141,4 +149,5 @@ namespace STDEXEC
   inline constexpr stopped_as_error_t stopped_as_error{};
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__storage.hpp b/include/stdexec/__detail/__storage.hpp
index fa83cb490..dda6459c7 100644
--- a/include/stdexec/__detail/__storage.hpp
+++ b/include/stdexec/__detail/__storage.hpp
@@ -15,15 +15,23 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__get_completion_signatures.hpp"
-#include "__meta.hpp"
-#include "__sender_concepts.hpp"
-#include "__tuple.hpp"
-#include "__variant.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__get_completion_signatures.hpp"
+#  include "__meta.hpp"
+#  include "__sender_concepts.hpp"
+#  include "__tuple.hpp"
+#  include "__variant.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -58,6 +66,7 @@ namespace STDEXEC
 
   // A variant type that is capable of storing the result datums of the specified
   // completion signatures.
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Signatures>
   struct __results_storage
     : __mcall<__mconcat<__qq<__uniqued_variant>>,
@@ -83,4 +92,5 @@ namespace STDEXEC
     __mapply_q<__results_storage, __completion_signatures_of_t<_CvSender, _Env>>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__submit.hpp b/include/stdexec/__detail/__submit.hpp
index 9ed43baa5..b2bf548ff 100644
--- a/include/stdexec/__detail/__submit.hpp
+++ b/include/stdexec/__detail/__submit.hpp
@@ -15,15 +15,23 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__manual_lifetime.hpp"
-#include "__operation_states.hpp"
-#include "__optional.hpp"
-#include "__senders.hpp"
-#include "__type_traits.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__manual_lifetime.hpp"
+#  include "__operation_states.hpp"
+#  include "__optional.hpp"
+#  include "__senders.hpp"
+#  include "__type_traits.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -90,12 +98,15 @@ namespace STDEXEC
       }
     };
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     inline constexpr __submit_t __submit{};
   }  // namespace __submit
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class _Receiver, class _Default = __submit::__submit_t::__void>
   using __submit_result_t = __call_result_t<__submit::__submit_t, _Sender, _Receiver, _Default>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class _Receiver>
   concept __submittable = requires(_Sender&& __sndr, _Receiver&& __rcvr) {
     __submit::__submit(static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr));
@@ -144,6 +155,7 @@ namespace STDEXEC
     return __submit_result_kind::__connect;
   }
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender,
             class _Receiver,
             __submit_result_kind _Kind = __get_submit_result_kind<_Sender, _Receiver>()>
@@ -224,4 +236,5 @@ namespace STDEXEC
 
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__sync_wait.hpp b/include/stdexec/__detail/__sync_wait.hpp
index ff2feeccc..198d64180 100644
--- a/include/stdexec/__detail/__sync_wait.hpp
+++ b/include/stdexec/__detail/__sync_wait.hpp
@@ -56,6 +56,7 @@ namespace STDEXEC::__sync_wait
   /////////////////////////////////////////////////////////////////////////////
   // [exec.sync.wait]
   // [exec.sync.wait.var]
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __env
   {
     template <__one_of<get_scheduler_t, get_start_scheduler_t, get_delegation_scheduler_t> _Query>
diff --git a/include/stdexec/__detail/__tag_invoke.hpp b/include/stdexec/__detail/__tag_invoke.hpp
index 5ea75ad6c..6819e783c 100644
--- a/include/stdexec/__detail/__tag_invoke.hpp
+++ b/include/stdexec/__detail/__tag_invoke.hpp
@@ -16,13 +16,20 @@
 #pragma once
 
 #include "__config.hpp"
-#include "__type_traits.hpp"
 
-#define STDEXEC_TAG_INVOKE_DEPRECATED_MSG                                                          \
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__type_traits.hpp"
+
+#  define STDEXEC_TAG_INVOKE_DEPRECATED_MSG                                                        \
   "The use of tag_invoke as a means of customization is deprecated. Please use member functions "  \
   "instead."
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -31,6 +38,7 @@ namespace STDEXEC
   {
     constexpr void tag_invoke();
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Tag, class... _Args>
     concept __tag_invocable = requires(_Tag __tag, _Args &&...__args) {
       tag_invoke(static_cast<_Tag &&>(__tag), static_cast<_Args &&>(__args)...);
@@ -43,6 +51,7 @@ namespace STDEXEC
       };
     };
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Tag, class... _Args>
     concept __nothrow_tag_invocable = __tag_invocable<_Tag, _Args...>
                                    && requires(_Tag __tag, _Args &&...__args) {
@@ -52,6 +61,7 @@ namespace STDEXEC
                                         } noexcept;
                                       };
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Tag, class... _Args>
     using __tag_invoke_result_t = decltype(tag_invoke(__declval<_Tag>(), __declval<_Args>()...));
 
@@ -85,17 +95,22 @@ namespace STDEXEC
 
   namespace __ti
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     inline constexpr __tag_invoke_t __tag_invoke{};
 
     [[deprecated(STDEXEC_TAG_INVOKE_DEPRECATED_MSG)]]
     inline constexpr __tag_invoke_t tag_invoke = __tag_invoke;
   }  // namespace __ti
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using namespace __ti;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __dispatch::__tag_invocable;
   using __dispatch::__tag_invocable_r;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __dispatch::__nothrow_tag_invocable;
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __dispatch::__tag_invoke_result_t;
   using __dispatch::__tag_invoke_result;
 
@@ -121,4 +136,5 @@ namespace STDEXEC
   = __decay_t<decltype(_Tag)>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__task.hpp b/include/stdexec/__detail/__task.hpp
index 92ce9bfdb..c461c8f75 100644
--- a/include/stdexec/__detail/__task.hpp
+++ b/include/stdexec/__detail/__task.hpp
@@ -275,6 +275,7 @@ namespace STDEXEC
 
   ////////////////////////////////////////////////////////////////////////////////
   // STDEXEC::task
+  STDEXEC_MODULE_EXPORT
   template <class _Ty = void, class _TaskEnv = env<>>
   class [[nodiscard]] task
   {
diff --git a/include/stdexec/__detail/__task_scheduler.hpp b/include/stdexec/__detail/__task_scheduler.hpp
index ef3264de6..476a2591d 100644
--- a/include/stdexec/__detail/__task_scheduler.hpp
+++ b/include/stdexec/__detail/__task_scheduler.hpp
@@ -70,7 +70,9 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Warray-bounds")
 
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT
   class task_scheduler;
+  STDEXEC_MODULE_EXPORT
   struct task_scheduler_domain;
 
   namespace __task
diff --git a/include/stdexec/__detail/__then.hpp b/include/stdexec/__detail/__then.hpp
index e201ec66c..c1a5084a5 100644
--- a/include/stdexec/__detail/__then.hpp
+++ b/include/stdexec/__detail/__then.hpp
@@ -15,18 +15,26 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__basic_sender.hpp"
-#include "__completion_signatures_of.hpp"
-#include "__diagnostics.hpp"
-#include "__meta.hpp"
-#include "__queries.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
-#include "__transform_completion_signatures.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__basic_sender.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__diagnostics.hpp"
+#  include "__meta.hpp"
+#  include "__queries.hpp"
+#  include "__sender_adaptor_closure.hpp"
+#  include "__senders.hpp"
+#  include "__transform_completion_signatures.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -243,4 +251,5 @@ namespace STDEXEC
   {};
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__transfer_just.hpp b/include/stdexec/__detail/__transfer_just.hpp
index d8165cb63..5a3abbbbf 100644
--- a/include/stdexec/__detail/__transfer_just.hpp
+++ b/include/stdexec/__detail/__transfer_just.hpp
@@ -15,20 +15,28 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__basic_sender.hpp"
-#include "__concepts.hpp"
-#include "__continues_on.hpp"
-#include "__just.hpp"
-#include "__schedulers.hpp"
-#include "__tuple.hpp"
+#  include "__basic_sender.hpp"
+#  include "__concepts.hpp"
+#  include "__continues_on.hpp"
+#  include "__just.hpp"
+#  include "__schedulers.hpp"
+#  include "__tuple.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 // Hide transfer_just from Doxygen since it's deprecated and we don't want to document it:
-#if !defined(STDEXEC_DOXYGEN_INVOKED)
+#  if !defined(STDEXEC_DOXYGEN_INVOKED)
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
 
@@ -101,6 +109,7 @@ namespace STDEXEC
   };
 }  // namespace STDEXEC
 
-#endif  // STDEXEC_DOXYGEN_INVOKED
+#  endif  // STDEXEC_DOXYGEN_INVOKED
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__transform_completion_signatures.hpp b/include/stdexec/__detail/__transform_completion_signatures.hpp
index 37e4bce1f..6d10b7814 100644
--- a/include/stdexec/__detail/__transform_completion_signatures.hpp
+++ b/include/stdexec/__detail/__transform_completion_signatures.hpp
@@ -15,24 +15,32 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "../functional.hpp"
-#include "__completion_signatures.hpp"
-#include "__completion_signatures_of.hpp"
-#include "__concepts.hpp"
-#include "__debug.hpp"  // IWYU pragma: keep
-#include "__get_completion_signatures.hpp"
-#include "__meta.hpp"
+#  include "../functional.hpp"
+#  include "__completion_signatures.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__concepts.hpp"
+#  include "__debug.hpp"  // IWYU pragma: keep
+#  include "__get_completion_signatures.hpp"
+#  include "__meta.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
   namespace __cmplsigs
   {
-#if STDEXEC_NO_STDCPP_CONSTEXPR_EXCEPTIONS()
+#  if STDEXEC_NO_STDCPP_CONSTEXPR_EXCEPTIONS()
     // Without constexpr exceptions, we cannot always produce a valid
     // completion_signatures type. We must permit get_completion_signatures to return an
     // error type because we can't throw it.
@@ -41,12 +49,12 @@ namespace STDEXEC
                                             || STDEXEC_IS_BASE_OF(STDEXEC::dependent_sender_error,
                                                                   _Completions)
                                             || __is_instance_of<_Completions, _ERROR_>;
-#else
+#  else
     // When we have constexpr exceptions, we can require that get_completion_signatures
     // always produces a valid completion_signatures type.
     template <class _Completions>
     concept __well_formed_completions_helper = __valid_completion_signatures<_Completions>;
-#endif
+#  endif
   }  // namespace __cmplsigs
 
   using __cmplsigs::get_completion_signatures_t;
@@ -133,6 +141,7 @@ namespace STDEXEC
     constexpr auto __transform_reduce_sigs(__undefined<completion_signatures<_Sigs...>> *)
       -> _Variant<__transform_sig_t<_Sigs, _SetVal, _SetErr, _SetStp>..., _More...>;
 
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class... _Values>
     using __default_set_value = completion_signatures<set_value_t(_Values...)>;
 
@@ -153,6 +162,7 @@ namespace STDEXEC
     decltype(__cmplsigs::__transform_reduce_sigs<_SetVal, _SetErr, _SetStp, _Variant, _More...>(
       static_cast<__undefined<_Sigs> *>(nullptr)));
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sigs,
             class _MoreSigs                           = completion_signatures<>,
             template <class...> class _ValueTransform = __cmplsigs::__default_set_value,
@@ -166,6 +176,7 @@ namespace STDEXEC
                                                __mtry_q<__concat_completion_signatures_t>::__f,
                                                _MoreSigs>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sndr,
             class _Env                                = env<>,
             class _MoreSigs                           = completion_signatures<>,
@@ -296,6 +307,7 @@ namespace STDEXEC
   //! * __ignore_completion
   //! * __transform_arguments
   //! * __decay_arguments
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _SetTag>
   struct __keep_completion
   {
@@ -306,6 +318,7 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __ignore_completion
   {
     template <class...>
@@ -315,6 +328,7 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _SetTag, class _Fn, class... _AlgoTag>
   struct __transform_arguments
   {
@@ -350,6 +364,7 @@ namespace STDEXEC
     }
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _SetTag, class... _AlgoTag>
   struct __decay_arguments
   {
@@ -482,6 +497,7 @@ namespace STDEXEC
   //! \endcode
   //!
   //! \note This function is evaluated at compile-time (consteval).
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Completions,
             class _ValueFn   = __keep_completion<set_value_t>,
             class _ErrorFn   = __keep_completion<set_error_t>,
@@ -534,7 +550,7 @@ namespace STDEXEC
   using __nothrow_decay_copyable_results_t =
     __cmplsigs::__partitions_of_t<_Completions>::__nothrow_decay_copyable::__all;
 
-#define STDEXEC_TRANSFORM_COMPLETION_SIGNATURES_DEPRECATION_MESSAGE \
+#  define STDEXEC_TRANSFORM_COMPLETION_SIGNATURES_DEPRECATION_MESSAGE \
   "Please migrate to the exec::transform_completion_signatures API in <exec/completion_signatures.hpp>"
 
   // Deprecated interfaces:
@@ -567,4 +583,5 @@ namespace STDEXEC
                                           _StoppedSigs>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__transform_sender.hpp b/include/stdexec/__detail/__transform_sender.hpp
index 55157b1e9..73e29c19f 100644
--- a/include/stdexec/__detail/__transform_sender.hpp
+++ b/include/stdexec/__detail/__transform_sender.hpp
@@ -15,15 +15,23 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__concepts.hpp"
-#include "__domain.hpp"
-#include "__meta.hpp"
-#include "__type_traits.hpp"
+#  include "__concepts.hpp"
+#  include "__domain.hpp"
+#  include "__meta.hpp"
+#  include "__type_traits.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 STDEXEC_PRAGMA_IGNORE_EDG(type_qualifiers_ignored_on_reference)
 
@@ -168,7 +176,7 @@ namespace STDEXEC
 
   /////////////////////////////////////////////////////////////////////////////
   // [exec.snd.apply]
-  inline constexpr struct apply_sender_t
+  STDEXEC_MODULE_EXPORT inline constexpr struct apply_sender_t
   {
     template <class _Domain, class _Tag, class _Sender, class... _Args>
       requires __has_implementation_for<_Tag, _Domain, _Sender, _Args...>
@@ -191,14 +199,16 @@ namespace STDEXEC
     }
   } apply_sender{};
 
-  template <class _Domain, class _Tag, class _Sender, class... _Args>
+  STDEXEC_MODULE_EXPORT template <class _Domain, class _Tag, class _Sender, class... _Args>
   using apply_sender_result_t = __call_result_t<apply_sender_t, _Domain, _Tag, _Sender, _Args...>;
 
   /////////////////////////////////////////////////////////////////////////////
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Sender, class _Scheduler, class _Env, class _Tag = set_value_t>
   concept __completes_on =
     __decays_to<__call_result_t<get_completion_scheduler_t<_Tag>, env_of_t<_Sender>, _Env>,
                 _Scheduler>;
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__tuple.hpp b/include/stdexec/__detail/__tuple.hpp
index 82255c293..78412d31b 100644
--- a/include/stdexec/__detail/__tuple.hpp
+++ b/include/stdexec/__detail/__tuple.hpp
@@ -53,6 +53,7 @@ namespace STDEXEC
 {
   namespace __tup
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class... _Ts>
     struct STDEXEC_ATTRIBUTE(empty_bases) __tuple;
 
@@ -320,16 +321,19 @@ namespace STDEXEC
 #  undef STDEXEC_TUPLE_GET
   }  // namespace __tup
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __tup::__tuple;
 
   inline constexpr __tup::__apply_t __apply{};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Fn, class _Tuple, class... _Us>
   using __apply_result_t = __call_result_t<__tup::__apply_t, _Fn, _Tuple, _Us...>;
 
   template <class _Fn, class _Tuple, class... _Us>
   concept __applicable = __callable<__tup::__apply_t::__impl_t<_Tuple>, _Fn, _Tuple, _Us...>;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Fn, class _Tuple, class... _Us>
   concept __nothrow_applicable =
     __nothrow_callable<__tup::__apply_t::__impl_t<_Tuple>, _Fn, _Tuple, _Us...>;
@@ -361,6 +365,7 @@ namespace STDEXEC
     }
   }  // namespace __tup
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <size_t _Index, class _Tuple>
   STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
   constexpr auto __get(_Tuple&& __tupl) noexcept -> auto&&
@@ -415,6 +420,7 @@ namespace STDEXEC
   //
   // __decayed_tuple<Ts...>
   //
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Ts>
   using __decayed_tuple = __tuple<__decay_t<_Ts>...>;
 
diff --git a/include/stdexec/__detail/__type_traits.hpp b/include/stdexec/__detail/__type_traits.hpp
index 21e25b91f..f3f4e54d0 100644
--- a/include/stdexec/__detail/__type_traits.hpp
+++ b/include/stdexec/__detail/__type_traits.hpp
@@ -36,9 +36,11 @@ namespace STDEXEC
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
   // A very simple std::declval replacement that doesn't handle void
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tp, bool _Noexcept = true>
   using __declfn_t = auto (*)() noexcept(_Noexcept) -> _Tp;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Tp, class...>
   extern __declfn_t<_Tp &&> __declval;
 
@@ -78,15 +80,18 @@ namespace STDEXEC
     };
   }  // namespace __tt
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty>
   using __decay_t = __tt::__decay_<bool(sizeof(__declfn_t<_Ty>))>::template __f<_Ty>;
 #  else
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty>
   using __decay_t = std::decay_t<_Ty>;
 #  endif
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
   // __copy_cvref_t: For copying cvref from one type to another
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __cp
   {
     template <class _Tp>
@@ -111,6 +116,7 @@ namespace STDEXEC
     using __f = _Tp &&;
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __cpclr
   {
     template <class _Tp>
@@ -138,6 +144,7 @@ namespace STDEXEC
   template <class _Tp>
   using __copy_cvref_fn = decltype(__cpcvr<_Tp>);
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _From, class _To>
   using __copy_cvref_t = __copy_cvref_fn<_From>::template __f<_To>;
 
@@ -172,6 +179,7 @@ namespace STDEXEC
   // template <bool _Bp>
   // using __mbool = __mconstant<_Bp>;
 
+  STDEXEC_MODULE_EXPORT_META
   template <bool _Bp>
   struct __mbool : std::bool_constant<_Bp>
   {};
diff --git a/include/stdexec/__detail/__typeinfo.hpp b/include/stdexec/__detail/__typeinfo.hpp
index 32d652a42..8712310c8 100644
--- a/include/stdexec/__detail/__typeinfo.hpp
+++ b/include/stdexec/__detail/__typeinfo.hpp
@@ -40,6 +40,7 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-private-field")
 
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty>
   struct __mtype
   {
@@ -48,11 +49,13 @@ namespace STDEXEC
 
   namespace __detail
   {
+    STDEXEC_MODULE_EXPORT_AUTHORING
     template <class _Ty>
     extern __mtype<_Ty> __demangle_v;
   }  // namespace __detail
 
   // A utility for pretty-printing type names in diagnostics
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty>
   using __demangle_t = decltype(__detail::__demangle_v<_Ty>)::__t;
 
@@ -266,6 +269,7 @@ namespace STDEXEC
   }  // namespace __detail
 
   // For a given type, return a __type_index object
+  STDEXEC_MODULE_EXPORT_META
   template <class _Ty>
   inline constexpr __type_index __mtypeid = __detail::__mtypeid_value<_Ty>::__id;
 
diff --git a/include/stdexec/__detail/__unstoppable.hpp b/include/stdexec/__detail/__unstoppable.hpp
index 5d81fe1f0..20f2c86f8 100644
--- a/include/stdexec/__detail/__unstoppable.hpp
+++ b/include/stdexec/__detail/__unstoppable.hpp
@@ -15,18 +15,28 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "../stop_token.hpp"
-#include "__env.hpp"
-#include "__write_env.hpp"
+#  include "../stop_token.hpp"
+#  include "__env.hpp"
+#  include "__write_env.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
+  STDEXEC_MODULE_EXPORT
   inline constexpr auto unstoppable = write_env(prop{get_stop_token, never_stop_token{}});
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__upon_error.hpp b/include/stdexec/__detail/__upon_error.hpp
index 6294f719a..0fba0f3fb 100644
--- a/include/stdexec/__detail/__upon_error.hpp
+++ b/include/stdexec/__detail/__upon_error.hpp
@@ -15,18 +15,26 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__basic_sender.hpp"
-#include "__completion_signatures_of.hpp"
-#include "__diagnostics.hpp"
-#include "__meta.hpp"
-#include "__queries.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"  // IWYU pragma: keep for __well_formed_sender
-#include "__transform_completion_signatures.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__basic_sender.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__diagnostics.hpp"
+#  include "__meta.hpp"
+#  include "__queries.hpp"
+#  include "__sender_adaptor_closure.hpp"
+#  include "__senders.hpp"  // IWYU pragma: keep for __well_formed_sender
+#  include "__transform_completion_signatures.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -242,4 +250,5 @@ namespace STDEXEC
   {};
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__upon_stopped.hpp b/include/stdexec/__detail/__upon_stopped.hpp
index 34258a1aa..a6b0eab9a 100644
--- a/include/stdexec/__detail/__upon_stopped.hpp
+++ b/include/stdexec/__detail/__upon_stopped.hpp
@@ -15,16 +15,24 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "__basic_sender.hpp"
-#include "__completion_signatures_of.hpp"
-#include "__meta.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"  // IWYU pragma: keep for __well_formed_sender
-#include "__transform_completion_signatures.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "__basic_sender.hpp"
+#  include "__completion_signatures_of.hpp"
+#  include "__meta.hpp"
+#  include "__sender_adaptor_closure.hpp"
+#  include "__senders.hpp"  // IWYU pragma: keep for __well_formed_sender
+#  include "__transform_completion_signatures.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -214,4 +222,5 @@ namespace STDEXEC
 
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__utility.hpp b/include/stdexec/__detail/__utility.hpp
index 6bd439e9b..d321f5164 100644
--- a/include/stdexec/__detail/__utility.hpp
+++ b/include/stdexec/__detail/__utility.hpp
@@ -43,19 +43,24 @@ namespace STDEXEC
 {
   inline constexpr std::size_t __npos = ~0UL;
 
+  STDEXEC_MODULE_EXPORT_META
   template <class...>
   struct __undefined;
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   using __empty = struct __
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __none_such
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr struct __no_init_t
   {
   } __no_init{};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr struct __in_place_from_t
   {
     explicit __in_place_from_t() = default;
@@ -67,12 +72,14 @@ namespace STDEXEC
     {};
   }  // namespace
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __immovable
   {
     __immovable() = default;
     STDEXEC_IMMOVABLE(__immovable);
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   struct __move_only
   {
     __move_only()                                          = default;
@@ -82,6 +89,7 @@ namespace STDEXEC
     auto operator=(__move_only const &) -> __move_only&    = delete;
   };
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Fun, class... _As>
   using __call_result_t = decltype(__declval<_Fun>()(__declval<_As>()...));
 
@@ -90,14 +98,17 @@ namespace STDEXEC
 
 // BUGBUG TODO file this bug with nvc++
 #  if STDEXEC_EDG()
-  template <const auto& _Fun, class... _As>
+  STDEXEC_MODULE_EXPORT_META
+  template <auto const & _Fun, class... _As>
   using __result_of = __call_result_t<decltype(_Fun), _As...>;
 #  else
-  template <const auto& _Fun, class... _As>
+  STDEXEC_MODULE_EXPORT_META
+  template <auto const & _Fun, class... _As>
   using __result_of = decltype(_Fun(__declval<_As>()...));
 #  endif
 
-  template <const auto& _Fun, class... _As>
+  STDEXEC_MODULE_EXPORT_AUTHORING
+  template <auto const & _Fun, class... _As>
   inline constexpr bool __noexcept_of = noexcept(_Fun(__declval<_As>()...));
 
   // For emplacing non-movable types into optionals:
@@ -135,6 +146,7 @@ namespace STDEXEC
   struct __priority<0>
   {};
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr auto __umin(std::initializer_list<std::size_t> __il) noexcept -> std::size_t
   {
     std::size_t __m = ~0UL;
@@ -148,6 +160,7 @@ namespace STDEXEC
     return __m;
   }
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr auto __umax(std::initializer_list<std::size_t> __il) noexcept -> std::size_t
   {
     std::size_t __m = 0;
@@ -181,6 +194,7 @@ namespace STDEXEC
     return __pos_of(__same, __same + sizeof...(_Ts));
   }
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Ty, class _Uy>
   STDEXEC_ATTRIBUTE(nodiscard, always_inline)
   constexpr auto __forward_like(_Uy&& __uy) noexcept -> auto&&
@@ -266,6 +280,7 @@ namespace STDEXEC
 
   //////////////////////////////////////////////////////////////////////////////////////////
   // __unconst
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class T>
   STDEXEC_ATTRIBUTE(nodiscard, always_inline)
   constexpr auto __unconst(T const & t) noexcept -> T&
@@ -340,8 +355,10 @@ namespace STDEXEC
 //////////////////////////////////////////////////////////////////////////////////////////
 // unreachable
 #  if defined(__cpp_lib_unreachable) && __cpp_lib_unreachable >= 202202L
+    STDEXEC_MODULE_EXPORT_AUTHORING
     using std::unreachable;
 #  else
+    STDEXEC_MODULE_EXPORT_AUTHORING
     [[noreturn]]
     inline void unreachable()
     {
diff --git a/include/stdexec/__detail/__variant.hpp b/include/stdexec/__detail/__variant.hpp
index 28fec791f..ebb13d30d 100644
--- a/include/stdexec/__detail/__variant.hpp
+++ b/include/stdexec/__detail/__variant.hpp
@@ -406,6 +406,7 @@ namespace STDEXEC
     using __variant_base_t = __variant<__indices_for<_Ts...>{}, _Ts...>;
   }  // namespace __var
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class... _Ts>
   struct __variant : __var::__variant_base_t<_Ts...>
   {
diff --git a/include/stdexec/__detail/__when_all.hpp b/include/stdexec/__detail/__when_all.hpp
index 22358a3b7..587e2157e 100644
--- a/include/stdexec/__detail/__when_all.hpp
+++ b/include/stdexec/__detail/__when_all.hpp
@@ -388,6 +388,7 @@ namespace STDEXEC
   //!             <tt>when_all(...) | continues_on(sch)</tt> instead.
   //!
   //! @hideinitializer
+  STDEXEC_MODULE_EXPORT_AUTHORING
   inline constexpr transfer_when_all_t transfer_when_all{};
 
   //! @brief The customization point object for the
diff --git a/include/stdexec/__detail/__with_awaitable_senders.hpp b/include/stdexec/__detail/__with_awaitable_senders.hpp
index d0778bf7b..d6bab6289 100644
--- a/include/stdexec/__detail/__with_awaitable_senders.hpp
+++ b/include/stdexec/__detail/__with_awaitable_senders.hpp
@@ -15,18 +15,26 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
 
-#include "../coroutine.hpp"  // IWYU pragma: keep for __coroutine_handle
-#include "__as_awaitable.hpp"
-#include "__concepts.hpp"
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
 
-#include "__prologue.hpp"
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
+
+#  include "../coroutine.hpp"  // IWYU pragma: keep for __coroutine_handle
+#  include "__as_awaitable.hpp"
+#  include "__concepts.hpp"
+
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
-#if !STDEXEC_NO_STDCPP_COROUTINES()
-  template <class _Promise>
+#  if !STDEXEC_NO_STDCPP_COROUTINES()
+  STDEXEC_MODULE_EXPORT template <class _Promise>
   struct with_awaitable_senders;
 
   namespace __detail
@@ -84,7 +92,8 @@ namespace STDEXEC
     friend _Promise;
     with_awaitable_senders() = default;
   };
-#endif
+#  endif
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/__detail/__write_env.hpp b/include/stdexec/__detail/__write_env.hpp
index be35a97d3..039732ffd 100644
--- a/include/stdexec/__detail/__write_env.hpp
+++ b/include/stdexec/__detail/__write_env.hpp
@@ -15,15 +15,23 @@
  */
 #pragma once
 
-#include "__execution_fwd.hpp"
+#include "__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
-#include "__basic_sender.hpp"
-#include "__env.hpp"
-#include "__queries.hpp"
-#include "__sender_adaptor_closure.hpp"
+#  include "__basic_sender.hpp"
+#  include "__env.hpp"
+#  include "__queries.hpp"
+#  include "__sender_adaptor_closure.hpp"
 
-#include "__prologue.hpp"
+#  include "__prologue.hpp"
 
 namespace STDEXEC
 {
@@ -142,11 +150,12 @@ namespace STDEXEC
   //! @see stdexec::get_env   — the CPO that exposes the merged environment
   //!
   //! @hideinitializer
-  inline constexpr __write_env_t write_env{};
+  STDEXEC_MODULE_EXPORT inline constexpr __write_env_t write_env{};
 
   template <>
   struct __sexpr_impl<__write_env_t> : __write::__write_env_impl
   {};
 }  // namespace STDEXEC
 
-#include "__epilogue.hpp"
+#  include "__epilogue.hpp"
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/execution.hpp b/include/stdexec/execution.hpp
index 9f5f6a4da..adb309326 100644
--- a/include/stdexec/execution.hpp
+++ b/include/stdexec/execution.hpp
@@ -15,72 +15,82 @@
  */
 #pragma once
 
-#include "__detail/__execution_fwd.hpp"
+#include "__detail/__config.hpp"
+
+#if STDEXEC_USE_MODULES() && !defined(STDEXEC_IN_MODULE_PURVIEW)
+
+import stdexec;
+
+#else
+
+#  include "__detail/__execution_fwd.hpp"
 
 // include these after __execution_fwd.hpp
 // IWYU pragma: begin_exports
-#include "__detail/__as_awaitable.hpp"
-#include "__detail/__associate.hpp"
-#include "__detail/__basic_sender.hpp"
-#include "__detail/__bulk.hpp"
-#include "__detail/__completion_signatures.hpp"
-#include "__detail/__connect_awaitable.hpp"
-#include "__detail/__continues_on.hpp"
-#include "__detail/__counting_scopes.hpp"
-#include "__detail/__debug.hpp"
-#include "__detail/__domain.hpp"
-#include "__detail/__env.hpp"
-#include "__detail/__execution_legacy.hpp"
-#include "__detail/__inline_scheduler.hpp"
-#include "__detail/__into_variant.hpp"
-#include "__detail/__intrusive_ptr.hpp"
-#include "__detail/__intrusive_slist.hpp"
-#include "__detail/__just.hpp"
-#include "__detail/__let.hpp"
-#include "__detail/__meta.hpp"
-#include "__detail/__on.hpp"
-#include "__detail/__operation_states.hpp"
-#include "__detail/__parallel_scheduler.hpp"
-#include "__detail/__read_env.hpp"
-#include "__detail/__receiver_adaptor.hpp"
-#include "__detail/__receivers.hpp"
-#include "__detail/__run_loop.hpp"
-#include "__detail/__schedule_from.hpp"
-#include "__detail/__schedulers.hpp"
-#include "__detail/__scope_concepts.hpp"
-#include "__detail/__sender_adaptor_closure.hpp"
-#include "__detail/__senders.hpp"
-#include "__detail/__spawn.hpp"
-#include "__detail/__spawn_future.hpp"
-#include "__detail/__starts_on.hpp"
-#include "__detail/__stopped_as_error.hpp"
-#include "__detail/__stopped_as_optional.hpp"
-#include "__detail/__submit.hpp"
-#include "__detail/__sync_wait.hpp"
-#include "__detail/__task.hpp"
-#include "__detail/__task_scheduler.hpp"
-#include "__detail/__then.hpp"
-#include "__detail/__transfer_just.hpp"
-#include "__detail/__transform_completion_signatures.hpp"
-#include "__detail/__transform_sender.hpp"
-#include "__detail/__type_traits.hpp"
-#include "__detail/__unstoppable.hpp"
-#include "__detail/__upon_error.hpp"
-#include "__detail/__upon_stopped.hpp"
-#include "__detail/__utility.hpp"
-#include "__detail/__when_all.hpp"
-#include "__detail/__with_awaitable_senders.hpp"
-#include "__detail/__write_env.hpp"
+#  include "__detail/__as_awaitable.hpp"
+#  include "__detail/__associate.hpp"
+#  include "__detail/__basic_sender.hpp"
+#  include "__detail/__bulk.hpp"
+#  include "__detail/__completion_signatures.hpp"
+#  include "__detail/__connect_awaitable.hpp"
+#  include "__detail/__continues_on.hpp"
+#  include "__detail/__counting_scopes.hpp"
+#  include "__detail/__debug.hpp"
+#  include "__detail/__domain.hpp"
+#  include "__detail/__env.hpp"
+#  include "__detail/__execution_legacy.hpp"
+#  include "__detail/__inline_scheduler.hpp"
+#  include "__detail/__into_variant.hpp"
+#  include "__detail/__intrusive_ptr.hpp"
+#  include "__detail/__intrusive_slist.hpp"
+#  include "__detail/__just.hpp"
+#  include "__detail/__let.hpp"
+#  include "__detail/__meta.hpp"
+#  include "__detail/__on.hpp"
+#  include "__detail/__operation_states.hpp"
+#  include "__detail/__parallel_scheduler.hpp"
+#  include "__detail/__read_env.hpp"
+#  include "__detail/__receiver_adaptor.hpp"
+#  include "__detail/__receivers.hpp"
+#  include "__detail/__run_loop.hpp"
+#  include "__detail/__schedule_from.hpp"
+#  include "__detail/__schedulers.hpp"
+#  include "__detail/__scope_concepts.hpp"
+#  include "__detail/__sender_adaptor_closure.hpp"
+#  include "__detail/__senders.hpp"
+#  include "__detail/__spawn.hpp"
+#  include "__detail/__spawn_future.hpp"
+#  include "__detail/__starts_on.hpp"
+#  include "__detail/__stopped_as_error.hpp"
+#  include "__detail/__stopped_as_optional.hpp"
+#  include "__detail/__submit.hpp"
+#  include "__detail/__sync_wait.hpp"
+#  include "__detail/__task.hpp"
+#  include "__detail/__task_scheduler.hpp"
+#  include "__detail/__then.hpp"
+#  include "__detail/__transfer_just.hpp"
+#  include "__detail/__transform_completion_signatures.hpp"
+#  include "__detail/__transform_sender.hpp"
+#  include "__detail/__type_traits.hpp"
+#  include "__detail/__unstoppable.hpp"
+#  include "__detail/__upon_error.hpp"
+#  include "__detail/__upon_stopped.hpp"
+#  include "__detail/__utility.hpp"
+#  include "__detail/__when_all.hpp"
+#  include "__detail/__with_awaitable_senders.hpp"
+#  include "__detail/__write_env.hpp"
 
-#include "concepts.hpp"
-#include "coroutine.hpp"
-#include "functional.hpp"
-#include "stop_token.hpp"
+#  include "concepts.hpp"
+#  include "coroutine.hpp"
+#  include "functional.hpp"
+#  include "stop_token.hpp"
 // IWYU pragma: end_exports
 
-#include "__detail/__deprecations.hpp"  // IWYU pragma: keep
+#  include "__detail/__deprecations.hpp"  // IWYU pragma: keep
 
 // For issuing a meaningful diagnostic for the erroneous `snd1 | snd2`.
 template <STDEXEC::sender _Ignore, STDEXEC::sender _Sender>
   requires STDEXEC::__ok<STDEXEC::__bad_pipe_sink_t<_Sender>>
 auto operator|(_Ignore&&, _Sender&&) noexcept;
+
+#endif  // !STDEXEC_USE_MODULES() || defined(STDEXEC_IN_MODULE_PURVIEW)
diff --git a/include/stdexec/functional.hpp b/include/stdexec/functional.hpp
index 50e79cd5b..1136f74c7 100644
--- a/include/stdexec/functional.hpp
+++ b/include/stdexec/functional.hpp
@@ -207,6 +207,7 @@ namespace STDEXEC
   template <class _Fun, class... _As>
   using __invoke_result_t = decltype(__invoke(__declval<_Fun>(), __declval<_As>()...));
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _Fn, class _Default>
   struct __with_default : _Fn
   {
diff --git a/include/stdexec/stop_token.hpp b/include/stdexec/stop_token.hpp
index 18453a870..8afc9a9fd 100644
--- a/include/stdexec/stop_token.hpp
+++ b/include/stdexec/stop_token.hpp
@@ -467,6 +467,7 @@ namespace STDEXEC
     }
   }  // namespace __stok
 
+  STDEXEC_MODULE_EXPORT_AUTHORING
   template <class _StopSource = inplace_stop_source>
   struct __forward_stop_request
   {
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index bf974fbc1..3abf3e13b 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -27,67 +27,72 @@ endfunction()
 
 set(stdexec_test_sources
     test_main.cpp
-    stdexec/cpos/test_cpo_bulk.cpp
-    stdexec/cpos/test_cpo_receiver.cpp
-    stdexec/cpos/test_cpo_start.cpp
-    stdexec/cpos/test_cpo_connect.cpp
-    stdexec/cpos/test_cpo_connect_awaitable.cpp
-    stdexec/cpos/test_cpo_schedule.cpp
-    stdexec/cpos/test_cpo_upon_error.cpp
-    stdexec/cpos/test_cpo_upon_stopped.cpp
-    stdexec/concepts/test_concept_scheduler.cpp
-    stdexec/concepts/test_concepts_receiver.cpp
-    stdexec/concepts/test_concept_operation_state.cpp
-    stdexec/concepts/test_concepts_sender.cpp
-    stdexec/concepts/test_concepts_stop_tokens.cpp
-    stdexec/concepts/test_concepts_scope_association.cpp
-    stdexec/concepts/test_concepts_scope_token.cpp
-    stdexec/concepts/test_awaitables.cpp
-    stdexec/algos/factories/test_just.cpp
-    stdexec/algos/factories/test_transfer_just.cpp
-    stdexec/algos/factories/test_just_error.cpp
-    stdexec/algos/factories/test_just_stopped.cpp
-    stdexec/algos/factories/test_read.cpp
-    stdexec/algos/factories/test_schedule.cpp
     stdexec/algos/adaptors/test_associate.cpp
-    stdexec/algos/adaptors/test_starts_on.cpp
-    stdexec/algos/adaptors/test_on.cpp
-    stdexec/algos/adaptors/test_on2.cpp
-    stdexec/algos/adaptors/test_on3.cpp
     stdexec/algos/adaptors/test_continues_on.cpp
     stdexec/algos/adaptors/test_finally.cpp
-    stdexec/algos/adaptors/test_then.cpp
-    stdexec/algos/adaptors/test_upon_error.cpp
-    stdexec/algos/adaptors/test_upon_stopped.cpp
-    stdexec/algos/adaptors/test_let_value.cpp
-    stdexec/algos/adaptors/test_let_error.cpp
-    stdexec/algos/adaptors/test_let_stopped.cpp
-    stdexec/algos/adaptors/test_bulk.cpp
-    stdexec/algos/adaptors/test_when_all.cpp
-    stdexec/algos/adaptors/test_transfer_when_all.cpp
     stdexec/algos/adaptors/test_into_variant.cpp
+    stdexec/algos/adaptors/test_let_error.cpp
+    stdexec/algos/adaptors/test_on.cpp
+    stdexec/algos/adaptors/test_on3.cpp
     stdexec/algos/adaptors/test_sequence.cpp
+    stdexec/algos/adaptors/test_starts_on.cpp
+    stdexec/algos/adaptors/test_stop_when.cpp
     stdexec/algos/adaptors/test_stopped_as_optional.cpp
-    stdexec/algos/adaptors/test_stopped_as_error.cpp
+    stdexec/algos/adaptors/test_then.cpp
+    stdexec/algos/adaptors/test_upon_error.cpp
+    stdexec/algos/adaptors/test_upon_stopped.cpp
     stdexec/algos/adaptors/test_write_env.cpp
-    stdexec/algos/adaptors/test_stop_when.cpp
-    stdexec/algos/adaptors/test_spawn_future.cpp
-    stdexec/algos/consumers/test_sync_wait.cpp
     stdexec/algos/consumers/test_spawn.cpp
+    stdexec/algos/factories/test_just.cpp
+    stdexec/algos/factories/test_just_error.cpp
+    stdexec/algos/factories/test_just_stopped.cpp
+    stdexec/algos/factories/test_read.cpp
+    stdexec/algos/factories/test_schedule.cpp
+    stdexec/algos/factories/test_transfer_just.cpp
+    stdexec/concepts/test_awaitables.cpp
+    stdexec/concepts/test_concept_operation_state.cpp
+    stdexec/concepts/test_concept_scheduler.cpp
+    stdexec/concepts/test_concepts_receiver.cpp
+    stdexec/concepts/test_concepts_scope_association.cpp
+    stdexec/concepts/test_concepts_scope_token.cpp
+    stdexec/concepts/test_concepts_sender.cpp
+    stdexec/concepts/test_concepts_stop_tokens.cpp
+    stdexec/cpos/test_cpo_bulk.cpp
+    stdexec/cpos/test_cpo_connect.cpp
+    stdexec/cpos/test_cpo_connect_awaitable.cpp
+    stdexec/cpos/test_cpo_receiver.cpp
+    stdexec/cpos/test_cpo_schedule.cpp
+    stdexec/cpos/test_cpo_start.cpp
+    stdexec/cpos/test_cpo_upon_error.cpp
+    stdexec/cpos/test_cpo_upon_stopped.cpp
     stdexec/detail/test_any.cpp
     stdexec/detail/test_common_domain.cpp
     stdexec/detail/test_completion_signatures.cpp
     stdexec/detail/test_demangle.cpp
-    stdexec/detail/test_utility.cpp
     stdexec/detail/test_intrusive_mpsc_queue.cpp
-    stdexec/schedulers/test_task_scheduler.cpp
-    stdexec/schedulers/test_parallel_scheduler.cpp
+    stdexec/detail/test_utility.cpp
     stdexec/queries/test_env.cpp
-    stdexec/queries/test_get_forward_progress_guarantee.cpp
-    stdexec/queries/test_get_completion_behavior.cpp
     stdexec/queries/test_forwarding_queries.cpp
-    stdexec/types/test_task.cpp
-    stdexec/types/test_counting_scopes.cpp)
+    stdexec/queries/test_get_completion_behavior.cpp
+    stdexec/queries/test_get_forward_progress_guarantee.cpp
+    )
+if(NOT STDEXEC_BUILD_MODULES)
+  # these tests don't build in modules mode, yet
+  list(APPEND stdexec_test_sources
+    stdexec/algos/adaptors/test_bulk.cpp
+    stdexec/algos/adaptors/test_let_stopped.cpp
+    stdexec/algos/adaptors/test_let_value.cpp
+    stdexec/algos/adaptors/test_on2.cpp
+    stdexec/algos/adaptors/test_spawn_future.cpp
+    stdexec/algos/adaptors/test_stopped_as_error.cpp
+    stdexec/algos/adaptors/test_transfer_when_all.cpp
+    stdexec/algos/adaptors/test_when_all.cpp
+    stdexec/algos/consumers/test_sync_wait.cpp
+    stdexec/schedulers/test_parallel_scheduler.cpp
+    stdexec/schedulers/test_task_scheduler.cpp
+    stdexec/types/test_counting_scopes.cpp
+    stdexec/types/test_task.cpp)
+endif()
 
 add_library(common_test_settings INTERFACE)
 set_target_properties(
@@ -115,13 +120,10 @@ target_link_libraries(common_test_settings
 # target_compile_definitions( common_test_settings INTERFACE
 # $<$<NOT:$<AND:$<CXX_COMPILER_ID:NVHPC>,$<COMPILE_LANGUAGE:CXX>>>:STDEXEC_ENABLE_EXTRA_TYPE_CHECKING>)
 
-if(STDEXEC_BUILD_MODULES)
-    # temporarily speed up the test cycle by building only one test
-    add_executable(test.stdexec stdexec/module/test_module.cpp)
+add_executable(test.stdexec ${stdexec_test_sources})
 
+if(STDEXEC_BUILD_MODULES)
     set_target_properties(test.stdexec PROPERTIES CXX_MODULE_STD ON)
-else()
-    add_executable(test.stdexec ${stdexec_test_sources})
 endif()
 
 add_compile_diagnostics(test.stdexec)
@@ -142,15 +144,16 @@ if(STDEXEC_BUILD_PARALLEL_SCHEDULER)
     PRIVATE common_test_settings)
 endif()
 
-if(NOT STDEXEC_BUILD_MODULES)
-  # TODO: this doesn't build with modules, yet
-  add_executable(test.scratch test_main.cpp test_scratch.cpp)
-  add_compile_diagnostics(test.scratch)
-  target_link_libraries(
-    test.scratch
-    PUBLIC STDEXEC::stdexec $<TARGET_NAME_IF_EXISTS:STDEXEC::tbbexec>
-           stdexec_executable_flags Catch2::Catch2WithMain
-    PRIVATE common_test_settings)
+add_executable(test.scratch test_main.cpp test_scratch.cpp)
+add_compile_diagnostics(test.scratch)
+target_link_libraries(
+  test.scratch
+  PUBLIC STDEXEC::stdexec $<TARGET_NAME_IF_EXISTS:STDEXEC::tbbexec>
+         stdexec_executable_flags Catch2::Catch2WithMain
+  PRIVATE common_test_settings)
+
+if(STDEXEC_BUILD_MODULES)
+    set_target_properties(test.scratch PROPERTIES CXX_MODULE_STD ON)
 endif()
 
 # Discover the Catch2 test built by the application
@@ -161,20 +164,14 @@ include(${icm_SOURCE_DIR}/icm_build_failure_testing.cmake)
 
 catch_discover_tests(test.stdexec PROPERTIES TIMEOUT 30)
 
-if(NOT STDEXEC_BUILD_MODULES)
-  # TODO: this doesn't build with modules, yet
-  catch_discover_tests(test.scratch PROPERTIES TIMEOUT 30)
-endif()
+catch_discover_tests(test.scratch PROPERTIES TIMEOUT 30)
 
 if(STDEXEC_BUILD_PARALLEL_SCHEDULER AND NOT STDEXEC_ENABLE_CUDA)
   catch_discover_tests(test.parallel_scheduler_replacement PROPERTIES TIMEOUT
                        30)
 endif()
 
-if(NOT STDEXEC_BUILD_MODULES)
-    # temporarily speed up the test cycle by building less
-    add_subdirectory(exec)
-endif()
+add_subdirectory(exec)
 
 if(STDEXEC_ENABLE_CUDA)
   add_subdirectory(nvexec)
diff --git a/test/exec/CMakeLists.txt b/test/exec/CMakeLists.txt
index 40b2fc2d1..f341aa564 100644
--- a/test/exec/CMakeLists.txt
+++ b/test/exec/CMakeLists.txt
@@ -70,7 +70,17 @@ set_source_files_properties(
   test_any_sender.cpp PROPERTIES COMPILE_FLAGS
                                  $<$<CXX_COMPILER_ID:MSVC>:/bigobj>)
 
-add_executable(test.exec ${exec_test_sources})
+if(STDEXEC_BUILD_MODULES)
+  # these are the only files that build right now...
+  add_executable(test.exec
+      ../test_main.cpp
+      async_scope/test_empty.cpp
+      async_scope/test_spawn.cpp)
+  set_target_properties(test.exec PROPERTIES CXX_MODULE_STD ON)
+else()
+  add_executable(test.exec ${exec_test_sources})
+endif()
+
 add_compile_diagnostics(test.exec)
 target_link_libraries(
   test.exec
diff --git a/test/exec/asio/CMakeLists.txt b/test/exec/asio/CMakeLists.txt
index 8621e928d..c9c0fc196 100644
--- a/test/exec/asio/CMakeLists.txt
+++ b/test/exec/asio/CMakeLists.txt
@@ -14,14 +14,30 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-set(asioexec_test_sources ../../test_main.cpp test_asio_thread_pool.cpp
-                          test_completion_token.cpp test_use_sender.cpp)
+set(asioexec_test_sources
+    ../../test_main.cpp
+    test_completion_token.cpp
+    test_use_sender.cpp
+)
+
+if(NOT STDEXEC_BUILD_MODULES)
+    # this test doesn't build with modules, yet
+    list(APPEND asio_test_sources test_asio_thread_pool.cpp)
+endif()
 
 add_executable(test.asioexec ${asioexec_test_sources})
 target_link_libraries(
-  test.asioexec
-  PUBLIC STDEXEC::stdexec $<TARGET_NAME_IF_EXISTS:STDEXEC::asioexec>
-         stdexec_executable_flags Catch2::Catch2WithMain
-  PRIVATE common_test_settings)
+    test.asioexec
+    PUBLIC
+        STDEXEC::stdexec
+        $<TARGET_NAME_IF_EXISTS:STDEXEC::asioexec>
+        stdexec_executable_flags
+        Catch2::Catch2WithMain
+    PRIVATE common_test_settings
+)
+
+if(STDEXEC_BUILD_MODULES)
+    set_target_properties(test.asioexec PROPERTIES CXX_MODULE_STD ON)
+endif()
 
 catch_discover_tests(test.asioexec PROPERTIES TIMEOUT 30)
diff --git a/test/exec/asio/test_asio_thread_pool.cpp b/test/exec/asio/test_asio_thread_pool.cpp
index 9e56cfee2..f9f84e8b6 100644
--- a/test/exec/asio/test_asio_thread_pool.cpp
+++ b/test/exec/asio/test_asio_thread_pool.cpp
@@ -15,10 +15,7 @@
  * limitations under the License.
  */
 
-#include <test_common/catch2.hpp>
-
-#include <numeric>
-#include <span>
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
 
@@ -29,6 +26,13 @@
 
 #include <exec/asio/use_sender.hpp>
 
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <numeric>
+#  include <span>
+#endif
+
 namespace ex = STDEXEC;
 
 namespace
diff --git a/test/exec/test_start_detached.cpp b/test/exec/test_start_detached.cpp
index 5ef6108d9..2d71bffcd 100644
--- a/test/exec/test_start_detached.cpp
+++ b/test/exec/test_start_detached.cpp
@@ -220,7 +220,7 @@ namespace
   }
 
 #if !STDEXEC_NO_STDCPP_MEMORY_RESOURCE()                                                           \
-  && (defined(__cpp_lib_polymorphic_allocator) && __cpp_lib_polymorphic_allocator >= 2019'02L)
+  && (defined(__cpp_lib_polymorphic_allocator) && __cpp_lib_polymorphic_allocator >= 201902L)
 
   struct counting_resource : std::pmr::memory_resource
   {
diff --git a/test/stdexec/algos/adaptors/test_associate.cpp b/test/stdexec/algos/adaptors/test_associate.cpp
index 76f7a2f52..038f5f3ec 100644
--- a/test/stdexec/algos/adaptors/test_associate.cpp
+++ b/test/stdexec/algos/adaptors/test_associate.cpp
@@ -14,14 +14,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/scope_tokens.hpp>
 
-#include <concepts>
-#include <memory>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <concepts>
+#  include <memory>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/adaptors/test_bulk.cpp b/test/stdexec/algos/adaptors/test_bulk.cpp
index 48c90e53b..4ef06f697 100644
--- a/test/stdexec/algos/adaptors/test_bulk.cpp
+++ b/test/stdexec/algos/adaptors/test_bulk.cpp
@@ -13,19 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <exception>
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include <exec/sender_for.hpp>
 #include <exec/static_thread_pool.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/senders.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <numeric>
-#include <vector>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <exception>
+#  include <numeric>
+#  include <vector>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/adaptors/test_continues_on.cpp b/test/stdexec/algos/adaptors/test_continues_on.cpp
index c4a829af3..022074e39 100644
--- a/test/stdexec/algos/adaptors/test_continues_on.cpp
+++ b/test/stdexec/algos/adaptors/test_continues_on.cpp
@@ -13,17 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include <exec/sender_for.hpp>
 #include <exec/start_detached.hpp>
 #include <exec/static_thread_pool.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono>  // IWYU pragma: keep for chrono_literals
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <chrono>  // IWYU pragma: keep for chrono_literals
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/adaptors/test_finally.cpp b/test/stdexec/algos/adaptors/test_finally.cpp
index 05b67bf45..b4be2ff88 100644
--- a/test/stdexec/algos/adaptors/test_finally.cpp
+++ b/test/stdexec/algos/adaptors/test_finally.cpp
@@ -13,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include "exec/finally.hpp"
 #include "test_common/type_helpers.hpp"
 
-#include <test_common/catch2.hpp>
-
 using namespace STDEXEC;
 
 namespace
diff --git a/test/stdexec/algos/adaptors/test_into_variant.cpp b/test/stdexec/algos/adaptors/test_into_variant.cpp
index 4357d68b3..197fa586b 100644
--- a/test/stdexec/algos/adaptors/test_into_variant.cpp
+++ b/test/stdexec/algos/adaptors/test_into_variant.cpp
@@ -13,15 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <numbers>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/senders.hpp>
 #include <test_common/type_helpers.hpp>
 
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <numbers>
+#endif
+
 namespace ex = STDEXEC;
 
 namespace
diff --git a/test/stdexec/algos/adaptors/test_let_error.cpp b/test/stdexec/algos/adaptors/test_let_error.cpp
index 9f3b5ba70..0375004f3 100644
--- a/test/stdexec/algos/adaptors/test_let_error.cpp
+++ b/test/stdexec/algos/adaptors/test_let_error.cpp
@@ -13,20 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include <exec/env.hpp>
 #include <exec/sender_for.hpp>
 #include <exec/split.hpp>
 #include <exec/start_detached.hpp>
 #include <exec/static_thread_pool.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/senders.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono>  // IWYU pragma: keep for chrono_literals
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <chrono>  // IWYU pragma: keep for chrono_literals
+#endif
 
 namespace ex = STDEXEC;
 
@@ -138,71 +143,84 @@ namespace
     auto op = ex::connect(std::move(snd), expect_error_receiver{13});
     ex::start(op);
   }
-#endif // !STDEXEC_NO_STDCPP_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STDCPP_EXCEPTIONS()
 
-  TEST_CASE("let_error can be used with just_stopped", "[adaptors][let_error]") {
+  TEST_CASE("let_error can be used with just_stopped", "[adaptors][let_error]")
+  {
     ex::sender auto snd = ex::just_stopped()
                         | ex::let_error([](std::exception_ptr) { return ex::just(17); });
     auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("let_error function is not called on regular flow", "[adaptors][let_error]") {
-    bool called{false};
+  TEST_CASE("let_error function is not called on regular flow", "[adaptors][let_error]")
+  {
+    bool            called{false};
     error_scheduler sched;
     ex::sender auto snd = ex::just() | ex::then([] { return 13; })
-                        | ex::let_error([&](std::exception_ptr) {
-                            called = true;
-                            return ex::just(0);
-                          });
+                        | ex::let_error(
+                            [&](std::exception_ptr)
+                            {
+                              called = true;
+                              return ex::just(0);
+                            });
     auto op = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     CHECK_FALSE(called);
   }
 
-  TEST_CASE("let_error function is not called when cancelled", "[adaptors][let_error]") {
-    bool called{false};
+  TEST_CASE("let_error function is not called when cancelled", "[adaptors][let_error]")
+  {
+    bool              called{false};
     stopped_scheduler sched;
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::let_error([&](std::exception_ptr) {
-                            called = true;
-                            return ex::just(0);
-                          });
+    ex::sender auto   snd = ex::just(13) | ex::continues_on(sched)
+                        | ex::let_error(
+                            [&](std::exception_ptr)
+                            {
+                              called = true;
+                              return ex::just(0);
+                            });
     auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
     CHECK_FALSE(called);
   }
 
   // Type that sets into a received boolean when the dtor is called
-  struct my_type {
+  struct my_type
+  {
     bool* p_called_{nullptr};
 
     explicit my_type(bool* p_called)
-      : p_called_(p_called) {
-    }
+      : p_called_(p_called)
+    {}
 
     my_type(my_type&& rhs)
-      : p_called_(rhs.p_called_) {
+      : p_called_(rhs.p_called_)
+    {
       rhs.p_called_ = nullptr;
     }
 
-    auto operator=(my_type&& rhs) -> my_type& {
+    auto operator=(my_type&& rhs) -> my_type&
+    {
       if (p_called_)
         *p_called_ = true;
-      p_called_ = rhs.p_called_;
+      p_called_     = rhs.p_called_;
       rhs.p_called_ = nullptr;
       return *this;
     }
 
-    ~my_type() {
+    ~my_type()
+    {
       if (p_called_)
         *p_called_ = true;
     }
   };
 
-  TEST_CASE("let_error of just_error with custom type", "[adaptors][let_error]") {
-    bool param_destructed{false};
+  TEST_CASE("let_error of just_error with custom type", "[adaptors][let_error]")
+  {
+    bool            param_destructed{false};
     ex::sender auto snd = ex::just_error(my_type(&param_destructed))
-                        | ex::let_error([&](const my_type&) { return ex::just(13); });
+                        | ex::let_error([&](my_type const &) { return ex::just(13); });
 
     {
       auto op = ex::connect(std::move(snd), expect_value_receiver{13});
@@ -214,20 +232,23 @@ namespace
     CHECK(param_destructed);
   }
 
-  TEST_CASE(
-    "let_error exposes a parameter that is destructed when the main operation is destructed ",
-    "[adaptors][let_error]") {
-    bool param_destructed{false};
-    bool fun_called{false};
+  TEST_CASE("let_error exposes a parameter that is destructed when the main operation is "
+            "destructed ",
+            "[adaptors][let_error]")
+  {
+    bool              param_destructed{false};
+    bool              fun_called{false};
     impulse_scheduler sched;
 
-    ex::sender auto s1 = ex::just_error(my_type(&param_destructed));
+    ex::sender auto s1  = ex::just_error(my_type(&param_destructed));
     ex::sender auto snd = ex::just_error(my_type(&param_destructed))
-                        | ex::let_error([&](const my_type&) {
-                            CHECK_FALSE(param_destructed);
-                            fun_called = true;
-                            return ex::just(13) | ex::continues_on(sched);
-                          });
+                        | ex::let_error(
+                            [&](my_type const &)
+                            {
+                              CHECK_FALSE(param_destructed);
+                              fun_called = true;
+                              return ex::just(13) | ex::continues_on(sched);
+                            });
     int res{0};
     {
       auto op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
@@ -250,27 +271,34 @@ namespace
     CHECK(res == 13);
   }
 
-  struct int_err_transform {
-    auto operator()(std::exception_ptr ep) const -> fallible_just<int> {
+  struct int_err_transform
+  {
+    auto operator()(std::exception_ptr ep) const -> fallible_just<int>
+    {
       std::rethrow_exception(ep);
       return fallible_just{0};
     }
 
-    auto operator()(int x) const -> fallible_just<int> {
+    auto operator()(int x) const -> fallible_just<int>
+    {
       return fallible_just{x * 2 - 1};
     }
   };
 
-  TEST_CASE("let_error works when changing threads", "[adaptors][let_error]") {
+  TEST_CASE("let_error works when changing threads", "[adaptors][let_error]")
+  {
     exec::static_thread_pool pool{2};
-    std::atomic<bool> called{false};
+    std::atomic<bool>        called{false};
     {
       // lunch some work on the thread pool
       ex::sender auto snd = ex::starts_on(pool.get_scheduler(), ex::just_error(7))
-                          | ex::let_error(int_err_transform{}) | ex::then([&](auto x) -> void {
-                              CHECK(x == 13);
-                              called.store(true);
-                            });
+                          | ex::let_error(int_err_transform{})
+                          | ex::then(
+                              [&](auto x) -> void
+                              {
+                                CHECK(x == 13);
+                                called.store(true);
+                              });
       exec::start_detached(std::move(snd));
     }
     // wait for the work to be executed, with timeout
@@ -282,9 +310,9 @@ namespace
     REQUIRE(called);
   }
 
-  TEST_CASE(
-    "let_error has the values_type from the input sender if returning error",
-    "[adaptors][let_error]") {
+  TEST_CASE("let_error has the values_type from the input sender if returning error",
+            "[adaptors][let_error]")
+  {
     check_val_types<ex::__mset<pack<int>>>(
       fallible_just{7} | ex::let_error([](std::exception_ptr) { return ex::just_error(0); }));
     check_val_types<ex::__mset<pack<double>>>(
@@ -294,9 +322,9 @@ namespace
       | ex::let_error([](std::exception_ptr) { return ex::just_error(0); }));
   }
 
-  TEST_CASE(
-    "let_error adds to values_type the value types of the returned sender",
-    "[adaptors][let_error]") {
+  TEST_CASE("let_error adds to values_type the value types of the returned sender",
+            "[adaptors][let_error]")
+  {
     check_val_types<ex::__mset<pack<int>>>(
       fallible_just{1} | ex::let_error([](std::exception_ptr) { return ex::just(11); }));
     check_val_types<ex::__mset<pack<int>, pack<double>>>(
@@ -306,57 +334,62 @@ namespace
       | ex::let_error([](std::exception_ptr) { return ex::just(std::string{"hello"}); }));
   }
 
-  TEST_CASE(
-    "let_error overrides error_types from input sender (and adds std::exception_ptr)",
-    "[adaptors][let_error]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("let_error overrides error_types from input sender (and adds std::exception_ptr)",
+            "[adaptors][let_error]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
     // Returning ex::just_error
-    check_err_types<ex::__mset<>>(ex::just() | ex::continues_on(sched1) | ex::let_error([](std::exception_ptr) {
-                                    return ex::just_error(std::string{"err"});
-                                  }));
+    check_err_types<ex::__mset<>>(
+      ex::just() | ex::continues_on(sched1)
+      | ex::let_error([](std::exception_ptr) { return ex::just_error(std::string{"err"}); }));
     check_err_types<ex::__mset<std::exception_ptr, std::string>>(
       ex::just() | ex::continues_on(sched2)
       | ex::let_error([](std::exception_ptr) { return ex::just_error(std::string{"err"}); }));
     check_err_types<ex::__mset<std::exception_ptr, std::string>>(
-      ex::just() | ex::continues_on(sched3) | ex::let_error([](ex::__one_of<int, std::exception_ptr> auto) {
-        return ex::just_error(std::string{"err"});
-      }));
+      ex::just() | ex::continues_on(sched3)
+      | ex::let_error([](ex::__one_of<int, std::exception_ptr> auto)
+                      { return ex::just_error(std::string{"err"}); }));
 
     // Returning ex::just
-    check_err_types<ex::__mset<>>(
-      ex::just() | ex::continues_on(sched1) | ex::let_error([](std::exception_ptr) { return ex::just(); }));
+    check_err_types<ex::__mset<>>(ex::just() | ex::continues_on(sched1)
+                                  | ex::let_error([](std::exception_ptr) { return ex::just(); }));
     check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just() | ex::continues_on(sched2) | ex::let_error([](std::exception_ptr) { return ex::just(); }));
+      ex::just() | ex::continues_on(sched2)
+      | ex::let_error([](std::exception_ptr) { return ex::just(); }));
     check_err_types<ex::__mset<std::exception_ptr>>(
       ex::just() | ex::continues_on(sched3)
       | ex::let_error([](ex::__one_of<int, std::exception_ptr> auto) { return ex::just(); }));
   }
 
-  TEST_CASE("let_error keeps sends_stopped from input sender", "[adaptors][let_error]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("let_error keeps sends_stopped from input sender", "[adaptors][let_error]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
-    check_sends_stopped<false>(
-      ex::just() | ex::continues_on(sched1) | ex::let_error([](std::exception_ptr) { return ex::just(); }));
-    check_sends_stopped<true>(
-      ex::just() | ex::continues_on(sched2) | ex::let_error([](std::exception_ptr) { return ex::just(); }));
-    check_sends_stopped<true>(
-      ex::just() | ex::continues_on(sched3) | ex::let_error([](std::exception_ptr) { return ex::just(); }));
+    check_sends_stopped<false>(ex::just() | ex::continues_on(sched1)
+                               | ex::let_error([](std::exception_ptr) { return ex::just(); }));
+    check_sends_stopped<true>(ex::just() | ex::continues_on(sched2)
+                              | ex::let_error([](std::exception_ptr) { return ex::just(); }));
+    check_sends_stopped<true>(ex::just() | ex::continues_on(sched3)
+                              | ex::let_error([](std::exception_ptr) { return ex::just(); }));
   }
 
   // Return a different sender when we invoke this custom defined let_error implementation
-  struct let_error_test_domain {
+  struct let_error_test_domain
+  {
     template <exec::sender_for<ex::let_error_t> Sender>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&&, auto&&...) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender&&, auto&&...)
+    {
       return ex::just(std::string{"what error?"});
     }
   };
 
-  TEST_CASE("let_error can be customized", "[adaptors][let_error]") {
+  TEST_CASE("let_error can be customized", "[adaptors][let_error]")
+  {
     basic_inline_scheduler<let_error_test_domain> sched{};
 
     // The customization will return a different value
@@ -364,4 +397,4 @@ namespace
              | ex::let_error([](std::exception_ptr) { return ex::just(std::string{"err"}); });
     wait_for_value(ex::starts_on(sched, std::move(snd)), std::string{"what error?"});
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_let_stopped.cpp b/test/stdexec/algos/adaptors/test_let_stopped.cpp
index c143604bb..f2c3ca465 100644
--- a/test/stdexec/algos/adaptors/test_let_stopped.cpp
+++ b/test/stdexec/algos/adaptors/test_let_stopped.cpp
@@ -13,17 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
-#include "stdexec/__detail/__sender_introspection.hpp"
 #include <exec/env.hpp>
 #include <exec/sender_for.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono>  // IWYU pragma: keep for chrono_literals
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <chrono>  // IWYU pragma: keep for chrono_literals
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/adaptors/test_let_value.cpp b/test/stdexec/algos/adaptors/test_let_value.cpp
index 939e550d3..d1a009490 100644
--- a/test/stdexec/algos/adaptors/test_let_value.cpp
+++ b/test/stdexec/algos/adaptors/test_let_value.cpp
@@ -13,21 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
-#include "stdexec/__detail/__let.hpp"
 #include <exec/env.hpp>
 #include <exec/sender_for.hpp>
 #include <exec/start_detached.hpp>
 #include <exec/static_thread_pool.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono>  // IWYU pragma: keep for chrono_literals
-#include <exception>
-#include <memory>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <chrono>  // IWYU pragma: keep for chrono_literals
+#  include <exception>
+#  include <memory>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/adaptors/test_on.cpp b/test/stdexec/algos/adaptors/test_on.cpp
index 6300b09cd..8d0f6ac7e 100644
--- a/test/stdexec/algos/adaptors/test_on.cpp
+++ b/test/stdexec/algos/adaptors/test_on.cpp
@@ -14,10 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <exec/static_thread_pool.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#include <exec/static_thread_pool.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 
diff --git a/test/stdexec/algos/adaptors/test_on2.cpp b/test/stdexec/algos/adaptors/test_on2.cpp
index 9a9a721b8..c28491ebb 100644
--- a/test/stdexec/algos/adaptors/test_on2.cpp
+++ b/test/stdexec/algos/adaptors/test_on2.cpp
@@ -14,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 
diff --git a/test/stdexec/algos/adaptors/test_on3.cpp b/test/stdexec/algos/adaptors/test_on3.cpp
index a4f417afe..65234ac5b 100644
--- a/test/stdexec/algos/adaptors/test_on3.cpp
+++ b/test/stdexec/algos/adaptors/test_on3.cpp
@@ -14,13 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include <exec/async_scope.hpp>
 #include <exec/ensure_started.hpp>
 #include <exec/split.hpp>
 #include <exec/start_detached.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/schedulers.hpp>
 
 namespace ex = STDEXEC;
diff --git a/test/stdexec/algos/adaptors/test_sequence.cpp b/test/stdexec/algos/adaptors/test_sequence.cpp
index 1373efb85..ca8ad5fc8 100644
--- a/test/stdexec/algos/adaptors/test_sequence.cpp
+++ b/test/stdexec/algos/adaptors/test_sequence.cpp
@@ -13,15 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <exec/sequence.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#include <exec/sequence.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <exception>
-#include <memory>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <exception>
+#  include <memory>
+#endif
 
 namespace
 {
diff --git a/test/stdexec/algos/adaptors/test_spawn_future.cpp b/test/stdexec/algos/adaptors/test_spawn_future.cpp
index d44931853..a6bb639e6 100644
--- a/test/stdexec/algos/adaptors/test_spawn_future.cpp
+++ b/test/stdexec/algos/adaptors/test_spawn_future.cpp
@@ -14,18 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <exec/static_thread_pool.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#include <exec/static_thread_pool.hpp>
 #include <test_common/scope_helpers.hpp>
 #include <test_common/scope_tokens.hpp>
 
-#include <array>
-#include <atomic>
-#include <optional>
-#include <string>
-#include <thread>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <array>
+#  include <atomic>
+#  include <optional>
+#  include <string>
+#  include <thread>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/adaptors/test_starts_on.cpp b/test/stdexec/algos/adaptors/test_starts_on.cpp
index 1fc8714e8..434413591 100644
--- a/test/stdexec/algos/adaptors/test_starts_on.cpp
+++ b/test/stdexec/algos/adaptors/test_starts_on.cpp
@@ -13,17 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include <exec/sender_for.hpp>
 #include <exec/start_detached.hpp>
 #include <exec/static_thread_pool.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono>  // IWYU pragma: keep for std::chrono_literals
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <chrono>  // IWYU pragma: keep for std::chrono_literals
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/adaptors/test_stop_when.cpp b/test/stdexec/algos/adaptors/test_stop_when.cpp
index f1e43f068..bdf0819b5 100644
--- a/test/stdexec/algos/adaptors/test_stop_when.cpp
+++ b/test/stdexec/algos/adaptors/test_stop_when.cpp
@@ -14,11 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <stdexec/__detail/__stop_when.hpp>
 #include <stdexec/execution.hpp>
-#include <stdexec/stop_token.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 
 namespace ex = STDEXEC;
@@ -69,6 +68,8 @@ namespace
     wait_for_value(ex::__stop_when(isTokenStoppable(), source.get_token()), true);
   }
 
+#if !STDEXEC_USE_MODULES()
+  // TODO: figure out why this fails in a modules build
   TEST_CASE("stop-when fuses its token with the receiver's when both are stoppable",
             "[adaptors][stop-when]")
   {
@@ -77,6 +78,7 @@ namespace
                                    source.get_token()),
                    true);
   }
+#endif
 
   template <std::invocable Fn>
   ex::sender auto make_stop_callback(Fn&& fn) noexcept
@@ -90,6 +92,8 @@ namespace
              });
   }
 
+#if !STDEXEC_USE_MODULES()
+  // TODO: figure out why this fails in a modules build
   TEST_CASE("callbacks registered with stop-when's token can be invoked", "[adaptors][stop-when]")
   {
     int  invokeCount = 0;
@@ -139,4 +143,5 @@ namespace
                      2);
     }
   }
+#endif
 }  // namespace
diff --git a/test/stdexec/algos/adaptors/test_stopped_as_error.cpp b/test/stdexec/algos/adaptors/test_stopped_as_error.cpp
index 6281f87a1..c056d8125 100644
--- a/test/stdexec/algos/adaptors/test_stopped_as_error.cpp
+++ b/test/stdexec/algos/adaptors/test_stopped_as_error.cpp
@@ -13,14 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <numbers>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <numbers>
+#endif
+
 namespace ex = STDEXEC;
 
 namespace
diff --git a/test/stdexec/algos/adaptors/test_stopped_as_optional.cpp b/test/stdexec/algos/adaptors/test_stopped_as_optional.cpp
index 4f7df75a7..5024f7d6e 100644
--- a/test/stdexec/algos/adaptors/test_stopped_as_optional.cpp
+++ b/test/stdexec/algos/adaptors/test_stopped_as_optional.cpp
@@ -13,15 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <numbers>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/senders.hpp>
 #include <test_common/type_helpers.hpp>
 
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <numbers>
+#endif
+
 namespace ex = STDEXEC;
 
 namespace
diff --git a/test/stdexec/algos/adaptors/test_then.cpp b/test/stdexec/algos/adaptors/test_then.cpp
index 596f7a6ad..4c6cc0235 100644
--- a/test/stdexec/algos/adaptors/test_then.cpp
+++ b/test/stdexec/algos/adaptors/test_then.cpp
@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <exec/sender_for.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#include <exec/sender_for.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/senders.hpp>
diff --git a/test/stdexec/algos/adaptors/test_transfer_when_all.cpp b/test/stdexec/algos/adaptors/test_transfer_when_all.cpp
index 3c07c1a5d..eeb775e41 100644
--- a/test/stdexec/algos/adaptors/test_transfer_when_all.cpp
+++ b/test/stdexec/algos/adaptors/test_transfer_when_all.cpp
@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <exec/sender_for.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#include <exec/sender_for.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
diff --git a/test/stdexec/algos/adaptors/test_upon_error.cpp b/test/stdexec/algos/adaptors/test_upon_error.cpp
index 7fa5287e3..9dab98d8f 100644
--- a/test/stdexec/algos/adaptors/test_upon_error.cpp
+++ b/test/stdexec/algos/adaptors/test_upon_error.cpp
@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
diff --git a/test/stdexec/algos/adaptors/test_upon_stopped.cpp b/test/stdexec/algos/adaptors/test_upon_stopped.cpp
index 4adc4f971..2aad13e4c 100644
--- a/test/stdexec/algos/adaptors/test_upon_stopped.cpp
+++ b/test/stdexec/algos/adaptors/test_upon_stopped.cpp
@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
diff --git a/test/stdexec/algos/adaptors/test_when_all.cpp b/test/stdexec/algos/adaptors/test_when_all.cpp
index 202d0a702..9224ea761 100644
--- a/test/stdexec/algos/adaptors/test_when_all.cpp
+++ b/test/stdexec/algos/adaptors/test_when_all.cpp
@@ -13,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include <exec/any_sender_of.hpp>
 #include <exec/async_scope.hpp>
 #include <exec/env.hpp>
 #include <exec/sender_for.hpp>
 #include <exec/split.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/senders.hpp>
diff --git a/test/stdexec/algos/adaptors/test_write_env.cpp b/test/stdexec/algos/adaptors/test_write_env.cpp
index 81a22e9fd..19cf9d2dd 100644
--- a/test/stdexec/algos/adaptors/test_write_env.cpp
+++ b/test/stdexec/algos/adaptors/test_write_env.cpp
@@ -16,16 +16,21 @@
  * limitations under the License.
  */
 
-#include <test_common/catch2.hpp>
+#include <catch2/catch_all.hpp>
 
-#include <type_traits>
-#include <utility>
+#include <stdexec/execution.hpp>
 
 #include <exec/completion_signatures.hpp>
 #include <exec/single_thread_context.hpp>
-#include <stdexec/execution.hpp>
 #include <test_common/receivers.hpp>
 
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <type_traits>
+#  include <utility>
+#endif
+
 namespace
 {
 
diff --git a/test/stdexec/algos/consumers/test_spawn.cpp b/test/stdexec/algos/consumers/test_spawn.cpp
index c919a73c1..364ff8827 100644
--- a/test/stdexec/algos/consumers/test_spawn.cpp
+++ b/test/stdexec/algos/consumers/test_spawn.cpp
@@ -14,15 +14,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/scope_helpers.hpp>
 #include <test_common/scope_tokens.hpp>
 
-#include <array>
-#include <memory_resource>
-#include <stdexcept>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <array>
+#  include <memory_resource>
+#  include <stdexcept>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/consumers/test_sync_wait.cpp b/test/stdexec/algos/consumers/test_sync_wait.cpp
index eddfa7713..b18f87fe8 100644
--- a/test/stdexec/algos/consumers/test_sync_wait.cpp
+++ b/test/stdexec/algos/consumers/test_sync_wait.cpp
@@ -13,18 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include <exec/env.hpp>
 #include <exec/static_thread_pool.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/senders.hpp>
 #include <test_common/tuple.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <thread>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <thread>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/factories/test_just.cpp b/test/stdexec/algos/factories/test_just.cpp
index 8eb1ad5b1..26dc3ab5d 100644
--- a/test/stdexec/algos/factories/test_just.cpp
+++ b/test/stdexec/algos/factories/test_just.cpp
@@ -13,17 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <exec/completion_behavior.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <cstddef>
-#include <stdexcept>
-#include <utility>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <cstddef>
+#  include <stdexcept>
+#  include <utility>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/factories/test_just_error.cpp b/test/stdexec/algos/factories/test_just_error.cpp
index 52c3db2b2..9c78ecbe3 100644
--- a/test/stdexec/algos/factories/test_just_error.cpp
+++ b/test/stdexec/algos/factories/test_just_error.cpp
@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/type_helpers.hpp>
 
diff --git a/test/stdexec/algos/factories/test_just_stopped.cpp b/test/stdexec/algos/factories/test_just_stopped.cpp
index 94c1d57f9..226109045 100644
--- a/test/stdexec/algos/factories/test_just_stopped.cpp
+++ b/test/stdexec/algos/factories/test_just_stopped.cpp
@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/type_helpers.hpp>
 
diff --git a/test/stdexec/algos/factories/test_read.cpp b/test/stdexec/algos/factories/test_read.cpp
index e5126e423..b5171794b 100644
--- a/test/stdexec/algos/factories/test_read.cpp
+++ b/test/stdexec/algos/factories/test_read.cpp
@@ -11,12 +11,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/type_helpers.hpp>
 
-#include <memory>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <memory>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/factories/test_schedule.cpp b/test/stdexec/algos/factories/test_schedule.cpp
index 3e9f640a2..d39375280 100644
--- a/test/stdexec/algos/factories/test_schedule.cpp
+++ b/test/stdexec/algos/factories/test_schedule.cpp
@@ -11,15 +11,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include "exec/static_thread_pool.hpp"
-#include "stdexec/__detail/__meta.hpp"
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#include <exec/static_thread_pool.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
-#include <utility>
+
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <utility>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/algos/factories/test_transfer_just.cpp b/test/stdexec/algos/factories/test_transfer_just.cpp
index 6eb84433f..39d05afb7 100644
--- a/test/stdexec/algos/factories/test_transfer_just.cpp
+++ b/test/stdexec/algos/factories/test_transfer_just.cpp
@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <exec/sender_for.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#include <exec/sender_for.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
diff --git a/test/stdexec/concepts/test_awaitables.cpp b/test/stdexec/concepts/test_awaitables.cpp
index 2d03a244d..ecf73a633 100644
--- a/test/stdexec/concepts/test_awaitables.cpp
+++ b/test/stdexec/concepts/test_awaitables.cpp
@@ -13,13 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 #include <exec/static_thread_pool.hpp>
-#include <stdexec/coroutine.hpp>
-
 #include <test_common/type_helpers.hpp>
 
 #if !STDEXEC_NO_STDCPP_COROUTINES()
diff --git a/test/stdexec/concepts/test_concept_operation_state.cpp b/test/stdexec/concepts/test_concept_operation_state.cpp
index 47b85b1fd..76456a30c 100644
--- a/test/stdexec/concepts/test_concept_operation_state.cpp
+++ b/test/stdexec/concepts/test_concept_operation_state.cpp
@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/concepts/test_concept_scheduler.cpp b/test/stdexec/concepts/test_concept_scheduler.cpp
index 376284ff1..7aa681348 100644
--- a/test/stdexec/concepts/test_concept_scheduler.cpp
+++ b/test/stdexec/concepts/test_concept_scheduler.cpp
@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 namespace ex = STDEXEC;
 
@@ -160,4 +160,4 @@ namespace
   }
 }  // namespace
 
-STDEXEC_PRAGMA_POP()
\ No newline at end of file
+STDEXEC_PRAGMA_POP()
diff --git a/test/stdexec/concepts/test_concepts_receiver.cpp b/test/stdexec/concepts/test_concepts_receiver.cpp
index 58e364fa3..b6f06ed23 100644
--- a/test/stdexec/concepts/test_concepts_receiver.cpp
+++ b/test/stdexec/concepts/test_concepts_receiver.cpp
@@ -13,9 +13,10 @@
 //  * See the License for the specific language governing permissions and
 //  * limitations under the License.
 //  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 
 namespace ex = STDEXEC;
diff --git a/test/stdexec/concepts/test_concepts_scope_association.cpp b/test/stdexec/concepts/test_concepts_scope_association.cpp
index 295b1df11..5a4cd4f58 100644
--- a/test/stdexec/concepts/test_concepts_scope_association.cpp
+++ b/test/stdexec/concepts/test_concepts_scope_association.cpp
@@ -14,9 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/concepts/test_concepts_scope_token.cpp b/test/stdexec/concepts/test_concepts_scope_token.cpp
index 562d16de2..539ce8f8b 100644
--- a/test/stdexec/concepts/test_concepts_scope_token.cpp
+++ b/test/stdexec/concepts/test_concepts_scope_token.cpp
@@ -14,9 +14,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <utility>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/concepts/test_concepts_sender.cpp b/test/stdexec/concepts/test_concepts_sender.cpp
index 85416efb9..b9b6005c8 100644
--- a/test/stdexec/concepts/test_concepts_sender.cpp
+++ b/test/stdexec/concepts/test_concepts_sender.cpp
@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/receivers.hpp>
 #include <test_common/type_helpers.hpp>
 
@@ -84,6 +85,7 @@ namespace
 
   TEST_CASE("Sender concept accepts awaiters and awaitables", "[concepts][sender]")
   {
+    // TODO: I don't know why these fail when modules are enabled
     STATIC_REQUIRE(ex::sender<an_awaiter>);
     STATIC_REQUIRE(ex::sender<an_awaitable>);
     STATIC_REQUIRE(ex::sender<has_as_awaitable>);
diff --git a/test/stdexec/concepts/test_concepts_stop_tokens.cpp b/test/stdexec/concepts/test_concepts_stop_tokens.cpp
index 4bb159a14..203b6a7bc 100644
--- a/test/stdexec/concepts/test_concepts_stop_tokens.cpp
+++ b/test/stdexec/concepts/test_concepts_stop_tokens.cpp
@@ -15,10 +15,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
 
-#include <type_traits>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <type_traits>
+#endif
 
 namespace
 {
@@ -28,17 +33,21 @@ namespace
     void operator()() && noexcept {}
   };
 
-  static_assert(::STDEXEC::stoppable_token<::STDEXEC::never_stop_token>);
-  static_assert(::STDEXEC::unstoppable_token<::STDEXEC::never_stop_token>);
-  static_assert(::STDEXEC::stoppable_token<::STDEXEC::inplace_stop_token>);
-  static_assert(!::STDEXEC::unstoppable_token<::STDEXEC::inplace_stop_token>);
-  static_assert(
-    std::is_same_v<::STDEXEC::stop_callback_for_t<::STDEXEC::never_stop_token, on_stop_request>,
-                   ::STDEXEC::never_stop_token::callback_type<on_stop_request>>);
+  TEST_CASE("(un)stoppable_token correctly categorizes various standard stop token types",
+            "[concepts]")
+  {
+    STATIC_REQUIRE(::STDEXEC::stoppable_token<::STDEXEC::never_stop_token>);
+    STATIC_REQUIRE(::STDEXEC::unstoppable_token<::STDEXEC::never_stop_token>);
+    STATIC_REQUIRE(::STDEXEC::stoppable_token<::STDEXEC::inplace_stop_token>);
+    STATIC_REQUIRE(!::STDEXEC::unstoppable_token<::STDEXEC::inplace_stop_token>);
+    STATIC_REQUIRE(
+      std::is_same_v<::STDEXEC::stop_callback_for_t<::STDEXEC::never_stop_token, on_stop_request>,
+                     ::STDEXEC::never_stop_token::callback_type<on_stop_request>>);
 
 #if defined(__cpp_lib_jthread) && __cpp_lib_jthread >= 201911L
-  static_assert(::STDEXEC::stoppable_token<std::stop_token>);
-  static_assert(std::is_same_v<::STDEXEC::stop_callback_for_t<std::stop_token, on_stop_request>,
-                               std::stop_callback<on_stop_request>>);
+    STATIC_REQUIRE(::STDEXEC::stoppable_token<std::stop_token>);
+    STATIC_REQUIRE(std::is_same_v<::STDEXEC::stop_callback_for_t<std::stop_token, on_stop_request>,
+                                  std::stop_callback<on_stop_request>>);
 #endif
+  }
 }  // namespace
diff --git a/test/stdexec/cpos/test_cpo_bulk.cpp b/test/stdexec/cpos/test_cpo_bulk.cpp
index b834ee47f..3824cc749 100644
--- a/test/stdexec/cpos/test_cpo_bulk.cpp
+++ b/test/stdexec/cpos/test_cpo_bulk.cpp
@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include "cpo_helpers.cuh"
 #include "test_common/receivers.hpp"
-#include <test_common/catch2.hpp>
 
 namespace
 {
diff --git a/test/stdexec/cpos/test_cpo_connect.cpp b/test/stdexec/cpos/test_cpo_connect.cpp
index 1fd17820c..0fddad484 100644
--- a/test/stdexec/cpos/test_cpo_connect.cpp
+++ b/test/stdexec/cpos/test_cpo_connect.cpp
@@ -13,11 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include "test_common/receivers.hpp"
 #include "test_common/type_helpers.hpp"
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/cpos/test_cpo_connect_awaitable.cpp b/test/stdexec/cpos/test_cpo_connect_awaitable.cpp
index 3fc7b5646..491d56e21 100644
--- a/test/stdexec/cpos/test_cpo_connect_awaitable.cpp
+++ b/test/stdexec/cpos/test_cpo_connect_awaitable.cpp
@@ -14,17 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
 #include <stdexec/coroutine.hpp>
 
 #if !STDEXEC_NO_STDCPP_COROUTINES()
 
+#  include <stdexec/execution.hpp>
+
 #  include "test_common/receivers.hpp"
 #  include "test_common/type_helpers.hpp"
-#  include <stdexec/execution.hpp>
-#  include <test_common/catch2.hpp>
 
-#  include <stdexcept>
-#  include <type_traits>
+#  if STDEXEC_USE_MODULES()
+import std;
+#  else
+#    include <stdexcept>
+#    include <type_traits>
+#  endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/cpos/test_cpo_receiver.cpp b/test/stdexec/cpos/test_cpo_receiver.cpp
index 952bea829..96267e389 100644
--- a/test/stdexec/cpos/test_cpo_receiver.cpp
+++ b/test/stdexec/cpos/test_cpo_receiver.cpp
@@ -13,13 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include "test_common/receivers.hpp"
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
-#include <climits>
-#include <string>
+#include "test_common/receivers.hpp"
+
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <climits>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/cpos/test_cpo_schedule.cpp b/test/stdexec/cpos/test_cpo_schedule.cpp
index 85db2acbd..34431ac1a 100644
--- a/test/stdexec/cpos/test_cpo_schedule.cpp
+++ b/test/stdexec/cpos/test_cpo_schedule.cpp
@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/type_helpers.hpp>
 
 namespace ex = STDEXEC;
diff --git a/test/stdexec/cpos/test_cpo_start.cpp b/test/stdexec/cpos/test_cpo_start.cpp
index 7b667a956..5fe412d31 100644
--- a/test/stdexec/cpos/test_cpo_start.cpp
+++ b/test/stdexec/cpos/test_cpo_start.cpp
@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/type_helpers.hpp>
 
 namespace ex = STDEXEC;
diff --git a/test/stdexec/cpos/test_cpo_upon_error.cpp b/test/stdexec/cpos/test_cpo_upon_error.cpp
index 493dbd5b8..0f7f024ce 100644
--- a/test/stdexec/cpos/test_cpo_upon_error.cpp
+++ b/test/stdexec/cpos/test_cpo_upon_error.cpp
@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include "cpo_helpers.cuh"
 #include "test_common/receivers.hpp"
-#include <test_common/catch2.hpp>
 
 namespace
 {
diff --git a/test/stdexec/cpos/test_cpo_upon_stopped.cpp b/test/stdexec/cpos/test_cpo_upon_stopped.cpp
index 1a8eb3a26..57f279291 100644
--- a/test/stdexec/cpos/test_cpo_upon_stopped.cpp
+++ b/test/stdexec/cpos/test_cpo_upon_stopped.cpp
@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include "cpo_helpers.cuh"
 #include "test_common/receivers.hpp"
-#include <test_common/catch2.hpp>
 
 namespace
 {
diff --git a/test/stdexec/detail/test_any.cpp b/test/stdexec/detail/test_any.cpp
index 4a7399486..1d4caaa86 100644
--- a/test/stdexec/detail/test_any.cpp
+++ b/test/stdexec/detail/test_any.cpp
@@ -13,12 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>  // IWYU pragma: keep
 
-#include <stdexec/__detail/__any.hpp>
+#include <stdexec/__detail/__config.hpp>
 
-#include <cstdio>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <stdexec/__detail/__any.hpp>
 
-#include <test_common/catch2.hpp>  // IWYU pragma: keep
+#  include <cstdio>
+#endif
 
 // NOLINTBEGIN(modernize-use-override)
 STDEXEC_PRAGMA_PUSH()
diff --git a/test/stdexec/detail/test_common_domain.cpp b/test/stdexec/detail/test_common_domain.cpp
index c03cacf48..aa3328151 100644
--- a/test/stdexec/detail/test_common_domain.cpp
+++ b/test/stdexec/detail/test_common_domain.cpp
@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 #include <test_common/receivers.hpp>
 
diff --git a/test/stdexec/detail/test_completion_signatures.cpp b/test/stdexec/detail/test_completion_signatures.cpp
index f1bb9372d..16b1654dc 100644
--- a/test/stdexec/detail/test_completion_signatures.cpp
+++ b/test/stdexec/detail/test_completion_signatures.cpp
@@ -13,10 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/schedulers.hpp>
+
 namespace ex = STDEXEC;
 
 using namespace std;
diff --git a/test/stdexec/detail/test_demangle.cpp b/test/stdexec/detail/test_demangle.cpp
index 743af46ae..6b1fa0a38 100644
--- a/test/stdexec/detail/test_demangle.cpp
+++ b/test/stdexec/detail/test_demangle.cpp
@@ -1,5 +1,21 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+#include <catch2/catch_all.hpp>
+
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 #include <test_common/receivers.hpp>
 
diff --git a/test/stdexec/detail/test_intrusive_mpsc_queue.cpp b/test/stdexec/detail/test_intrusive_mpsc_queue.cpp
index df3bf0e44..b69a6c4e5 100644
--- a/test/stdexec/detail/test_intrusive_mpsc_queue.cpp
+++ b/test/stdexec/detail/test_intrusive_mpsc_queue.cpp
@@ -1,11 +1,33 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/__detail/__config.hpp>
+
 #include <stdexec/__detail/__intrusive_mpsc_queue.hpp>
-#include <test_common/catch2.hpp>
 
-#include <algorithm>
-#include <atomic>
-#include <set>
-#include <thread>
-#include <vector>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <algorithm>
+#  include <atomic>
+#  include <set>
+#  include <thread>
+#  include <vector>
+#endif
 
 namespace
 {
diff --git a/test/stdexec/detail/test_utility.cpp b/test/stdexec/detail/test_utility.cpp
index eed8126a5..a909e983f 100644
--- a/test/stdexec/detail/test_utility.cpp
+++ b/test/stdexec/detail/test_utility.cpp
@@ -13,11 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <stdexec/__detail/__meta.hpp>
-#include <test_common/catch2.hpp>
+#include <stdexec/__detail/__config.hpp>
 
-#include <optional>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <stdexec/__detail/__meta.hpp>
+
+#  include <optional>
+#endif
 
 using namespace std;
 using namespace STDEXEC;
diff --git a/test/stdexec/module/test_module.cpp b/test/stdexec/module/test_module.cpp
deleted file mode 100644
index 63b2c8dd8..000000000
--- a/test/stdexec/module/test_module.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2026 Ian Petersen
- * 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.
- */
-#include <catch2/catch_all.hpp>
-
-import std;
-import stdexec;
-
-namespace ex = stdexec;
-
-namespace
-{
-  TEST_CASE("I can use ex::just in a modules build", "[modules]")
-  {
-    STATIC_REQUIRE(sizeof(ex::just_t) > 0);
-  }
-}  // namespace
diff --git a/test/stdexec/queries/test_env.cpp b/test/stdexec/queries/test_env.cpp
index af37a8192..6b2abfd44 100644
--- a/test/stdexec/queries/test_env.cpp
+++ b/test/stdexec/queries/test_env.cpp
@@ -15,9 +15,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/queries/test_forwarding_queries.cpp b/test/stdexec/queries/test_forwarding_queries.cpp
index 9fa9c2c48..b5e6108ae 100644
--- a/test/stdexec/queries/test_forwarding_queries.cpp
+++ b/test/stdexec/queries/test_forwarding_queries.cpp
@@ -11,9 +11,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity_with_custom_message)
diff --git a/test/stdexec/queries/test_get_completion_behavior.cpp b/test/stdexec/queries/test_get_completion_behavior.cpp
index 0999f3fe5..37ef0adb8 100644
--- a/test/stdexec/queries/test_get_completion_behavior.cpp
+++ b/test/stdexec/queries/test_get_completion_behavior.cpp
@@ -14,9 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 namespace ex = STDEXEC;
 using cb     = ex::__completion_behavior;
diff --git a/test/stdexec/queries/test_get_forward_progress_guarantee.cpp b/test/stdexec/queries/test_get_forward_progress_guarantee.cpp
index 78cbdc461..f9a553ad7 100644
--- a/test/stdexec/queries/test_get_forward_progress_guarantee.cpp
+++ b/test/stdexec/queries/test_get_forward_progress_guarantee.cpp
@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
 #include <test_common/schedulers.hpp>
 
 STDEXEC_PRAGMA_PUSH()
diff --git a/test/stdexec/schedulers/test_parallel_scheduler.cpp b/test/stdexec/schedulers/test_parallel_scheduler.cpp
index 5106278c2..76bf85cc6 100644
--- a/test/stdexec/schedulers/test_parallel_scheduler.cpp
+++ b/test/stdexec/schedulers/test_parallel_scheduler.cpp
@@ -13,23 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-#include <atomic>
-#include <memory>
-#include <stdexcept>
-#include <thread>
+#include <catch2/catch_all.hpp>
 
 #define STDEXEC_PARALLEL_SCHEDULER_HEADER_ONLY 1
-
 #include <stdexec/execution.hpp>
 
 #include <exec/async_scope.hpp>
 #include <exec/inline_scheduler.hpp>
 #include <exec/static_thread_pool.hpp>
-
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <atomic>
+#  include <memory>
+#  include <stdexcept>
+#  include <thread>
+#endif
+
 namespace ex  = STDEXEC;
 namespace scr = ex::parallel_scheduler_replacement;
 
diff --git a/test/stdexec/schedulers/test_parallel_scheduler_replacement.cpp b/test/stdexec/schedulers/test_parallel_scheduler_replacement.cpp
index 8b4aaaaa7..8f4e93793 100644
--- a/test/stdexec/schedulers/test_parallel_scheduler_replacement.cpp
+++ b/test/stdexec/schedulers/test_parallel_scheduler_replacement.cpp
@@ -13,13 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/__detail/__parallel_scheduler.hpp>
 #include <stdexec/__detail/__parallel_scheduler_default_impl.hpp>
 #include <stdexec/execution.hpp>
 
-#include <test_common/catch2.hpp>
-
 #if defined(STDEXEC_PARALLEL_SCHEDULER_HEADER_ONLY)
 #  error This should be testing replacement of the system context with weak linking.
 #endif
diff --git a/test/stdexec/schedulers/test_task_scheduler.cpp b/test/stdexec/schedulers/test_task_scheduler.cpp
index 027738188..65b93e51d 100644
--- a/test/stdexec/schedulers/test_task_scheduler.cpp
+++ b/test/stdexec/schedulers/test_task_scheduler.cpp
@@ -14,11 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/execution.hpp>
 
 #include <exec/sender_for.hpp>
 #include <exec/single_thread_context.hpp>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>
diff --git a/test/stdexec/types/test_counting_scopes.cpp b/test/stdexec/types/test_counting_scopes.cpp
index 07a07da49..2465386cf 100644
--- a/test/stdexec/types/test_counting_scopes.cpp
+++ b/test/stdexec/types/test_counting_scopes.cpp
@@ -14,16 +14,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
-#include <exec/static_thread_pool.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+
+#include <exec/static_thread_pool.hpp>
 #include <test_common/receivers.hpp>
 
-#include <atomic>
-#include <concepts>
-#include <optional>
-#include <type_traits>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <atomic>
+#  include <concepts>
+#  include <optional>
+#  include <type_traits>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/stdexec/types/test_task.cpp b/test/stdexec/types/test_task.cpp
index 5fb0b4e3d..ca70ce890 100644
--- a/test/stdexec/types/test_task.cpp
+++ b/test/stdexec/types/test_task.cpp
@@ -14,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/coroutine.hpp>
 
@@ -25,13 +26,15 @@
 #  include <exec/single_thread_context.hpp>
 #  include <exec/static_thread_pool.hpp>
 
-#  include <atomic>
-
-#  include <test_common/catch2.hpp>
-
 #  include <test_common/allocators.hpp>
 #  include <test_common/senders.hpp>
 
+#  if STDEXEC_USE_MODULES()
+import std;
+#  else
+#    include <atomic>
+#  endif
+
 namespace ex = STDEXEC;
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wmismatched-new-delete")
diff --git a/test/test_common/allocators.hpp b/test/test_common/allocators.hpp
index cb0cea31c..c3d193e9c 100644
--- a/test/test_common/allocators.hpp
+++ b/test/test_common/allocators.hpp
@@ -15,11 +15,17 @@
  */
 
 #pragma once
+#include <catch2/catch_all.hpp>
 
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+#include <stdexec/__detail/__config.hpp>
 
-#include <new>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <new>
+#  include <stdexec/execution.hpp>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/test_common/receivers.hpp b/test/test_common/receivers.hpp
index 89158dcd7..b8e096bc6 100644
--- a/test/test_common/receivers.hpp
+++ b/test/test_common/receivers.hpp
@@ -16,15 +16,24 @@
 
 #pragma once
 
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/__detail/__config.hpp>
+
 #include <test_common/tuple.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <atomic>
-#include <exception>
-#include <tuple>
-#include <typeinfo>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <stdexec/execution.hpp>
+
+#  include <atomic>
+#  include <exception>
+#  include <tuple>
+#  include <typeinfo>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/test_common/require_terminate.hpp b/test/test_common/require_terminate.hpp
index 4e0a3afa7..416a36eef 100644
--- a/test/test_common/require_terminate.hpp
+++ b/test/test_common/require_terminate.hpp
@@ -15,16 +15,22 @@
  */
 #pragma once
 
+#include <catch2/catch_all.hpp>
+
 #if __has_include(<unistd.h>) && __has_include(<sys/wait.h>)
 #  include <sys/wait.h>
 #  include <unistd.h>
 #  define REQUIRE_TERMINATE __require_terminate
 #endif
 
-#include <cstdlib>
-#include <exception>
+#include <stdexec/__detail/__config.hpp>
 
-#include <test_common/catch2.hpp>
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <cstdlib>
+#  include <exception>
+#endif
 
 #ifdef REQUIRE_TERMINATE
 namespace
diff --git a/test/test_common/retry.hpp b/test/test_common/retry.hpp
index 4374f1fa1..9e3add6c4 100644
--- a/test/test_common/retry.hpp
+++ b/test/test_common/retry.hpp
@@ -16,14 +16,21 @@
 
 #pragma once
 
-// Pull in the reference implementation of P2300:
+#include <stdexec/__detail/__config.hpp>
+
 #include <exec/completion_signatures.hpp>
-#include <stdexec/execution.hpp>
 
-#include <concepts>
-#include <exception>
-#include <optional>
-#include <type_traits>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <stdexec/execution.hpp>
+
+#  include <concepts>
+#  include <exception>
+#  include <optional>
+#  include <type_traits>
+#endif
 
 namespace
 {
diff --git a/test/test_common/schedulers.hpp b/test/test_common/schedulers.hpp
index dd44cbf43..ab1ad13f2 100644
--- a/test/test_common/schedulers.hpp
+++ b/test/test_common/schedulers.hpp
@@ -16,16 +16,24 @@
 
 #pragma once
 
-#include <stdexec/execution.hpp>
+#include <stdexec/__detail/__config.hpp>
+
 #include <test_common/type_helpers.hpp>
 
-#include <condition_variable>
-#include <exception>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <utility>
-#include <vector>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <stdexec/execution.hpp>
+
+#  include <condition_variable>
+#  include <exception>
+#  include <functional>
+#  include <memory>
+#  include <mutex>
+#  include <utility>
+#  include <vector>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/test_common/scope_helpers.hpp b/test/test_common/scope_helpers.hpp
index ab87e8e36..d12b43faa 100644
--- a/test/test_common/scope_helpers.hpp
+++ b/test/test_common/scope_helpers.hpp
@@ -14,16 +14,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-#include <stdexec/execution.hpp>
+#include <stdexec/__detail/__config.hpp>
 
 #include "test_common/scope_tokens.hpp"
 
-#include <cstddef>
-#include <cstdint>
-#include <memory_resource>
-#include <type_traits>
-#include <utility>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <stdexec/execution.hpp>
+
+#  include <cstddef>
+#  include <cstdint>
+#  include <memory_resource>
+#  include <type_traits>
+#  include <utility>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/test_common/scope_tokens.hpp b/test/test_common/scope_tokens.hpp
index 1649dd297..1ed9531f1 100644
--- a/test/test_common/scope_tokens.hpp
+++ b/test/test_common/scope_tokens.hpp
@@ -17,9 +17,16 @@
 
 #pragma once
 
-#include <stdexec/execution.hpp>
+#include <stdexec/__detail/__config.hpp>
 
-#include <utility>
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <stdexec/execution.hpp>
+
+#  include <utility>
+#endif
 
 namespace
 {
diff --git a/test/test_common/senders.hpp b/test/test_common/senders.hpp
index 83f068411..abe7bca1a 100644
--- a/test/test_common/senders.hpp
+++ b/test/test_common/senders.hpp
@@ -16,12 +16,21 @@
 
 #pragma once
 
+#include <catch2/catch_all.hpp>
+
+#include <stdexec/__detail/__config.hpp>
+
 #include <exec/completion_behavior.hpp>
-#include <memory>
-#include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/type_helpers.hpp>
 
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <memory>
+#  include <stdexec/execution.hpp>
+#endif
+
 namespace ex = STDEXEC;
 
 namespace
diff --git a/test/test_common/tuple.hpp b/test/test_common/tuple.hpp
index 0be1952e1..d7769b2e4 100644
--- a/test/test_common/tuple.hpp
+++ b/test/test_common/tuple.hpp
@@ -16,9 +16,15 @@
 
 #pragma once
 
-#include <test_common/catch2.hpp>
+#include <catch2/catch_all.hpp>
 
-#include <tuple>
+#include <stdexec/__detail/__config.hpp>
+
+#if STDEXEC_USE_MODULES()
+import std;
+#else
+#  include <tuple>
+#endif
 
 // Workaround for https://github.com/llvm/llvm-project/issues/113087
 #if defined(__clang__) && defined(__cpp_lib_tuple_like)
diff --git a/test/test_common/type_helpers.hpp b/test/test_common/type_helpers.hpp
index 592a677b3..f6b85ce2b 100644
--- a/test/test_common/type_helpers.hpp
+++ b/test/test_common/type_helpers.hpp
@@ -16,7 +16,14 @@
 
 #pragma once
 
-#include <stdexec/execution.hpp>
+#include <stdexec/__detail/__config.hpp>
+
+#if STDEXEC_USE_MODULES()
+import std;
+import stdexec;
+#else
+#  include <stdexec/execution.hpp>
+#endif
 
 namespace ex = STDEXEC;
 
diff --git a/test/test_main.cpp b/test/test_main.cpp
index 51a22506d..f6b8e5fe5 100644
--- a/test/test_main.cpp
+++ b/test/test_main.cpp
@@ -1,2 +1,9 @@
 #define CATCH_CONFIG_MAIN
-#include <test_common/catch2.hpp>
+
+#include <catch2/catch_all.hpp>
+
+#include "stdexec/__detail/__config.hpp"
+
+#if STDEXEC_USE_MODULES()
+import std;
+#endif
diff --git a/test/test_scratch.cpp b/test/test_scratch.cpp
index c7071eefc..bb32a4a08 100644
--- a/test/test_scratch.cpp
+++ b/test/test_scratch.cpp
@@ -14,9 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <catch2/catch_all.hpp>
 
 #include <stdexec/execution.hpp>
-#include <test_common/catch2.hpp>
 #include <test_common/receivers.hpp>
 #include <test_common/schedulers.hpp>