diff --git a/include/fn/detail/functional.hpp b/include/fn/detail/functional.hpp
index c27511a8..294917bd 100644
--- a/include/fn/detail/functional.hpp
+++ b/include/fn/detail/functional.hpp
@@ -19,7 +19,22 @@
 namespace fn::detail {
 
 namespace _fold_detail {
-template <typename L, typename R> [[nodiscard]] constexpr auto _fold(auto &&l, auto &&r)
+// The branch the fold takes is chosen by `if constexpr`, so a single expression cannot state its
+// specification: the two untaken spellings would be ill-formed. Hence one specialization per branch.
+template <typename L, typename R, typename Lv, typename Rv>
+struct _nothrow_fold : ::std::bool_constant<noexcept(::fn::pack<L, R>{::std::declval<Lv>(), ::std::declval<Rv>()})> {};
+template <typename L, typename R, typename Lv, typename Rv>
+  requires _some_pack<L>
+struct _nothrow_fold<L, R, Lv, Rv>
+    : ::std::bool_constant<noexcept(::std::declval<Lv>().append(::std::in_place_type_t<R>{}, ::std::declval<Rv>()))> {};
+template <typename L, typename R, typename Lv, typename Rv>
+  requires(not _some_pack<L>) && _some_pack<R>
+struct _nothrow_fold<L, R, Lv, Rv> : ::std::bool_constant<noexcept(::fn::pack<L>{::std::declval<Lv>()}.append(
+                                         ::std::in_place_type_t<R>{}, ::std::declval<Rv>()))> {};
+
+template <typename L, typename R>
+[[nodiscard]] constexpr auto _fold(auto &&l, auto &&r) //
+    noexcept(_nothrow_fold<L, R, decltype(l), decltype(r)>::value)
 {
   if constexpr (_some_pack<L>) {
     return FWD(l).append(::std::in_place_type_t<R>{}, FWD(r));
@@ -32,35 +47,70 @@ template <typename L, typename R> [[nodiscard]] constexpr auto _fold(auto &&l, a
   }
 }
 
+// Named types, not lambdas: `fold` and everything above it specify themselves in terms of what
+// dispatching through these promises, and a lambda can be named neither in a noexcept-specifier nor
+// (before clang 17) in any unevaluated operand at all.
+template <typename R, typename Rv> struct _fold_rh final {
+  Rv rv;
+
+  template <typename L>
+  [[nodiscard]] constexpr auto operator()(::std::in_place_type_t<L>, auto &&l) const
+      noexcept(noexcept(_fold<L, R>(FWD(l), ::std::declval<Rv>())))
+  {
+    return _fold<L, R>(FWD(l), static_cast<Rv &&>(rv));
+  }
+};
+
+template <typename L, typename Lv> struct _fold_lh final {
+  Lv lv;
+
+  template <typename R>
+  [[nodiscard]] constexpr auto operator()(::std::in_place_type_t<R>, auto &&r) const
+      noexcept(noexcept(_fold<L, R>(::std::declval<Lv>(), FWD(r))))
+  {
+    return _fold<L, R>(static_cast<Lv &&>(lv), FWD(r));
+  }
+};
+
+template <typename Rv> struct _fold_rh_sum final {
+  Rv rv;
+
+  template <typename L>
+  [[nodiscard]] constexpr auto operator()(::std::in_place_type_t<L>, auto &&l) const
+      noexcept(noexcept(::std::declval<Rv>()._transform(_fold_lh<L, decltype(l)>{FWD(l)})))
+  {
+    return static_cast<Rv &&>(rv)._transform(_fold_lh<L, decltype(l)>{FWD(l)});
+  }
+};
+
 template <typename Lh, typename Rh>
   requires _some_sum<Lh> && _some_sum<Rh>
-[[nodiscard]] constexpr auto fold(auto &&lv, auto &&rv)
+[[nodiscard]] constexpr auto fold(auto &&lv, auto &&rv) //
+    noexcept(noexcept(FWD(lv)._transform(_fold_rh_sum<decltype(rv)>{FWD(rv)})))
 {
-  return FWD(lv)._transform([&rv]<typename L>(::std::in_place_type_t<L>, auto &&l) {
-    return FWD(rv)._transform(
-        [&l]<typename R>(::std::in_place_type_t<R>, auto &&r) { return _fold<L, R>(FWD(l), FWD(r)); });
-  });
+  return FWD(lv)._transform(_fold_rh_sum<decltype(rv)>{FWD(rv)});
 }
 
 template <typename Lh, typename Rh>
   requires _some_sum<Lh> && (not _some_sum<Rh>)
-[[nodiscard]] constexpr auto fold(auto &&lv, auto &&rv)
+[[nodiscard]] constexpr auto fold(auto &&lv, auto &&rv) //
+    noexcept(noexcept(FWD(lv)._transform(_fold_rh<Rh, decltype(rv)>{FWD(rv)})))
 {
-  return FWD(lv)._transform(
-      [&rv]<typename L>(::std::in_place_type_t<L>, auto &&l) { return _fold<L, Rh>(FWD(l), FWD(rv)); });
+  return FWD(lv)._transform(_fold_rh<Rh, decltype(rv)>{FWD(rv)});
 }
 
 template <typename Lh, typename Rh>
   requires(not _some_sum<Lh>) && _some_sum<Rh>
-[[nodiscard]] constexpr auto fold(auto &&lv, auto &&rv)
+[[nodiscard]] constexpr auto fold(auto &&lv, auto &&rv) //
+    noexcept(noexcept(FWD(rv)._transform(_fold_lh<Lh, decltype(lv)>{FWD(lv)})))
 {
-  return FWD(rv)._transform(
-      [&lv]<typename R>(::std::in_place_type_t<R>, auto &&r) { return _fold<Lh, R>(FWD(lv), FWD(r)); });
+  return FWD(rv)._transform(_fold_lh<Lh, decltype(lv)>{FWD(lv)});
 }
 
 template <typename Lh, typename Rh>
   requires(not _some_sum<Lh>) && (not _some_sum<Rh>)
-[[nodiscard]] constexpr auto fold(auto &&lv, auto &&rv)
+[[nodiscard]] constexpr auto fold(auto &&lv, auto &&rv) //
+    noexcept(noexcept(_fold<Lh, Rh>(FWD(lv), FWD(rv))))
 {
   return _fold<Lh, Rh>(FWD(lv), FWD(rv));
 }
diff --git a/include/fn/expected.hpp b/include/fn/expected.hpp
index ce5feb41..48e6d7cd 100644
--- a/include/fn/expected.hpp
+++ b/include/fn/expected.hpp
@@ -57,16 +57,105 @@ template <typename U, typename G> struct _expected_types<::fn::expected<U, G>> {
   using error_type = G;
 };
 
+// A sum<> error is unconstructible, so an expected carrying one can never hold an error: every arm
+// that lifts one is unreachable, and what cannot run cannot throw. Guarded on the SOURCE's error
+// type - the value arms of the same expected still relocate, and still weigh.
+template <typename E, typename Type, typename... Args>
+constexpr inline bool _nothrow_error_arm = _nothrow_initializable<Type, Args...>;
+template <typename E, typename Type, typename... Args>
+  requires ::std::is_same_v<E, sum<>>
+constexpr inline bool _nothrow_error_arm<E, Type, Args...> = true;
+
+// Carrying the callback's value across into a widened result. An expected<void, ...> has no value to
+// carry, and `declval<void>()` is not a thing to ask about.
+template <typename Type, typename Src>
+constexpr inline bool _nothrow_carry_value
+    = _nothrow_initializable<Type, ::std::in_place_t, decltype(::std::declval<Src>().value())>;
+template <typename Type, typename Src>
+  requires ::std::is_void_v<typename ::std::remove_cvref_t<Src>::value_type>
+constexpr inline bool _nothrow_carry_value<Type, Src> = _nothrow_initializable<Type, ::std::in_place_t>;
+
+// `and_then` and `or_else` each have two arms - the callback's own expected is returned, or the two
+// error (value) types are widened into a sum - and `if constexpr` picks between them. A
+// noexcept-specifier is an ordinary constant expression and cannot pick: the untaken arm's spelling
+// would have to be well-formed too. Hence a trait, whose constrained specializations mirror the
+// body's arms. Both lead with `_is_some_expected`, so a callback returning something else leaves the
+// unconstrained primary to answer, and the body's static_assert to diagnose - a specification must
+// not pre-empt that with a hard error.
+template <typename E, typename Fn, typename ErrArg, typename... ValArg> struct _nothrow_and_then : ::std::false_type {};
+
+template <typename E, typename Fn, typename ErrArg, typename... ValArg>
+  requires _is_some_expected<::std::remove_cvref_t<typename _invoke_result<Fn, ValArg...>::type> &>
+           && ::std::is_same_v<typename _expected_types<
+                                   ::std::remove_cvref_t<typename _invoke_result<Fn, ValArg...>::type>>::error_type,
+                               E>
+struct _nothrow_and_then<E, Fn, ErrArg, ValArg...>
+    : ::std::bool_constant<
+          _is_nothrow_invocable<Fn, ValArg...>::value // the callback
+              && ::std::is_nothrow_constructible_v<::std::remove_cvref_t<typename _invoke_result<Fn, ValArg...>::type>,
+                                                   ::fn::unexpect_t, ErrArg>> {}; // lifting self's error
+
+template <typename E, typename Fn, typename ErrArg, typename... ValArg>
+  requires _is_some_expected<::std::remove_cvref_t<typename _invoke_result<Fn, ValArg...>::type> &>
+           && (not ::std::is_same_v<typename _expected_types<::std::remove_cvref_t<
+                                        typename _invoke_result<Fn, ValArg...>::type>>::error_type,
+                                    E>)
+struct _nothrow_and_then<E, Fn, ErrArg, ValArg...> {
+  using type = ::std::remove_cvref_t<typename _invoke_result<Fn, ValArg...>::type>;
+  using new_type = ::fn::expected<typename type::value_type, sum_for<E, typename type::error_type>>;
+
+  static constexpr bool value
+      = _is_nothrow_invocable<Fn, ValArg...>::value // the callback
+        && _nothrow_carry_value<new_type, type>     // carrying its value across
+        && _nothrow_initializable<new_type, ::fn::unexpect_t,
+                                  decltype(::std::declval<type>().error())> // widening its error
+        && _nothrow_error_arm<E, new_type, ::fn::unexpect_t, ErrArg>;       // widening self's error
+};
+
+// or_else's arms, mirrored the same way. ValArg is the type of self's value as the body relocates it
+// (spelled through apply_const_lvalue_t by the caller, since for a void T there is no value to name).
+template <typename T, typename Fn, typename ErrArg, typename ValArg> struct _nothrow_or_else : ::std::false_type {};
+
+template <typename T, typename Fn, typename ErrArg, typename ValArg>
+  requires _is_some_expected<::std::remove_cvref_t<typename _invoke_result<Fn, ErrArg>::type> &>
+           && ::std::is_same_v<
+               typename _expected_types<::std::remove_cvref_t<typename _invoke_result<Fn, ErrArg>::type>>::value_type,
+               T>
+struct _nothrow_or_else<T, Fn, ErrArg, ValArg>
+    : ::std::bool_constant<
+          _is_nothrow_invocable<Fn, ErrArg>::value // the callback
+          && (::std::is_void_v<T>
+              || _nothrow_initializable<::std::remove_cvref_t<typename _invoke_result<Fn, ErrArg>::type>,
+                                        ::std::in_place_t, ValArg>)> {}; // carrying self's value
+
+template <typename T, typename Fn, typename ErrArg, typename ValArg>
+  requires _is_some_expected<::std::remove_cvref_t<typename _invoke_result<Fn, ErrArg>::type> &>
+           && (not ::std::is_same_v<
+               typename _expected_types<::std::remove_cvref_t<typename _invoke_result<Fn, ErrArg>::type>>::value_type,
+               T>)
+struct _nothrow_or_else<T, Fn, ErrArg, ValArg> {
+  using type = ::std::remove_cvref_t<typename _invoke_result<Fn, ErrArg>::type>;
+  using new_type = ::fn::expected<sum_for<T, typename type::value_type>, typename type::error_type>;
+
+  static constexpr bool value
+      = _is_nothrow_invocable<Fn, ErrArg>::value                       // the callback
+        && _nothrow_initializable<new_type, ::std::in_place_t, ValArg> // widening self's value
+        && _nothrow_carry_value<new_type, type>                        // widening its value
+        && _nothrow_initializable<new_type, ::fn::unexpect_t,
+                                  decltype(::std::declval<type>().error())>; // carrying its error
+};
+
 // Storage layer for ::fn::expected. Inherits the standard-conformant base from
 // pfn, then hides the four monadic static helpers with sum-widening variants
 // that materialise their result via `expected_policy::template type<U, G>`.
 // The transform/transform_error helpers hand pfn's _expected_from_invoke constructors a
 // zero-argument thunk, so the result's member is direct-non-list-initialized from fn's own
 // _invoke (or sum::transform) result: no extra move, and immovable result types work.
-// The statics carry the same extension noexcept as pfn's, spelled with the std traits: for
-// the sum/pack dispatch and sum-widening extensions the lead conjunct is false (the callable
-// is not directly invocable, or the result is differently shaped), so those are
-// conservatively noexcept(false).
+// The statics carry the same extension noexcept as pfn's, computed through fn's own machinery: the
+// callback of a sum/pack dispatch is invoked through `_invoke`, not called directly, so it is
+// `_is_nothrow_invocable` - not the std trait, which is false for a callable that is not directly
+// invocable on a sum or a pack - that answers for it, and the widening arms are weighed by the
+// traits above.
 template <typename T, typename E> struct _expected_base : ::pfn::detail::_expected_base<T, E, expected_policy> {
   using _pfn_base = ::pfn::detail::_expected_base<T, E, expected_policy>;
   using _pfn_base::_pfn_base;
@@ -74,11 +163,8 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
   // and_then, non-void value type
   template <typename Self, typename Fn>
   static constexpr auto _and_then(Self &&self, Fn &&fn) //
-      noexcept(::std::is_same_v<typename _expected_types<::std::remove_cvref_t<typename ::fn::detail::_invoke_result<
-                                    Fn, decltype(_pfn_base::_value(FWD(self)))>::type>>::error_type,
-                                E>
-               && ::std::is_nothrow_invocable_v<Fn, decltype(_pfn_base::_value(FWD(self)))>
-               && ::std::is_nothrow_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>) // extension
+      noexcept(::fn::detail::_nothrow_and_then<E, Fn, decltype(_pfn_base::_error(FWD(self))),
+                                               decltype(_pfn_base::_value(FWD(self)))>::value) // extension
     requires(not ::std::is_void_v<T>) && ::fn::detail::_is_invocable<Fn, decltype(_pfn_base::_value(FWD(self)))>::value
             && ::std::is_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>
   {
@@ -113,12 +199,8 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
 
   // and_then, void value type
   template <typename Self, typename Fn>
-  static constexpr auto _and_then(Self &&self, Fn &&fn) //
-      noexcept(::std::is_same_v<typename _expected_types<
-                                    ::std::remove_cvref_t<typename ::fn::detail::_invoke_result<Fn>::type>>::error_type,
-                                E>
-               && ::std::is_nothrow_invocable_v<Fn>
-               && ::std::is_nothrow_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>) // extension
+  static constexpr auto _and_then(Self &&self, Fn &&fn)                                               //
+      noexcept(::fn::detail::_nothrow_and_then<E, Fn, decltype(_pfn_base::_error(FWD(self)))>::value) // extension
     requires(::std::is_void_v<T>) && ::fn::detail::_is_invocable<Fn>::value
             && ::std::is_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>
   {
@@ -157,13 +239,8 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
   // an ill-formed _value call (constrained away for void) from being a hard error.
   template <typename Self, typename Fn>
   static constexpr auto _or_else(Self &&self, Fn &&fn) //
-      noexcept(::std::is_same_v<typename _expected_types<::std::remove_cvref_t<typename ::fn::detail::_invoke_result<
-                                    Fn, decltype(_pfn_base::_error(FWD(self)))>::type>>::value_type,
-                                T>
-               && ::std::is_nothrow_invocable_v<Fn, decltype(_pfn_base::_error(FWD(self)))>
-               && (::std::is_void_v<T>
-                   || ::std::is_nothrow_constructible_v<
-                       T, ::fn::apply_const_lvalue_t<Self, typename _pfn_base::_value_t &&>>)) // extension
+      noexcept(::fn::detail::_nothrow_or_else<T, Fn, decltype(_pfn_base::_error(FWD(self))),
+                                              ::fn::apply_const_lvalue_t<Self, typename _pfn_base::_value_t &&>>::value)
     requires ::fn::detail::_is_invocable<Fn, decltype(_pfn_base::_error(FWD(self)))>::value
              && (::std::is_void_v<T> || ::std::is_constructible_v<T, decltype(_pfn_base::_value(FWD(self)))>)
   {
@@ -213,7 +290,7 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
   // new value/error is direct-non-list-initialized from the thunk's result (guaranteed elision).
   template <typename Self, typename Fn>
   static constexpr auto _transform(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_pfn_base::_value(FWD(self)))>
+      noexcept(::fn::detail::_is_nothrow_invocable<Fn, decltype(_pfn_base::_value(FWD(self)))>::value
                && ::std::is_nothrow_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>) // extension
     requires(not ::std::is_void_v<T>) && (not some_sum<T>)
             && ::fn::detail::_is_invocable_if<not some_sum<T>, Fn, decltype(_pfn_base::_value(FWD(self)))>::value
@@ -236,7 +313,9 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
   // transform, value type is a sum (delegates to sum::transform). The callback is constrained here,
   // in the immediate context, for the reason given on optional's sum-case _transform.
   template <typename Self, typename Fn>
-  static constexpr auto _transform(Self &&self, Fn &&fn)
+  static constexpr auto _transform(Self &&self, Fn &&fn) //
+      noexcept(noexcept(_pfn_base::_value(FWD(self)).transform(FWD(fn)))
+               && ::std::is_nothrow_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>) // extension
     requires some_sum<T> && ::fn::detail::_typelist_invocable<Fn, decltype(_pfn_base::_value(FWD(self)))>
              && ::std::is_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>
   {
@@ -256,7 +335,7 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
   // transform, void value type
   template <typename Self, typename Fn>
   static constexpr auto _transform(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn>
+      noexcept(::fn::detail::_is_nothrow_invocable<Fn>::value
                && ::std::is_nothrow_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>) // extension
     requires(::std::is_void_v<T>) && ::fn::detail::_is_invocable<Fn>::value
             && ::std::is_constructible_v<E, decltype(_pfn_base::_error(FWD(self)))>
@@ -278,7 +357,7 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
   // apply_const_lvalue_t for the same reason as _or_else's above)
   template <typename Self, typename Fn>
   static constexpr auto _transform_error(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_pfn_base::_error(FWD(self)))>
+      noexcept(::fn::detail::_is_nothrow_invocable<Fn, decltype(_pfn_base::_error(FWD(self)))>::value
                && (::std::is_void_v<T>
                    || ::std::is_nothrow_constructible_v<
                        T, ::fn::apply_const_lvalue_t<Self, typename _pfn_base::_value_t &&>>)) // extension
@@ -302,7 +381,11 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
   // transform_error, error type is a sum (delegates to sum::transform). The callback is constrained
   // here, in the immediate context, for the reason given on optional's sum-case _transform.
   template <typename Self, typename Fn>
-  static constexpr auto _transform_error(Self &&self, Fn &&fn)
+  static constexpr auto _transform_error(Self &&self, Fn &&fn) //
+      noexcept(noexcept(_pfn_base::_error(FWD(self)).transform(FWD(fn)))
+               && (::std::is_void_v<T>
+                   || ::std::is_nothrow_constructible_v<
+                       T, ::fn::apply_const_lvalue_t<Self, typename _pfn_base::_value_t &&>>)) // extension
     requires some_sum<E> && ::fn::detail::_typelist_invocable<Fn, decltype(_pfn_base::_error(FWD(self)))>
              && (::std::is_void_v<T> || ::std::is_constructible_v<T, decltype(_pfn_base::_value(FWD(self)))>)
   {
@@ -1051,13 +1134,59 @@ template <typename Err> class expected<void, Err> : private detail::_expected_ba
   return FWD(src).sum_error();
 }
 
+namespace detail {
+template <typename E> struct _expected_type {
+  template <typename T> using type = ::fn::expected<T, E>;
+};
+
+// `error()` throws when the expected holds a value, but every arm below is reached only once
+// `has_value()` has answered - so these ask what constructing the result promises, with the accessor
+// spelled as a type rather than as a call which would drag its own throw in.
+template <typename Type, typename Lh, typename Rh, typename... Vs>
+constexpr inline bool _nothrow_join_expected
+    = _nothrow_initializable<Type, ::std::in_place_t, Vs...>
+      && _nothrow_initializable<Type, ::fn::unexpect_t, decltype(::std::declval<Lh>().error())>
+      && _nothrow_initializable<Type, ::fn::unexpect_t, decltype(::std::declval<Rh>().error())>;
+
+// Lifting an operand's error into a widened error type, through the sum<> guard of _nothrow_error_arm
+// (the joins below assert the same unreachability with pfn::unreachable).
+template <typename Src, typename Err>
+constexpr inline bool _nothrow_error_lift
+    = _nothrow_error_arm<typename ::std::remove_cvref_t<Src>::error_type, Err, decltype(::std::declval<Src>().error())>;
+
+template <typename Type, typename Err, typename Lh, typename Rh, typename... Vs>
+constexpr inline bool _nothrow_join_widened = _nothrow_initializable<Type, ::std::in_place_t, Vs...>
+                                              && (_nothrow_error_lift<Lh, Err> && _nothrow_error_lift<Rh, Err>)
+                                              && _nothrow_initializable<Type, ::fn::unexpect_t, Err>;
+
+// A named type, not a lambda: `operator&` specifies itself in terms of what lifting the error
+// promises, and a lambda can be named neither in a noexcept-specifier nor (before clang 17) in any
+// unevaluated operand at all.
+template <typename E> struct _expected_efn final {
+  // Explicit return type: for a sum<> (never-erroring) operand the else branch is the only one
+  // instantiated, and without this it would deduce void - poisoning _join's return-type deduction.
+  [[nodiscard]] constexpr auto operator()(auto &&v) const noexcept(_nothrow_error_lift<decltype(v), unexpected<E>>)
+      -> ::fn::unexpected<E>
+  {
+    if constexpr (not ::std::is_same_v<typename ::std::remove_cvref_t<decltype(v)>::error_type, sum<>>) {
+      return ::fn::unexpected<E>(FWD(v).error());
+    } else {
+      ::pfn::unreachable(); // LCOV_EXCL_LINE
+    }
+  }
+};
+} // namespace detail
+
 // When any of the sides is expected<void, ...>, we do not produce expected<pack<...>, ...>
 // Instead just elide void and carry non-void (or elide both voids if that's what we get)
 template <typename Lh, typename Rh>
   requires some_expected_void<Lh> && (not some_expected_void<Rh>)
            && ::std::is_same_v<typename ::std::remove_cvref_t<Lh>::error_type,
                                typename ::std::remove_cvref_t<Rh>::error_type>
-[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(detail::_nothrow_join_expected<
+             expected<typename ::std::remove_cvref_t<Rh>::value_type, typename ::std::remove_cvref_t<Lh>::error_type>,
+             Lh, Rh, decltype(FWD(rh).value())>)
 {
   using error_type = ::std::remove_cvref_t<Lh>::error_type;
   using value_type = ::std::remove_cvref_t<Rh>::value_type;
@@ -1076,7 +1205,13 @@ template <typename Lh, typename Rh>
                                     typename ::std::remove_cvref_t<Rh>::error_type>)
            && (some_sum<typename ::std::remove_cvref_t<Lh>::error_type>
                || some_sum<typename ::std::remove_cvref_t<Rh>::error_type>)
-[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(detail::_nothrow_join_widened<
+             expected<typename ::std::remove_cvref_t<Rh>::value_type,
+                      sum_for<typename ::std::remove_cvref_t<Lh>::error_type,
+                              typename ::std::remove_cvref_t<Rh>::error_type>>,
+             sum_for<typename ::std::remove_cvref_t<Lh>::error_type, typename ::std::remove_cvref_t<Rh>::error_type>,
+             Lh, Rh, decltype(FWD(rh).value())>)
 {
   using new_error_type
       = sum_for<typename ::std::remove_cvref_t<Lh>::error_type, typename ::std::remove_cvref_t<Rh>::error_type>;
@@ -1101,7 +1236,10 @@ template <typename Lh, typename Rh>
   requires(not some_expected_void<Lh>) && some_expected_void<Rh>
           && ::std::is_same_v<typename ::std::remove_cvref_t<Lh>::error_type,
                               typename ::std::remove_cvref_t<Rh>::error_type>
-[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(detail::_nothrow_join_expected<
+             expected<typename ::std::remove_cvref_t<Lh>::value_type, typename ::std::remove_cvref_t<Lh>::error_type>,
+             Lh, Rh, decltype(FWD(lh).value())>)
 {
   using error_type = ::std::remove_cvref_t<Lh>::error_type;
   using value_type = ::std::remove_cvref_t<Lh>::value_type;
@@ -1120,7 +1258,13 @@ template <typename Lh, typename Rh>
                                    typename ::std::remove_cvref_t<Rh>::error_type>)
           && (some_sum<typename ::std::remove_cvref_t<Lh>::error_type>
               || some_sum<typename ::std::remove_cvref_t<Rh>::error_type>)
-[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(detail::_nothrow_join_widened<
+             expected<typename ::std::remove_cvref_t<Lh>::value_type,
+                      sum_for<typename ::std::remove_cvref_t<Lh>::error_type,
+                              typename ::std::remove_cvref_t<Rh>::error_type>>,
+             sum_for<typename ::std::remove_cvref_t<Lh>::error_type, typename ::std::remove_cvref_t<Rh>::error_type>,
+             Lh, Rh, decltype(FWD(lh).value())>)
 {
   using new_error_type
       = sum_for<typename ::std::remove_cvref_t<Lh>::error_type, typename ::std::remove_cvref_t<Rh>::error_type>;
@@ -1145,7 +1289,8 @@ template <typename Lh, typename Rh>
   requires some_expected_void<Lh> && some_expected_void<Rh>
            && ::std::is_same_v<typename ::std::remove_cvref_t<Lh>::error_type,
                                typename ::std::remove_cvref_t<Rh>::error_type>
-[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(detail::_nothrow_join_expected<expected<void, typename ::std::remove_cvref_t<Lh>::error_type>, Lh, Rh>)
 {
   using error_type = ::std::remove_cvref_t<Lh>::error_type;
   using type = expected<void, error_type>;
@@ -1163,7 +1308,12 @@ template <typename Lh, typename Rh>
                                     typename ::std::remove_cvref_t<Rh>::error_type>)
            && (some_sum<typename ::std::remove_cvref_t<Lh>::error_type>
                || some_sum<typename ::std::remove_cvref_t<Rh>::error_type>)
-[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(detail::_nothrow_join_widened<
+             expected<void, sum_for<typename ::std::remove_cvref_t<Lh>::error_type,
+                                    typename ::std::remove_cvref_t<Rh>::error_type>>,
+             sum_for<typename ::std::remove_cvref_t<Lh>::error_type, typename ::std::remove_cvref_t<Rh>::error_type>,
+             Lh, Rh>)
 {
   using new_error_type
       = sum_for<typename ::std::remove_cvref_t<Lh>::error_type, typename ::std::remove_cvref_t<Rh>::error_type>;
@@ -1185,21 +1335,18 @@ template <typename Lh, typename Rh>
 
 // Overloads when both sides are non-void, producing either of
 // expected<pack<...>, ...> or expected<sum<pack<...>, pack...>, ...>
-namespace detail {
-template <typename E> struct _expected_type {
-  template <typename T> using type = ::fn::expected<T, E>;
-};
-} // namespace detail
-
 template <typename Lh, typename Rh>
   requires(not some_expected_void<Lh>) && (not some_expected_void<Rh>)
           && ::std::is_same_v<typename ::std::remove_cvref_t<Lh>::error_type,
                               typename ::std::remove_cvref_t<Rh>::error_type>
-[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(noexcept(::fn::detail::_join<
+                      detail::template _expected_type<typename ::std::remove_cvref_t<Lh>::error_type>::template type>(
+        FWD(lh), FWD(rh), detail::_expected_efn<typename ::std::remove_cvref_t<Lh>::error_type>{})))
 {
   using error_type = ::std::remove_cvref_t<Lh>::error_type;
-  constexpr auto efn = [](auto &&v) { return ::fn::unexpected<error_type>(FWD(v).error()); };
-  return ::fn::detail::_join<detail::template _expected_type<error_type>::template type>(FWD(lh), FWD(rh), efn);
+  return ::fn::detail::_join<detail::template _expected_type<error_type>::template type>(
+      FWD(lh), FWD(rh), detail::_expected_efn<error_type>{});
 }
 
 template <typename Lh, typename Rh>
@@ -1208,20 +1355,19 @@ template <typename Lh, typename Rh>
                                    typename ::std::remove_cvref_t<Rh>::error_type>)
           && (some_sum<typename ::std::remove_cvref_t<Lh>::error_type>
               || some_sum<typename ::std::remove_cvref_t<Rh>::error_type>)
-[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(noexcept(
+        ::fn::detail::_join<
+            detail::template _expected_type<sum_for<typename ::std::remove_cvref_t<Lh>::error_type,
+                                                    typename ::std::remove_cvref_t<Rh>::error_type>>::template type>(
+            FWD(lh), FWD(rh),
+            detail::_expected_efn<sum_for<typename ::std::remove_cvref_t<Lh>::error_type,
+                                          typename ::std::remove_cvref_t<Rh>::error_type>>{})))
 {
   using new_error_type
       = sum_for<typename ::std::remove_cvref_t<Lh>::error_type, typename ::std::remove_cvref_t<Rh>::error_type>;
-  // Explicit return type: for a sum<> (never-erroring) operand the else branch is the only one
-  // instantiated, and without this it would deduce void — poisoning _join's return-type deduction.
-  constexpr auto efn = [](auto &&v) -> ::fn::unexpected<new_error_type> {
-    if constexpr (not ::std::is_same_v<typename ::std::remove_cvref_t<decltype(v)>::error_type, sum<>>) {
-      return ::fn::unexpected<new_error_type>(FWD(v).error());
-    } else {
-      ::pfn::unreachable(); // LCOV_EXCL_LINE
-    }
-  };
-  return ::fn::detail::_join<detail::template _expected_type<new_error_type>::template type>(FWD(lh), FWD(rh), efn);
+  return ::fn::detail::_join<detail::template _expected_type<new_error_type>::template type>(
+      FWD(lh), FWD(rh), detail::_expected_efn<new_error_type>{});
 }
 
 } // namespace fn
diff --git a/include/fn/optional.hpp b/include/fn/optional.hpp
index c9980f91..d4168621 100644
--- a/include/fn/optional.hpp
+++ b/include/fn/optional.hpp
@@ -127,23 +127,52 @@ struct optional_policy {
   template <class X> static constexpr bool is_specialization = _is_some_optional<X &>;
 };
 
+// `or_else` has two arms - the callback's own optional is returned, or its value type and T are
+// widened into a sum - and `if constexpr` picks between them. A noexcept-specifier is an ordinary
+// constant expression, so it cannot pick: the untaken arm's spelling would have to be well-formed
+// too, and it is not. Hence a trait, whose constrained specializations mirror the body's arms. The
+// unconstrained primary answers for a callback returning something that is not an optional at all -
+// the body's static_assert is the diagnostic there, and it must not be pre-empted by a hard error
+// in the specification.
+template <typename T, typename Fn, typename ValArg> struct _nothrow_optional_or_else : ::std::false_type {};
+
+template <typename T, typename Fn, typename ValArg>
+  requires ::std::is_same_v<::std::remove_cvref_t<typename _invoke_result<Fn>::type>, ::fn::optional<T>>
+struct _nothrow_optional_or_else<T, Fn, ValArg>
+    : ::std::bool_constant<_is_nothrow_invocable<Fn>::value
+                               && ::std::is_nothrow_constructible_v<::fn::optional<T>, ::std::in_place_t, ValArg>> {};
+
+template <typename T, typename Fn, typename ValArg>
+  requires _is_some_optional<::std::remove_cvref_t<typename _invoke_result<Fn>::type> &>
+           && (not ::std::is_same_v<::std::remove_cvref_t<typename _invoke_result<Fn>::type>, ::fn::optional<T>>)
+struct _nothrow_optional_or_else<T, Fn, ValArg> {
+  using type = ::std::remove_cvref_t<typename _invoke_result<Fn>::type>;
+  using new_type = ::fn::optional<sum_for<T, typename type::value_type>>;
+
+  static constexpr bool value
+      = _is_nothrow_invocable<Fn>::value                               // the callback
+        && _nothrow_initializable<new_type, ::std::in_place_t, ValArg> // self's value
+        && _nothrow_initializable<new_type, ::std::in_place_t, decltype(::std::declval<type>().value())>; // its value
+};
+
 // Storage layer for ::fn::optional. Inherits the standard-conformant base from
 // pfn, then hides the three monadic static helpers with sum-aware variants that
 // materialise their result via `optional_policy::template type<U>`.
 // The transform helpers hand pfn's _optional_from_invoke constructor a zero-argument
 // thunk, so the result's contained value is direct-non-list-initialized from fn's own
 // _invoke (or sum::transform) result: no extra move, and immovable result types work.
-// The statics carry the same extension noexcept as pfn's, spelled with the std traits: for
-// the sum/pack dispatch extensions std::is_nothrow_invocable_v is false (the callable is not
-// directly invocable on a sum or pack), so those are conservatively noexcept(false).
+// The statics carry the same extension noexcept as pfn's, computed through fn's own machinery:
+// the callback of a sum/pack dispatch is invoked through `_invoke`, not called directly, so it is
+// `_is_nothrow_invocable` - not the std trait, which is false for a callable that is not directly
+// invocable on a sum or a pack - that answers for it.
 template <typename T> struct _optional_base : ::pfn::detail::_optional_base<T, optional_policy> {
   using _pfn_base = ::pfn::detail::_optional_base<T, optional_policy>;
   using _pfn_base::_pfn_base;
 
   // and_then
   template <typename Self, typename Fn>
-  static constexpr auto _and_then(Self &&self, Fn &&fn)                 //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(*FWD(self))>) // extension
+  static constexpr auto _and_then(Self &&self, Fn &&fn)                              //
+      noexcept(::fn::detail::_is_nothrow_invocable<Fn, decltype(*FWD(self))>::value) // extension
     requires ::fn::detail::_is_invocable<Fn, decltype(*FWD(self))>::value
   {
     using type = ::std::remove_cvref_t<typename ::fn::detail::_invoke_result<Fn, decltype(*FWD(self))>::type>;
@@ -169,11 +198,8 @@ template <typename T> struct _optional_base : ::pfn::detail::_optional_base<T, o
 
   // or_else (with value-widening into a sum)
   template <typename Self, typename Fn>
-  static constexpr auto _or_else(Self &&self, Fn &&fn) //
-      noexcept(
-          ::std::is_same_v<::std::remove_cvref_t<typename ::fn::detail::_invoke_result<Fn>::type>, ::fn::optional<T>>
-          && ::std::is_nothrow_invocable_v<Fn>
-          && ::std::is_nothrow_constructible_v<::fn::optional<T>, Self>) // extension
+  static constexpr auto _or_else(Self &&self, Fn &&fn)                                      //
+      noexcept(::fn::detail::_nothrow_optional_or_else<T, Fn, decltype(*FWD(self))>::value) // extension
     requires ::fn::detail::_is_invocable<Fn>::value && ::std::is_constructible_v<T, decltype(*FWD(self))>
   {
     using type = ::std::remove_cvref_t<typename ::fn::detail::_invoke_result<Fn>::type>;
@@ -215,8 +241,8 @@ template <typename T> struct _optional_base : ::pfn::detail::_optional_base<T, o
   // transform, value type is not a sum. In the noexcept spec, only the invoke can throw: the
   // result is direct-non-list-initialized from the thunk's result (guaranteed elision).
   template <typename Self, typename Fn>
-  static constexpr auto _transform(Self &&self, Fn &&fn)                //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(*FWD(self))>) // extension
+  static constexpr auto _transform(Self &&self, Fn &&fn)                             //
+      noexcept(::fn::detail::_is_nothrow_invocable<Fn, decltype(*FWD(self))>::value) // extension
     requires(not some_sum<T>) && ::fn::detail::_is_invocable_if<not some_sum<T>, Fn, decltype(*FWD(self))>::value
   {
     using new_value_type = ::std::remove_cv_t<typename ::fn::detail::_invoke_result<Fn, decltype(*FWD(self))>::type>;
@@ -234,7 +260,8 @@ template <typename T> struct _optional_base : ::pfn::detail::_optional_base<T, o
   // candidate - and would poison overload resolution, since the losing candidates form their
   // signatures too.
   template <typename Self, typename Fn>
-  static constexpr auto _transform(Self &&self, Fn &&fn)
+  static constexpr auto _transform(Self &&self, Fn &&fn)  //
+      noexcept(noexcept((*FWD(self)).transform(FWD(fn)))) // extension
     requires some_sum<T> && ::fn::detail::_typelist_invocable<Fn, decltype(*FWD(self))>
   {
     using new_value_type = decltype((*FWD(self)).transform(FWD(fn)));
@@ -891,10 +918,19 @@ constexpr optional<T> make_optional(::std::initializer_list<U> il, Args &&...arg
   return FWD(src).sum_value();
 }
 
-template <some_optional Lh, some_optional Rh> [[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
+namespace detail {
+// A named type, not a lambda: `operator&`'s specification has to name it, and a lambda cannot be
+// spelled in an unevaluated operand before C++20's P0315, which our floor compilers predate.
+struct _optional_efn final {
+  [[nodiscard]] constexpr auto operator()(auto const &) const noexcept -> ::std::nullopt_t { return ::std::nullopt; }
+};
+} // namespace detail
+
+template <some_optional Lh, some_optional Rh>
+[[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) //
+    noexcept(noexcept(::fn::detail::_join<fn::optional>(FWD(lh), FWD(rh), detail::_optional_efn{})))
 {
-  constexpr auto efn = [](auto const &) { return ::std::nullopt; };
-  return ::fn::detail::_join<fn::optional>(FWD(lh), FWD(rh), efn);
+  return ::fn::detail::_join<fn::optional>(FWD(lh), FWD(rh), detail::_optional_efn{});
 }
 
 } // namespace fn
diff --git a/include/fn/pack.hpp b/include/fn/pack.hpp
index 9deb48c8..4e10930c 100644
--- a/include/fn/pack.hpp
+++ b/include/fn/pack.hpp
@@ -357,16 +357,36 @@ template <typename T, typename... Args>
 
 namespace detail {
 
+// `value()` throws when the monad holds no value, but the join only reaches it once `has_value()`
+// has answered - so the specification below asks what folding and lifting the value promise, with
+// the accessor spelled as a type rather than as a call which would drag its own throw in.
+template <typename Monad> using _value_of_t = decltype(::std::declval<Monad>().value());
+
+template <typename Lh, typename Rh>
+using _joined_t = decltype(::fn::detail::_fold_detail::fold<typename ::std::remove_cvref_t<Lh>::value_type,
+                                                            typename ::std::remove_cvref_t<Rh>::value_type>(
+    ::std::declval<_value_of_t<Lh>>(), ::std::declval<_value_of_t<Rh>>()));
+
+// `_join` invokes `efn` as an lvalue - a named parameter - so the `Efn &` questions ask about the
+// call the body performs; the reference collapses to it whatever category the callable arrived in.
+template <template <typename> typename Tpl, typename Lh, typename Rh, typename Efn>
+constexpr inline bool _nothrow_join
+    = noexcept(::fn::detail::_fold_detail::fold<typename ::std::remove_cvref_t<Lh>::value_type,
+                                                typename ::std::remove_cvref_t<Rh>::value_type>(
+          ::std::declval<_value_of_t<Lh>>(), ::std::declval<_value_of_t<Rh>>()))
+      && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::in_place_t, _joined_t<Lh, Rh>>
+      && ::std::is_nothrow_invocable_v<Efn &, Lh> && ::std::is_nothrow_invocable_v<Efn &, Rh>
+      && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::invoke_result_t<Efn &, Lh>>
+      && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::invoke_result_t<Efn &, Rh>>;
+
 template <template <typename> typename Tpl>
-[[nodiscard]] constexpr auto _join(auto &&lh, auto &&rh, auto &&efn)
-    -> Tpl<decltype(::fn::detail::_fold_detail::fold<typename ::std::remove_cvref_t<decltype(lh)>::value_type,
-                                                     typename ::std::remove_cvref_t<decltype(rh)>::value_type>(
-        FWD(lh).value(), FWD(rh).value()))>
+[[nodiscard]] constexpr auto _join(auto &&lh, auto &&rh, auto &&efn) //
+    noexcept(_nothrow_join<Tpl, decltype(lh), decltype(rh), decltype(efn)>)
+        -> Tpl<_joined_t<decltype(lh), decltype(rh)>>
 {
   using Lh = ::std::remove_cvref_t<decltype(lh)>::value_type;
   using Rh = ::std::remove_cvref_t<decltype(rh)>::value_type;
-  using value_type = decltype(::fn::detail::_fold_detail::fold<Lh, Rh>(FWD(lh).value(), FWD(rh).value()));
-  using type = Tpl<value_type>;
+  using type = Tpl<_joined_t<decltype(lh), decltype(rh)>>;
   if (lh.has_value() && rh.has_value())
     return type{::std::in_place, ::fn::detail::_fold_detail::fold<Lh, Rh>(FWD(lh).value(), FWD(rh).value())};
   else if (not lh.has_value())
@@ -384,7 +404,9 @@ template <template <typename> typename Tpl>
  * @param rh TODO
  * @return TODO
  */
-[[nodiscard]] constexpr auto operator&(auto &&lh, auto &&rh)
+[[nodiscard]] constexpr auto operator&(auto &&lh, auto &&rh) //
+    noexcept(noexcept(::fn::detail::_fold_detail::fold<::std::remove_cvref_t<decltype(lh)>,
+                                                       ::std::remove_cvref_t<decltype(rh)>>(FWD(lh), FWD(rh))))
   requires(some_sum<decltype(lh)> || some_pack<decltype(lh)>)
 {
   using Lh = ::std::remove_cvref_t<decltype(lh)>;
diff --git a/tests/fn/expected.cpp b/tests/fn/expected.cpp
index 4c041639..4091b859 100644
--- a/tests/fn/expected.cpp
+++ b/tests/fn/expected.cpp
@@ -21,6 +21,14 @@ struct Xint {
   constexpr bool operator==(Xint const &) const noexcept = default;
 };
 
+// Nothrow move, throwing copy: joining lvalue operands copies the value or error, joining rvalues
+// moves it
+struct MoveNothrow {
+  MoveNothrow() = default;
+  MoveNothrow(MoveNothrow const &) noexcept(false) {}
+  MoveNothrow(MoveNothrow &&) noexcept = default;
+};
+
 // Sums whose alternatives include a non-builtin (Error/Xint/std::string_view/fn::pack — any
 // class/struct/enum) have platform-specific order (see sum.cpp); pure-builtin sums keep `sum<...>`.
 } // namespace
@@ -615,6 +623,47 @@ TEST_CASE("graded monad", "[expected][sum][graded][and_then][or_else][sum_value]
       CHECK(r.has_value());
     }
   }
+
+  WHEN("noexcept")
+  {
+    // the widening arms relocate BOTH sides into the summed result - self's, and the callback's -
+    // and weigh both, rather than reporting potentially-throwing merely because the shape changed
+    WHEN("and_then widens the error")
+    {
+      using T = fn::expected<int, fn::sum<Error>>;
+      constexpr auto widen = [](int) noexcept -> fn::expected<bool, bool> { return {true}; };
+      static_assert(
+          std::is_same_v<decltype(std::declval<T &>().and_then(widen)), fn::expected<bool, fn::sum_for<Error, bool>>>);
+      static_assert(noexcept(std::declval<T &>().and_then(widen)));
+      static_assert(not noexcept(std::declval<T &>().and_then([](int) -> fn::expected<bool, bool> { return {true}; })));
+
+      using W = fn::expected<int, fn::sum_for<MoveNothrow, Error>>;
+      static_assert(not noexcept(std::declval<W &>().and_then(widen))); // copies self's error
+      static_assert(noexcept(std::declval<W &&>().and_then(widen)));    // moves it
+    }
+
+    WHEN("or_else widens the value")
+    {
+      using T = fn::expected<fn::sum<int>, Error>;
+      constexpr auto widen = [](Error) noexcept -> fn::expected<bool, bool> { return {true}; };
+      static_assert(noexcept(std::declval<T &>().or_else(widen)));
+      static_assert(
+          not noexcept(std::declval<T &>().or_else([](Error) -> fn::expected<bool, bool> { return {true}; })));
+
+      using W = fn::expected<fn::sum_for<MoveNothrow, int>, Error>;
+      static_assert(not noexcept(std::declval<W &>().or_else(widen))); // copies self's value
+      static_assert(noexcept(std::declval<W &&>().or_else(widen)));    // moves it
+    }
+
+    WHEN("the unit error grade")
+    {
+      // sum<> can hold no error, so the arm lifting self's error is unreachable, and cannot throw
+      using T = fn::expected<int, fn::sum<>>;
+      static_assert(
+          noexcept(std::declval<T &>().and_then([](int) noexcept -> fn::expected<bool, Error> { return {true}; })));
+    }
+    SUCCEED();
+  }
 }
 
 TEST_CASE("graded monad constexpr and runtime", "[constexpr][and_then][or_else][expected][graded][sum]")
@@ -820,6 +869,18 @@ TEST_CASE("expected pack support", "[expected][pack][and_then][transform][operat
                 .error()
             == FileNotFound);
     }
+
+    WHEN("noexcept")
+    {
+      // a pack's callback is invoked through fn's own dispatch, taking one argument per element: it
+      // is not directly invocable on the pack, so only fn's nothrow-invocable trait can answer
+      using T = fn::expected<fn::pack<int, double>, Error>;
+      static_assert(noexcept(
+          std::declval<T &>().and_then([](int, double) noexcept -> fn::expected<bool, Error> { return {true}; })));
+      static_assert(
+          not noexcept(std::declval<T &>().and_then([](int, double) -> fn::expected<bool, Error> { return {true}; })));
+      SUCCEED();
+    }
   }
 
   WHEN("transform")
@@ -899,6 +960,14 @@ TEST_CASE("expected pack support", "[expected][pack][and_then][transform][operat
             == FileNotFound);
       CHECK(std::move(std::as_const(s)).transform([](auto...) -> bool { throw 0; }).error() == FileNotFound);
     }
+
+    WHEN("noexcept")
+    {
+      using T = fn::expected<fn::pack<int, double>, Error>;
+      static_assert(noexcept(std::declval<T &>().transform([](int, double) noexcept -> bool { return true; })));
+      static_assert(not noexcept(std::declval<T &>().transform([](int, double) -> bool { return true; })));
+      SUCCEED();
+    }
   }
 
   WHEN("operator &")
@@ -2247,6 +2316,49 @@ TEST_CASE("expected pack support", "[expected][pack][and_then][transform][operat
         CHECK((Rh{::fn::unexpect, FileNotFound} & VoidUnit{}).error() == fn::sum{FileNotFound});
       }
     }
+
+    WHEN("noexcept")
+    {
+      // the join relocates both operands' values and errors into the result, so it promises only
+      // what relocating them promises
+      using Lh = fn::expected<MoveNothrow, Error>;
+      using Rh = fn::expected<int, Error>;
+      static_assert(noexcept(std::declval<Rh &>() & std::declval<Rh &>()));
+      static_assert(not noexcept(std::declval<Lh &>() & std::declval<Rh &>())); // copies the value
+      static_assert(noexcept(std::declval<Lh &&>() & std::declval<Rh &&>()));   // moves it
+
+      using Eh = fn::expected<int, MoveNothrow>;
+      static_assert(not noexcept(std::declval<Eh &>() & std::declval<Eh &>())); // copies the error
+      static_assert(noexcept(std::declval<Eh &&>() & std::declval<Eh &&>()));
+
+      WHEN("void operand")
+      {
+        using Vh = fn::expected<void, Error>;
+        static_assert(noexcept(std::declval<Vh &>() & std::declval<Rh &>()));
+        static_assert(not noexcept(std::declval<Vh &>() & std::declval<Lh &>())); // carries the value
+        static_assert(noexcept(std::declval<Vh &&>() & std::declval<Lh &&>()));
+        static_assert(noexcept(std::declval<Vh &>() & std::declval<Vh &>()));
+      }
+
+      WHEN("widening the error")
+      {
+        using Wh = fn::expected<int, fn::sum<MoveNothrow>>;
+        static_assert(not noexcept(std::declval<Wh &>() & std::declval<Rh &>())); // copies the error
+        static_assert(noexcept(std::declval<Wh &&>() & std::declval<Rh &&>()));
+      }
+
+      WHEN("unit error operand")
+      {
+        // sum<> can hold no error, so the arm lifting it is unreachable and cannot throw - but the
+        // value is still relocated, and still weighs
+        using Uh = fn::expected<int, fn::sum<>>;
+        using Ut = fn::expected<MoveNothrow, fn::sum<>>;
+        static_assert(noexcept(std::declval<Uh &>() & std::declval<Rh &>()));
+        static_assert(noexcept(std::declval<fn::expected<void, fn::sum<>> &>() & std::declval<Rh &>()));
+        static_assert(not noexcept(std::declval<Ut &>() & std::declval<Rh &>()));
+      }
+      SUCCEED();
+    }
   }
 }
 
@@ -2342,6 +2454,20 @@ TEST_CASE("expected sum support and_then", "[expected][sum][and_then]")
     static_assert(std::is_same_v<decltype(a.and_then(fn)), fn::expected<bool, Error>>);
     static_assert(a.and_then(fn).value());
   }
+
+  WHEN("noexcept")
+  {
+    // the callback is invoked through fn's own dispatch, so only fn's nothrow-invocable trait can
+    // answer for it - and it is nothrow only if EVERY alternative's call is
+    using T = fn::expected<fn::sum<double, int>, Error>;
+    static_assert(
+        noexcept(std::declval<T &>().and_then([](auto) noexcept -> fn::expected<bool, Error> { return {true}; })));
+    static_assert(not noexcept(std::declval<T &>().and_then([](auto) -> fn::expected<bool, Error> { return {true}; })));
+    static_assert(not noexcept(std::declval<T &>().and_then(
+        fn::overload{[](int) noexcept -> fn::expected<bool, Error> { return {true}; },
+                     [](double) -> fn::expected<bool, Error> { return {true}; }}))); // one throwing arm is enough
+    SUCCEED();
+  }
 }
 
 TEST_CASE("expected sum support or_else", "[expected][sum][or_else]")
@@ -2642,6 +2768,20 @@ TEST_CASE("expected sum support transform", "[expected][sum][transform]")
     T s{fn::sum{12}};
     CHECK(s.transform(lval_only).value() == fn::sum{true});
   }
+
+  WHEN("noexcept")
+  {
+    // the dispatch is nothrow only if every alternative's call is, and only if relocating what each
+    // returns into the result sum is - and, as ever, if lifting the untouched error is
+    using T = fn::expected<fn::sum<double, int>, Error>;
+    static_assert(noexcept(std::declval<T &>().transform([](auto) noexcept -> bool { return true; })));
+    static_assert(not noexcept(std::declval<T &>().transform([](auto) -> bool { return true; })));
+    static_assert(not noexcept(std::declval<fn::expected<fn::sum_for<MoveNothrow, int>, Error> &>().transform(
+        [](auto v) noexcept { return v; })));
+    static_assert(not noexcept(std::declval<fn::expected<fn::sum<double, int>, MoveNothrow> &>().transform(
+        [](auto) noexcept -> bool { return true; }))); // copies the error
+    SUCCEED();
+  }
 }
 
 TEST_CASE("expected sum support transform_error", "[expected][sum][transform_error]")
@@ -2851,6 +2991,17 @@ TEST_CASE("expected sum support transform_error", "[expected][sum][transform_err
     static_assert(std::is_same_v<decltype(r), fn::expected<std::unique_ptr<int>, bool>>);
     CHECK(*r.value() == 7);
   }
+
+  WHEN("noexcept")
+  {
+    // the error side dispatches through the sum exactly as the value side does
+    using T = fn::expected<int, fn::sum<double, int>>;
+    static_assert(noexcept(std::declval<T &>().transform_error([](auto) noexcept -> bool { return true; })));
+    static_assert(not noexcept(std::declval<T &>().transform_error([](auto) -> bool { return true; })));
+    static_assert(not noexcept(std::declval<fn::expected<MoveNothrow, fn::sum<double, int>> &>().transform_error(
+        [](auto) noexcept -> bool { return true; }))); // copies the untouched value
+    SUCCEED();
+  }
 }
 
 TEST_CASE("expected pack support or_else", "[expected][or_else][pack]")
diff --git a/tests/fn/optional.cpp b/tests/fn/optional.cpp
index 71fb5f9d..5d07e0c5 100644
--- a/tests/fn/optional.cpp
+++ b/tests/fn/optional.cpp
@@ -21,6 +21,30 @@ struct Xint {
   constexpr Xint &operator=(Xint const &) = default;
 };
 
+// Nothrow move, throwing copy: joining lvalue operands copies the value, joining rvalues moves it
+struct MoveNothrow {
+  MoveNothrow() = default;
+  MoveNothrow(MoveNothrow const &) noexcept(false) {}
+  MoveNothrow(MoveNothrow &&) noexcept = default;
+};
+
+// The join invokes its error-continuation as an lvalue - a named parameter - whatever the value
+// category it was passed in, and its specification must ask about that call. These answer the
+// lvalue and the rvalue question differently, in both directions - and the third offers only the
+// call the body performs. Namespace scope: a local class cannot have member templates.
+struct EfnLvalueNothrow {
+  constexpr auto operator()(auto const &) & noexcept -> std::nullopt_t { return std::nullopt; }
+  auto operator()(auto const &) && noexcept(false) -> std::nullopt_t { throw 0; }
+};
+struct EfnRvalueNothrow {
+  auto operator()(auto const &) & noexcept(false) -> std::nullopt_t { throw 0; }
+  constexpr auto operator()(auto const &) && noexcept -> std::nullopt_t { return std::nullopt; }
+};
+struct EfnLvalueOnly {
+  constexpr auto operator()(auto const &) & noexcept -> std::nullopt_t { return std::nullopt; }
+  auto operator()(auto const &) && -> std::nullopt_t = delete;
+};
+
 // Sums whose alternatives include a non-builtin (Xint/std::string_view/fn::pack — any
 // class/struct/enum) have platform-specific order (see sum.cpp); pure-builtin sums keep sum<...>.
 } // namespace
@@ -176,6 +200,25 @@ TEST_CASE("optional graded monad", "[optional][sum][graded][or_else][sum_value]"
       CHECK(std::move(std::as_const(s)).or_else(fn).value() == fn::sum{12});
       CHECK(std::move(s).or_else(fn).value() == fn::sum{12});
     }
+
+    WHEN("noexcept")
+    {
+      // the widening arm builds a sum from either side's value, and weighs both
+      using T = fn::optional<fn::sum<int>>;
+      constexpr auto widen = []() noexcept -> fn::optional<double> { return {0.5}; };
+      static_assert(std::is_same_v<decltype(std::declval<T &>().or_else(widen)), fn::optional<fn::sum<double, int>>>);
+      static_assert(noexcept(std::declval<T &>().or_else(widen)));
+      static_assert(not noexcept(std::declval<T &>().or_else([]() -> fn::optional<double> { return {0.5}; })));
+
+      // ... including relocating self's value into it
+      using W = fn::optional<fn::sum_for<MoveNothrow, int>>;
+      static_assert(not noexcept(std::declval<W &>().or_else(widen))); // copies
+      static_assert(noexcept(std::declval<W &&>().or_else(widen)));    // moves
+
+      // the same-shape arm, which pfn's own or_else would take
+      static_assert(noexcept(std::declval<T &>().or_else([]() noexcept -> T { return {fn::sum{1}}; })));
+      SUCCEED();
+    }
   }
 }
 
@@ -239,6 +282,18 @@ TEST_CASE("optional pack support", "[optional][pack][and_then][transform][operat
                                      [](int const &&, auto &&...) -> fn::optional<bool> { throw 0; }}) //
                     .has_value());
     }
+
+    WHEN("noexcept")
+    {
+      // a pack's callback is invoked through fn's own dispatch, taking one argument per element: it
+      // is not directly invocable on the pack, so only fn's nothrow-invocable trait can answer
+      using T = fn::optional<fn::pack<int, double>>;
+      static_assert(
+          noexcept(std::declval<T &>().and_then([](int, double) noexcept -> fn::optional<bool> { return {true}; })));
+      static_assert(
+          not noexcept(std::declval<T &>().and_then([](int, double) -> fn::optional<bool> { return {true}; })));
+      SUCCEED();
+    }
   }
 
   WHEN("transform")
@@ -285,6 +340,14 @@ TEST_CASE("optional pack support", "[optional][pack][and_then][transform][operat
       CHECK(not std::move(std::as_const(s)).transform([](auto...) -> bool { throw 0; }).has_value());
       CHECK(not std::move(s).transform([](auto...) -> bool { throw 0; }).has_value());
     }
+
+    WHEN("noexcept")
+    {
+      using T = fn::optional<fn::pack<int, double>>;
+      static_assert(noexcept(std::declval<T &>().transform([](int, double) noexcept -> bool { return true; })));
+      static_assert(not noexcept(std::declval<T &>().transform([](int, double) -> bool { return true; })));
+      SUCCEED();
+    }
   }
 
   WHEN("operator &")
@@ -485,6 +548,47 @@ TEST_CASE("optional pack support", "[optional][pack][and_then][transform][operat
         CHECK(not(Lh{std::nullopt} & Rh{std::nullopt}).has_value());
       }
     }
+
+    WHEN("noexcept")
+    {
+      // the join relocates both operands' values into the result, so it promises only what
+      // relocating them promises - the nullopt arm is a tag, and cannot throw
+      using Lh = fn::optional<MoveNothrow>;
+      using Rh = fn::optional<int>;
+      static_assert(noexcept(std::declval<Rh &>() & std::declval<Rh &>()));
+      static_assert(not noexcept(std::declval<Lh &>() & std::declval<Rh &>())); // copies
+      static_assert(not noexcept(std::declval<Rh &>() & std::declval<Lh &>()));
+      static_assert(noexcept(std::declval<Lh &&>() & std::declval<Rh &&>())); // moves
+      static_assert(noexcept(std::declval<Rh &&>() & std::declval<Lh &&>()));
+
+      // the same, dispatched through a sum
+      using Sh = fn::optional<fn::sum<MoveNothrow>>;
+      static_assert(not noexcept(std::declval<Sh &>() & std::declval<Rh &>()));
+      static_assert(noexcept(std::declval<Sh &&>() & std::declval<Rh &&>()));
+
+      WHEN("_join")
+      {
+        // the join invokes its error-continuation as an lvalue, and its specification asks about
+        // that call - whether the callable arrives as a temporary or an lvalue
+        using fn::detail::_join;
+        static_assert(noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnLvalueNothrow{})));
+        static_assert(
+            not noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnRvalueNothrow{})));
+        static_assert(noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnLvalueOnly{})));
+        static_assert(noexcept(
+            _join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), std::declval<EfnLvalueNothrow &>())));
+        static_assert(not noexcept(
+            _join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), std::declval<EfnRvalueNothrow &>())));
+
+        // the body performs the lvalue call: the rvalue overload throws, or does not exist
+        CHECK(not _join<fn::optional>(Rh{std::nullopt}, Rh{12}, EfnLvalueNothrow{}).has_value());
+        CHECK(not _join<fn::optional>(Rh{12}, Rh{std::nullopt}, EfnLvalueOnly{}).has_value());
+        CHECK(_join<fn::optional>(Rh{3}, Rh{4}, EfnLvalueOnly{}).has_value());
+        static_assert(not _join<fn::optional>(Rh{std::nullopt}, Rh{12}, EfnLvalueNothrow{}).has_value());
+        static_assert(not _join<fn::optional>(Rh{12}, Rh{std::nullopt}, EfnLvalueOnly{}).has_value());
+        static_assert(_join<fn::optional>(Rh{3}, Rh{4}, EfnLvalueOnly{}).has_value());
+      }
+    }
   }
 }
 
@@ -586,6 +690,19 @@ TEST_CASE("optional and_then sum", "[optional][sum][and_then]")
     static_assert(std::is_same_v<decltype(a.and_then(fn)), fn::optional<bool>>);
     static_assert(a.and_then(fn).value());
   }
+
+  WHEN("noexcept")
+  {
+    // the callback is invoked through fn's own dispatch, so only fn's nothrow-invocable trait can
+    // answer for it - and it is nothrow only if EVERY alternative's call is
+    using T = fn::optional<fn::sum<double, int>>;
+    static_assert(noexcept(std::declval<T &>().and_then([](auto) noexcept -> fn::optional<bool> { return {true}; })));
+    static_assert(not noexcept(std::declval<T &>().and_then([](auto) -> fn::optional<bool> { return {true}; })));
+    static_assert(not noexcept(std::declval<T &>().and_then(
+        fn::overload{[](int) noexcept -> fn::optional<bool> { return {true}; },
+                     [](double) -> fn::optional<bool> { return {true}; }}))); // one throwing alternative is enough
+    SUCCEED();
+  }
 }
 
 TEST_CASE("optional transform sum", "[optional][sum][transform]")
@@ -684,4 +801,19 @@ TEST_CASE("optional transform sum", "[optional][sum][transform]")
     T s{12};
     CHECK(s.transform(lval_only).value() == fn::sum{true});
   }
+
+  WHEN("noexcept")
+  {
+    // the dispatch is nothrow only if every alternative's call is, and only if relocating what each
+    // returns into the result sum is
+    using T = fn::optional<fn::sum<double, int>>;
+    static_assert(noexcept(std::declval<T &>().transform([](auto) noexcept -> bool { return true; })));
+    static_assert(not noexcept(std::declval<T &>().transform([](auto) -> bool { return true; })));
+    static_assert(not noexcept(std::declval<T &>().transform(
+        fn::overload{[](double) noexcept -> bool { return true; },
+                     [](int) -> bool { return true; }}))); // one throwing alternative is enough
+    static_assert(not noexcept(
+        std::declval<fn::optional<fn::sum_for<MoveNothrow, int>> &>().transform([](auto v) noexcept { return v; })));
+    SUCCEED();
+  }
 }