diff --git a/include/fn/expected.hpp b/include/fn/expected.hpp
index dbe265d6..ce5feb41 100644
--- a/include/fn/expected.hpp
+++ b/include/fn/expected.hpp
@@ -632,8 +632,12 @@ template <typename T, typename Err> class expected : private detail::_expected_b
     return _base::_transform_error(::std::move(*this), FWD(f));
   }
 
-  // Convert to graded monad
-  auto sum_error() const & -> expected<value_type, sum<error_type>>
+  // Convert to graded monad. A lifting overload wraps one side in a sum and relocates the other
+  // untouched, so it weighs both; the ones whose side already is a sum only return *this.
+  constexpr auto sum_error() const & noexcept(::std::is_nothrow_constructible_v<value_type, value_type const &>
+                                              && ::std::is_nothrow_constructible_v<sum<error_type>, error_type const &>
+                                              && ::std::is_nothrow_move_constructible_v<sum<error_type>>) // extension
+      -> expected<value_type, sum<error_type>>
     requires(not some_sum<error_type>)
   {
     using type = expected<value_type, sum<error_type>>;
@@ -642,7 +646,10 @@ template <typename T, typename Err> class expected : private detail::_expected_b
     else
       return type{::fn::unexpect, sum<error_type>(this->error())};
   }
-  auto sum_error() && -> expected<value_type, sum<error_type>>
+  constexpr auto sum_error() && noexcept(::std::is_nothrow_constructible_v<value_type, value_type>
+                                         && ::std::is_nothrow_constructible_v<sum<error_type>, error_type>
+                                         && ::std::is_nothrow_move_constructible_v<sum<error_type>>) // extension
+      -> expected<value_type, sum<error_type>>
     requires(not some_sum<error_type>)
   {
     using type = expected<value_type, sum<error_type>>;
@@ -651,28 +658,32 @@ template <typename T, typename Err> class expected : private detail::_expected_b
     else
       return type{::fn::unexpect, sum<error_type>(::std::move(*this).error())};
   }
-  auto sum_error() & -> decltype(auto)
+  constexpr auto sum_error() & noexcept -> decltype(auto)
     requires(some_sum<error_type>)
   {
     return *this;
   }
-  auto sum_error() const & -> decltype(auto)
+  constexpr auto sum_error() const & noexcept -> decltype(auto)
     requires(some_sum<error_type>)
   {
     return *this;
   }
-  auto sum_error() && -> decltype(auto)
+  constexpr auto sum_error() && noexcept -> decltype(auto)
     requires(some_sum<error_type>)
   {
     return ::std::move(*this);
   }
-  auto sum_error() const && -> decltype(auto)
+  constexpr auto sum_error() const && noexcept -> decltype(auto)
     requires(some_sum<error_type>)
   {
     return ::std::move(*this);
   }
 
-  auto sum_value() const & -> expected<sum<value_type>, error_type>
+  constexpr auto
+  sum_value() const & noexcept(::std::is_nothrow_constructible_v<sum<value_type>, value_type const &>
+                               && ::std::is_nothrow_move_constructible_v<sum<value_type>>
+                               && ::std::is_nothrow_constructible_v<error_type, error_type const &>) // extension
+      -> expected<sum<value_type>, error_type>
     requires(not some_sum<value_type>)
   {
     using type = expected<sum<value_type>, error_type>;
@@ -681,7 +692,10 @@ template <typename T, typename Err> class expected : private detail::_expected_b
     else
       return type{::fn::unexpect, this->error()};
   }
-  auto sum_value() && -> expected<sum<value_type>, error_type>
+  constexpr auto sum_value() && noexcept(::std::is_nothrow_constructible_v<sum<value_type>, value_type>
+                                         && ::std::is_nothrow_move_constructible_v<sum<value_type>>
+                                         && ::std::is_nothrow_constructible_v<error_type, error_type>) // extension
+      -> expected<sum<value_type>, error_type>
     requires(not some_sum<value_type>)
   {
     using type = expected<sum<value_type>, error_type>;
@@ -690,22 +704,22 @@ template <typename T, typename Err> class expected : private detail::_expected_b
     else
       return type{::fn::unexpect, ::std::move(*this).error()};
   }
-  auto sum_value() & -> decltype(auto)
+  constexpr auto sum_value() & noexcept -> decltype(auto)
     requires(some_sum<value_type>)
   {
     return *this;
   }
-  auto sum_value() const & -> decltype(auto)
+  constexpr auto sum_value() const & noexcept -> decltype(auto)
     requires(some_sum<value_type>)
   {
     return *this;
   }
-  auto sum_value() && -> decltype(auto)
+  constexpr auto sum_value() && noexcept -> decltype(auto)
     requires(some_sum<value_type>)
   {
     return ::std::move(*this);
   }
-  auto sum_value() const && -> decltype(auto)
+  constexpr auto sum_value() const && noexcept -> decltype(auto)
     requires(some_sum<value_type>)
   {
     return ::std::move(*this);
@@ -971,8 +985,10 @@ template <typename Err> class expected<void, Err> : private detail::_expected_ba
     return _base::_transform_error(::std::move(*this), FWD(f));
   }
 
-  // Convert to graded monad
-  auto sum_error() const & -> expected<value_type, sum<error_type>>
+  // Convert to graded monad. There is no value to relocate here, so only the error's lift weighs.
+  constexpr auto sum_error() const & noexcept(::std::is_nothrow_constructible_v<sum<error_type>, error_type const &>
+                                              && ::std::is_nothrow_move_constructible_v<sum<error_type>>) // extension
+      -> expected<value_type, sum<error_type>>
     requires(not some_sum<error_type>)
   {
     using type = expected<value_type, sum<error_type>>;
@@ -981,7 +997,9 @@ template <typename Err> class expected<void, Err> : private detail::_expected_ba
     else
       return type{::fn::unexpect, sum<error_type>(this->error())};
   }
-  auto sum_error() && -> expected<value_type, sum<error_type>>
+  constexpr auto sum_error() && noexcept(::std::is_nothrow_constructible_v<sum<error_type>, error_type>
+                                         && ::std::is_nothrow_move_constructible_v<sum<error_type>>) // extension
+      -> expected<value_type, sum<error_type>>
     requires(not some_sum<error_type>)
   {
     using type = expected<value_type, sum<error_type>>;
@@ -990,22 +1008,22 @@ template <typename Err> class expected<void, Err> : private detail::_expected_ba
     else
       return type{::fn::unexpect, sum<error_type>(::std::move(*this).error())};
   }
-  auto sum_error() & -> decltype(auto)
+  constexpr auto sum_error() & noexcept -> decltype(auto)
     requires(some_sum<error_type>)
   {
     return *this;
   }
-  auto sum_error() const & -> decltype(auto)
+  constexpr auto sum_error() const & noexcept -> decltype(auto)
     requires(some_sum<error_type>)
   {
     return *this;
   }
-  auto sum_error() && -> decltype(auto)
+  constexpr auto sum_error() && noexcept -> decltype(auto)
     requires(some_sum<error_type>)
   {
     return ::std::move(*this);
   }
-  auto sum_error() const && -> decltype(auto)
+  constexpr auto sum_error() const && noexcept -> decltype(auto)
     requires(some_sum<error_type>)
   {
     return ::std::move(*this);
@@ -1022,11 +1040,16 @@ template <typename Err> class expected<void, Err> : private detail::_expected_ba
   }
 };
 // Lifts for sum transformation functions
-[[nodiscard]] constexpr auto sum_value(some_expected_non_void auto &&src) -> decltype(auto)
+[[nodiscard]] constexpr auto sum_value(some_expected_non_void auto &&src) noexcept(noexcept(FWD(src).sum_value()))
+    -> decltype(auto)
 {
   return FWD(src).sum_value();
 }
-[[nodiscard]] constexpr auto sum_error(some_expected auto &&src) -> decltype(auto) { return FWD(src).sum_error(); }
+[[nodiscard]] constexpr auto sum_error(some_expected auto &&src) noexcept(noexcept(FWD(src).sum_error()))
+    -> decltype(auto)
+{
+  return FWD(src).sum_error();
+}
 
 // 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)
diff --git a/include/fn/optional.hpp b/include/fn/optional.hpp
index f0937a97..c9980f91 100644
--- a/include/fn/optional.hpp
+++ b/include/fn/optional.hpp
@@ -477,8 +477,11 @@ template <typename T> class optional : private detail::_optional_base<T> { // NO
     return _base::_transform(::std::move(*this), FWD(f));
   }
 
-  // Convert to graded monad
-  auto sum_value() const & -> optional<sum<value_type>>
+  // Convert to graded monad. The lifting overloads wrap the value in a sum and that sum in the
+  // result, so they weigh both; the ones whose value type already is a sum only return *this.
+  constexpr auto sum_value() const & noexcept(::std::is_nothrow_constructible_v<sum<value_type>, value_type const &>
+                                              && ::std::is_nothrow_move_constructible_v<sum<value_type>>) // extension
+      -> optional<sum<value_type>>
     requires(not some_sum<value_type>)
   {
     using type = optional<sum<value_type>>;
@@ -487,7 +490,9 @@ template <typename T> class optional : private detail::_optional_base<T> { // NO
     else
       return type{::std::nullopt};
   }
-  auto sum_value() && -> optional<sum<value_type>>
+  constexpr auto sum_value() && noexcept(::std::is_nothrow_constructible_v<sum<value_type>, value_type>
+                                         && ::std::is_nothrow_move_constructible_v<sum<value_type>>) // extension
+      -> optional<sum<value_type>>
     requires(not some_sum<value_type>)
   {
     using type = optional<sum<value_type>>;
@@ -496,22 +501,22 @@ template <typename T> class optional : private detail::_optional_base<T> { // NO
     else
       return type{::std::nullopt};
   }
-  auto sum_value() & -> decltype(auto)
+  constexpr auto sum_value() & noexcept -> decltype(auto)
     requires(some_sum<value_type>)
   {
     return *this;
   }
-  auto sum_value() const & -> decltype(auto)
+  constexpr auto sum_value() const & noexcept -> decltype(auto)
     requires(some_sum<value_type>)
   {
     return *this;
   }
-  auto sum_value() && -> decltype(auto)
+  constexpr auto sum_value() && noexcept -> decltype(auto)
     requires(some_sum<value_type>)
   {
     return ::std::move(*this);
   }
-  auto sum_value() const && -> decltype(auto)
+  constexpr auto sum_value() const && noexcept -> decltype(auto)
     requires(some_sum<value_type>)
   {
     return ::std::move(*this);
@@ -880,7 +885,11 @@ constexpr optional<T> make_optional(::std::initializer_list<U> il, Args &&...arg
 }
 
 // Lifts for sum transformation functions
-[[nodiscard]] constexpr auto sum_value(some_optional auto &&src) -> decltype(auto) { return FWD(src).sum_value(); }
+[[nodiscard]] constexpr auto sum_value(some_optional auto &&src) noexcept(noexcept(FWD(src).sum_value()))
+    -> decltype(auto)
+{
+  return FWD(src).sum_value();
+}
 
 template <some_optional Lh, some_optional Rh> [[nodiscard]] constexpr auto operator&(Lh &&lh, Rh &&rh) noexcept
 {
diff --git a/tests/fn/expected.cpp b/tests/fn/expected.cpp
index bf11fa86..61b65d69 100644
--- a/tests/fn/expected.cpp
+++ b/tests/fn/expected.cpp
@@ -232,6 +232,48 @@ TEST_CASE("graded monad", "[expected][sum][graded][and_then][or_else][sum_value]
     static_assert(std::is_same_v<decltype(fn::sum_error(s)), T &>);
   }
 
+  WHEN("constexpr")
+  {
+    static_assert([] {
+      fn::expected<int, Error> const a{::fn::unexpect, Unknown};
+      return a.sum_error().error() == fn::sum{Unknown};
+    }());
+    static_assert([] { return fn::expected<int, Error>{12}.sum_error().value() == 12; }());
+    static_assert([] { return fn::expected<int, Error>{12}.sum_value().value() == fn::sum{12}; }());
+    static_assert([] {
+      fn::expected<void, Error> const a{::fn::unexpect, Unknown};
+      return a.sum_error().error() == fn::sum{Unknown};
+    }());
+    static_assert([] {
+      fn::expected<int, Error> a{12};
+      return fn::sum_value(a).value() == fn::sum{12};
+    }());
+    SUCCEED();
+  }
+
+  WHEN("noexcept")
+  {
+    using S = fn::expected<int, fn::sum<Error>>; // error already a sum
+    using V = fn::expected<fn::sum<int>, Error>; // value already a sum
+
+    // the overloads whose side already is a sum only return *this
+    static_assert(noexcept(std::declval<S &>().sum_error()));
+    static_assert(noexcept(std::declval<S const &&>().sum_error()));
+    static_assert(noexcept(std::declval<V &>().sum_value()));
+    static_assert(noexcept(std::declval<V const &&>().sum_value()));
+    static_assert(noexcept(fn::sum_error(std::declval<S &>())));
+    static_assert(noexcept(fn::sum_value(std::declval<V &>())));
+
+    // a lifting overload wraps one side in a sum and relocates the other, so it weighs both. sum's
+    // own value constructor carries no noexcept specifier yet (#280), so these are conservatively
+    // false, and sharpen when it does
+    static_assert(not noexcept(std::declval<fn::expected<int, Error> &>().sum_error()));
+    static_assert(not noexcept(std::declval<fn::expected<int, Error> &&>().sum_value()));
+    static_assert(not noexcept(std::declval<fn::expected<void, Error> &>().sum_error()));
+    static_assert(not noexcept(fn::sum_error(std::declval<fn::expected<int, Error> &>())));
+    SUCCEED();
+  }
+
   WHEN("sum_value from sum")
   {
     using T = fn::expected<fn::sum<int>, Error>;
diff --git a/tests/fn/optional.cpp b/tests/fn/optional.cpp
index b060c27e..524e14ca 100644
--- a/tests/fn/optional.cpp
+++ b/tests/fn/optional.cpp
@@ -79,6 +79,42 @@ TEST_CASE("optional graded monad", "[optional][sum][graded][or_else][sum_value]"
     }
 
     static_assert(std::is_same_v<decltype(fn::sum_value(s)), fn::optional<fn::sum<int>>>);
+
+    WHEN("constexpr")
+    {
+      static_assert([] {
+        fn::optional<int> const a{12};
+        return a.sum_value().value() == fn::sum{12};
+      }());
+      static_assert([] { return fn::optional<int>{12}.sum_value().value() == fn::sum{12}; }());
+      static_assert([] { return not fn::optional<int>{std::nullopt}.sum_value().has_value(); }());
+      static_assert([] {
+        fn::optional<int> a{12};
+        return fn::sum_value(a).value() == fn::sum{12};
+      }());
+      SUCCEED();
+    }
+  }
+
+  WHEN("noexcept")
+  {
+    using T = fn::optional<int>;
+    using S = fn::optional<fn::sum<int>>;
+
+    // the sum-valued overloads only return *this
+    static_assert(noexcept(std::declval<S &>().sum_value()));
+    static_assert(noexcept(std::declval<S const &>().sum_value()));
+    static_assert(noexcept(std::declval<S &&>().sum_value()));
+    static_assert(noexcept(std::declval<S const &&>().sum_value()));
+    static_assert(noexcept(fn::sum_value(std::declval<S &>())));
+
+    // the lifting overloads wrap the value in a sum, so they weigh that construction: sum's own
+    // value constructor carries no noexcept specifier yet (#280), so they are conservatively false
+    // even for int, and sharpen when it does
+    static_assert(not noexcept(std::declval<T &>().sum_value()));
+    static_assert(not noexcept(std::declval<T &&>().sum_value()));
+    static_assert(not noexcept(fn::sum_value(std::declval<T &>())));
+    SUCCEED();
   }
 
   WHEN("or_else")