diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ed9ea600..55fd9cd8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,7 +4,7 @@ This is for working *on* libfn; to *use* the library, see the [README](README.md
 
 ## Development environment
 
-Building and testing libfn needs a C++20 toolchain (with one exception). `pfn` polyfills the C++23 standard-library utilities that `fn` builds on (`pfn::expected`, `pfn::invoke_r`, `pfn::unreachable`). The minimum supported compilers are [gcc 12][gcc-standard-support] and [clang 16][clang-standard-support]; if your OS does not ship one recent enough, use the [devcontainer] or [Nix][nix] (see [nix/README.md][nixmd]). You may also use Apple Clang 16.0 or Microsoft Visual Studio 2022 or newer.
+Building and testing libfn needs a C++20 toolchain (with one exception). `pfn` polyfills C++23/26 standard-library utilities (`pfn::expected`, `pfn::optional`, `pfn::invoke_r`, `pfn::unreachable`); `fn` builds on `pfn` rather than the newer standard library. The minimum supported compilers are [gcc 12][gcc-standard-support] and [clang 16][clang-standard-support]; if your OS does not ship one recent enough, use the [devcontainer] or [Nix][nix] (see [nix/README.md][nixmd]). You may also use Apple Clang 16.0 or Microsoft Visual Studio 2022 or newer.
 
 When working with `tests/pfn/expected.cpp` you will need a C++23 compiler, in order to enable the `VALIDATE_CXX23` option for `expected_validation.cpp` tests.
 
diff --git a/include/fn/expected.hpp b/include/fn/expected.hpp
index 3cfb7aeb..2dc0d227 100644
--- a/include/fn/expected.hpp
+++ b/include/fn/expected.hpp
@@ -41,8 +41,8 @@ struct expected_policy {
 // 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>`.
-template <typename T, typename E> struct _storage : ::pfn::detail::_storage<T, E, expected_policy> {
-  using _pfn_base = ::pfn::detail::_storage<T, E, expected_policy>;
+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;
 
   // and_then, non-void value type
@@ -248,8 +248,8 @@ template <typename T, typename E> struct _storage : ::pfn::detail::_storage<T, E
 } // namespace detail
 
 // Primary template - non-void value type
-template <typename T, typename Err> struct expected : private detail::_storage<T, Err> {
-  using _base = detail::_storage<T, Err>;
+template <typename T, typename Err> struct expected : private detail::_expected_base<T, Err> {
+  using _base = detail::_expected_base<T, Err>;
   using value_type = T;
   using error_type = Err;
   using unexpected_type = ::pfn::unexpected<Err>;
@@ -257,9 +257,9 @@ template <typename T, typename Err> struct expected : private detail::_storage<T
 
   template <class U> using rebind = expected<U, error_type>;
 
-  // Allow sibling _storage instantiations to downcast into the private base.
-  template <class, class, class> friend struct ::pfn::detail::_storage;
-  template <class, class> friend struct ::fn::detail::_storage;
+  // Allow sibling _expected_base instantiations to downcast into the private base.
+  template <class, class, class> friend struct ::pfn::detail::_expected_base;
+  template <class, class> friend struct ::fn::detail::_expected_base;
 
   // Constructors. Explicit forwarders to the base mirror pfn::expected.
   constexpr expected() noexcept(::std::is_nothrow_default_constructible_v<T>)
@@ -414,7 +414,7 @@ template <typename T, typename Err> struct expected : private detail::_storage<T
     return *this;
   }
 
-  // Observers inherited from _storage
+  // Observers inherited from _expected_base
   using _base::operator*;
   using _base::operator->;
   using _base::operator bool;
@@ -425,10 +425,10 @@ template <typename T, typename Err> struct expected : private detail::_storage<T
   using _base::value;
   using _base::value_or;
 
-  // Emplace inherited from _storage
+  // Emplace inherited from _expected_base
   using _base::emplace;
 
-  // Swap; body delegates to _storage helper
+  // Swap; body delegates to _expected_base helper
   constexpr void
   swap(expected &rhs) noexcept(::std::is_nothrow_move_constructible_v<T> && ::std::is_nothrow_swappable_v<T>
                                && ::std::is_nothrow_move_constructible_v<Err> && ::std::is_nothrow_swappable_v<Err>)
@@ -439,7 +439,7 @@ template <typename T, typename Err> struct expected : private detail::_storage<T
     this->_swap_with(rhs);
   }
 
-  // Monadic operations. Bodies delegate to _storage static helpers, which perform sum-widening.
+  // Monadic operations. Bodies delegate to _expected_base static helpers, which perform sum-widening.
   template <class F>
   constexpr auto and_then(F &&f) &                        //
       noexcept(noexcept(_base::_and_then(*this, FWD(f)))) // extension
@@ -636,16 +636,16 @@ template <typename T, typename Err> struct expected : private detail::_storage<T
   }
 };
 
-template <typename Err> struct expected<void, Err> : private detail::_storage<void, Err> {
-  using _base = detail::_storage<void, Err>;
+template <typename Err> struct expected<void, Err> : private detail::_expected_base<void, Err> {
+  using _base = detail::_expected_base<void, Err>;
   using value_type = void;
   using error_type = Err;
   using unexpected_type = ::pfn::unexpected<Err>;
 
   template <class U> using rebind = expected<U, error_type>;
 
-  template <class, class, class> friend struct ::pfn::detail::_storage;
-  template <class, class> friend struct ::fn::detail::_storage;
+  template <class, class, class> friend struct ::pfn::detail::_expected_base;
+  template <class, class> friend struct ::fn::detail::_expected_base;
 
   constexpr expected() noexcept : _base(::std::in_place) {}
 
@@ -766,7 +766,7 @@ template <typename Err> struct expected<void, Err> : private detail::_storage<vo
   using _base::has_value;
   using _base::value;
 
-  // Monadic operations. Bodies delegate to _storage static helpers, which perform sum-widening.
+  // Monadic operations. Bodies delegate to _expected_base static helpers, which perform sum-widening.
   template <class F>
   constexpr auto and_then(F &&f) &                        //
       noexcept(noexcept(_base::_and_then(*this, FWD(f)))) // extension
diff --git a/include/pfn/expected.hpp b/include/pfn/expected.hpp
index 9cd1425e..4c3c8b07 100644
--- a/include/pfn/expected.hpp
+++ b/include/pfn/expected.hpp
@@ -194,13 +194,13 @@ constexpr bool _is_valid_expected =                                   //
 
 // Internal union wrapper for the value/error storage. Copy/move ctors
 // are defaulted iff both `T` and `E` are trivially copy/move-constructible.
-template <class T, class E> union _storage_union_t {
+template <class T, class E> union _expected_union_t {
   using _value_t = T;
   T v_;
   E e_;
 
   template <typename S>
-  constexpr explicit _storage_union_t(bool s, S &&src) //
+  constexpr explicit _expected_union_t(bool s, S &&src) //
       noexcept(::std::is_nothrow_constructible_v<T, decltype((FWD(src).v_))>
                && ::std::is_nothrow_constructible_v<E, decltype((FWD(src).e_))>)
   {
@@ -210,36 +210,36 @@ template <class T, class E> union _storage_union_t {
       ::std::construct_at(::std::addressof(e_), FWD(src).e_);
   }
 
-  constexpr _storage_union_t(_storage_union_t const &) = delete;
-  constexpr _storage_union_t(_storage_union_t const &) //
+  constexpr _expected_union_t(_expected_union_t const &) = delete;
+  constexpr _expected_union_t(_expected_union_t const &) noexcept //
     requires(::std::is_trivially_copy_constructible_v<T> && ::std::is_trivially_copy_constructible_v<E>)
   = default;
-  constexpr _storage_union_t(_storage_union_t &&) = delete;
-  constexpr _storage_union_t(_storage_union_t &&) //
+  constexpr _expected_union_t(_expected_union_t &&) = delete;
+  constexpr _expected_union_t(_expected_union_t &&) noexcept //
     requires(::std::is_trivially_move_constructible_v<T> && ::std::is_trivially_move_constructible_v<E>)
   = default;
-  constexpr _storage_union_t &operator=(_storage_union_t const &) = delete;
-  constexpr _storage_union_t &operator=(_storage_union_t &&) = delete;
+  constexpr _expected_union_t &operator=(_expected_union_t const &) = delete;
+  constexpr _expected_union_t &operator=(_expected_union_t &&) = delete;
 
   template <class... Args>
-  constexpr explicit _storage_union_t(::std::in_place_t /*ignored*/, Args &&...a) //
+  constexpr explicit _expected_union_t(::std::in_place_t /*ignored*/, Args &&...a) //
       noexcept(::std::is_nothrow_constructible_v<T, Args...>)
     requires ::std::is_constructible_v<T, Args...>
       : v_(FWD(a)...)
   {
   }
   template <class... Args>
-  constexpr explicit _storage_union_t(unexpect_t /*ignored*/, Args &&...a) //
+  constexpr explicit _expected_union_t(unexpect_t /*ignored*/, Args &&...a) //
       noexcept(::std::is_nothrow_constructible_v<E, Args...>)
     requires ::std::is_constructible_v<E, Args...>
       : e_(FWD(a)...)
   {
   }
 
-  constexpr ~_storage_union_t() noexcept
+  constexpr ~_expected_union_t() noexcept
     requires(::std::is_trivially_destructible_v<T> && ::std::is_trivially_destructible_v<E>)
   = default;
-  constexpr ~_storage_union_t() noexcept {}
+  constexpr ~_expected_union_t() noexcept {}
 
   // [expected.object.assign], implementation of reinit-expected
   template <typename New, typename Old, typename... Args>
@@ -296,7 +296,7 @@ template <class T, class E> union _storage_union_t {
   }
 };
 
-template <class E> union _storage_union_t<void, E> {
+template <class E> union _expected_union_t<void, E> {
   // _dummy_t placeholder, so the union always has an active member
   struct _dummy_t final {
     constexpr _dummy_t() noexcept = default;
@@ -307,7 +307,7 @@ template <class E> union _storage_union_t<void, E> {
   E e_;
 
   template <typename S>
-  constexpr explicit _storage_union_t(bool s, S &&src) //
+  constexpr explicit _expected_union_t(bool s, S &&src) //
       noexcept(::std::is_nothrow_constructible_v<E, decltype((FWD(src).e_))>)
   {
     if (s)
@@ -316,31 +316,31 @@ template <class E> union _storage_union_t<void, E> {
       ::std::construct_at(::std::addressof(e_), FWD(src).e_);
   }
 
-  constexpr _storage_union_t(_storage_union_t const &) = delete;
-  constexpr _storage_union_t(_storage_union_t const &) //
+  constexpr _expected_union_t(_expected_union_t const &) = delete;
+  constexpr _expected_union_t(_expected_union_t const &) noexcept //
     requires(::std::is_trivially_copy_constructible_v<E>)
   = default;
-  constexpr _storage_union_t(_storage_union_t &&) = delete;
-  constexpr _storage_union_t(_storage_union_t &&) //
+  constexpr _expected_union_t(_expected_union_t &&) = delete;
+  constexpr _expected_union_t(_expected_union_t &&) noexcept //
     requires(::std::is_trivially_move_constructible_v<E>)
   = default;
-  constexpr _storage_union_t &operator=(_storage_union_t const &) = delete;
-  constexpr _storage_union_t &operator=(_storage_union_t &&) = delete;
+  constexpr _expected_union_t &operator=(_expected_union_t const &) = delete;
+  constexpr _expected_union_t &operator=(_expected_union_t &&) = delete;
 
-  constexpr explicit _storage_union_t(::std::in_place_t /*ignored*/) noexcept : v_{} {}
+  constexpr explicit _expected_union_t(::std::in_place_t /*ignored*/) noexcept : v_{} {}
 
   template <class... Args>
-  constexpr explicit _storage_union_t(unexpect_t /*ignored*/, Args &&...a) //
+  constexpr explicit _expected_union_t(unexpect_t /*ignored*/, Args &&...a) //
       noexcept(::std::is_nothrow_constructible_v<E, Args...>)
     requires ::std::is_constructible_v<E, Args...>
       : e_(FWD(a)...)
   {
   }
 
-  constexpr ~_storage_union_t() noexcept
+  constexpr ~_expected_union_t() noexcept
     requires(::std::is_trivially_destructible_v<E>)
   = default;
-  constexpr ~_storage_union_t() noexcept {}
+  constexpr ~_expected_union_t() noexcept {}
 
   // [expected.void.assign] mandates direct construction (no temporary).
   template <typename New, typename Old, typename... Args>
@@ -365,13 +365,13 @@ template <class E> union _storage_union_t<void, E> {
   }
 };
 
-template <typename> constexpr bool _is_storage_union = false;
-template <typename T, typename E> constexpr bool _is_storage_union<_storage_union_t<T, E>> = true;
+template <typename> constexpr bool _is_expected_union = false;
+template <typename T, typename E> constexpr bool _is_expected_union<_expected_union_t<T, E>> = true;
 
 // Shared implementation base class for ::pfn::expected, both primary template
 // and void specialization. Members are public since inheritance is private.
-template <class T, class E, class Policy> struct _storage {
-  using _storage_t = _storage_union_t<T, E>;
+template <class T, class E, class Policy> struct _expected_base {
+  using _storage_t = _expected_union_t<T, E>;
   // `_value_t` is `T` for non-void, and trivial `_dummy_t` for void.
   using _value_t = _storage_t::_value_t;
   _storage_t storage_;
@@ -438,10 +438,10 @@ template <class T, class E, class Policy> struct _storage {
 
   // Shared construction helper used by both the converting copy/move ctors
   // and same-type non-trivial copy/move ctors. Delegates the union's
-  // member selection to _storage_union_t(bool, S&&), based on first parameter.
+  // member selection to _expected_union_t(bool, S&&), based on first parameter.
   template <typename S>
-  constexpr explicit _storage(bool s, S &&src)
-    requires(_is_storage_union<::std::remove_cvref_t<S>>)
+  constexpr explicit _expected_base(bool s, S &&src)
+    requires(_is_expected_union<::std::remove_cvref_t<S>>)
       : storage_(s, FWD(src)), set_(s)
   {
   }
@@ -449,28 +449,28 @@ template <class T, class E, class Policy> struct _storage {
   // The wrapper's default, value (U&&) and unexpected<G> converting ctors forward directly to the
   // in_place / unexpect overloads below, so no dedicated overloads for those are provided here.
   template <class... Args>
-  constexpr explicit _storage(::std::in_place_t /*ignored*/, Args &&...a) //
+  constexpr explicit _expected_base(::std::in_place_t /*ignored*/, Args &&...a) //
       noexcept(::std::is_nothrow_constructible_v<_storage_t, ::std::in_place_t, Args...>)
     requires ::std::is_constructible_v<_storage_t, ::std::in_place_t, Args...>
       : storage_(::std::in_place, FWD(a)...), set_(true)
   {
   }
   template <class U, class... Args>
-  constexpr explicit _storage(::std::in_place_t /*ignored*/, ::std::initializer_list<U> il, Args &&...a) //
+  constexpr explicit _expected_base(::std::in_place_t /*ignored*/, ::std::initializer_list<U> il, Args &&...a) //
       noexcept(::std::is_nothrow_constructible_v<_storage_t, ::std::in_place_t, ::std::initializer_list<U> &, Args...>)
     requires ::std::is_constructible_v<_storage_t, ::std::in_place_t, ::std::initializer_list<U> &, Args...>
       : storage_(::std::in_place, il, FWD(a)...), set_(true)
   {
   }
   template <class... Args>
-  constexpr explicit _storage(unexpect_t /*ignored*/, Args &&...a) //
+  constexpr explicit _expected_base(unexpect_t /*ignored*/, Args &&...a) //
       noexcept(::std::is_nothrow_constructible_v<E, Args...>)
     requires ::std::is_constructible_v<E, Args...>
       : storage_(unexpect, FWD(a)...), set_(false)
   {
   }
   template <class U, class... Args>
-  constexpr explicit _storage(unexpect_t /*ignored*/, ::std::initializer_list<U> il, Args &&...a) //
+  constexpr explicit _expected_base(unexpect_t /*ignored*/, ::std::initializer_list<U> il, Args &&...a) //
       noexcept(::std::is_nothrow_constructible_v<E, ::std::initializer_list<U> &, Args...>)
     requires ::std::is_constructible_v<E, ::std::initializer_list<U> &, Args...>
       : storage_(unexpect, il, FWD(a)...), set_(false)
@@ -482,23 +482,23 @@ template <class T, class E, class Policy> struct _storage {
   template <class U, class G>
   constexpr explicit(not ::std::is_convertible_v<::std::add_lvalue_reference_t<::std::add_const_t<U>>, T>
                      || not ::std::is_convertible_v<G const &, E>)
-      _storage(typename Policy::template type<U, G> const &s) //
+      _expected_base(typename Policy::template type<U, G> const &s) //
       noexcept((::std::is_void_v<T>
                 || ::std::is_nothrow_constructible_v<_value_t, ::std::add_lvalue_reference_t<::std::add_const_t<U>>>)
                && ::std::is_nothrow_constructible_v<E, G const &>) // extension
     requires(_can_copy_convert<U, G>::value)
-      : _storage(static_cast<_storage<U, G, Policy> const &>(s).set_,
-                 static_cast<_storage<U, G, Policy> const &>(s).storage_)
+      : _expected_base(static_cast<_expected_base<U, G, Policy> const &>(s).set_,
+                       static_cast<_expected_base<U, G, Policy> const &>(s).storage_)
   {
   }
   template <class U, class G>
   constexpr explicit(not ::std::is_convertible_v<U, T> || not ::std::is_convertible_v<G, E>)
-      _storage(typename Policy::template type<U, G> &&s)                               //
+      _expected_base(typename Policy::template type<U, G> &&s)                         //
       noexcept((::std::is_void_v<T> || ::std::is_nothrow_constructible_v<_value_t, U>) //
                &&::std::is_nothrow_constructible_v<E, G>)                              // extension
     requires(_can_move_convert<U, G>::value)
-      : _storage(static_cast<_storage<U, G, Policy> &&>(s).set_,
-                 ::std::move(static_cast<_storage<U, G, Policy> &&>(s).storage_))
+      : _expected_base(static_cast<_expected_base<U, G, Policy> &&>(s).set_,
+                       ::std::move(static_cast<_expected_base<U, G, Policy> &&>(s).storage_))
   {
   }
 
@@ -541,27 +541,27 @@ template <class T, class E, class Policy> struct _storage {
     }
   }
 
-  constexpr _storage(_storage const &) = default;
-  constexpr _storage(_storage &&) = default;
-  constexpr _storage &operator=(_storage const &) = delete;
-  constexpr _storage &operator=(_storage &&) = delete;
+  constexpr _expected_base(_expected_base const &) noexcept = default;
+  constexpr _expected_base(_expected_base &&) noexcept = default;
+  constexpr _expected_base &operator=(_expected_base const &) = delete;
+  constexpr _expected_base &operator=(_expected_base &&) = delete;
 
-  constexpr ~_storage() //
+  constexpr ~_expected_base() //
     requires(::std::is_trivially_destructible_v<_value_t> && ::std::is_trivially_destructible_v<E>)
   = default;
-  constexpr ~_storage() //
+  constexpr ~_expected_base() //
     requires(::std::is_trivially_destructible_v<_value_t> && not ::std::is_trivially_destructible_v<E>)
   {
     if (not set_)
       ::std::destroy_at(::std::addressof(storage_.e_));
   }
-  constexpr ~_storage() //
+  constexpr ~_expected_base() //
     requires(not ::std::is_trivially_destructible_v<_value_t> && ::std::is_trivially_destructible_v<E>)
   {
     if (set_)
       ::std::destroy_at(::std::addressof(storage_.v_));
   }
-  constexpr ~_storage() //
+  constexpr ~_expected_base() //
     requires(not ::std::is_trivially_destructible_v<_value_t> && not ::std::is_trivially_destructible_v<E>)
   {
     if (set_)
@@ -737,26 +737,26 @@ template <class T, class E, class Policy> struct _storage {
 
   template <typename Self, typename Fn>
   static constexpr auto _and_then(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_storage::_value(FWD(self)))>
-               && ::std::is_nothrow_constructible_v<E, decltype(_storage::_error(FWD(self)))>)
-    requires(not ::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_storage::_value(FWD(self)))>
-             && ::std::is_constructible_v<E, decltype(_storage::_error(FWD(self)))>)
+      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_expected_base::_value(FWD(self)))>
+               && ::std::is_nothrow_constructible_v<E, decltype(_expected_base::_error(FWD(self)))>)
+    requires(not ::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_expected_base::_value(FWD(self)))>
+             && ::std::is_constructible_v<E, decltype(_expected_base::_error(FWD(self)))>)
   {
-    using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn, decltype(_storage::_value(FWD(self)))>>;
+    using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn, decltype(_expected_base::_value(FWD(self)))>>;
     static_assert(Policy::template is_specialization<result_t>);
     static_assert(::std::is_same_v<typename result_t::error_type, typename ::std::remove_cvref_t<Self>::error_type>);
     if (self.has_value()) {
-      return ::std::invoke(FWD(fn), _storage::_value(FWD(self)));
+      return ::std::invoke(FWD(fn), _expected_base::_value(FWD(self)));
     }
-    return result_t(unexpect, _storage::_error(FWD(self)));
+    return result_t(unexpect, _expected_base::_error(FWD(self)));
   }
 
   template <typename Self, typename Fn>
   static constexpr auto _and_then(Self &&self, Fn &&fn) //
       noexcept(::std::is_nothrow_invocable_v<Fn>
-               && ::std::is_nothrow_constructible_v<E, decltype(_storage::_error(FWD(self)))>)
+               && ::std::is_nothrow_constructible_v<E, decltype(_expected_base::_error(FWD(self)))>)
     requires(::std::is_void_v<T> && ::std::is_invocable_v<Fn>
-             && ::std::is_constructible_v<E, decltype(_storage::_error(FWD(self)))>)
+             && ::std::is_constructible_v<E, decltype(_expected_base::_error(FWD(self)))>)
   {
     using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn>>;
     static_assert(Policy::template is_specialization<result_t>);
@@ -764,75 +764,76 @@ template <class T, class E, class Policy> struct _storage {
     if (self.has_value()) {
       return ::std::invoke(FWD(fn));
     }
-    return result_t(unexpect, _storage::_error(FWD(self)));
+    return result_t(unexpect, _expected_base::_error(FWD(self)));
   }
 
   template <typename Self, typename Fn>
   static constexpr auto _or_else(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_storage::_error(FWD(self)))>
-               && ::std::is_nothrow_constructible_v<T, decltype(_storage::_value(FWD(self)))>)
-    requires(not ::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_storage::_error(FWD(self)))>
-             && ::std::is_constructible_v<T, decltype(_storage::_value(FWD(self)))>)
+      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_expected_base::_error(FWD(self)))>
+               && ::std::is_nothrow_constructible_v<T, decltype(_expected_base::_value(FWD(self)))>)
+    requires(not ::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_expected_base::_error(FWD(self)))>
+             && ::std::is_constructible_v<T, decltype(_expected_base::_value(FWD(self)))>)
   {
-    using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>;
+    using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>;
     static_assert(Policy::template is_specialization<result_t>);
     static_assert(::std::is_same_v<typename result_t::value_type, typename ::std::remove_cvref_t<Self>::value_type>);
     if (self.has_value()) {
-      return result_t(::std::in_place, _storage::_value(FWD(self)));
+      return result_t(::std::in_place, _expected_base::_value(FWD(self)));
     }
-    return ::std::invoke(FWD(fn), _storage::_error(FWD(self)));
+    return ::std::invoke(FWD(fn), _expected_base::_error(FWD(self)));
   }
 
   template <typename Self, typename Fn>
   static constexpr auto _or_else(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_storage::_error(FWD(self)))>)
-    requires(::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_storage::_error(FWD(self)))>)
+      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_expected_base::_error(FWD(self)))>)
+    requires(::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_expected_base::_error(FWD(self)))>)
   {
-    using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>;
+    using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>;
     static_assert(Policy::template is_specialization<result_t>);
     static_assert(::std::is_same_v<typename result_t::value_type, typename ::std::remove_cvref_t<Self>::value_type>);
     if (self.has_value()) {
       return result_t(::std::in_place);
     }
-    return ::std::invoke(FWD(fn), _storage::_error(FWD(self)));
+    return ::std::invoke(FWD(fn), _expected_base::_error(FWD(self)));
   }
 
   template <typename Self, typename Fn>
   static constexpr auto _transform(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_storage::_value(FWD(self)))>
-               && ::std::is_nothrow_constructible_v<E, decltype(_storage::_error(FWD(self)))>
-               && (::std::is_void_v<::std::invoke_result_t<Fn, decltype(_storage::_value(FWD(self)))>>
+      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_expected_base::_value(FWD(self)))>
+               && ::std::is_nothrow_constructible_v<E, decltype(_expected_base::_error(FWD(self)))>
+               && (::std::is_void_v<::std::invoke_result_t<Fn, decltype(_expected_base::_value(FWD(self)))>>
                    || ::std::is_nothrow_constructible_v<
-                       ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_storage::_value(FWD(self)))>>,
-                       ::std::invoke_result_t<Fn, decltype(_storage::_value(FWD(self)))>>))
-    requires(not ::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_storage::_value(FWD(self)))>
-             && ::std::is_constructible_v<E, decltype(_storage::_error(FWD(self)))>)
+                       ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_expected_base::_value(FWD(self)))>>,
+                       ::std::invoke_result_t<Fn, decltype(_expected_base::_value(FWD(self)))>>))
+    requires(not ::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_expected_base::_value(FWD(self)))>
+             && ::std::is_constructible_v<E, decltype(_expected_base::_error(FWD(self)))>)
   {
-    using value_t = ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_storage::_value(FWD(self)))>>;
+    using value_t = ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_expected_base::_value(FWD(self)))>>;
     static_assert(detail::_is_valid_expected<value_t, E>);
     using result_t = typename Policy::template type<value_t, E>;
     if (self.has_value()) {
       if constexpr (not ::std::is_void_v<value_t>) {
         static_assert(
-            ::std::is_constructible_v<value_t, ::std::invoke_result_t<Fn, decltype(_storage::_value(FWD(self)))>>);
-        return result_t(::std::in_place, ::std::invoke(FWD(fn), _storage::_value(FWD(self))));
+            ::std::is_constructible_v<value_t,
+                                      ::std::invoke_result_t<Fn, decltype(_expected_base::_value(FWD(self)))>>);
+        return result_t(::std::in_place, ::std::invoke(FWD(fn), _expected_base::_value(FWD(self))));
       } else {
-        ::std::invoke(FWD(fn), _storage::_value(FWD(self)));
+        ::std::invoke(FWD(fn), _expected_base::_value(FWD(self)));
         return result_t(::std::in_place);
       }
     }
-    return result_t(unexpect, _storage::_error(FWD(self)));
+    return result_t(unexpect, _expected_base::_error(FWD(self)));
   }
 
   template <typename Self, typename Fn>
   static constexpr auto _transform(Self &&self, Fn &&fn) //
       noexcept(::std::is_nothrow_invocable_v<Fn>
-               && ::std::is_nothrow_constructible_v<E, decltype(_storage::_error(FWD(self)))>
+               && ::std::is_nothrow_constructible_v<E, decltype(_expected_base::_error(FWD(self)))>
                && (::std::is_void_v<::std::invoke_result_t<Fn>>
                    || ::std::is_nothrow_constructible_v<::std::remove_cv_t<::std::invoke_result_t<Fn>>,
                                                         ::std::invoke_result_t<Fn>>))
     requires(::std::is_void_v<T> && ::std::is_invocable_v<Fn>
-             && ::std::is_constructible_v<E, decltype(_storage::_error(FWD(self)))>)
+             && ::std::is_constructible_v<E, decltype(_expected_base::_error(FWD(self)))>)
   {
     using value_t = ::std::remove_cv_t<::std::invoke_result_t<Fn>>;
     static_assert(detail::_is_valid_expected<value_t, E>);
@@ -846,45 +847,45 @@ template <class T, class E, class Policy> struct _storage {
         return result_t(::std::in_place);
       }
     }
-    return result_t(unexpect, _storage::_error(FWD(self)));
+    return result_t(unexpect, _expected_base::_error(FWD(self)));
   }
 
   template <typename Self, typename Fn>
   static constexpr auto _transform_error(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_storage::_error(FWD(self)))>
-               && ::std::is_nothrow_constructible_v<T, decltype(_storage::_value(FWD(self)))>
+      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_expected_base::_error(FWD(self)))>
+               && ::std::is_nothrow_constructible_v<T, decltype(_expected_base::_value(FWD(self)))>
                && ::std::is_nothrow_constructible_v<
-                   ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>,
-                   ::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>)
-    requires(not ::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_storage::_error(FWD(self)))>
-             && ::std::is_constructible_v<T, decltype(_storage::_value(FWD(self)))>)
+                   ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>,
+                   ::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>)
+    requires(not ::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_expected_base::_error(FWD(self)))>
+             && ::std::is_constructible_v<T, decltype(_expected_base::_value(FWD(self)))>)
   {
-    using error_t = ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>;
+    using error_t = ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>;
     static_assert(detail::_is_valid_unexpected<error_t>);
     static_assert(
-        ::std::is_constructible_v<error_t, ::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>);
+        ::std::is_constructible_v<error_t, ::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>);
     using result_t = typename Policy::template type<T, error_t>;
     if (not self.has_value()) {
-      return result_t(unexpect, ::std::invoke(FWD(fn), _storage::_error(FWD(self))));
+      return result_t(unexpect, ::std::invoke(FWD(fn), _expected_base::_error(FWD(self))));
     }
-    return result_t(::std::in_place, _storage::_value(FWD(self)));
+    return result_t(::std::in_place, _expected_base::_value(FWD(self)));
   }
 
   template <typename Self, typename Fn>
   static constexpr auto _transform_error(Self &&self, Fn &&fn) //
-      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_storage::_error(FWD(self)))>
+      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(_expected_base::_error(FWD(self)))>
                && ::std::is_nothrow_constructible_v<
-                   ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>,
-                   ::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>)
-    requires(::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_storage::_error(FWD(self)))>)
+                   ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>,
+                   ::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>)
+    requires(::std::is_void_v<T> && ::std::is_invocable_v<Fn, decltype(_expected_base::_error(FWD(self)))>)
   {
-    using error_t = ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>;
+    using error_t = ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>;
     static_assert(detail::_is_valid_unexpected<error_t>);
     static_assert(
-        ::std::is_constructible_v<error_t, ::std::invoke_result_t<Fn, decltype(_storage::_error(FWD(self)))>>);
+        ::std::is_constructible_v<error_t, ::std::invoke_result_t<Fn, decltype(_expected_base::_error(FWD(self)))>>);
     using result_t = typename Policy::template type<void, error_t>;
     if (not self.has_value()) {
-      return result_t(unexpect, ::std::invoke(FWD(fn), _storage::_error(FWD(self))));
+      return result_t(unexpect, ::std::invoke(FWD(fn), _expected_base::_error(FWD(self))));
     }
     return result_t(::std::in_place);
   }
@@ -927,7 +928,7 @@ template <class T, class E, class Policy> struct _storage {
   }
 
   // Cross-state swap; lhs holds value, rhs holds error.
-  static constexpr void _swap_helper(_storage &lhs, _storage &rhs) //
+  static constexpr void _swap_helper(_expected_base &lhs, _expected_base &rhs) //
       noexcept(::std::is_nothrow_move_constructible_v<T> && ::std::is_nothrow_move_constructible_v<E>)
   {
     if constexpr (::std::is_nothrow_move_constructible_v<E>) {
@@ -957,7 +958,7 @@ template <class T, class E, class Policy> struct _storage {
     rhs.set_ = true;
   }
 
-  constexpr void _swap_with(_storage &rhs)
+  constexpr void _swap_with(_expected_base &rhs)
   {
     if (set_ == rhs.set_) {
       if (set_) {
@@ -1077,13 +1078,13 @@ struct expected_policy {
 
 } // namespace detail
 
-template <class T, class E> class expected : private detail::_storage<T, E, detail::expected_policy> {
+template <class T, class E> class expected : private detail::_expected_base<T, E, detail::expected_policy> {
   static_assert(detail::_is_valid_expected<T, E>);
-  using _base = detail::_storage<T, E, detail::expected_policy>;
+  using _base = detail::_expected_base<T, E, detail::expected_policy>;
 
-  // Allow sibling `_storage` instantiations to downcast into our private base
+  // Allow sibling `_expected_base` instantiations to downcast into our private base
   // (needed for the lifted converting ctors and friend operators).
-  template <class, class, class> friend struct detail::_storage;
+  template <class, class, class> friend struct detail::_expected_base;
 
 public:
   using value_type = T;
@@ -1250,10 +1251,10 @@ template <class T, class E> class expected : private detail::_storage<T, E, deta
     return *this;
   }
 
-  // [expected.object.emplace], emplace inherited from _storage
+  // [expected.object.emplace], emplace inherited from _expected_base
   using _base::emplace;
 
-  // [expected.object.swap], swap; body delegates to _storage helper
+  // [expected.object.swap], swap; body delegates to _expected_base helper
   constexpr void swap(expected &rhs) // NOSONAR cpp:S5018 standard mandated `noexcept` spec.
       noexcept(::std::is_nothrow_move_constructible_v<T> && ::std::is_nothrow_swappable_v<T>
                && ::std::is_nothrow_move_constructible_v<E> && ::std::is_nothrow_swappable_v<E>)
@@ -1264,7 +1265,7 @@ template <class T, class E> class expected : private detail::_storage<T, E, deta
     this->_swap_with(rhs);
   }
 
-  // [expected.object.obs], observers inherited from _storage
+  // [expected.object.obs], observers inherited from _expected_base
   using _base::operator*;
   using _base::operator->;
   using _base::operator bool;
@@ -1392,17 +1393,17 @@ template <class T, class E> class expected : private detail::_storage<T, E, deta
     return _base::_transform_error(::std::move(*this), FWD(f));
   }
 
-  // [expected.object.eq], equality operators are hidden friends of _storage,
+  // [expected.object.eq], equality operators are hidden friends of _expected_base,
   // found via ADL (associated classes include the private base).
 };
 
-template <class E> class expected<void, E> : private detail::_storage<void, E, detail::expected_policy> {
+template <class E> class expected<void, E> : private detail::_expected_base<void, E, detail::expected_policy> {
   static_assert(detail::_is_valid_unexpected<E>);
-  using _base = detail::_storage<void, E, detail::expected_policy>;
+  using _base = detail::_expected_base<void, E, detail::expected_policy>;
 
-  // Allow sibling `_storage` instantiations to downcast into our private base
+  // Allow sibling `_expected_base` instantiations to downcast into our private base
   // (needed for the lifted converting ctors and friend operators).
-  template <class, class, class> friend struct detail::_storage;
+  template <class, class, class> friend struct detail::_expected_base;
 
 public:
   using value_type = void;
@@ -1519,10 +1520,10 @@ template <class E> class expected<void, E> : private detail::_storage<void, E, d
     return *this;
   }
 
-  // [expected.void.emplace], emplace inherited from _storage
+  // [expected.void.emplace], emplace inherited from _expected_base
   using _base::emplace;
 
-  // [expected.void.swap], swap; body delegates to _storage helper
+  // [expected.void.swap], swap; body delegates to _expected_base helper
   constexpr void swap(expected &rhs) // NOSONAR cpp:S5018 standard mandated `noexcept` spec.
       noexcept(::std::is_nothrow_move_constructible_v<E> && ::std::is_nothrow_swappable_v<E>)
     requires(::std::is_swappable_v<E> && ::std::is_move_constructible_v<E>)
@@ -1530,7 +1531,7 @@ template <class E> class expected<void, E> : private detail::_storage<void, E, d
     this->_swap_with(rhs);
   }
 
-  // [expected.void.obs], observers inherited from _storage
+  // [expected.void.obs], observers inherited from _expected_base
   using _base::operator*;
   using _base::operator bool;
   using _base::error;
@@ -1656,7 +1657,7 @@ template <class E> class expected<void, E> : private detail::_storage<void, E, d
     return _base::_transform_error(::std::move(*this), FWD(f));
   }
 
-  // [expected.void.eq], equality operators are hidden friends of _storage,
+  // [expected.void.eq], equality operators are hidden friends of _expected_base,
   // found via ADL (associated classes include the private base).
 };
 
diff --git a/include/pfn/optional.hpp b/include/pfn/optional.hpp
new file mode 100644
index 00000000..cd1e2dd0
--- /dev/null
+++ b/include/pfn/optional.hpp
@@ -0,0 +1,1466 @@
+// Copyright (c) 2026 Bronek Kozicki
+//
+// Distributed under the ISC License. See accompanying file LICENSE.md
+// or copy at https://opensource.org/licenses/ISC
+
+#ifndef INCLUDE_PFN_OPTIONAL
+#define INCLUDE_PFN_OPTIONAL
+
+#include <cassert>
+#include <compare>
+#include <concepts>
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <optional> // For anything that is not std::optional or std::make_optional
+#include <type_traits>
+#include <utility>
+
+#ifdef FWD
+#pragma push_macro("FWD")
+#define INCLUDE_PFN_OPTIONAL__POP_FWD
+#undef FWD
+#endif
+
+// Also defined in fn/detail/fwd_macro.hpp but pfn/* headers are standalone
+#define FWD(...) static_cast<decltype(__VA_ARGS__) &&>(__VA_ARGS__)
+
+#ifdef ASSERT
+#pragma push_macro("ASSERT")
+#define INCLUDE_PFN_OPTIONAL__POP_ASSERT
+#undef ASSERT
+#endif
+
+// LIBFN_ASSERT is a customization point for the user
+#ifdef LIBFN_ASSERT
+#define ASSERT(...) LIBFN_ASSERT(__VA_ARGS__)
+#else
+#define ASSERT(...) assert((__VA_ARGS__) == true)
+#endif
+
+namespace pfn {
+
+// [optional.optional], class template optional
+template <class T> class optional; // partially freestanding
+
+// [optional.optional.ref], partial specialization of optional for lvalue reference types
+template <class T> class optional<T &>; // partially freestanding
+
+template <class T>
+concept _is_derived_from_optional = requires(T const &t) { // exposition only
+  []<class U>(optional<U> const &) {}(t);
+};
+
+namespace detail {
+
+// Helper used as noexcept(...) operand where we want to evaluate both:
+// * noexcept of an expression itself (e.g. operator==) AND
+// * noexcept of the expression's implicit conversion to bool
+// May only be used in unevaluated contexts; any ODR-use will trigger a link error.
+// Also declared in pfn/expected.hpp (a benign redeclaration; pfn/* headers are standalone).
+constexpr bool _implicit_to_bool(bool) noexcept;
+
+template <typename> constexpr bool _is_some_optional = false;
+template <typename T> constexpr bool _is_some_optional<::pfn::optional<T>> = true;
+
+// [optional.relops] and [optional.comp.with.t] Constraints: the comparison expression is
+// well-formed and its result is convertible to bool. Operands are probed as const lvalues,
+// matching both *x on a const optional (L const& collapses to plain V& when L is V&, i.e.
+// for optional<V&>) and the value operand of [optional.comp.with.t].
+template <class L, class R>
+concept _eq_bool = requires(L const &l, R const &r) {
+  { l == r } -> ::std::convertible_to<bool>;
+};
+template <class L, class R>
+concept _ne_bool = requires(L const &l, R const &r) {
+  { l != r } -> ::std::convertible_to<bool>;
+};
+template <class L, class R>
+concept _lt_bool = requires(L const &l, R const &r) {
+  { l < r } -> ::std::convertible_to<bool>;
+};
+template <class L, class R>
+concept _gt_bool = requires(L const &l, R const &r) {
+  { l > r } -> ::std::convertible_to<bool>;
+};
+template <class L, class R>
+concept _le_bool = requires(L const &l, R const &r) {
+  { l <= r } -> ::std::convertible_to<bool>;
+};
+template <class L, class R>
+concept _ge_bool = requires(L const &l, R const &r) {
+  { l >= r } -> ::std::convertible_to<bool>;
+};
+
+// Conditional noexcept of the same comparison expressions, for the comparison operators'
+// extension noexcept clauses (probing the implicit conversion too, hence _implicit_to_bool).
+template <class L, class R>
+constexpr bool _eq_bool_noexcept
+    = noexcept(_implicit_to_bool(::std::declval<L const &>() == ::std::declval<R const &>()));
+template <class L, class R>
+constexpr bool _ne_bool_noexcept
+    = noexcept(_implicit_to_bool(::std::declval<L const &>() != ::std::declval<R const &>()));
+template <class L, class R>
+constexpr bool _lt_bool_noexcept
+    = noexcept(_implicit_to_bool(::std::declval<L const &>() < ::std::declval<R const &>()));
+template <class L, class R>
+constexpr bool _gt_bool_noexcept
+    = noexcept(_implicit_to_bool(::std::declval<L const &>() > ::std::declval<R const &>()));
+template <class L, class R>
+constexpr bool _le_bool_noexcept
+    = noexcept(_implicit_to_bool(::std::declval<L const &>() <= ::std::declval<R const &>()));
+template <class L, class R>
+constexpr bool _ge_bool_noexcept
+    = noexcept(_implicit_to_bool(::std::declval<L const &>() >= ::std::declval<R const &>()));
+
+} // namespace detail
+
+// [optional.relops], relational operators
+template <class T, class U>
+constexpr bool operator==(optional<T> const &, optional<U> const &) //
+    noexcept(detail::_eq_bool_noexcept<T, U>)                       // extension
+  requires detail::_eq_bool<T, U>;
+template <class T, class U>
+constexpr bool operator!=(optional<T> const &, optional<U> const &) //
+    noexcept(detail::_ne_bool_noexcept<T, U>)                       // extension
+  requires detail::_ne_bool<T, U>;
+template <class T, class U>
+constexpr bool operator<(optional<T> const &, optional<U> const &) //
+    noexcept(detail::_lt_bool_noexcept<T, U>)                      // extension
+  requires detail::_lt_bool<T, U>;
+template <class T, class U>
+constexpr bool operator>(optional<T> const &, optional<U> const &) //
+    noexcept(detail::_gt_bool_noexcept<T, U>)                      // extension
+  requires detail::_gt_bool<T, U>;
+template <class T, class U>
+constexpr bool operator<=(optional<T> const &, optional<U> const &) //
+    noexcept(detail::_le_bool_noexcept<T, U>)                       // extension
+  requires detail::_le_bool<T, U>;
+template <class T, class U>
+constexpr bool operator>=(optional<T> const &, optional<U> const &) //
+    noexcept(detail::_ge_bool_noexcept<T, U>)                       // extension
+  requires detail::_ge_bool<T, U>;
+template <class T, ::std::three_way_comparable_with<T> U>
+constexpr ::std::compare_three_way_result_t<T, U> operator<=>(optional<T> const &, optional<U> const &);
+
+// [optional.nullops], comparison with nullopt
+template <class T> constexpr bool operator==(optional<T> const &, ::std::nullopt_t) noexcept;
+template <class T> constexpr ::std::strong_ordering operator<=>(optional<T> const &, ::std::nullopt_t) noexcept;
+
+// [optional.comp.with.t], comparison with T
+template <class T, class U>
+constexpr bool operator==(optional<T> const &, U const &) //
+    noexcept(detail::_eq_bool_noexcept<T, U>)             // extension
+  requires(not detail::_is_some_optional<U>) && detail::_eq_bool<T, U>;
+template <class T, class U>
+constexpr bool operator==(T const &, optional<U> const &) //
+    noexcept(detail::_eq_bool_noexcept<T, U>)             // extension
+  requires(not detail::_is_some_optional<T>) && detail::_eq_bool<T, U>;
+template <class T, class U>
+constexpr bool operator!=(optional<T> const &, U const &) //
+    noexcept(detail::_ne_bool_noexcept<T, U>)             // extension
+  requires(not detail::_is_some_optional<U>) && detail::_ne_bool<T, U>;
+template <class T, class U>
+constexpr bool operator!=(T const &, optional<U> const &) //
+    noexcept(detail::_ne_bool_noexcept<T, U>)             // extension
+  requires(not detail::_is_some_optional<T>) && detail::_ne_bool<T, U>;
+template <class T, class U>
+constexpr bool operator<(optional<T> const &, U const &) //
+    noexcept(detail::_lt_bool_noexcept<T, U>)            // extension
+  requires(not detail::_is_some_optional<U>) && detail::_lt_bool<T, U>;
+template <class T, class U>
+constexpr bool operator<(T const &, optional<U> const &) //
+    noexcept(detail::_lt_bool_noexcept<T, U>)            // extension
+  requires(not detail::_is_some_optional<T>) && detail::_lt_bool<T, U>;
+template <class T, class U>
+constexpr bool operator>(optional<T> const &, U const &) //
+    noexcept(detail::_gt_bool_noexcept<T, U>)            // extension
+  requires(not detail::_is_some_optional<U>) && detail::_gt_bool<T, U>;
+template <class T, class U>
+constexpr bool operator>(T const &, optional<U> const &) //
+    noexcept(detail::_gt_bool_noexcept<T, U>)            // extension
+  requires(not detail::_is_some_optional<T>) && detail::_gt_bool<T, U>;
+template <class T, class U>
+constexpr bool operator<=(optional<T> const &, U const &) //
+    noexcept(detail::_le_bool_noexcept<T, U>)             // extension
+  requires(not detail::_is_some_optional<U>) && detail::_le_bool<T, U>;
+template <class T, class U>
+constexpr bool operator<=(T const &, optional<U> const &) //
+    noexcept(detail::_le_bool_noexcept<T, U>)             // extension
+  requires(not detail::_is_some_optional<T>) && detail::_le_bool<T, U>;
+template <class T, class U>
+constexpr bool operator>=(optional<T> const &, U const &) //
+    noexcept(detail::_ge_bool_noexcept<T, U>)             // extension
+  requires(not detail::_is_some_optional<U>) && detail::_ge_bool<T, U>;
+template <class T, class U>
+constexpr bool operator>=(T const &, optional<U> const &) //
+    noexcept(detail::_ge_bool_noexcept<T, U>)             // extension
+  requires(not detail::_is_some_optional<T>) && detail::_ge_bool<T, U>;
+template <class T, class U>
+  requires(not _is_derived_from_optional<U>) && ::std::three_way_comparable_with<T, U>
+constexpr ::std::compare_three_way_result_t<T, U> operator<=>(optional<T> const &, U const &);
+
+// [optional.specalg], specialized algorithms
+template <class T>
+constexpr void swap(optional<T> &x, optional<T> &y) noexcept(noexcept(x.swap(y)))
+  requires(::std::is_reference_v<T> || (::std::is_move_constructible_v<T> && ::std::is_swappable_v<T>));
+
+// The leading defaulted non-type parameter implements this overload's [optional.specalg]
+// Constraints: "the call to make_optional does not use an explicit template-argument-list
+// that begins with a type template-argument" -- so make_optional<U>(...) always selects an
+// in_place overload below (for U = X& there is nothing this overload could do: decay_t
+// strips the reference and would silently copy the referent).
+template <int = 0, class T>
+constexpr optional<::std::decay_t<T>> make_optional(T &&v)                       //
+    noexcept(::std::is_nothrow_constructible_v<optional<::std::decay_t<T>>, T>); // extension
+template <class T, class... Args>
+constexpr optional<T> make_optional(Args &&...args)          //
+    noexcept(::std::is_nothrow_constructible_v<T, Args...>); // extension
+template <class T, class U, class... Args>
+constexpr optional<T> make_optional(::std::initializer_list<U> il, Args &&...args)         //
+    noexcept(::std::is_nothrow_constructible_v<T, ::std::initializer_list<U> &, Args...>); // extension
+
+namespace detail {
+
+// Internal union wrapper for optional's value / no-value storage. This mirrors the
+// strategy of `pfn::detail::_expected_union_t<void, E>` with the value and "empty"
+// roles reversed: the engaged value lives in `v_`, and `e_` is a trivial placeholder
+// for the disengaged state, so the union always has an active member (required for
+// constexpr use). Copy/move ctors are defaulted iff `T` is trivially copy/move
+// constructible; the destructor is defaulted iff `T` is trivially destructible.
+// Tag selecting _optional_union_t's/_optional_base's "construct from any source exposing
+// has_value()/operator*()" constructor, disambiguating it from the (bool, S&&) one below
+// (which instead reads another union's raw v_ member directly).
+struct _from_optional_t {
+  explicit _from_optional_t() = default;
+};
+constexpr inline _from_optional_t _from_optional{};
+
+// Tag selecting the "direct-non-list-initialize the contained value from the result of
+// std::invoke" constructors, required by transform ([optional.monadic]/[optional.ref.monadic]):
+// the specified initialization is exactly `U u(invoke(...))` -- guaranteed elision, so no
+// extra move and an immovable U works -- which means the invoke expression itself must reach
+// the contained value's initializer.
+struct _from_invoke_t {
+  explicit _from_invoke_t() = default;
+};
+constexpr inline _from_invoke_t _from_invoke{};
+
+template <class T> union _optional_union_t {
+  // _dummy_t placeholder, so the union always has an active member
+  struct _dummy_t final {
+    constexpr _dummy_t() noexcept = default;
+  };
+
+  using _value_t = T;
+  T v_;
+  _dummy_t e_; // disengaged-state placeholder
+
+  template <typename S>
+  constexpr explicit _optional_union_t(bool s, S &&src) //
+      noexcept(::std::is_nothrow_constructible_v<T, decltype((FWD(src).v_))>)
+  {
+    if (s)
+      ::std::construct_at(::std::addressof(v_), FWD(src).v_);
+    else
+      ::std::construct_at(::std::addressof(e_));
+  }
+
+  // Constructs from any source exposing has_value()/operator*() (e.g. a differently-typed
+  // optional, value or reference) -- mirrors the (bool, S&&) ctor above but reads engagement
+  // and the value through that public API instead of another union's raw v_ member, so it
+  // works uniformly for optional<U&> sources too (a completely different internal
+  // representation: a bare pointer, no union or set_ at all).
+  template <typename S>
+  constexpr explicit _optional_union_t(_from_optional_t /*ignored*/, S &&src) //
+      noexcept(::std::is_nothrow_constructible_v<T, decltype(*FWD(src))>)
+  {
+    if (src.has_value())
+      ::std::construct_at(::std::addressof(v_), *FWD(src));
+    else
+      ::std::construct_at(::std::addressof(e_));
+  }
+
+  template <typename Fn, typename... Args>
+  constexpr explicit _optional_union_t(_from_invoke_t /*ignored*/, Fn &&fn, Args &&...args) //
+      noexcept(::std::is_nothrow_invocable_v<Fn, Args...>
+               && ::std::is_nothrow_constructible_v<T, ::std::invoke_result_t<Fn, Args...>>)
+      : v_(::std::invoke(FWD(fn), FWD(args)...))
+  {
+  }
+
+  constexpr _optional_union_t(_optional_union_t const &) = delete;
+  constexpr _optional_union_t(_optional_union_t const &) noexcept //
+    requires(::std::is_trivially_copy_constructible_v<T>)
+  = default;
+  constexpr _optional_union_t(_optional_union_t &&) = delete;
+  constexpr _optional_union_t(_optional_union_t &&) noexcept //
+    requires(::std::is_trivially_move_constructible_v<T>)
+  = default;
+  constexpr _optional_union_t &operator=(_optional_union_t const &) = delete;
+  constexpr _optional_union_t &operator=(_optional_union_t &&) = delete;
+
+  template <class... Args>
+  constexpr explicit _optional_union_t(::std::in_place_t /*ignored*/, Args &&...a) //
+      noexcept(::std::is_nothrow_constructible_v<T, Args...>)
+    requires ::std::is_constructible_v<T, Args...>
+      : v_(FWD(a)...)
+  {
+  }
+  constexpr explicit _optional_union_t(::std::nullopt_t /*ignored*/) noexcept : e_{} {}
+
+  constexpr ~_optional_union_t() noexcept
+    requires(::std::is_trivially_destructible_v<T>)
+  = default;
+  constexpr ~_optional_union_t() noexcept {}
+
+  // reinit, mirroring [expected.void.assign]'s direct construction: one of New/Old is
+  // always the trivial `_dummy_t` (value <-> empty transition), so no strong-exception
+  // snapshot of the old member is needed.
+  template <typename New, typename Old, typename... Args>
+  static constexpr void _reinit(New *newp, Old *oldp, Args &&...args) //
+      noexcept(::std::is_nothrow_constructible_v<New, Args...>)
+  {
+    if constexpr (::std::is_same_v<New, _dummy_t>) {
+      ::std::destroy_at(oldp);
+      ::std::construct_at(newp); // Never throws, since New is _dummy_t
+    } else if constexpr (::std::is_nothrow_constructible_v<New, Args...>) {
+      ::std::destroy_at(oldp);
+      ::std::construct_at(newp, ::std::forward<Args>(args)...); // Never throws
+    } else {
+      ::std::destroy_at(oldp);
+      try {
+        ::std::construct_at(newp, ::std::forward<Args>(args)...);
+      } catch (...) {
+        ::std::construct_at(oldp); // Never throws, since Old is _dummy_t
+        throw;
+      }
+    }
+  }
+};
+
+template <typename> constexpr bool _is_optional_union = false;
+template <typename T> constexpr bool _is_optional_union<_optional_union_t<T>> = true;
+
+// [optional.optional.general]: only lvalue references and complete non-array object types are
+// valid contained types; also the Mandates of transform's result type ([optional.monadic]).
+template <typename T>
+constexpr bool _is_valid_optional =                                                         //
+    (::std::is_lvalue_reference_v<T>                                                        //
+     || (::std::is_object_v<T> && ::std::is_destructible_v<T> && not ::std::is_array_v<T>)) //
+    && not ::std::is_same_v<::std::remove_cv_t<T>, ::std::in_place_t>                       //
+    && not ::std::is_same_v<::std::remove_cv_t<T>, ::std::nullopt_t>;
+
+// Shared implementation base class for ::pfn::optional. Members are public since inheritance is
+// private. Not used by ::pfn::optional<T&> which models a pointer and does not need `bool set_`.
+template <class T, class Policy> struct _optional_base {
+  using _storage_t = _optional_union_t<T>;
+  using _value_t = _storage_t::_value_t; // == T
+  _storage_t storage_;
+  bool set_;
+
+  template <class U>
+  using _can_convert = ::std::bool_constant<                                               //
+      ::std::is_constructible_v<T, U>                                                      //
+      && not ::std::is_same_v<::std::remove_cvref_t<U>, ::std::in_place_t>                 //
+      && not ::std::is_same_v<::std::remove_cvref_t<U>, typename Policy::template type<T>> //
+      && (not ::std::is_same_v<bool, ::std::remove_cv_t<T>>                                //
+          || not Policy::template is_specialization<::std::remove_cvref_t<U>>)>;
+
+  template <class U>
+  using _can_assign = ::std::bool_constant<                                                  //
+      ::std::is_constructible_v<T, U>                                                        //
+          && ::std::is_assignable_v<T &, U>                                                  //
+      && not ::std::conjunction_v<::std::is_scalar<T>, ::std::is_same<T, ::std::decay_t<U>>> //
+      && not ::std::is_same_v<::std::remove_cvref_t<U>, typename Policy::template type<T>>>;
+
+  // [optional.ctor], implementation of converts-from-any-cvref
+  template <class W>
+  using _converts_from_an_cvrev = ::std::bool_constant<::std::disjunction_v<      //
+      ::std::is_constructible<T, W &>, ::std::is_convertible<W &, T>,             //
+      ::std::is_constructible<T, W>, ::std::is_convertible<W, T>,                 //
+      ::std::is_constructible<T, W const &>, ::std::is_convertible<W const &, T>, //
+      ::std::is_constructible<T, W const>, ::std::is_convertible<W const, T>>>;
+
+  template <typename U>
+  using _can_copy_convert = ::std::bool_constant<       //
+      ::std::is_constructible_v<T, U const &>           //
+      && (::std::is_same_v<bool, ::std::remove_cv_t<T>> //
+          || not _converts_from_an_cvrev<typename Policy::template type<U>>::value)>;
+
+  template <typename U>
+  using _can_move_convert = ::std::bool_constant<       //
+      ::std::is_constructible_v<T, U>                   //
+      && (::std::is_same_v<bool, ::std::remove_cv_t<T>> //
+          || not _converts_from_an_cvrev<typename Policy::template type<U>>::value)>;
+
+  template <typename U, typename UF>
+  using _can_copy_assign_detail = ::std::bool_constant< //
+      ::std::is_constructible_v<T, UF>                  //
+          && ::std::is_assignable_v<T &, UF>
+      && not _converts_from_an_cvrev<typename Policy::template type<U>>::value      //
+      && not ::std::is_assignable_v<T &, typename Policy::template type<U> &>       //
+      && not ::std::is_assignable_v<T &, typename Policy::template type<U> &&>      //
+      && not ::std::is_assignable_v<T &, typename Policy::template type<U> const &> //
+      && not ::std::is_assignable_v<T &, typename Policy::template type<U> const &&>>;
+
+  template <typename U> using _can_copy_assign = _can_copy_assign_detail<U, U const &>;
+  template <typename U> using _can_move_assign = _can_copy_assign_detail<U, U>;
+
+  // Shared construction helper: selects the union's active member from `s`. Used by
+  // the wrapper's copy/move and (later) the converting constructors.
+  template <typename S>
+  constexpr explicit _optional_base(bool s, S &&src)
+    requires(_is_optional_union<::std::remove_cvref_t<S>>)
+      : storage_(s, FWD(src)), set_(s)
+  {
+  }
+
+  template <class... Args>
+  constexpr explicit _optional_base(::std::in_place_t /*ignored*/, Args &&...a) //
+      noexcept(::std::is_nothrow_constructible_v<_storage_t, ::std::in_place_t, Args...>)
+    requires ::std::is_constructible_v<_storage_t, ::std::in_place_t, Args...>
+      : storage_(::std::in_place, FWD(a)...), set_(true)
+  {
+  }
+  template <class U, class... Args>
+  constexpr explicit _optional_base(::std::in_place_t /*ignored*/, ::std::initializer_list<U> il, Args &&...a) //
+      noexcept(::std::is_nothrow_constructible_v<_storage_t, ::std::in_place_t, ::std::initializer_list<U> &, Args...>)
+    requires ::std::is_constructible_v<_storage_t, ::std::in_place_t, ::std::initializer_list<U> &, Args...>
+      : storage_(::std::in_place, il, FWD(a)...), set_(true)
+  {
+  }
+  template <typename Fn, typename... Args>
+  constexpr explicit _optional_base(_from_invoke_t tag, Fn &&fn, Args &&...args) //
+      noexcept(::std::is_nothrow_constructible_v<_storage_t, _from_invoke_t, Fn, Args...>)
+      : storage_(tag, FWD(fn), FWD(args)...), set_(true)
+  {
+  }
+  constexpr explicit _optional_base(::std::nullopt_t /*ignored*/) noexcept //
+      : storage_(::std::nullopt), set_(false)
+  {
+  }
+
+  // Shared construction helper for any source exposing has_value()/operator*() -- i.e.
+  // another optional, same or differently typed, value or reference. Delegates to the
+  // union's own _from_optional_t ctor, which reads that public observer API directly rather
+  // than reaching into the source's storage, so it works uniformly for both optional<U> (a
+  // discriminated union) and optional<U&> (a bare pointer, no union or `set_` at all)
+  // sources alike. Used by the converting ctors below and by _assign_from.
+  template <typename S>
+  constexpr explicit _optional_base(_from_optional_t tag, S &&s) //
+      noexcept(::std::is_nothrow_constructible_v<_storage_t, _from_optional_t, S>)
+      : storage_(tag, FWD(s)), set_(s.has_value())
+  {
+  }
+
+  // [optional.ctor], converting constructors from a differently-typed optional<U>.
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U const &, T>)
+      _optional_base(typename Policy::template type<U> const &s) //
+      noexcept(::std::is_nothrow_constructible_v<T, U const &>)  // extension
+    requires(_can_copy_convert<U>::value)
+      : _optional_base(_from_optional, s)
+  {
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U, T>) _optional_base(typename Policy::template type<U> &&s) //
+      noexcept(::std::is_nothrow_constructible_v<T, U>) // extension
+    requires(_can_move_convert<U>::value)
+      : _optional_base(_from_optional, ::std::move(s))
+  {
+  }
+
+  constexpr _optional_base(_optional_base const &) noexcept = default;
+  constexpr _optional_base(_optional_base &&) noexcept = default;
+  constexpr _optional_base &operator=(_optional_base const &) = delete;
+  constexpr _optional_base &operator=(_optional_base &&) = delete;
+
+  constexpr ~_optional_base() //
+    requires(::std::is_trivially_destructible_v<_value_t>)
+  = default;
+  constexpr ~_optional_base() //
+    requires(not ::std::is_trivially_destructible_v<_value_t>)
+  {
+    if (set_)
+      ::std::destroy_at(::std::addressof(storage_.v_));
+  }
+
+  // [optional.mod] reset; also the disengage step of operator=(nullopt_t) and emplace
+  constexpr void reset() noexcept
+  {
+    if (set_) {
+      _storage_t::_reinit(::std::addressof(storage_.e_), ::std::addressof(storage_.v_));
+      set_ = false;
+    }
+  }
+
+  // Assignment body shared by the public optional operator= overloads, which keep their
+  // constraints/noexcept clauses and forward `s` here as an lvalue or rvalue.
+  constexpr void _assign(auto &&s)
+  {
+    if (set_ && s.set_) {
+      storage_.v_ = FWD(s).storage_.v_;
+    } else if (set_) {
+      _storage_t::_reinit(::std::addressof(storage_.e_), ::std::addressof(storage_.v_), FWD(s).storage_.e_);
+      set_ = false;
+    } else if (s.set_) {
+      _storage_t::_reinit(::std::addressof(storage_.v_), ::std::addressof(storage_.e_), FWD(s).storage_.v_);
+      set_ = true;
+    } else {
+      // no effect: both are disengaged, so the trivial `_dummy_t` is already active
+    }
+  }
+
+  template <class U> constexpr void _assign_value(U &&s)
+  {
+    if (set_) {
+      storage_.v_ = FWD(s);
+    } else {
+      _storage_t::_reinit(::std::addressof(storage_.v_), ::std::addressof(storage_.e_), FWD(s));
+      set_ = true;
+    }
+  }
+
+  // Converting-assignment body shared by the public optional operator= overloads. Reads `s`
+  // through its public has_value()/operator*() (same reasoning as the converting ctors'
+  // shared helper above: works uniformly for optional<U> and optional<U&> sources alike),
+  // and reuses _reinit for *this's own storage exactly like _assign above.
+  template <typename S> constexpr void _assign_from(S &&s)
+  {
+    if (set_ && s.has_value()) {
+      storage_.v_ = *FWD(s);
+    } else if (set_) {
+      _storage_t::_reinit(::std::addressof(storage_.e_), ::std::addressof(storage_.v_));
+      set_ = false;
+    } else if (s.has_value()) {
+      _storage_t::_reinit(::std::addressof(storage_.v_), ::std::addressof(storage_.e_), *FWD(s));
+      set_ = true;
+    }
+    // else: both disengaged, no effect
+  }
+
+  // Swap body shared by the public optional swap. Same-state mirrors _expected_base::_swap_with;
+  // cross-state reuses _reinit: the empty side gains the value first (and _reinit restores its
+  // dummy if that move throws), the donor is destroyed only afterwards -- [optional.swap]'s
+  // construct-then-destroy order and its unchanged-engagement-on-exception guarantee.
+  constexpr void _swap_with(_optional_base &rhs)
+  {
+    if (set_ == rhs.set_) {
+      if (set_) {
+        using ::std::swap;
+        swap(storage_.v_, rhs.storage_.v_);
+      }
+      // both disengaged: no effect
+    } else if (set_) {
+      _storage_t::_reinit(::std::addressof(rhs.storage_.v_), ::std::addressof(rhs.storage_.e_),
+                          ::std::move(storage_.v_));
+      rhs.set_ = true;
+      _storage_t::_reinit(::std::addressof(storage_.e_), ::std::addressof(storage_.v_));
+      set_ = false;
+    } else {
+      rhs._swap_with(*this);
+    }
+  }
+
+  template <class... Args>
+  constexpr T &emplace(Args &&...args) //
+    requires ::std::is_constructible_v<T, Args...>
+  {
+    reset();
+    _storage_t::_reinit(::std::addressof(storage_.v_), ::std::addressof(storage_.e_), FWD(args)...);
+    set_ = true;
+    return storage_.v_;
+  }
+  template <class U, class... Args>
+  constexpr T &emplace(::std::initializer_list<U> il, Args &&...args) //
+    requires ::std::is_constructible_v<T, ::std::initializer_list<U> &, Args...>
+  {
+    reset();
+    _storage_t::_reinit(::std::addressof(storage_.v_), ::std::addressof(storage_.e_), il, FWD(args)...);
+    set_ = true;
+    return storage_.v_;
+  }
+
+  // [optional.observe], observers
+  constexpr T const *operator->() const noexcept
+  {
+    ASSERT(set_); // LCOV_EXCL_LINE
+    return ::std::addressof(storage_.v_);
+  }
+  constexpr T *operator->() noexcept
+  {
+    ASSERT(set_); // LCOV_EXCL_LINE
+    return ::std::addressof(storage_.v_);
+  }
+  constexpr T const &operator*() const & noexcept { return *(this->operator->()); }
+  constexpr T &operator*() & noexcept { return *(this->operator->()); }
+  constexpr T const &&operator*() const && noexcept { return ::std::move(*(this->operator->())); }
+  constexpr T &&operator*() && noexcept { return ::std::move(*(this->operator->())); }
+  constexpr explicit operator bool() const noexcept { return set_; }
+  constexpr bool has_value() const noexcept { return set_; }
+
+  constexpr T const &value() const &
+  {
+    if (not set_)
+      throw ::std::bad_optional_access();
+    return storage_.v_;
+  }
+  constexpr T &value() &
+  {
+    if (not set_)
+      throw ::std::bad_optional_access();
+    return storage_.v_;
+  }
+  constexpr T const &&value() const &&
+  {
+    if (not set_)
+      throw ::std::bad_optional_access();
+    return ::std::move(storage_.v_);
+  }
+  constexpr T &&value() &&
+  {
+    if (not set_)
+      throw ::std::bad_optional_access();
+    return ::std::move(storage_.v_);
+  }
+
+  template <class U = ::std::remove_cv_t<T>> constexpr T value_or(U &&v) const &
+  {
+    static_assert(::std::is_copy_constructible_v<T> && ::std::is_convertible_v<U &&, T>);
+    return set_ ? storage_.v_ : static_cast<T>(::std::forward<U>(v));
+  }
+  template <class U = ::std::remove_cv_t<T>> constexpr T value_or(U &&v) &&
+  {
+    static_assert(::std::is_move_constructible_v<T> && ::std::is_convertible_v<U &&, T>);
+    return set_ ? ::std::move(storage_.v_) : static_cast<T>(::std::forward<U>(v));
+  }
+
+  // [optional.monadic] bodies, shared by the public optional's ref-qualified overload sets.
+  // Self is the public optional (not this base), so `*FWD(self)` spells the draft's exact
+  // decltype((val)) / decltype(std::move(val)) value category and everything is reached
+  // through public API -- same reasoning as the _from_optional_t constructors above.
+  template <typename Self, typename Fn>
+  static constexpr auto _and_then(Self &&self, Fn &&fn) //
+      noexcept(::std::is_nothrow_invocable_v<Fn, decltype(*FWD(self))>)
+    requires ::std::is_invocable_v<Fn, decltype(*FWD(self))>
+  {
+    using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn, decltype(*FWD(self))>>;
+    static_assert(Policy::template is_specialization<result_t>); // [optional.monadic] Mandates
+    if (self.has_value()) {
+      return ::std::invoke(FWD(fn), *FWD(self));
+    }
+    return result_t();
+  }
+
+  template <typename Self, typename Fn>
+  static constexpr auto _transform(Self &&self, Fn &&fn) //
+      noexcept(
+          ::std::is_nothrow_invocable_v<Fn, decltype(*FWD(self))>
+          && ::std::is_nothrow_constructible_v<::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(*FWD(self))>>,
+                                               ::std::invoke_result_t<Fn, decltype(*FWD(self))>>)
+    requires ::std::is_invocable_v<Fn, decltype(*FWD(self))>
+  {
+    using value_t = ::std::remove_cv_t<::std::invoke_result_t<Fn, decltype(*FWD(self))>>;
+    static_assert(_is_valid_optional<value_t>); // [optional.monadic] Mandates
+    using result_t = typename Policy::template type<value_t>;
+    if (self.has_value()) {
+      return result_t(_from_invoke, FWD(fn), *FWD(self));
+    }
+    return result_t();
+  }
+
+  template <typename Self, typename Fn>
+  static constexpr auto _or_else(Self &&self, Fn &&fn) //
+      noexcept(::std::is_nothrow_invocable_v<Fn>
+               && ::std::is_nothrow_constructible_v<typename Policy::template type<T>, Self>)
+    requires(::std::is_invocable_v<Fn> && ::std::is_constructible_v<typename Policy::template type<T>, Self>)
+  {
+    using result_t = typename Policy::template type<T>;
+    static_assert(::std::is_same_v<::std::remove_cvref_t<::std::invoke_result_t<Fn>>, result_t>); // Mandates
+    if (self.has_value()) {
+      return result_t(FWD(self)); // the draft's `return *this;` / `return std::move(*this);`
+    }
+    return ::std::invoke(FWD(fn));
+  }
+};
+
+// optional<T&> needs its own base: the referent is held directly as a pointer (nullptr
+// encodes the disengaged state), so there is no value union, no discriminant flag, and
+// every special member is implicitly trivial.
+//
+// TODO reference_constructs_from_temporary_v is a C++23 trait with no portable C++20
+// fallback, so the dangling-reference guards of [optional.ref.ctor] (constraints and
+// deleted overloads for binding a temporary) and of [optional.ref.assign]'s emplace are
+// deferred; until then such constructions compile and dangle.
+template <class T, class Policy> struct _optional_base<T &, Policy> {
+  using _value_t = T &;
+  T *v_ = nullptr;
+
+  // [optional.ref.expos], exposition only helper. Binds a reference to `u` (through whatever conversion T&
+  // requires -- possibly a throwing user conversion operator) and stores its address.
+  template <class U> constexpr void _convert_ref_init_val(U &&u) noexcept(::std::is_nothrow_constructible_v<T &, U>)
+  {
+    // Workaround for MSVC error C2440, same semantics as the specified `T &r(FWD(u));` ([expr.static.cast]/4)
+    v_ = ::std::addressof(static_cast<T &>(FWD(u)));
+  }
+
+  template <class U>
+  using _can_convert = ::std::bool_constant<                                              //
+      not ::std::is_same_v<::std::remove_cvref_t<U>, typename Policy::template type<T &>> //
+      && not ::std::is_same_v<::std::remove_cvref_t<U>, ::std::in_place_t>                //
+      && ::std::is_constructible_v<T &, U>>;
+
+  // [optional.ref.ctor], shared constraint of the converting constructors from optional<U>;
+  // UF is the U flavor the overload binds from (U&, U const&, U, U const).
+  template <class U, class UF>
+  using _can_convert_from = ::std::bool_constant<                                    //
+      not ::std::is_same_v<::std::remove_cv_t<T>, typename Policy::template type<U>> //
+      && not ::std::is_same_v<T &, U>                                                //
+      && ::std::is_constructible_v<T &, UF>>;
+
+  constexpr _optional_base() noexcept = default;
+  constexpr explicit _optional_base(::std::nullopt_t /*ignored*/) noexcept {}
+
+  template <class Arg>
+  constexpr explicit _optional_base(::std::in_place_t /*ignored*/, Arg &&arg) //
+      noexcept(::std::is_nothrow_constructible_v<T &, Arg>)                   // extension
+    requires ::std::is_constructible_v<T &, Arg>
+  {
+    _convert_ref_init_val(FWD(arg));
+  }
+
+  template <typename Fn, typename... Args>
+  constexpr explicit _optional_base(_from_invoke_t /*ignored*/, Fn &&fn, Args &&...args) //
+      noexcept(::std::is_nothrow_invocable_v<Fn, Args...>
+               && ::std::is_nothrow_constructible_v<T &, ::std::invoke_result_t<Fn, Args...>>)
+  {
+    _convert_ref_init_val(::std::invoke(FWD(fn), FWD(args)...));
+  }
+
+  // [optional.ref.ctor], converting constructors from a differently-typed optional<U>: four
+  // overloads (unlike optional<T>'s two), since both the constness and the value category of
+  // the source select which U flavor T& must bind.
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U &, T &>) _optional_base(typename Policy::template type<U> &rhs) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U &>)
+    requires(_can_convert_from<U, U &>::value)
+  {
+    if (rhs.has_value())
+      _convert_ref_init_val(*rhs);
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U const &, T &>)
+      _optional_base(typename Policy::template type<U> const &rhs) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U const &>)
+    requires(_can_convert_from<U, U const &>::value)
+  {
+    if (rhs.has_value())
+      _convert_ref_init_val(*rhs);
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U, T &>) _optional_base(typename Policy::template type<U> &&rhs) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U>)
+    requires(_can_convert_from<U, U>::value)
+  {
+    if (rhs.has_value())
+      _convert_ref_init_val(*::std::move(rhs));
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U const, T &>)
+      _optional_base(typename Policy::template type<U> const &&rhs) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U const>)
+    requires(_can_convert_from<U, U const>::value)
+  {
+    if (rhs.has_value())
+      _convert_ref_init_val(*::std::move(rhs));
+  }
+
+  // [optional.ref.assign]
+  template <class U>
+  constexpr T &emplace(U &&u) noexcept(::std::is_nothrow_constructible_v<T &, U>)
+    requires ::std::is_constructible_v<T &, U>
+  {
+    _convert_ref_init_val(FWD(u));
+    return *v_;
+  }
+
+  // [optional.ref.swap] and [optional.ref.mod]: the pointer representation makes both trivial
+  constexpr void _swap_with(_optional_base &rhs) noexcept { ::std::swap(v_, rhs.v_); }
+  constexpr void reset() noexcept { v_ = nullptr; }
+
+  // [optional.ref.observe], observers. Unlike optional<T>, const does not propagate to the
+  // referent: *this being const only means the stored pointer can't be rebound, not that T
+  // becomes T const -- so these all return plain T&/T*, and there is only ever one overload
+  // (no ref-qualifier/const overload set like optional<T>'s).
+  constexpr T *operator->() const noexcept
+  {
+    ASSERT(v_ != nullptr); // LCOV_EXCL_LINE
+    return v_;
+  }
+  constexpr T &operator*() const noexcept { return *(this->operator->()); }
+  constexpr explicit operator bool() const noexcept { return v_ != nullptr; }
+  constexpr bool has_value() const noexcept { return v_ != nullptr; }
+
+  constexpr T &value() const
+  {
+    if (v_ == nullptr)
+      throw ::std::bad_optional_access();
+    return *v_;
+  }
+
+  template <class U = ::std::remove_cv_t<T>> constexpr ::std::remove_cv_t<T> value_or(U &&u) const
+  {
+    static_assert(::std::is_constructible_v<::std::remove_cv_t<T>, T &> //
+                  && ::std::is_convertible_v<U, ::std::remove_cv_t<T>>);
+    return v_ != nullptr ? *v_ : static_cast<::std::remove_cv_t<T>>(::std::forward<U>(u));
+  }
+
+  // [optional.ref.monadic] bodies; unlike optional<T>'s, the callable always receives plain
+  // T& (const on the optional does not propagate to the referent), so Self only says which
+  // public overload delegated here.
+  template <typename Self, typename Fn>
+  static constexpr auto _and_then(Self &&self, Fn &&fn) noexcept(::std::is_nothrow_invocable_v<Fn, T &>)
+    requires ::std::is_invocable_v<Fn, T &>
+  {
+    using result_t = ::std::remove_cvref_t<::std::invoke_result_t<Fn, T &>>;
+    static_assert(Policy::template is_specialization<result_t>); // [optional.ref.monadic] Mandates
+    if (self.has_value()) {
+      return ::std::invoke(FWD(fn), *self);
+    }
+    return result_t();
+  }
+
+  template <typename Self, typename Fn>
+  static constexpr auto _transform(Self &&self, Fn &&fn) //
+      noexcept(::std::is_nothrow_invocable_v<Fn, T &>
+               && ::std::is_nothrow_constructible_v<::std::remove_cv_t<::std::invoke_result_t<Fn, T &>>,
+                                                    ::std::invoke_result_t<Fn, T &>>)
+    requires ::std::is_invocable_v<Fn, T &>
+  {
+    using value_t = ::std::remove_cv_t<::std::invoke_result_t<Fn, T &>>;
+    static_assert(_is_valid_optional<value_t>); // [optional.ref.monadic] Mandates
+    using result_t = typename Policy::template type<value_t>;
+    if (self.has_value()) {
+      return result_t(_from_invoke, FWD(fn), *self);
+    }
+    return result_t();
+  }
+
+  template <typename Self, typename Fn>
+  static constexpr auto _or_else(Self &&self, Fn &&fn) noexcept(::std::is_nothrow_invocable_v<Fn>)
+    requires ::std::is_invocable_v<Fn>
+  {
+    using result_t = typename Policy::template type<T &>;
+    static_assert(::std::is_same_v<::std::remove_cvref_t<::std::invoke_result_t<Fn>>, result_t>); // Mandates
+    if (self.has_value()) {
+      return result_t(*self); // the draft's `return *val;` -- rebinds the same referent
+    }
+    return ::std::invoke(FWD(fn));
+  }
+};
+
+struct optional_policy {
+  template <class T> using type = ::pfn::optional<T>;
+  template <class X> static constexpr bool is_specialization = _is_some_optional<X>;
+};
+
+// [optional.hash]: hash<optional<T>> is enabled iff hash<remove_const_t<T>> is enabled --
+// detected through the disabled-specialization criteria of [unord.hash] (an unspecialized
+// std::hash is a complete but disabled type on all mainstream implementations). Never true
+// for T = U& (no std::hash specialization for reference types is ever enabled), so
+// hash<optional<U&>> is disabled.
+template <class X>
+concept _hash_enabled_for = ::std::is_default_constructible_v<::std::hash<X>> //
+                            && requires(::std::hash<X> const &h, X const &x) {
+                                 { h(x) } -> ::std::same_as<::std::size_t>;
+                               };
+
+template <class T, bool = _hash_enabled_for<::std::remove_const_t<T>>> struct _optional_hash_base {
+  ::std::size_t operator()(::pfn::optional<T> const &o) const         //
+      noexcept(noexcept(::std::hash<::std::remove_const_t<T>>{}(*o))) // extension
+  {
+    if (o.has_value())
+      return ::std::hash<::std::remove_const_t<T>>{}(*o);
+    return static_cast<::std::size_t>(-7919); // [optional.hash] disengaged: an unspecified value
+  }
+};
+// Disabled case: per [unord.hash] a disabled hash specialization is not a function object
+// (no call operator) and is neither constructible nor assignable.
+template <class T> struct _optional_hash_base<T, false> {
+  _optional_hash_base() = delete;
+  _optional_hash_base(_optional_hash_base const &) = delete;
+  _optional_hash_base(_optional_hash_base &&) = delete;
+  _optional_hash_base &operator=(_optional_hash_base const &) = delete;
+  _optional_hash_base &operator=(_optional_hash_base &&) = delete;
+};
+
+} // namespace detail
+
+template <class T> class optional : private detail::_optional_base<T, detail::optional_policy> {
+  static_assert(detail::_is_valid_optional<T>);
+  using _base = detail::_optional_base<T, detail::optional_policy>;
+
+public:
+  using value_type = T;
+
+  // [optional.ctor], constructors
+  constexpr optional() noexcept : _base(::std::nullopt) {}
+  constexpr optional(::std::nullopt_t) noexcept : _base(::std::nullopt) {}
+
+  constexpr optional(optional const &) = delete;
+  constexpr optional(optional const &s)                   //
+      noexcept(::std::is_nothrow_copy_constructible_v<T>) // extension
+    requires(::std::is_copy_constructible_v<T> && ::std::is_trivially_copy_constructible_v<T>)
+  = default;
+  constexpr optional(optional const &s)                   //
+      noexcept(::std::is_nothrow_copy_constructible_v<T>) // extension
+    requires(::std::is_copy_constructible_v<T> && not ::std::is_trivially_copy_constructible_v<T>)
+      : _base(s.set_, FWD(s).storage_)
+  {
+  }
+  constexpr optional(optional &&) noexcept
+    requires(::std::is_move_constructible_v<T> && ::std::is_trivially_move_constructible_v<T>)
+  = default;
+  constexpr optional(optional &&s) //
+      noexcept(::std::is_nothrow_move_constructible_v<T>)
+    requires(::std::is_move_constructible_v<T> && not ::std::is_trivially_move_constructible_v<T>)
+      : _base(s.set_, FWD(s).storage_)
+  {
+  }
+
+  template <class... Args>
+  constexpr explicit optional(::std::in_place_t, Args &&...a) //
+      noexcept(::std::is_nothrow_constructible_v<T, Args...>) // extension
+    requires ::std::is_constructible_v<T, Args...>
+      : _base(::std::in_place, FWD(a)...)
+  {
+  }
+  template <class U, class... Args>
+  constexpr explicit optional(::std::in_place_t, ::std::initializer_list<U> il, Args &&...a) //
+      noexcept(::std::is_nothrow_constructible_v<T, ::std::initializer_list<U> &, Args...>)  // extension
+    requires ::std::is_constructible_v<T, ::std::initializer_list<U> &, Args...>
+      : _base(::std::in_place, il, FWD(a)...)
+  {
+  }
+
+  // Direct-non-list-initializes the contained value from the result of std::invoke; used by
+  // transform ([optional.monadic]), and public because the caller is another optional's base.
+  template <class Fn, class... Args>
+  constexpr explicit optional(detail::_from_invoke_t tag, Fn &&fn, Args &&...args) //
+      noexcept(::std::is_nothrow_constructible_v<_base, detail::_from_invoke_t, Fn, Args...>)
+      : _base(tag, FWD(fn), FWD(args)...)
+  {
+  }
+
+  template <class U = ::std::remove_cv_t<T>>
+  constexpr explicit(not ::std::is_convertible_v<U, T>) optional(U &&v) // NOSONAR cpp:S6458 _can_convert excludes self
+      noexcept(::std::is_nothrow_constructible_v<T, U>)                 // extension
+    requires(_base::template _can_convert<U>::value)
+      : _base(::std::in_place, FWD(v))
+  {
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U const &, T>) optional(optional<U> const &s) //
+      noexcept(::std::is_nothrow_constructible_v<T, U const &>)                                // extension
+    requires(_base::template _can_copy_convert<U>::value)
+      : _base(s)
+  {
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U, T>) optional(optional<U> &&s) //
+      noexcept(::std::is_nothrow_constructible_v<T, U>)                           // extension
+    requires(_base::template _can_move_convert<U>::value)
+      : _base(::std::move(s))
+  {
+  }
+
+  // [optional.dtor], destructor
+  constexpr ~optional() = default;
+
+  // [optional.assign], assignment
+  constexpr optional &operator=(::std::nullopt_t) noexcept
+  {
+    this->reset();
+    return *this;
+  }
+  constexpr optional &operator=(optional const &) = delete;
+  constexpr optional &operator=(optional const &s)                                                  //
+      noexcept(::std::is_nothrow_copy_assignable_v<T> && ::std::is_nothrow_copy_constructible_v<T>) // extension
+    requires(::std::is_copy_constructible_v<T> && ::std::is_copy_assignable_v<T>)
+  {
+    this->_assign(static_cast<_base const &>(s));
+    return *this;
+  }
+  constexpr optional &operator=(optional &&s) // NOSONAR cpp:S5018 standard mandated `noexcept` spec.
+      noexcept(::std::is_nothrow_move_assignable_v<T> && ::std::is_nothrow_move_constructible_v<T>) // required
+    requires(::std::is_move_constructible_v<T> && ::std::is_move_assignable_v<T>)
+  {
+    this->_assign(static_cast<_base &&>(s));
+    return *this;
+  }
+
+  template <class U = ::std::remove_cv_t<T>>
+  constexpr optional &operator=(U &&v)                                                            //
+      noexcept(::std::is_nothrow_assignable_v<T &, U> && ::std::is_nothrow_constructible_v<T, U>) // extension
+    requires(_base::template _can_assign<U>::value)
+  {
+    this->_assign_value(FWD(v));
+    return *this;
+  }
+  template <class U>
+  constexpr optional &operator=(optional<U> const &s) //
+      noexcept(::std::is_nothrow_assignable_v<T &, U const &>
+               && ::std::is_nothrow_constructible_v<T, U const &>) // extension
+    requires(_base::template _can_copy_assign<U>::value)
+  {
+    this->_assign_from(s);
+    return *this;
+  }
+  template <class U>
+  constexpr optional &operator=(optional<U> &&s)                                                  //
+      noexcept(::std::is_nothrow_assignable_v<T &, U> && ::std::is_nothrow_constructible_v<T, U>) // extension
+    requires(_base::template _can_move_assign<U>::value)
+  {
+    this->_assign_from(::std::move(s));
+    return *this;
+  }
+
+  using _base::emplace;
+
+  // [optional.swap], swap; body delegates to _optional_base helper
+  constexpr void swap(optional &rhs) // NOSONAR cpp:S5018 standard mandated `noexcept` spec.
+      noexcept(::std::is_nothrow_move_constructible_v<T> && ::std::is_nothrow_swappable_v<T>) // required
+  {
+    static_assert(::std::is_move_constructible_v<T>);
+    this->_swap_with(rhs);
+  }
+
+  // [optional.observe], observers
+  using _base::has_value;
+  using _base::operator bool;
+  using _base::operator*;
+  using _base::operator->;
+  using _base::value; // freestanding-deleted
+  using _base::value_or;
+
+  // [optional.monadic], monadic operations; bodies delegate to _optional_base helpers
+  template <class F>
+  constexpr auto and_then(F &&f) &                        //
+      noexcept(noexcept(_base::_and_then(*this, FWD(f)))) // extension
+      -> decltype(_base::_and_then(*this, FWD(f)))
+  {
+    return _base::_and_then(*this, FWD(f));
+  }
+  template <class F>
+  constexpr auto and_then(F &&f) &&                                    //
+      noexcept(noexcept(_base::_and_then(::std::move(*this), FWD(f)))) // extension
+      -> decltype(_base::_and_then(::std::move(*this), FWD(f)))
+  {
+    return _base::_and_then(::std::move(*this), FWD(f));
+  }
+  template <class F>
+  constexpr auto and_then(F &&f) const &                  //
+      noexcept(noexcept(_base::_and_then(*this, FWD(f)))) // extension
+      -> decltype(_base::_and_then(*this, FWD(f)))
+  {
+    return _base::_and_then(*this, FWD(f));
+  }
+  template <class F>
+  constexpr auto and_then(F &&f) const &&                              //
+      noexcept(noexcept(_base::_and_then(::std::move(*this), FWD(f)))) // extension
+      -> decltype(_base::_and_then(::std::move(*this), FWD(f)))
+  {
+    return _base::_and_then(::std::move(*this), FWD(f));
+  }
+  template <class F>
+  constexpr auto transform(F &&f) &                        //
+      noexcept(noexcept(_base::_transform(*this, FWD(f)))) // extension
+      -> decltype(_base::_transform(*this, FWD(f)))
+  {
+    return _base::_transform(*this, FWD(f));
+  }
+  template <class F>
+  constexpr auto transform(F &&f) &&                                    //
+      noexcept(noexcept(_base::_transform(::std::move(*this), FWD(f)))) // extension
+      -> decltype(_base::_transform(::std::move(*this), FWD(f)))
+  {
+    return _base::_transform(::std::move(*this), FWD(f));
+  }
+  template <class F>
+  constexpr auto transform(F &&f) const &                  //
+      noexcept(noexcept(_base::_transform(*this, FWD(f)))) // extension
+      -> decltype(_base::_transform(*this, FWD(f)))
+  {
+    return _base::_transform(*this, FWD(f));
+  }
+  template <class F>
+  constexpr auto transform(F &&f) const &&                              //
+      noexcept(noexcept(_base::_transform(::std::move(*this), FWD(f)))) // extension
+      -> decltype(_base::_transform(::std::move(*this), FWD(f)))
+  {
+    return _base::_transform(::std::move(*this), FWD(f));
+  }
+  template <class F>
+  constexpr auto or_else(F &&f) &&                                    //
+      noexcept(noexcept(_base::_or_else(::std::move(*this), FWD(f)))) // extension
+      -> decltype(_base::_or_else(::std::move(*this), FWD(f)))
+    requires(::std::invocable<F> && ::std::move_constructible<T>)
+  {
+    return _base::_or_else(::std::move(*this), FWD(f));
+  }
+  template <class F>
+  constexpr auto or_else(F &&f) const &                  //
+      noexcept(noexcept(_base::_or_else(*this, FWD(f)))) // extension
+      -> decltype(_base::_or_else(*this, FWD(f)))
+    requires(::std::invocable<F> && ::std::copy_constructible<T>)
+  {
+    return _base::_or_else(*this, FWD(f));
+  }
+
+  // [optional.mod], modifiers
+  using _base::reset;
+};
+
+template <class T> optional(T) -> optional<T>;
+
+template <class T> class optional<T &> : private detail::_optional_base<T &, detail::optional_policy> {
+  static_assert(detail::_is_valid_optional<T>);
+  using _base = detail::_optional_base<T &, detail::optional_policy>;
+
+public:
+  using value_type = T;
+
+  // [optional.ref.ctor], constructors
+  constexpr optional() noexcept = default;
+  constexpr optional(::std::nullopt_t) noexcept : optional() {}
+  constexpr optional(optional const &rhs) noexcept = default;
+
+  template <class Arg>
+  constexpr explicit optional(::std::in_place_t, Arg &&arg) //
+      noexcept(::std::is_nothrow_constructible_v<T &, Arg>) // extension
+    requires ::std::is_constructible_v<T &, Arg>
+      : _base(::std::in_place, FWD(arg))
+  {
+  }
+
+  // Direct-non-list-initializes the bound reference from the result of std::invoke; used by
+  // transform ([optional.ref.monadic]), and public because the caller is another optional's base.
+  template <class Fn, class... Args>
+  constexpr explicit optional(detail::_from_invoke_t tag, Fn &&fn, Args &&...args) //
+      noexcept(::std::is_nothrow_constructible_v<_base, detail::_from_invoke_t, Fn, Args...>)
+      : _base(tag, FWD(fn), FWD(args)...)
+  {
+  }
+
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U, T &>) optional(U &&u) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U>)
+    requires(_base::template _can_convert<U>::value)
+      : _base(::std::in_place, FWD(u))
+  {
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U &, T &>) optional(optional<U> &rhs) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U &>)
+    requires(_base::template _can_convert_from<U, U &>::value)
+      : _base(rhs)
+  {
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U const &, T &>) optional(optional<U> const &rhs) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U const &>)
+    requires(_base::template _can_convert_from<U, U const &>::value)
+      : _base(rhs)
+  {
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U, T &>) optional(optional<U> &&rhs) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U>)
+    requires(_base::template _can_convert_from<U, U>::value)
+      : _base(::std::move(rhs))
+  {
+  }
+  template <class U>
+  constexpr explicit(not ::std::is_convertible_v<U const, T &>) optional(optional<U> const &&rhs) //
+      noexcept(::std::is_nothrow_constructible_v<T &, U const>)
+    requires(_base::template _can_convert_from<U, U const>::value)
+      : _base(::std::move(rhs))
+  {
+  }
+
+  constexpr ~optional() = default;
+
+  // [optional.ref.assign], assignment
+  constexpr optional &operator=(::std::nullopt_t) noexcept
+  {
+    this->reset();
+    return *this;
+  }
+  constexpr optional &operator=(optional const &rhs) noexcept = default;
+
+  using _base::emplace;
+
+  // [optional.ref.swap], swap
+  constexpr void swap(optional &rhs) noexcept { this->_swap_with(rhs); }
+
+  // [optional.ref.observe], observers
+  using _base::has_value;
+  using _base::operator bool;
+  using _base::operator*;
+  using _base::operator->;
+  using _base::value; // freestanding-deleted
+  using _base::value_or;
+
+  // [optional.ref.monadic], monadic operations; bodies delegate to _optional_base helpers
+  template <class F>
+  constexpr auto and_then(F &&f) const                    //
+      noexcept(noexcept(_base::_and_then(*this, FWD(f)))) // extension
+      -> decltype(_base::_and_then(*this, FWD(f)))
+  {
+    return _base::_and_then(*this, FWD(f));
+  }
+  template <class F>
+  constexpr auto transform(F &&f) const                    //
+      noexcept(noexcept(_base::_transform(*this, FWD(f)))) // extension
+      -> decltype(_base::_transform(*this, FWD(f)))
+  {
+    return _base::_transform(*this, FWD(f));
+  }
+  template <class F>
+  constexpr auto or_else(F &&f) const                    //
+      noexcept(noexcept(_base::_or_else(*this, FWD(f)))) // extension
+      -> decltype(_base::_or_else(*this, FWD(f)))
+    requires ::std::invocable<F>
+  {
+    return _base::_or_else(*this, FWD(f));
+  }
+
+  // [optional.ref.mod], modifiers
+  using _base::reset;
+};
+
+// [optional.relops], relational operators
+template <class T, class U>
+constexpr bool operator==(optional<T> const &x, optional<U> const &y) //
+    noexcept(detail::_eq_bool_noexcept<T, U>)                         // extension
+  requires detail::_eq_bool<T, U>
+{
+  if (x.has_value() != y.has_value())
+    return false;
+  if (not x.has_value())
+    return true;
+  return *x == *y;
+}
+template <class T, class U>
+constexpr bool operator!=(optional<T> const &x, optional<U> const &y) //
+    noexcept(detail::_ne_bool_noexcept<T, U>)                         // extension
+  requires detail::_ne_bool<T, U>
+{
+  if (x.has_value() != y.has_value())
+    return true;
+  if (not x.has_value())
+    return false;
+  return *x != *y;
+}
+template <class T, class U>
+constexpr bool operator<(optional<T> const &x, optional<U> const &y) //
+    noexcept(detail::_lt_bool_noexcept<T, U>)                        // extension
+  requires detail::_lt_bool<T, U>
+{
+  if (not y.has_value())
+    return false;
+  if (not x.has_value())
+    return true;
+  return *x < *y;
+}
+template <class T, class U>
+constexpr bool operator>(optional<T> const &x, optional<U> const &y) //
+    noexcept(detail::_gt_bool_noexcept<T, U>)                        // extension
+  requires detail::_gt_bool<T, U>
+{
+  if (not x.has_value())
+    return false;
+  if (not y.has_value())
+    return true;
+  return *x > *y;
+}
+template <class T, class U>
+constexpr bool operator<=(optional<T> const &x, optional<U> const &y) //
+    noexcept(detail::_le_bool_noexcept<T, U>)                         // extension
+  requires detail::_le_bool<T, U>
+{
+  if (not x.has_value())
+    return true;
+  if (not y.has_value())
+    return false;
+  return *x <= *y;
+}
+template <class T, class U>
+constexpr bool operator>=(optional<T> const &x, optional<U> const &y) //
+    noexcept(detail::_ge_bool_noexcept<T, U>)                         // extension
+  requires detail::_ge_bool<T, U>
+{
+  if (not y.has_value())
+    return true;
+  if (not x.has_value())
+    return false;
+  return *x >= *y;
+}
+template <class T, ::std::three_way_comparable_with<T> U>
+constexpr ::std::compare_three_way_result_t<T, U> operator<=>(optional<T> const &x, optional<U> const &y)
+{
+  return x.has_value() && y.has_value() ? *x <=> *y : x.has_value() <=> y.has_value();
+}
+
+// [optional.nullops], comparison with nullopt
+template <class T> constexpr bool operator==(optional<T> const &x, ::std::nullopt_t) noexcept
+{
+  return not x.has_value();
+}
+template <class T> constexpr ::std::strong_ordering operator<=>(optional<T> const &x, ::std::nullopt_t) noexcept
+{
+  return x.has_value() <=> false;
+}
+
+// [optional.comp.with.t], comparison with T
+template <class T, class U>
+constexpr bool operator==(optional<T> const &x, U const &v) //
+    noexcept(detail::_eq_bool_noexcept<T, U>)               // extension
+  requires(not detail::_is_some_optional<U>) && detail::_eq_bool<T, U>
+{
+  return x.has_value() ? *x == v : false;
+}
+template <class T, class U>
+constexpr bool operator==(T const &v, optional<U> const &x) //
+    noexcept(detail::_eq_bool_noexcept<T, U>)               // extension
+  requires(not detail::_is_some_optional<T>) && detail::_eq_bool<T, U>
+{
+  return x.has_value() ? v == *x : false;
+}
+template <class T, class U>
+constexpr bool operator!=(optional<T> const &x, U const &v) //
+    noexcept(detail::_ne_bool_noexcept<T, U>)               // extension
+  requires(not detail::_is_some_optional<U>) && detail::_ne_bool<T, U>
+{
+  return x.has_value() ? *x != v : true;
+}
+template <class T, class U>
+constexpr bool operator!=(T const &v, optional<U> const &x) //
+    noexcept(detail::_ne_bool_noexcept<T, U>)               // extension
+  requires(not detail::_is_some_optional<T>) && detail::_ne_bool<T, U>
+{
+  return x.has_value() ? v != *x : true;
+}
+template <class T, class U>
+constexpr bool operator<(optional<T> const &x, U const &v) //
+    noexcept(detail::_lt_bool_noexcept<T, U>)              // extension
+  requires(not detail::_is_some_optional<U>) && detail::_lt_bool<T, U>
+{
+  return x.has_value() ? *x < v : true;
+}
+template <class T, class U>
+constexpr bool operator<(T const &v, optional<U> const &x) //
+    noexcept(detail::_lt_bool_noexcept<T, U>)              // extension
+  requires(not detail::_is_some_optional<T>) && detail::_lt_bool<T, U>
+{
+  return x.has_value() ? v < *x : false;
+}
+template <class T, class U>
+constexpr bool operator>(optional<T> const &x, U const &v) //
+    noexcept(detail::_gt_bool_noexcept<T, U>)              // extension
+  requires(not detail::_is_some_optional<U>) && detail::_gt_bool<T, U>
+{
+  return x.has_value() ? *x > v : false;
+}
+template <class T, class U>
+constexpr bool operator>(T const &v, optional<U> const &x) //
+    noexcept(detail::_gt_bool_noexcept<T, U>)              // extension
+  requires(not detail::_is_some_optional<T>) && detail::_gt_bool<T, U>
+{
+  return x.has_value() ? v > *x : true;
+}
+template <class T, class U>
+constexpr bool operator<=(optional<T> const &x, U const &v) //
+    noexcept(detail::_le_bool_noexcept<T, U>)               // extension
+  requires(not detail::_is_some_optional<U>) && detail::_le_bool<T, U>
+{
+  return x.has_value() ? *x <= v : true;
+}
+template <class T, class U>
+constexpr bool operator<=(T const &v, optional<U> const &x) //
+    noexcept(detail::_le_bool_noexcept<T, U>)               // extension
+  requires(not detail::_is_some_optional<T>) && detail::_le_bool<T, U>
+{
+  return x.has_value() ? v <= *x : false;
+}
+template <class T, class U>
+constexpr bool operator>=(optional<T> const &x, U const &v) //
+    noexcept(detail::_ge_bool_noexcept<T, U>)               // extension
+  requires(not detail::_is_some_optional<U>) && detail::_ge_bool<T, U>
+{
+  return x.has_value() ? *x >= v : false;
+}
+template <class T, class U>
+constexpr bool operator>=(T const &v, optional<U> const &x) //
+    noexcept(detail::_ge_bool_noexcept<T, U>)               // extension
+  requires(not detail::_is_some_optional<T>) && detail::_ge_bool<T, U>
+{
+  return x.has_value() ? v >= *x : true;
+}
+template <class T, class U>
+  requires(not _is_derived_from_optional<U>) && ::std::three_way_comparable_with<T, U>
+constexpr ::std::compare_three_way_result_t<T, U> operator<=>(optional<T> const &x, U const &v)
+{
+  return x.has_value() ? *x <=> v : ::std::strong_ordering::less;
+}
+
+// [optional.specalg], specialized algorithms
+template <class T>
+constexpr void swap(optional<T> &x, optional<T> &y) noexcept(noexcept(x.swap(y)))
+  requires(::std::is_reference_v<T> || (::std::is_move_constructible_v<T> && ::std::is_swappable_v<T>))
+{
+  x.swap(y);
+}
+
+// The int parameter's default lives on the declaration above, along with the explanation of
+// the [optional.specalg] constraint it implements.
+template <int, class T>
+constexpr optional<::std::decay_t<T>> make_optional(T &&v)                      //
+    noexcept(::std::is_nothrow_constructible_v<optional<::std::decay_t<T>>, T>) // extension
+{
+  return optional<::std::decay_t<T>>(FWD(v));
+}
+template <class T, class... Args>
+constexpr optional<T> make_optional(Args &&...args)         //
+    noexcept(::std::is_nothrow_constructible_v<T, Args...>) // extension
+{
+  return optional<T>(::std::in_place, FWD(args)...);
+}
+template <class T, class U, class... Args>
+constexpr optional<T> make_optional(::std::initializer_list<U> il, Args &&...args)        //
+    noexcept(::std::is_nothrow_constructible_v<T, ::std::initializer_list<U> &, Args...>) // extension
+{
+  return optional<T>(::std::in_place, il, FWD(args)...);
+}
+
+} // namespace pfn
+
+namespace std {
+// [optional.hash], hash support
+template <class T> struct hash<::pfn::optional<T>> : ::pfn::detail::_optional_hash_base<T> {};
+} // namespace std
+
+#undef ASSERT
+
+#ifdef INCLUDE_PFN_OPTIONAL__POP_ASSERT
+#pragma pop_macro("ASSERT")
+#endif
+
+#undef FWD
+
+#ifdef INCLUDE_PFN_OPTIONAL__POP_FWD
+#pragma pop_macro("FWD")
+#endif
+
+#endif // INCLUDE_PFN_OPTIONAL
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7fd5291b..208ddf99 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -48,7 +48,9 @@ endforeach()
 
 set(TESTS_PFN_SOURCES
     pfn/expected.cpp
+    pfn/optional.cpp
     pfn/expected_validation.cpp
+    pfn/optional_validation.cpp
     pfn/functional.cpp
     pfn/utility.cpp
 )
diff --git a/tests/pfn/optional.cpp b/tests/pfn/optional.cpp
new file mode 100644
index 00000000..b36733e0
--- /dev/null
+++ b/tests/pfn/optional.cpp
@@ -0,0 +1,2641 @@
+// Copyright (c) 2026 Bronek Kozicki
+//
+// Distributed under the ISC License. See accompanying file LICENSE.md
+// or copy at https://opensource.org/licenses/ISC
+
+#include "catch2/catch_test_macros.hpp"
+
+#ifndef PFN_TEST_NESTED
+
+#include <pfn/optional.hpp>
+
+using pfn::make_optional;
+using pfn::optional;
+
+#endif
+// When nested via PFN_TEST_NESTED (e.g optional_validation.cpp), the wrapper TU
+// already includes the necessary header(s) and brings the relevant aliases into the
+// global namespace to select right set of types expected as the subject under test.
+
+#include <util/helper_types.hpp>
+
+#include <catch2/catch_all.hpp>
+
+#include <cstring>
+#include <functional>
+#include <initializer_list>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <version>
+
+// Constructible from literally anything, but itself neither copyable nor movable -- so
+// optional<greedy_t> can only be "constructible from an optional<greedy_t>&/&&/etc." via a
+// hijacking converting ctor, never via the (unavailable) dedicated copy/move ctor. Mirrors
+// pfn/expected.cpp's own greedy_t, used the same way for the same anti-hijack purpose.
+struct greedy_t {
+  greedy_t() = delete;
+  greedy_t(greedy_t const &) = delete;
+  greedy_t(greedy_t &&) = delete;
+  template <class U> constexpr greedy_t(U &&) noexcept {}
+};
+
+namespace {
+
+template <typename T> struct non_swappable {
+  friend void swap(T &, T &) = delete;
+};
+
+template <typename T> struct swappable {
+  friend void swap(T &, T &) noexcept(false) {}
+};
+
+template <typename T> struct nothrow_swappable {
+  friend void swap(T &, T &) noexcept(true) {}
+};
+
+// NOTE: not the same as std::is_swappable https://eel.is/c++draft/swappable.requirements
+// because std::is_swappable brings std::swap https://eel.is/c++draft/utility.swap#lib:swap
+// into scope, which we do not want for this check.
+template <typename T>
+concept is_swappable = requires { swap(std::declval<T &>(), std::declval<T &>()); };
+
+template <typename T>
+concept is_nothrow_swappable = requires {
+  { swap(std::declval<T &>(), std::declval<T &>()) } noexcept;
+};
+
+// SFINAE probes for the comparison operators' constraints; a generic (dependent) context, so
+// a non-viable comparison yields false instead of a hard error.
+template <typename L, typename R = L>
+concept has_eq = requires(L const &l, R const &r) { l == r; };
+template <typename L, typename R = L>
+concept has_ne = requires(L const &l, R const &r) { l != r; };
+template <typename L, typename R = L>
+concept has_lt = requires(L const &l, R const &r) { l < r; };
+template <typename L, typename R = L>
+concept has_gt = requires(L const &l, R const &r) { l > r; };
+template <typename L, typename R = L>
+concept has_le = requires(L const &l, R const &r) { l <= r; };
+template <typename L, typename R = L>
+concept has_ge = requires(L const &l, R const &r) { l >= r; };
+template <typename L, typename R = L>
+concept has_spaceship = requires(L const &l, R const &r) { l <=> r; };
+
+// SFINAE probe for or_else's constraints (the only constrained monadic operation)
+template <typename O, typename F>
+concept has_or_else = requires(O &&o, F &&f) { std::forward<O>(o).or_else(std::forward<F>(f)); };
+
+} // namespace
+
+TEST_CASE("optional", "[optional][polyfill]")
+{
+#ifndef PFN_TEST_VALIDATION
+  constexpr bool extension = true;
+#else
+  constexpr bool extension = false;
+#endif
+
+  SECTION("type aliases")
+  {
+    static_assert(std::is_same_v<optional<int>::value_type, int>);
+    static_assert(std::is_same_v<optional<helper>::value_type, helper>);
+    SUCCEED();
+  }
+
+  SECTION("constructors")
+  {
+    SECTION("default and nullopt")
+    {
+      // optional<T> is default constructible (disengaged) even when T is not.
+      static_assert(not std::is_default_constructible_v<helper>); // prerequisite
+      static_assert(std::is_default_constructible_v<optional<helper>>);
+      static_assert(std::is_nothrow_default_constructible_v<optional<helper>>);
+      static_assert(std::is_nothrow_constructible_v<optional<helper>, std::nullopt_t>);
+
+      using T = optional<int>;
+      static_assert(std::is_nothrow_default_constructible_v<T>);
+      static_assert(std::is_trivially_destructible_v<T>);
+
+      constexpr T a;
+      constexpr T b(std::nullopt);
+      (void)a;
+      (void)b;
+      SUCCEED();
+    }
+
+    SECTION("in_place")
+    {
+      using T = optional<helper>;
+      static_assert(std::is_constructible_v<T, std::in_place_t, int>);
+      static_assert(not std::is_constructible_v<T, std::in_place_t>); // helper has no default ctor
+      static_assert(not extension || not std::is_nothrow_constructible_v<T, std::in_place_t, int>);
+      static_assert(not extension || std::is_nothrow_constructible_v<optional<helper_t<8>>, std::in_place_t, int>);
+
+      // value ctor path is witnessed by helper_t::state
+      int const s0 = helper::state;
+      T a(std::in_place, 11);
+      CHECK(helper::state - s0 == 11);
+
+      // throwing value ctor propagates
+      REQUIRE_THROWS_AS(T(std::in_place, 0), std::runtime_error);
+    }
+
+    SECTION("in_place initializer_list")
+    {
+      using T = optional<helper>;
+      static_assert(std::is_constructible_v<T, std::in_place_t, helper_list_t>);
+      static_assert(std::is_constructible_v<T, std::in_place_t, helper_list_t, int>);
+
+      int const s0 = helper::state;
+      T a(std::in_place, {1.0, 2.0, 3.0}); // helper(list): state += 1*2*3
+      CHECK(helper::state - s0 == 6);
+    }
+
+    SECTION("converting")
+    {
+      using T = optional<helper>;
+      static_assert(std::is_constructible_v<T, int>);
+      static_assert(not std::is_nothrow_constructible_v<T, int>);
+      static_assert(std::is_constructible_v<T, helper>);
+      static_assert(not extension || std::is_nothrow_constructible_v<T, helper>);
+
+      T const a(11);
+      CHECK(a->v == 11);
+
+      T const b(helper(13));
+      CHECK(b->v == 13 * from_rval);
+
+      // explicit-ness follows is_convertible_v<U, T>: helper(int) is an implicit ctor, so the
+      // optional(U&&) ctor must be implicit too, but an explicit-only value type forces it explicit.
+      static_assert(std::is_convertible_v<int, T>);
+      struct explicit_only {
+        int v;
+        constexpr explicit explicit_only(int x) noexcept : v(x) {}
+      };
+      static_assert(std::is_constructible_v<optional<explicit_only>, int>);
+      static_assert(not std::is_convertible_v<int, optional<explicit_only>>);
+
+      // Self-hijack guard: greedy_t is constructible from literally anything but has no copy
+      // or move ctor at all, so optional<greedy_t> can only spuriously look "constructible from
+      // itself" if optional(U&&) (U = optional<greedy_t> and its ref-qualified variants) were
+      // NOT excluded from the overload set.
+      using H = optional<greedy_t>;
+      static_assert(not std::is_copy_constructible_v<H>);
+      static_assert(not std::is_move_constructible_v<H>);
+      static_assert(not std::is_constructible_v<H, H &>);
+      static_assert(not std::is_constructible_v<H, H const &>);
+      static_assert(not std::is_constructible_v<H, H &&>);
+      static_assert(not std::is_constructible_v<H, H const &&>);
+
+      // nullopt_t/in_place_t must still select the dedicated ctors, never the converting one,
+      // even for a value type that (unlike a normal type) is ALSO directly constructible from
+      // both tags -- see the _can_convert exclusion in include/pfn/optional.hpp, an LWG4222-
+      // style fix (that issue added the analogous unexpect_t exclusion to expected's converting
+      // ctor; optional's own draft constraint list omits the equivalent nullopt_t exclusion).
+      static_assert(std::is_constructible_v<greedy_t, std::nullopt_t>);  // prerequisite
+      static_assert(std::is_constructible_v<greedy_t, std::in_place_t>); // prerequisite
+      H c(std::nullopt);
+      CHECK(not c.has_value());
+      H d(std::in_place, 1);
+      CHECK(d.has_value());
+    }
+  }
+
+  SECTION("copy, move and dtor")
+  {
+    SECTION("unavailable")
+    {
+      static_assert(not std::is_copy_constructible_v<optional<helper_move_only>>);
+      static_assert(std::is_move_constructible_v<optional<helper_move_only>>);
+
+      // An immovable value type cannot be copied or moved, but the optional can
+      // still be built in place.
+      static_assert(not std::is_copy_constructible_v<optional<helper_immovable>>);
+      static_assert(not std::is_move_constructible_v<optional<helper_immovable>>);
+      optional<helper_immovable> a(std::in_place, 6, 7);
+      (void)a;
+      SUCCEED();
+    }
+
+    SECTION("move-only value type")
+    {
+      using T = optional<helper_move_only>;
+      static_assert(not std::is_copy_constructible_v<T>);
+      static_assert(std::is_move_constructible_v<T>);
+      static_assert(not std::is_trivially_move_constructible_v<T>);
+      static_assert(std::is_nothrow_move_constructible_v<T>);
+
+      T a(std::in_place, 7);
+      T b = std::move(a);
+      (void)b;
+      SUCCEED();
+    }
+
+    SECTION("trivial")
+    {
+      using T = optional<int>;
+      static_assert(std::is_copy_constructible_v<T>);
+      static_assert(std::is_trivially_copy_constructible_v<T>);
+      static_assert(not extension || std::is_nothrow_copy_constructible_v<T>);
+      static_assert(std::is_move_constructible_v<T>);
+      static_assert(std::is_trivially_move_constructible_v<T>);
+      static_assert(std::is_trivially_destructible_v<T>);
+      static_assert(std::is_nothrow_destructible_v<T>);
+
+      constexpr T a(std::in_place, 13);
+      constexpr T b = a;
+      constexpr T c = std::move(a);
+      (void)b;
+      (void)c;
+      SUCCEED();
+    }
+
+    SECTION("non-trivial value type")
+    {
+      using T = optional<helper>;
+      static_assert(std::is_copy_constructible_v<T>);
+      static_assert(not std::is_trivially_copy_constructible_v<T>);
+      static_assert(not extension || std::is_nothrow_copy_constructible_v<T>);
+      static_assert(std::is_move_constructible_v<T>);
+      static_assert(not std::is_trivially_move_constructible_v<T>);
+      static_assert(std::is_nothrow_move_constructible_v<T>);
+      static_assert(not std::is_trivially_destructible_v<T>);
+      static_assert(std::is_nothrow_destructible_v<T>);
+
+      // copy/move of the disengaged state invokes no value ctor
+      T a(std::nullopt);
+      T b = a;
+      T c = std::move(a);
+      (void)b;
+      (void)c;
+
+      // move of the engaged state is witnessed via helper_t<30>::state
+      using H = helper_t<30>;
+      static_assert(not std::is_trivially_move_constructible_v<optional<H>>);
+      int const s0 = H::state;
+      optional<H> d(std::in_place, 7); // value ctor: state += 7
+      optional<H> e = std::move(d);    // move ctor (V>=30): state += 7*from_rval
+      CHECK(H::state - s0 == 7 + 7 * from_rval);
+    }
+
+    SECTION("noexcept(false) from value type")
+    {
+      using T = optional<helper_t<2>>; // throwing copy ctor, nothrow move ctor
+      static_assert(std::is_copy_constructible_v<T>);
+      static_assert(not std::is_trivially_copy_constructible_v<T>);
+      static_assert(not std::is_nothrow_copy_constructible_v<T>);
+      static_assert(std::is_move_constructible_v<T>);
+      static_assert(std::is_nothrow_move_constructible_v<T>);
+      SUCCEED();
+    }
+  }
+
+  SECTION("from other optional")
+  {
+    SECTION("rval")
+    {
+      SECTION("engaged")
+      {
+        using T = optional<helper>;
+        static_assert(std::is_constructible_v<T, optional<int>>);
+        static_assert(not std::is_nothrow_constructible_v<T, optional<int>>);
+        static_assert(not extension || std::is_nothrow_constructible_v<T, optional<helper_list_t>>);
+        static_assert(std::is_convertible_v<optional<int>, T>);
+
+        constexpr optional<int> a{5};
+        constexpr optional<double> b{a};
+        static_assert(b.has_value() && *b == 5.0);
+
+        T c((optional<int>(5)));
+        CHECK(c.has_value());
+        CHECK(c->v == 5);
+
+#ifndef PFN_TEST_VALIDATION
+        // Also converts from a *reference* optional<U&> (pfn-only: no released standard
+        // library implements C++26's optional<T&> yet), exercising the fact that the
+        // converting ctor reads its source through the public has_value()/operator*() API
+        // rather than its private storage -- optional<int&> has a completely different
+        // internal representation (a bare pointer, no union or set_ at all).
+        static_assert(std::is_constructible_v<T, optional<int &>>);
+        int x = 9;
+        T d(optional<int &>(std::in_place, x));
+        CHECK(d.has_value());
+        CHECK(d->v == 9);
+#endif
+      }
+
+      SECTION("disengaged")
+      {
+        using T = optional<helper>;
+        constexpr optional<int> a;
+        constexpr optional<double> b{a};
+        static_assert(not b.has_value());
+
+        T c((optional<int>(std::nullopt)));
+        CHECK(not c.has_value());
+      }
+    }
+
+    SECTION("lval const")
+    {
+      SECTION("engaged")
+      {
+        using T = optional<helper>;
+        static_assert(std::is_constructible_v<T, optional<int> const &>);
+        static_assert(not std::is_nothrow_constructible_v<T, optional<int> const &>);
+        static_assert(not extension || std::is_nothrow_constructible_v<T, optional<helper_list_t> const &>);
+        static_assert(std::is_convertible_v<optional<int> const &, T>);
+
+        constexpr optional<bool> v{true};
+        constexpr optional<int> a{v};
+        static_assert(a.has_value() && *a == 1);
+
+        optional<int> const w(11);
+        T b(w);
+        CHECK(b.has_value());
+        CHECK(b->v == 11);
+      }
+
+      SECTION("disengaged")
+      {
+        using T = optional<helper>;
+        optional<int> const a(std::nullopt);
+        T b(a);
+        CHECK(not b.has_value());
+      }
+    }
+
+    SECTION("move-only and immovable value types")
+    {
+      // The converting ctor constructs T fresh from U's contained value -- it never
+      // copies or moves a T, so it works even when T itself has neither ctor.
+      static_assert(std::is_constructible_v<optional<helper_move_only>, optional<int>>);
+      optional<int> a(std::in_place, 7);
+      optional<helper_move_only> b(std::move(a));
+      CHECK(b.has_value());
+      CHECK(b->v == 7);
+
+      static_assert(std::is_constructible_v<optional<helper_immovable>, optional<int>>);
+      optional<int> c(std::in_place, 6);
+      optional<helper_immovable> d(std::move(c));
+      CHECK(d.has_value());
+      CHECK(d->v == 6);
+    }
+  }
+
+  SECTION("assignment")
+  {
+    // helper_t<V> fixtures used below (see helper_types.hpp for the full nothrow table)
+    using M = helper_t<2>;  // nothrow move constructible, throwing copy constructible
+    using E = helper_t<3>;  // may throw on move and copy
+    using C = helper_t<4>;  // nothrow copy constructible, throwing move constructible
+    using H = helper_t<40>; // nothrow copy/move constructible; throwing copy/move assignable
+    static_assert(not std::is_nothrow_copy_constructible_v<M>);
+    static_assert(std::is_nothrow_move_constructible_v<M>);
+    static_assert(not std::is_nothrow_copy_constructible_v<E>);
+    static_assert(not std::is_nothrow_move_constructible_v<E>);
+    static_assert(std::is_nothrow_copy_constructible_v<C>);
+    static_assert(not std::is_nothrow_move_constructible_v<C>);
+    static_assert(std::is_nothrow_copy_constructible_v<H>);
+    static_assert(std::is_nothrow_move_constructible_v<H>);
+    static_assert(not std::is_nothrow_copy_assignable_v<H>);
+    static_assert(not std::is_nothrow_move_assignable_v<H>);
+
+    SECTION("nullopt_t")
+    {
+      optional<helper> a(std::in_place, 21);
+      CHECK(a.has_value());
+      a = std::nullopt;
+      CHECK(not a.has_value());
+      a = std::nullopt; // already disengaged: no-op path
+      CHECK(not a.has_value());
+    }
+
+    SECTION("from rval")
+    {
+      SECTION("engaged to engaged")
+      {
+        using T = optional<helper>;
+        static_assert(std::is_nothrow_assignable_v<T &, T &&>); // standard-mandated, not an extension
+
+        T a(std::in_place, 17);
+        a = T(std::in_place, 19);
+        CHECK(a->v == 19 * from_rval);
+
+        { // the move-assignment operator propagates a throwing T::operator=
+          using T = optional<H>;
+          static_assert(not std::is_nothrow_assignable_v<T &, T &&>);
+
+          T b(std::in_place, 11);
+          b = T(std::in_place, 13);
+          CHECK(b->v == 13 * from_rval);
+
+          try {
+            b = T(std::in_place, 0);
+            FAIL();
+          } catch (std::runtime_error const &e) {
+            CHECK(std::strcmp(e.what(), "invalid input") == 0);
+            CHECK(b.has_value());
+            CHECK(b->v == 13 * from_rval); // unchanged: H::operator= throws before mutating
+          }
+        }
+      }
+
+      SECTION("engaged to disengaged")
+      {
+        using T = optional<helper>;
+        T a(std::in_place, 13);
+        a = T(std::nullopt);
+        CHECK(not a.has_value());
+      }
+
+      SECTION("disengaged to engaged")
+      {
+        SECTION("nothrow move")
+        {
+          using T = optional<M>;
+          static_assert(std::is_nothrow_assignable_v<T &, T &&>);
+
+          T a(std::nullopt);
+          a = T(std::in_place, 11);
+          CHECK(a->v == 11 * from_rval);
+        }
+
+        SECTION("throwing")
+        {
+          using T = optional<E>;
+          static_assert(not std::is_nothrow_assignable_v<T &, T &&>);
+
+          T a(std::nullopt);
+          a = T(std::in_place, 5);
+          CHECK(a->v == 5 * from_rval);
+
+          T b(std::nullopt);
+          try {
+            // constructed via the initializer_list ctor (no V<8 throw-check there) to
+            // get a stored 0 without the value ctor itself throwing first.
+            b = T(std::in_place, {0.0});
+            FAIL();
+          } catch (std::runtime_error const &e) {
+            CHECK(std::strcmp(e.what(), "invalid input") == 0);
+            CHECK(not b.has_value());
+          }
+        }
+      }
+
+      SECTION("disengaged to disengaged")
+      {
+        using T = optional<helper>;
+        T a(std::nullopt);
+        a = T(std::nullopt);
+        CHECK(not a.has_value());
+      }
+
+      SECTION("constexpr")
+      {
+        using T = optional<int>;
+        constexpr auto fn = [](T &&v) constexpr -> T {
+          T tmp{std::in_place, 1};
+          tmp = std::move(v);
+          return tmp;
+        };
+
+        constexpr T a = fn(T(std::in_place, 7));
+        static_assert(a.has_value() && *a == 7);
+
+        constexpr T b = fn(T(std::nullopt));
+        static_assert(not b.has_value());
+
+        SUCCEED();
+      }
+    }
+
+    SECTION("from lval const")
+    {
+      SECTION("engaged to engaged")
+      {
+        using T = optional<helper>;
+        static_assert(not extension || std::is_nothrow_assignable_v<T &, T const &>);
+
+        T a(std::in_place, 3);
+        T const b(std::in_place, 5);
+        a = b;
+        CHECK(a->v == 5 * from_lval_const);
+      }
+
+      SECTION("engaged to disengaged")
+      {
+        using T = optional<helper>;
+        T a(std::in_place, 9);
+        T const b(std::nullopt);
+        a = b;
+        CHECK(not a.has_value());
+      }
+
+      SECTION("disengaged to engaged")
+      {
+        SECTION("nothrow copy")
+        {
+          using T = optional<C>;
+          static_assert(not extension || std::is_nothrow_assignable_v<T &, T const &>);
+
+          T a(std::nullopt);
+          T const b(std::in_place, 7);
+          a = b;
+          CHECK(a->v == 7 * from_lval_const);
+        }
+
+        SECTION("throwing")
+        {
+          using T = optional<E>;
+          static_assert(not std::is_nothrow_assignable_v<T &, T const &>);
+
+          T a(std::nullopt);
+          T const b(std::in_place, 7);
+          a = b;
+          CHECK(a->v == 7 * from_lval_const);
+
+          T c(std::nullopt);
+          try {
+            T const d(std::in_place, {0.0});
+            c = d;
+            FAIL();
+          } catch (std::runtime_error const &e) {
+            CHECK(std::strcmp(e.what(), "invalid input") == 0);
+            CHECK(not c.has_value());
+          }
+        }
+      }
+
+      SECTION("disengaged to disengaged")
+      {
+        using T = optional<helper>;
+        T a(std::nullopt);
+        T const b(std::nullopt);
+        a = b;
+        CHECK(not a.has_value());
+      }
+
+      SECTION("constexpr")
+      {
+        using T = optional<int>;
+        constexpr auto fn = [](T const &v) constexpr -> T {
+          T tmp{std::in_place, 1};
+          tmp = v;
+          return tmp;
+        };
+
+        constexpr T a = fn(T(std::in_place, 7));
+        static_assert(a.has_value() && *a == 7);
+
+        constexpr T b = fn(T(std::nullopt));
+        static_assert(not b.has_value());
+
+        SUCCEED();
+      }
+    }
+
+    SECTION("unavailable")
+    {
+      // Copy-assignment is deleted, so only rval (move) assignment is available.
+      static_assert(not std::is_copy_assignable_v<optional<helper_move_only>>);
+      static_assert(std::is_move_assignable_v<optional<helper_move_only>>);
+      static_assert(std::is_nothrow_move_assignable_v<optional<helper_move_only>>);
+
+      static_assert(not std::is_copy_assignable_v<optional<helper_immovable>>);
+      static_assert(not std::is_move_assignable_v<optional<helper_immovable>>);
+      SUCCEED();
+    }
+
+    SECTION("converting value")
+    {
+      using T = optional<double>;
+      static_assert(std::is_assignable_v<T &, int>);
+      // operator=(U&&)'s noexcept-specifier is a pfn extension (unspecified by the standard,
+      // like the in_place ctor's), so this only holds for pfn itself, not real std::optional.
+      static_assert(not extension || std::is_nothrow_assignable_v<T &, int>); // double(int) never throws
+
+      T a;
+      a = 5; // disengaged -> engaged, construct
+      CHECK(a.has_value());
+      CHECK(*a == 5.0);
+
+      a = 7; // engaged -> engaged, plain T assignment
+      CHECK(*a == 7.0);
+
+      // Self-exclusion: operator=(U&&) must not compete with operator=(optional const&).
+      // If _can_assign's exclusion were broken, this call would be ambiguous (a hard
+      // compile error), not silently wrong.
+      optional<int> b(std::in_place, 1);
+      optional<int> const c(std::in_place, 2);
+      b = c;
+      CHECK(*b == 2);
+    }
+
+    SECTION("from other optional")
+    {
+      SECTION("rval")
+      {
+        SECTION("engaged to engaged")
+        {
+          using T = optional<double>;
+          T a(std::in_place, 1.0);
+          optional<int> b(std::in_place, 5);
+          a = std::move(b); // both engaged: plain T assignment (double::operator=(int))
+          CHECK(*a == 5.0);
+        }
+
+        SECTION("disengaged to engaged")
+        {
+          using T = optional<double>;
+          T a;
+          optional<int> b(std::in_place, 7);
+          a = std::move(b); // construct
+          CHECK(a.has_value());
+          CHECK(*a == 7.0);
+        }
+
+        SECTION("engaged to disengaged")
+        {
+          using T = optional<double>;
+          T a(std::in_place, 1.0);
+          optional<int> b(std::nullopt);
+          a = std::move(b); // destroy
+          CHECK(not a.has_value());
+        }
+
+        SECTION("disengaged to disengaged")
+        {
+          using T = optional<double>;
+          T a;
+          optional<int> b(std::nullopt);
+          a = std::move(b);
+          CHECK(not a.has_value());
+        }
+      }
+
+      SECTION("lval const")
+      {
+        SECTION("engaged to engaged")
+        {
+          using T = optional<double>;
+          T a(std::in_place, 1.0);
+          optional<int> const b(std::in_place, 5);
+          a = b;
+          CHECK(*a == 5.0);
+        }
+
+        SECTION("disengaged to engaged")
+        {
+          using T = optional<double>;
+          T a;
+          optional<int> const b(std::in_place, 7);
+          a = b;
+          CHECK(a.has_value());
+          CHECK(*a == 7.0);
+        }
+
+        SECTION("engaged to disengaged")
+        {
+          using T = optional<double>;
+          T a(std::in_place, 1.0);
+          optional<int> const b(std::nullopt);
+          a = b;
+          CHECK(not a.has_value());
+        }
+      }
+
+#ifndef PFN_TEST_VALIDATION
+      SECTION("reference source")
+      {
+        // pfn-only (no released standard library implements C++26's optional<T&> yet).
+        // Exercises _assign_from reading through has_value()/operator*() rather than
+        // private storage -- optional<int&> has a completely different internal
+        // representation (a bare pointer, no union or set_ at all).
+        using T = optional<double>;
+        int x = 9;
+        optional<int &> const r(std::in_place, x);
+        T a;
+        a = r;
+        CHECK(a.has_value());
+        CHECK(*a == 9.0);
+      }
+#endif
+    }
+  }
+
+  SECTION("emplace")
+  {
+    using T = optional<helper>;
+
+    SECTION("engaged to engaged")
+    {
+      T a(std::in_place, 1);
+      a.emplace(2, 3, 5);
+      CHECK(a->v == 2 * 3 * 5);
+    }
+
+    SECTION("disengaged to engaged")
+    {
+      T a(std::nullopt);
+      a.emplace(2, 3, 5);
+      CHECK(a->v == 2 * 3 * 5);
+    }
+
+    SECTION("initializer_list")
+    {
+      T a(std::nullopt);
+      a.emplace({7.0, 11.0});
+      CHECK(a->v == 7 * 11);
+    }
+
+    SECTION("move-only value type")
+    {
+      // emplace constructs in place, so it needs neither copy nor move of the value.
+      optional<helper_move_only> a(std::nullopt);
+      a.emplace(7);
+      CHECK(a->v == 7);
+    }
+
+    SECTION("immovable value type")
+    {
+      optional<helper_immovable> a(std::nullopt);
+      a.emplace(6, 7);
+      CHECK(a->v == 6 * 7);
+    }
+
+    SECTION("throwing constructor leaves the optional disengaged")
+    {
+      T a(std::in_place, 1);
+      try {
+        a.emplace(0);
+        FAIL();
+      } catch (std::runtime_error const &e) {
+        CHECK(std::strcmp(e.what(), "invalid input") == 0);
+        CHECK(not a.has_value());
+      }
+    }
+
+    SECTION("no noexcept-specifier: unlike expected's, still callable for a throwing ctor")
+    {
+      // [optional.assign] leaves emplace's noexcept-specifier unspecified (unlike expected's
+      // emplace, which pfn constrains to nothrow construction); libstdc++ and libc++ actually
+      // disagree here (libstdc++ conditions it on is_nothrow_constructible_v, libc++ doesn't),
+      // so only the pfn-specific choice (no noexcept-specifier at all) is asserted, and only
+      // the direction that holds regardless of that choice -- a throwing ctor is never
+      // noexcept -- is asserted unconditionally.
+      static_assert(not std::is_nothrow_constructible_v<helper, int>);
+      static_assert(not noexcept(std::declval<T &>().emplace(1)));
+
+      static_assert(std::is_nothrow_constructible_v<helper_t<8>, int>);
+      static_assert(not extension || not noexcept(std::declval<optional<helper_t<8>> &>().emplace(1)));
+      SUCCEED();
+    }
+
+    SECTION("constexpr")
+    {
+      constexpr helper c{helper_list_t(), 5};
+
+      SECTION("from disengaged")
+      {
+        constexpr auto fn = [](auto &&...args) constexpr -> T {
+          T tmp{std::nullopt};
+          tmp.emplace(std::forward<decltype(args)>(args)...);
+          return tmp;
+        };
+
+        constexpr T a = fn(c);
+        static_assert(a->v == 5 * from_lval_const * from_rval);
+
+        constexpr T b = fn(helper_list_t{3.0, 11.0}, 7);
+        static_assert(b->v == 3 * 11 * 7 * from_rval);
+
+        SUCCEED();
+      }
+
+      SECTION("from engaged")
+      {
+        constexpr auto fn = [](auto &&...args) constexpr -> T {
+          T tmp{std::in_place, helper_list_t(), 13};
+          tmp.emplace(std::forward<decltype(args)>(args)...);
+          return tmp;
+        };
+
+        constexpr T a = fn(c);
+        static_assert(a->v == 5 * from_lval_const * from_rval);
+
+        constexpr T b = fn(helper_list_t{3.0, 11.0}, 7);
+        static_assert(b->v == 3 * 11 * 7 * from_rval);
+
+        SUCCEED();
+      }
+    }
+  }
+
+  SECTION("swap")
+  {
+    SECTION("non-swappable")
+    {
+      struct A : non_swappable<A> {};
+      static_assert(not std::is_swappable_v<A>);
+      static_assert(std::is_move_constructible_v<A>);
+
+      static_assert(not extension || not is_swappable<optional<A>>);
+
+      SUCCEED();
+    }
+
+    SECTION("non-move-constructible")
+    {
+      struct A : swappable<A> {
+        A(A &&) = delete;
+      };
+      static_assert(std::is_swappable_v<A>);
+      static_assert(not std::is_move_constructible_v<A>);
+
+      static_assert(not is_swappable<optional<A>>);
+
+#ifndef PFN_TEST_VALIDATION
+      // [optional.swap] Mandates (rather than constrains) move-constructibility and only
+      // preconditions swappability, unlike [expected.object.swap]'s constraints: the member
+      // stays declared even when the namespace-scope swap is constrained away
+      static_assert(requires(optional<A> &a, optional<A> &b) { a.swap(b); });
+#endif
+      SUCCEED();
+    }
+
+    SECTION("swappable, nothrow-move-constructible")
+    {
+      struct A : swappable<A> {
+        A(A &&) noexcept(true) = default;
+      };
+      static_assert(std::is_swappable_v<A>);
+      static_assert(not std::is_nothrow_swappable_v<A>);
+      static_assert(std::is_nothrow_move_constructible_v<A>);
+
+      static_assert(is_swappable<optional<A>>);
+      static_assert(not is_nothrow_swappable<optional<A>>);
+
+      SUCCEED();
+    }
+
+    SECTION("nothrow-swappable, no-nothrow-move-constructible")
+    {
+      struct A : nothrow_swappable<A> {
+        A(A &&) noexcept(false) {}
+      };
+      static_assert(std::is_nothrow_swappable_v<A>);
+      static_assert(std::is_move_constructible_v<A>);
+      static_assert(not std::is_nothrow_move_constructible_v<A>);
+
+      // unlike expected's swap, a throwing move alone does not disable swap -- the
+      // cross-state transfer may throw, with the engagement states left unchanged
+      static_assert(is_swappable<optional<A>>);
+      static_assert(not is_nothrow_swappable<optional<A>>);
+
+      SUCCEED();
+    }
+
+    SECTION("nothrow-swappable, nothrow-move-constructible")
+    {
+      struct A : nothrow_swappable<A> {
+        A(A &&) noexcept(true) = default;
+      };
+      static_assert(std::is_nothrow_swappable_v<A>);
+      static_assert(std::is_nothrow_move_constructible_v<A>);
+
+      static_assert(is_swappable<optional<A>>);
+      static_assert(is_nothrow_swappable<optional<A>>);
+
+      static_assert(is_nothrow_swappable<optional<int>>);
+
+      SUCCEED();
+    }
+
+    SECTION("both engaged")
+    {
+      using T = optional<helper>;
+      T a(std::in_place, 7);
+      T b(std::in_place, 13);
+      a.swap(b);
+      CHECK(a->v == 13 * swapped);
+      CHECK(b->v == 7 * swapped);
+
+      swap(a, b); // the namespace-scope swap, found by ADL
+      CHECK(a->v == 7 * swapped * swapped);
+      CHECK(b->v == 13 * swapped * swapped);
+    }
+
+    SECTION("engaged/disengaged")
+    {
+      using T = optional<helper>;
+      T a(std::in_place, 19);
+      T b(std::nullopt);
+      a.swap(b);
+      CHECK(not a.has_value());
+      CHECK(b.has_value());
+      CHECK(b->v == 19 * from_rval);
+
+      a.swap(b); // mirrored: *this disengaged, rhs engaged
+      CHECK(a.has_value());
+      CHECK(a->v == 19 * from_rval * from_rval);
+      CHECK(not b.has_value());
+    }
+
+    SECTION("both disengaged")
+    {
+      using T = optional<helper>;
+      T a(std::nullopt);
+      T b(std::nullopt);
+      a.swap(b);
+      CHECK(not a.has_value());
+      CHECK(not b.has_value());
+    }
+
+    SECTION("exception")
+    {
+      // a throwing move during the cross-state transfer: engagement states unchanged
+      using T = optional<helper_t<3>>;
+      static_assert(not std::is_nothrow_move_constructible_v<helper_t<3>>);
+
+      // constructed via the initializer_list ctor (no V<8 throw-check there) to get a
+      // stored 0 without the value ctor itself throwing first
+      T a(std::in_place, {0.0});
+      T b(std::nullopt);
+      try {
+        a.swap(b);
+        FAIL();
+      } catch (std::runtime_error const &e) {
+        CHECK(std::strcmp(e.what(), "invalid input") == 0);
+        CHECK(a.has_value());
+        CHECK(a->v == 0);
+        CHECK(not b.has_value());
+      }
+
+      try {
+        b.swap(a); // mirrored orientation takes the delegating branch
+        FAIL();
+      } catch (std::runtime_error const &) {
+        CHECK(a.has_value());
+        CHECK(not b.has_value());
+      }
+    }
+
+    SECTION("constexpr")
+    {
+      using T = optional<int>;
+
+      // in-lambda asserts rather than the fn-return idiom of the sibling sections: copying a
+      // swapped-to-disengaged std::optional out of the lambda is not a constant expression on
+      // libstdc++ 14 (its swap ends the donor payload's lifetime; the trivial copy reads it)
+      SECTION("cross-state")
+      {
+        static_assert([] {
+          T a(std::in_place, 12);
+          T b(std::nullopt);
+          swap(a, b);
+          return not a.has_value() && b.has_value() && *b == 12;
+        }());
+        static_assert([] {
+          T a(std::nullopt);
+          T b(std::in_place, 12);
+          swap(a, b);
+          return a.has_value() && *a == 12 && not b.has_value();
+        }());
+        SUCCEED();
+      }
+
+      SECTION("same-state")
+      {
+        static_assert([] {
+          T a(std::in_place, 7);
+          T b(std::in_place, 12);
+          swap(a, b);
+          return *a == 12 && *b == 7;
+        }());
+        static_assert([] {
+          T a(std::nullopt);
+          T b(std::nullopt);
+          swap(a, b);
+          return not a.has_value() && not b.has_value();
+        }());
+        SUCCEED();
+      }
+    }
+  }
+
+  SECTION("accessors")
+  {
+    SECTION("value")
+    {
+      using T = optional<helper>;
+      static_assert(not noexcept(std::declval<T &>().value()));
+      static_assert(not noexcept(std::declval<T const &>().value()));
+      static_assert(not noexcept(std::declval<T &&>().value()));
+      static_assert(not noexcept(std::declval<T const &&>().value()));
+
+      {
+        T a(std::in_place, 11);
+        CHECK(a.value().v == 11);
+        CHECK(std::as_const(a).value().v == 11);
+        CHECK(std::move(std::as_const(a)).value().v == 11);
+        CHECK(std::move(a).value().v == 11);
+
+        static_assert(std::is_same_v<decltype(a.value()), helper &>);
+        static_assert(std::is_same_v<decltype(std::as_const(a).value()), helper const &>);
+        static_assert(std::is_same_v<decltype(std::move(a).value()), helper &&>);
+        static_assert(std::is_same_v<decltype(std::move(std::as_const(a)).value()), helper const &&>);
+      }
+
+      {
+        T a(std::in_place, 13);
+        CHECK(a);
+        helper b{1};
+        CHECK((b = a.value()).v == 13 * from_lval);
+        CHECK((b = std::as_const(a).value()).v == 13 * from_lval_const);
+        CHECK((b = std::move(std::as_const(a)).value()).v == 13 * from_rval_const);
+        CHECK((b = std::move(a).value()).v == 13 * from_rval);
+      }
+
+      {
+        // value() returns a reference, so it needs neither copy nor move of the value
+        optional<helper_immovable> a(std::in_place, 6, 7);
+        CHECK(a.value().v == 6 * 7);
+        CHECK(std::as_const(a).value().v == 6 * 7);
+        static_assert(std::is_same_v<decltype(std::move(a).value()), helper_immovable &&>);
+      }
+
+      SECTION("constexpr")
+      {
+        static_assert([] {
+          T a{std::in_place, helper_list_t{}, 1};
+          a.value().v = 13;
+          return (                                //
+              a.value().v == 13                   //
+              && std::as_const(a).value().v == 13 //
+              && std::move(a).value().v == 13     //
+              && std::move(std::as_const(a)).value().v == 13);
+        }());
+        SUCCEED();
+      }
+
+      SECTION("throwing")
+      {
+        static_assert(std::is_base_of_v<std::exception, std::bad_optional_access>);
+
+        T a(std::nullopt);
+        CHECK(!a);
+        REQUIRE_THROWS_AS(a.value(), std::bad_optional_access);
+        REQUIRE_THROWS_AS(std::as_const(a).value(), std::bad_optional_access);
+        REQUIRE_THROWS_AS(std::move(std::as_const(a)).value(), std::bad_optional_access);
+        REQUIRE_THROWS_AS(std::move(a).value(), std::bad_optional_access);
+
+        // the exact type, not std::exception: gcc on macOS fails to match a base-class
+        // handler for this exception (thrown by pfn and libstdc++ alike); the base
+        // relationship is already static_assert'd above
+        try {
+          (void)a.value();
+          FAIL();
+        } catch (std::bad_optional_access const &e) {
+          CHECK(e.what() != nullptr);
+        }
+      }
+    }
+
+    SECTION("value_or")
+    {
+      using T = optional<helper>;
+      static_assert(std::is_same_v<decltype(std::declval<T &>().value_or(0)), helper>);
+      static_assert(std::is_same_v<decltype(std::declval<T>().value_or(0)), helper>);
+      static_assert(not noexcept(std::declval<T>().value_or(std::declval<int>())));
+      static_assert(not noexcept(std::declval<T &>().value_or(std::declval<int>())));
+      // value_or has no noexcept-specifier ([optional.observe] puts none, and unlike expected's
+      // pfn adds no extension), so even nothrow arguments yield noexcept(false) -- asserted only
+      // for pfn, since a standard library is free to strengthen its own.
+      static_assert(not extension || not noexcept(std::declval<T>().value_or(std::declval<helper_list_t>())));
+      static_assert(not extension || not noexcept(std::declval<T &>().value_or(std::declval<helper_list_t>())));
+
+      SECTION("default template parameter")
+      {
+        // std::optional's value_or gained the `= remove_cv_t<T>` default late: libstdc++ in
+        // GCC 15, libc++ in LLVM 22. Older implementations don't have this default, so we
+        // can't test it there.
+#if !defined(PFN_TEST_VALIDATION) || (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION >= 220000)                           \
+    || (defined(__GLIBCXX__) && _GLIBCXX_RELEASE >= 15)
+        using D = optional<int>;
+        static_assert(requires(D &o) { o.value_or({}); });             // const & overload
+        static_assert(requires(D &&o) { std::move(o).value_or({}); }); // && overload
+#endif
+        SUCCEED();
+      }
+
+#ifndef _MSC_VER
+      SECTION("engaged")
+      {
+        T a(std::in_place, 7);
+        CHECK(a.value_or(0) == helper(7 * from_lval_const));
+        CHECK(std::as_const(a).value_or(0) == helper(7 * from_lval_const));
+        CHECK(std::move(std::as_const(a)).value_or(0) == helper(7 * from_lval_const));
+        CHECK(std::move(a).value_or(0) == helper(7 * from_rval));
+      }
+
+      SECTION("disengaged")
+      {
+        {
+          T a(std::nullopt);
+          CHECK(a.value_or(13) == helper(13));
+          CHECK(std::move(a).value_or(5) == helper(5));
+        }
+
+        {
+          T const a(std::nullopt);
+          helper b(11);
+          CHECK(a.value_or(b) == helper(11 * from_lval));
+          CHECK(a.value_or(std::as_const(b)) == helper(11 * from_lval_const));
+          CHECK(a.value_or(std::move(std::as_const(b))) == helper(11 * from_rval_const));
+          CHECK(a.value_or(std::move(b)) == helper(11 * from_rval));
+        }
+      }
+#endif
+
+      SECTION("conversion")
+      {
+        optional<double> a(std::in_place, 0.5);
+        static_assert(std::is_same_v<decltype(a.value_or(3)), double>);
+        CHECK(a.value_or(3) == 0.5);
+        a = std::nullopt;
+        CHECK(a.value_or(3) == 3.0);
+      }
+
+#ifndef _MSC_VER
+      SECTION("move-only value type")
+      {
+        optional<helper_move_only> a(std::in_place, 7);
+        CHECK(std::move(a).value_or(3) == helper_move_only(7 * from_rval));
+
+        optional<helper_move_only> b(std::nullopt);
+        CHECK(std::move(b).value_or(3) == helper_move_only(3));
+      }
+#endif
+
+#ifndef _MSC_VER
+      SECTION("constexpr")
+      {
+        constexpr helper c{helper_list_t(), 7};
+
+        SECTION("lval const")
+        {
+          {
+            constexpr T a(std::in_place, {3.0}, 5);
+            static_assert(a.value_or(c).v == 3 * 5 * from_lval_const);
+          }
+          {
+            constexpr T a(std::nullopt);
+            static_assert(a.value_or(c).v == 7 * from_lval_const);
+          }
+
+          SUCCEED();
+        }
+
+        SECTION("rval")
+        {
+          static_assert(T{std::in_place, {3.0}, 5}.value_or(c).v == 3 * 5 * from_rval);
+          static_assert(T{std::nullopt}.value_or(c).v == 7 * from_lval_const);
+          static_assert(T{std::nullopt}.value_or(helper(helper_list_t{7.0}, 3)).v == 7 * 3 * from_rval);
+
+          SUCCEED();
+        }
+      }
+#endif
+    }
+  }
+
+// C++23 members: gated away when validating against a pre-C++23 std::optional
+#if !defined(PFN_TEST_VALIDATION) || (defined(__cpp_lib_optional) && __cpp_lib_optional >= 202110L)
+  SECTION("monadic functions")
+  {
+    SECTION("and_then")
+    {
+      SECTION("value")
+      {
+        using T = optional<helper>;
+        constexpr auto fn
+            = [](auto &&a) constexpr -> optional<int> { return helper(std::forward<decltype(a)>(a)).v * 2; };
+
+        T a(std::in_place, 7);
+        static_assert(std::is_same_v<decltype(a.and_then(fn)), optional<int>>);
+        CHECK(a.and_then(fn).value() == 7 * 2 * from_lval);
+        CHECK(std::as_const(a).and_then(fn).value() == 7 * 2 * from_lval_const);
+        CHECK(std::move(std::as_const(a)).and_then(fn).value() == 7 * 2 * from_rval_const);
+        CHECK(std::move(a).and_then(fn).value() == 7 * 2 * from_rval);
+      }
+
+      SECTION("disengaged")
+      {
+        using T = optional<helper>;
+        constexpr auto fn = [](auto &&) constexpr -> optional<int> { return 1; };
+        T a(std::nullopt);
+        CHECK(not a.and_then(fn).has_value());
+        CHECK(not std::as_const(a).and_then(fn).has_value());
+        CHECK(not std::move(std::as_const(a)).and_then(fn).has_value());
+        CHECK(not std::move(a).and_then(fn).has_value());
+      }
+
+      SECTION("constexpr")
+      {
+        using T = optional<helper>;
+        constexpr auto fn
+            = [](auto &&a) constexpr -> optional<int> { return helper(std::forward<decltype(a)>(a)).v * 3; };
+
+        SECTION("lval const")
+        {
+          {
+            constexpr T a(std::in_place, {3.0}, 5);
+            static_assert(a.and_then(fn).value() == 3 * 3 * 5 * from_lval_const);
+          }
+
+          {
+            constexpr T a(std::nullopt);
+            static_assert(not a.and_then(fn).has_value());
+          }
+
+          SUCCEED();
+        }
+
+        SECTION("rval")
+        {
+          static_assert(T{std::in_place, {3.0}, 5}.and_then(fn) == 3 * 3 * 5 * from_rval);
+          static_assert(not T{std::nullopt}.and_then(fn).has_value());
+
+          SUCCEED();
+        }
+
+        SECTION("lval")
+        {
+          static_assert([&fn] {
+            T a{std::in_place, {3.0}, 5};
+            T b{std::nullopt};
+            return a.and_then(fn).value() == 3 * 3 * 5 * from_lval //
+                   && not b.and_then(fn).has_value();
+          }());
+
+          SUCCEED();
+        }
+
+        SECTION("rval const")
+        {
+          static_assert([&fn] {
+            T a{std::in_place, {3.0}, 5};
+            T b{std::nullopt};
+            return std::move(std::as_const(a)).and_then(fn).value() == 3 * 3 * 5 * from_rval_const //
+                   && not std::move(std::as_const(b)).and_then(fn).has_value();
+          }());
+
+          SUCCEED();
+        }
+      }
+
+      SECTION("move-only type")
+      {
+        optional<std::unique_ptr<int>> o(std::in_place, std::make_unique<int>(42));
+        auto res = std::move(o).and_then([](std::unique_ptr<int> p) -> optional<int> { return *p + 1; });
+        CHECK(res.value() == 43);
+      }
+    }
+
+    SECTION("or_else")
+    {
+      SECTION("engaged")
+      {
+        using T = optional<helper>;
+        constexpr auto fn = []() constexpr -> T { return T(std::in_place, 1); };
+
+        T a(std::in_place, 13);
+        // or_else has only const& and && overloads; the engaged path returns a copy of *this
+        // (the contained value through helper's const& copy ctor) or a move of it
+        CHECK(a.or_else(fn).value().v == 13 * from_lval_const);
+        CHECK(std::as_const(a).or_else(fn).value().v == 13 * from_lval_const);
+        CHECK(std::move(std::as_const(a)).or_else(fn).value().v == 13 * from_lval_const);
+        CHECK(std::move(a).or_else(fn).value().v == 13 * from_rval);
+      }
+
+      SECTION("disengaged")
+      {
+        using T = optional<helper>;
+        constexpr auto fn = []() constexpr -> T { return T(std::in_place, 5); };
+        T a(std::nullopt);
+        // the callable's result is returned as-is: no witness factor multiplied in
+        CHECK(a.or_else(fn).value().v == 5);
+        CHECK(std::move(a).or_else(fn).value().v == 5);
+        CHECK(not T(std::nullopt).or_else([]() -> T { return T(std::nullopt); }).has_value());
+      }
+
+      SECTION("constraints")
+      {
+        // [optional.monadic] or_else Constraints: invocable F and, per overload, copy- or
+        // move-constructible T
+        constexpr auto fn = []() -> optional<helper_move_only> { return {}; };
+        static_assert(has_or_else<optional<helper_move_only> &&, decltype(fn)>);
+        static_assert(not has_or_else<optional<helper_move_only> &, decltype(fn)>);
+        static_assert(not has_or_else<optional<helper_move_only> const &, decltype(fn)>);
+        static_assert(not has_or_else<optional<int> &&, int>); // not invocable
+        SUCCEED();
+      }
+
+      SECTION("constexpr")
+      {
+        using T = optional<int>;
+        constexpr auto fn = []() constexpr -> T { return T(99); };
+        static_assert(T(5).or_else(fn).value() == 5);
+        static_assert(T(std::nullopt).or_else(fn).value() == 99);
+        static_assert([&fn] {
+          T a(7);
+          T e(std::nullopt);
+          return a.or_else(fn).value() == 7 && e.or_else(fn).value() == 99;
+        }());
+        SUCCEED();
+      }
+    }
+
+    SECTION("transform")
+    {
+      SECTION("value")
+      {
+        using T = optional<helper>;
+        constexpr auto fn = [](auto &&a) constexpr { return helper(std::forward<decltype(a)>(a)).v * 2; };
+
+        T a(std::in_place, 7);
+        static_assert(std::is_same_v<decltype(a.transform(fn)), optional<int>>);
+        CHECK(a.transform(fn).value() == 7 * 2 * from_lval);
+        CHECK(std::as_const(a).transform(fn).value() == 7 * 2 * from_lval_const);
+        CHECK(std::move(std::as_const(a)).transform(fn).value() == 7 * 2 * from_rval_const);
+        CHECK(std::move(a).transform(fn).value() == 7 * 2 * from_rval);
+      }
+
+      SECTION("direct initialization")
+      {
+        // the contained value is direct-non-list-initialized from the invoke result:
+        // guaranteed elision, so no copy/move witness factor and an immovable type works
+        optional<int> a(7);
+        auto r = a.transform([](int v) { return helper(v); });
+        static_assert(std::is_same_v<decltype(r), optional<helper>>);
+        CHECK(r.value().v == 7);
+
+        static_assert(not std::is_move_constructible_v<helper_immovable>);
+        auto ri = a.transform([](int v) { return helper_immovable(v, 3); });
+        static_assert(std::is_same_v<decltype(ri), optional<helper_immovable>>);
+        CHECK(ri.value().v == 7 * 3);
+      }
+
+      SECTION("disengaged")
+      {
+        using T = optional<helper>;
+        constexpr auto fn = [](auto &&) constexpr { return 1; };
+        T a(std::nullopt);
+        CHECK(not a.transform(fn).has_value());
+        CHECK(not std::as_const(a).transform(fn).has_value());
+        CHECK(not std::move(std::as_const(a)).transform(fn).has_value());
+        CHECK(not std::move(a).transform(fn).has_value());
+      }
+
+#ifndef PFN_TEST_VALIDATION
+      SECTION("to reference")
+      {
+        // C++26 via P2988: remove_cv_t<invoke_result_t<F, ...>> does not strip references and
+        // T& is now a valid contained type, so a reference-returning callable produces an
+        // optional<X&> bound to the returned lvalue
+        int x = 5;
+        optional<int> a(1);
+        auto r = a.transform([&x](int) -> int & { return x; });
+        static_assert(std::is_same_v<decltype(r), optional<int &>>);
+        CHECK(&*r == &x);
+      }
+#endif
+
+      SECTION("constexpr")
+      {
+        using T = optional<helper>;
+        constexpr auto fn = [](auto &&a) constexpr { return helper(std::forward<decltype(a)>(a)).v * 3; };
+
+        SECTION("lval const")
+        {
+          constexpr T a(std::in_place, {3.0}, 5);
+          constexpr T e(std::nullopt);
+          static_assert(a.transform(fn).value() == 3 * 3 * 5 * from_lval_const);
+          static_assert(not e.transform(fn).has_value());
+          SUCCEED();
+        }
+
+        SECTION("rval")
+        {
+          static_assert(T{std::in_place, {3.0}, 5}.transform(fn) == 3 * 3 * 5 * from_rval);
+          SUCCEED();
+        }
+
+        SECTION("lval")
+        {
+          static_assert([&fn] {
+            T a{std::in_place, {3.0}, 5};
+            return a.transform(fn).value() == 3 * 3 * 5 * from_lval;
+          }());
+          SUCCEED();
+        }
+
+        SECTION("rval const")
+        {
+          static_assert([&fn] {
+            T a{std::in_place, {3.0}, 5};
+            return std::move(std::as_const(a)).transform(fn).value() == 3 * 3 * 5 * from_rval_const;
+          }());
+          SUCCEED();
+        }
+      }
+    }
+  }
+#endif
+
+  SECTION("reset")
+  {
+    using T = optional<helper>;
+    static_assert(noexcept(std::declval<T &>().reset()));
+
+    SECTION("engaged")
+    {
+      // dtor witness: the contained value flips a flag when destroyed
+      struct D {
+        bool *flag;
+        constexpr explicit D(bool *f) noexcept : flag(f) {}
+        constexpr ~D() { *flag = true; }
+      };
+      bool destroyed = false;
+      optional<D> a(std::in_place, &destroyed);
+      CHECK(a.has_value());
+      a.reset();
+      CHECK(not a.has_value());
+      CHECK(destroyed);
+    }
+
+    SECTION("disengaged")
+    {
+      T a(std::nullopt);
+      a.reset(); // no effect
+      CHECK(not a.has_value());
+    }
+
+    SECTION("constexpr")
+    {
+      static_assert([] {
+        T a{std::in_place, helper_list_t{}, 5};
+        a.reset();
+        bool const disengaged = not a.has_value();
+        a.emplace(helper_list_t{3.0}, 7);
+        return disengaged && a.has_value() && a->v == 3 * 7;
+      }());
+      SUCCEED();
+    }
+  }
+
+  SECTION("relational operators")
+  {
+    SECTION("constraints")
+    {
+      struct A {};
+      struct B {
+        constexpr bool operator==(B const &) const noexcept = default;
+      };
+      // each operator is individually constrained on its own comparison expression
+      static_assert(not extension || not has_eq<optional<A>>);
+      static_assert(not extension || not has_ne<optional<A>>);
+      static_assert(not extension || not has_lt<optional<A>>);
+      static_assert(not extension || not has_gt<optional<A>>);
+      static_assert(not extension || not has_le<optional<A>>);
+      static_assert(not extension || not has_ge<optional<A>>);
+      static_assert(has_eq<optional<B>>);
+      static_assert(has_ne<optional<B>>); // *x != *y is well-formed through B's rewritten ==
+      static_assert(not has_spaceship<optional<A>>);
+      static_assert(not has_spaceship<optional<B>>); // == alone does not satisfy three_way_comparable_with
+// libc++ 16 has no operator<=> for std::optional (P1614 incomplete there);
+// __cpp_lib_three_way_comparison tracks the stdlib's library-wide <=> support
+#if !defined(PFN_TEST_VALIDATION) || defined(__cpp_lib_three_way_comparison)
+      static_assert(has_spaceship<optional<int>, optional<long>>);
+#endif
+      SUCCEED();
+    }
+
+    SECTION("equality")
+    {
+      SECTION("same type")
+      {
+        using T = optional<helper>;
+        T const e1(std::nullopt);
+        T const e2(std::nullopt);
+        T const v1(std::in_place, 12);
+        T const v2(std::in_place, {3.0}, 4);
+        T const v3(std::in_place, 5);
+        CHECK((e1 == e2));
+        CHECK(not(e1 != e2));
+        CHECK(not(e1 == v1));
+        CHECK((e1 != v1));
+        CHECK(not(v1 == e1)); // both argument orders go through the one [optional.relops] overload
+        CHECK((v1 != e1));
+        CHECK((v1 == v2));
+        CHECK(not(v1 != v2));
+        CHECK(not(v1 == v3));
+        CHECK((v1 != v3));
+      }
+
+      SECTION("different types")
+      {
+        using V = optional<int>;
+        using W = optional<double>;
+        static_assert(V{12} == W{12.0});
+        static_assert(V{12} != W{12.5});
+        static_assert(V{std::nullopt} == W{std::nullopt});
+        static_assert(V{12} != W{std::nullopt});
+        SUCCEED();
+      }
+    }
+
+    SECTION("ordering")
+    {
+      using V = optional<int>;
+      constexpr V e(std::nullopt);
+      constexpr V a(1);
+      constexpr V b(2);
+      // a disengaged optional orders before every engaged one
+      static_assert(e < a);
+      static_assert(not(a < e));
+      static_assert(e <= a);
+      static_assert(e <= e);
+      static_assert(not(e < e));
+      static_assert(not(e > e));
+      static_assert(e >= e);
+      static_assert(a < b);
+      static_assert(a <= b);
+      static_assert(b > a);
+      static_assert(b >= a);
+      static_assert(a > e);
+      static_assert(a >= e);
+
+      SECTION("different types")
+      {
+        static_assert(optional<int>(1) < optional<double>(1.5));
+        static_assert(optional<double>(0.5) < optional<int>(1));
+        SUCCEED();
+      }
+
+      SECTION("runtime")
+      {
+        V const e1(std::nullopt);
+        V const v1(3);
+        V const v2(7);
+        CHECK((e1 < v1));
+        CHECK(not(v1 < e1));
+        CHECK((v1 < v2));
+        CHECK((v2 > v1));
+        CHECK((v1 <= v1));
+        CHECK((v1 >= v1));
+        // disengaged branches again, at runtime: the constexpr matrix above earns no coverage
+        CHECK(not(e1 > v1));
+        CHECK((v1 > e1));
+        CHECK((e1 <= v1));
+        CHECK(not(v1 <= e1));
+        CHECK((v1 >= e1));
+        CHECK(not(e1 >= v1));
+      }
+    }
+
+#if !defined(PFN_TEST_VALIDATION) || defined(__cpp_lib_three_way_comparison)
+    SECTION("three-way") // no std::optional operator<=> in libc++ 16
+    {
+      using V = optional<int>;
+      static_assert(
+          std::is_same_v<decltype(std::declval<V const &>() <=> std::declval<V const &>()), std::strong_ordering>);
+      static_assert(std::is_same_v<decltype(std::declval<V const &>() <=> std::declval<optional<double> const &>()),
+                                   std::partial_ordering>);
+      constexpr V e(std::nullopt);
+      constexpr V a(1);
+      constexpr V b(2);
+      static_assert((e <=> e) == std::strong_ordering::equal);
+      static_assert((e <=> a) == std::strong_ordering::less);
+      static_assert((a <=> e) == std::strong_ordering::greater);
+      static_assert((a <=> b) == std::strong_ordering::less);
+      static_assert((a <=> a) == std::strong_ordering::equal);
+
+      SECTION("partial ordering")
+      {
+        optional<double> const n(std::numeric_limits<double>::quiet_NaN());
+        optional<double> const e1(std::nullopt);
+        optional<double> const v(1.0);
+        CHECK((n <=> v) == std::partial_ordering::unordered);
+        CHECK((n <=> n) == std::partial_ordering::unordered); // engaged NaNs compare unordered...
+        CHECK((e1 <=> n) == std::partial_ordering::less);     // ...but engagement still orders first
+      }
+    }
+#endif
+  }
+
+  SECTION("comparison with nullopt")
+  {
+    using V = optional<int>;
+    // [optional.nullops] both operators are noexcept, and <=> returns strong_ordering for any T
+    static_assert(noexcept(std::declval<V const &>() == std::nullopt));
+    static_assert(noexcept(std::nullopt == std::declval<V const &>()));
+#if !defined(PFN_TEST_VALIDATION) || defined(__cpp_lib_three_way_comparison)
+    // no std::optional operator<=> in libc++ 16
+    static_assert(noexcept(std::declval<V const &>() <=> std::nullopt));
+    static_assert(
+        std::is_same_v<decltype(std::declval<optional<double> const &>() <=> std::nullopt), std::strong_ordering>);
+#endif
+
+    constexpr V e(std::nullopt);
+    constexpr V v(5);
+    static_assert(e == std::nullopt);
+    static_assert(std::nullopt == e);
+    static_assert(v != std::nullopt);
+    static_assert(std::nullopt != v);
+#if !defined(PFN_TEST_VALIDATION) || defined(__cpp_lib_three_way_comparison)
+    static_assert((e <=> std::nullopt) == std::strong_ordering::equal);
+    static_assert((v <=> std::nullopt) == std::strong_ordering::greater);
+#endif
+    // the ordering relations are rewritten from <=> (libc++ 16 falls back to its legacy operators)
+    static_assert(std::nullopt < v);
+    static_assert(not(std::nullopt < e));
+    static_assert(e <= std::nullopt);
+    static_assert(v > std::nullopt);
+    static_assert(v >= std::nullopt);
+    static_assert(not(std::nullopt >= v));
+
+    V const r(7);
+    CHECK(not(r == std::nullopt));
+    CHECK((r != std::nullopt));
+    CHECK((std::nullopt < r));
+  }
+
+  SECTION("comparison with value")
+  {
+    SECTION("constraints")
+    {
+      struct A {};
+      static_assert(not extension || not has_eq<optional<A>, A>);
+      static_assert(not extension || not has_eq<A, optional<A>>);
+      static_assert(not extension || not has_lt<optional<A>, A>);
+      static_assert(not extension || not has_lt<A, optional<A>>);
+
+      // LWG4072: the value operand must not itself be a specialization of optional. weird_t
+      // compares only with a whole optional<move_only_t> (its == takes exactly that), and with
+      // the value-operand overloads constrained away no comparison is viable at all: the
+      // [optional.relops] overload would need weird_t == move_only_t, which does not exist
+      // (move_only_t is not copyable, so it does not implicitly convert to optional<move_only_t>)
+      struct move_only_t {
+        move_only_t() = default;
+        move_only_t(move_only_t &&) = default;
+      };
+      struct weird_t {
+        constexpr bool operator==(optional<move_only_t> const &) const noexcept { return true; }
+      };
+      static_assert(not extension || not has_eq<optional<weird_t>, optional<move_only_t>>);
+      // ...while as a direct value operand weird_t's own member operator== still applies
+      static_assert(has_eq<weird_t, optional<move_only_t>>);
+      SUCCEED();
+    }
+
+    SECTION("equality")
+    {
+      using V = optional<int>;
+      constexpr V e(std::nullopt);
+      constexpr V v(5);
+      static_assert(v == 5);
+      static_assert(5 == v);
+      static_assert(v != 7);
+      static_assert(7 != v);
+      static_assert(not(e == 5));
+      static_assert(e != 5);
+      static_assert(not(5 == e));
+      static_assert(5 != e);
+      static_assert(v == 5.0); // heterogeneous
+      static_assert(v != 5.5);
+
+      using T = optional<helper>;
+      T const t(std::in_place, {3.0}, 4);
+      CHECK((t == helper(12)));
+      CHECK((helper(12) == t));
+      CHECK((t != helper(7)));
+      CHECK((helper(7) != t));
+      CHECK(not(T(std::nullopt) == helper(12)));
+    }
+
+    SECTION("ordering")
+    {
+      using V = optional<int>;
+      constexpr V e(std::nullopt);
+      constexpr V v(5);
+      // a disengaged optional orders before any value
+      static_assert(e < 0);
+      static_assert(not(0 < e));
+      static_assert(e <= 0);
+      static_assert(not(0 <= e));
+      static_assert(0 > e);
+      static_assert(not(e > 0));
+      static_assert(0 >= e);
+      static_assert(not(e >= 0));
+      static_assert(v < 6);
+      static_assert(4 < v);
+      static_assert(v <= 5);
+      static_assert(5 <= v);
+      static_assert(v > 4);
+      static_assert(6 > v);
+      static_assert(v >= 5);
+      static_assert(5 >= v);
+      static_assert(v < 5.5); // heterogeneous
+
+      V const r(3);
+      CHECK((r < 5));
+      CHECK((5 > r));
+      CHECK((V(std::nullopt) < 5));
+    }
+
+#if !defined(PFN_TEST_VALIDATION) || defined(__cpp_lib_three_way_comparison)
+    SECTION("three-way") // no std::optional operator<=> in libc++ 16
+    {
+      using V = optional<int>;
+      static_assert(std::is_same_v<decltype(std::declval<V const &>() <=> 5), std::strong_ordering>);
+      static_assert(std::is_same_v<decltype(std::declval<V const &>() <=> 5.0), std::partial_ordering>);
+      constexpr V e(std::nullopt);
+      constexpr V v(5);
+      static_assert((v <=> 5) == std::strong_ordering::equal);
+      static_assert((v <=> 7) == std::strong_ordering::less);
+      static_assert((e <=> 5) == std::strong_ordering::less);  // disengaged: strong_ordering::less
+      static_assert((5 <=> v) == std::strong_ordering::equal); // reversed, synthesized by rewriting
+      static_assert((5 <=> e) == std::strong_ordering::greater);
+
+      // a type derived from optional is compared by [optional.relops], not [optional.comp.with.t]
+      struct derived_t : optional<int> {
+        using optional<int>::optional;
+      };
+      static_assert(has_spaceship<optional<int>, derived_t>);
+      CHECK((V(5) <=> derived_t(3)) == std::strong_ordering::greater);
+      CHECK((V(5) <=> derived_t(std::nullopt)) == std::strong_ordering::greater); // compared as optionals
+    }
+#endif
+  }
+}
+
+// No released standard library implements C++26's optional<T&> ([optional.optional.ref])
+// yet, so this section is pfn-only and skipped when nested into optional_validation.cpp.
+#ifndef PFN_TEST_VALIDATION
+
+// Conversion-operator fixtures for optional<T&>'s convert-then-bind (_convert_ref_init_val)
+// paths: T& can also be obtained through a user conversion operator -- implicitly or
+// explicitly -- and that conversion (not any constructor of T) is what may throw.
+struct ref_holder {
+  int v;
+  constexpr operator int &() noexcept { return v; }
+};
+struct explicit_ref_holder {
+  int v;
+  constexpr explicit operator int &() noexcept { return v; }
+};
+struct throwing_ref_holder {
+  int v;
+  constexpr operator int &() noexcept(false) { return v; }
+};
+
+TEST_CASE("optional reference", "[optional_ref][polyfill]")
+{
+  SECTION("type aliases")
+  {
+    static_assert(std::is_same_v<optional<int &>::value_type, int>);
+    static_assert(std::is_same_v<optional<int const &>::value_type, int const>);
+    SUCCEED();
+  }
+
+  SECTION("trivial")
+  {
+    using T = optional<int &>;
+    static_assert(std::is_trivially_copyable_v<T>);
+    static_assert(std::is_trivially_destructible_v<T>);
+    static_assert(std::is_nothrow_default_constructible_v<T>);
+    static_assert(std::is_copy_constructible_v<T>);
+    static_assert(std::is_trivially_copy_constructible_v<T>);
+    static_assert(std::is_nothrow_constructible_v<T, std::nullopt_t>);
+    SUCCEED();
+  }
+
+  SECTION("constructors")
+  {
+    using T = optional<int &>;
+
+    SECTION("default and nullopt")
+    {
+      static_assert(std::is_nothrow_default_constructible_v<T>);
+      static_assert(std::is_nothrow_constructible_v<T, std::nullopt_t>);
+
+      constexpr T a;
+      static_assert(not a.has_value());
+      constexpr T b(std::nullopt);
+      static_assert(not b.has_value());
+      SUCCEED();
+    }
+
+    SECTION("in_place")
+    {
+      static_assert(std::is_constructible_v<T, std::in_place_t, int &>);
+      static_assert(not std::is_constructible_v<T, std::in_place_t, int>);      // int& cannot bind an rvalue
+      static_assert(not std::is_constructible_v<T, std::in_place_t, double &>); // nor a different lvalue type
+      // the noexcept-specifier is a pfn extension ([optional.ref.ctor] leaves in_place without one)
+      static_assert(std::is_nothrow_constructible_v<T, std::in_place_t, int &>);
+      static_assert(not std::is_nothrow_constructible_v<T, std::in_place_t, throwing_ref_holder &>);
+
+      int x = 5;
+      T c(std::in_place, x); // binds the reference to x
+      CHECK(c.has_value());
+      CHECK(&*c == &x);
+
+      // converts (through a user conversion operator), then binds
+      ref_holder h{7};
+      T d(std::in_place, h);
+      CHECK(&*d == &h.v);
+      CHECK(*d == 7);
+    }
+
+    SECTION("copy")
+    {
+      int x = 5;
+      T c(std::in_place, x);
+      T d = c; // trivial copy
+      CHECK(&*d == &x);
+
+      T const e(std::nullopt);
+      T f = e;
+      CHECK(not f.has_value());
+    }
+
+    SECTION("converting")
+    {
+      static_assert(std::is_constructible_v<T, int &>);
+      static_assert(std::is_convertible_v<int &, T>);
+      static_assert(not std::is_constructible_v<T, int>); // int& cannot bind an rvalue
+      static_assert(not std::is_constructible_v<T, double &>);
+      static_assert(std::is_nothrow_constructible_v<T, int &>); // standard-mandated, not an extension
+      static_assert(not std::is_nothrow_constructible_v<T, throwing_ref_holder &>);
+
+      int x = 5;
+      T a = x;
+      CHECK(&*a == &x);
+
+      ref_holder h{7};
+      T b = h;
+      CHECK(&*b == &h.v);
+
+      // explicit-ness follows is_convertible_v<U, T&>: an explicit-only conversion operator
+      // still constructs, but no longer converts
+      static_assert(std::is_constructible_v<T, explicit_ref_holder &>);
+      static_assert(not std::is_convertible_v<explicit_ref_holder &, T>);
+      explicit_ref_holder e{9};
+      T c(e);
+      CHECK(&*c == &e.v);
+    }
+
+    SECTION("from other optional")
+    {
+      SECTION("value source")
+      {
+        using S = optional<int>;
+        static_assert(std::is_constructible_v<T, S &>);
+        static_assert(std::is_convertible_v<S &, T>);
+        static_assert(std::is_nothrow_constructible_v<T, S &>); // standard-mandated
+        // int& can bind neither a const nor an rvalue source's contained value, nor one
+        // whose contained type would require a conversion (i.e. a temporary)
+        static_assert(not std::is_constructible_v<T, S const &>);
+        static_assert(not std::is_constructible_v<T, S>);
+        static_assert(not std::is_constructible_v<T, S const &&>);
+        static_assert(not std::is_constructible_v<T, optional<double> &>);
+        static_assert(not std::is_constructible_v<optional<long &>, S &>);
+
+        S s(std::in_place, 5);
+        T a = s;
+        CHECK(a.has_value());
+        CHECK(&*a == &*s); // a observes s's contained value...
+        *a = 7;
+        CHECK(*s == 7); // ...and writes through to it
+
+        S d(std::nullopt);
+        T b = d;
+        CHECK(not b.has_value());
+      }
+
+      SECTION("const value source")
+      {
+        using C = optional<int const &>;
+        static_assert(std::is_constructible_v<C, optional<int> &>);
+        static_assert(std::is_constructible_v<C, optional<int> const &>);
+        static_assert(std::is_convertible_v<optional<int> const &, C>);
+
+        optional<int> const s(std::in_place, 5);
+        C a = s;
+        CHECK(a.has_value());
+        CHECK(&*a == &*s);
+      }
+
+      SECTION("reference source")
+      {
+        // a differently-typed reference source: B& binds D& directly (derived-to-base), so
+        // this is safe for any source value category -- the referent outlives the source
+        struct B {
+          int v;
+        };
+        struct D : B {};
+
+        D d{{5}};
+        optional<D &> s(std::in_place, d);
+        optional<B &> a = s;
+        CHECK(&*a == static_cast<B *>(&d));
+
+        optional<B &> b = std::move(s); // rval source: the referent (d) is unaffected
+        CHECK(&*b == static_cast<B *>(&d));
+
+        optional<D &> const cs(std::in_place, d);
+        optional<B &> g = std::move(cs); // const rval source, same directly-bound referent
+        CHECK(&*g == static_cast<B *>(&d));
+
+        optional<D &> const e(std::nullopt);
+        optional<B &> f = e;
+        CHECK(not f.has_value());
+      }
+
+      SECTION("constexpr")
+      {
+        static_assert([] {
+          optional<int> s(std::in_place, 5);
+          optional<int &> a(s);
+          *a = 7;
+          return &*a == &*s && *s == 7;
+        }());
+        static_assert([] {
+          optional<int> s(std::nullopt);
+          optional<int &> a(s);
+          return not a.has_value();
+        }());
+        SUCCEED();
+      }
+    }
+  }
+
+  SECTION("assignment")
+  {
+    using T = optional<int &>;
+
+    SECTION("nullopt_t")
+    {
+      int x = 5;
+      T a(std::in_place, x);
+      CHECK(a.has_value());
+      a = std::nullopt;
+      CHECK(not a.has_value());
+      a = std::nullopt; // already disengaged: no-op path
+      CHECK(not a.has_value());
+    }
+
+    SECTION("copy rebinds rather than assigning through")
+    {
+      int x = 5, y = 9;
+      T a(std::in_place, x);
+      T const b(std::in_place, y);
+      a = b;
+      CHECK(&*a == &y);
+      CHECK(x == 5); // x untouched by the rebind
+      y = 11;
+      CHECK(*a == 11); // a now observes y, not a copy of its old value
+    }
+
+    SECTION("copy from disengaged")
+    {
+      int x = 5;
+      T a(std::in_place, x);
+      T const b(std::nullopt);
+      a = b;
+      CHECK(not a.has_value());
+      CHECK(x == 5);
+    }
+
+    SECTION("from value rebinds via the converting constructor")
+    {
+      // [optional.ref.assign] has no operator=(U&&): assigning from a value goes through the
+      // implicit converting constructor, then the trivial copy-assignment -- a rebind, never
+      // an assign-through
+      int x = 5, y = 9;
+      T a(std::in_place, x);
+      a = y;
+      CHECK(&*a == &y);
+      CHECK(x == 5);
+    }
+  }
+
+  SECTION("emplace")
+  {
+    using T = optional<int &>;
+
+    SECTION("from disengaged")
+    {
+      int x = 7;
+      T a(std::nullopt);
+      int &r = a.emplace(x);
+      CHECK(a.has_value());
+      CHECK(&*a == &x);
+      CHECK(&r == &x);
+    }
+
+    SECTION("rebinds rather than assigning through")
+    {
+      int x = 5, y = 9;
+      T a(std::in_place, x);
+      a.emplace(y);
+      CHECK(&*a == &y);
+      CHECK(x == 5); // x untouched
+    }
+
+    SECTION("converts then binds")
+    {
+      ref_holder h{7};
+      T a(std::nullopt);
+      int &r = a.emplace(h);
+      CHECK(&*a == &h.v);
+      CHECK(&r == &h.v);
+    }
+
+    SECTION("SFINAE and noexcept")
+    {
+      static_assert(std::is_nothrow_constructible_v<int &, int &>);
+      static_assert(noexcept(std::declval<T &>().emplace(std::declval<int &>())));
+      static_assert(not noexcept(std::declval<T &>().emplace(std::declval<throwing_ref_holder &>())));
+
+      // int&& cannot bind int&: emplace must be SFINAE'd out, not a hard error. Wrapped in a
+      // generic lambda so the constraint failure is genuine SFINAE (substitution during the
+      // lambda's own instantiation), rather than a hard error from a non-dependent call.
+      static_assert(not std::is_constructible_v<int &, int &&>);
+      constexpr auto fn = [](auto &&...args) constexpr -> bool {
+        return requires(T &o) { o.emplace(std::forward<decltype(args)>(args)...); };
+      };
+      static_assert(not fn(5));
+      SUCCEED();
+    }
+
+    SECTION("constexpr")
+    {
+      static_assert([] {
+        int x = 1, y = 2;
+        T o(std::in_place, x);
+        o.emplace(y);
+        return &*o == &y && x == 1;
+      }());
+      SUCCEED();
+    }
+  }
+
+  SECTION("swap")
+  {
+    using T = optional<int &>;
+    static_assert(noexcept(std::declval<T &>().swap(std::declval<T &>())));
+    // the namespace-scope swap accepts optional<T&> through the is_reference_v arm of its
+    // constraint, and is unconditionally noexcept here
+    static_assert(is_swappable<T>);
+    static_assert(is_nothrow_swappable<T>);
+
+    SECTION("rebinds both sides")
+    {
+      int x = 5, y = 9;
+      T a(std::in_place, x);
+      T b(std::in_place, y);
+      a.swap(b);
+      CHECK(&*a == &y);
+      CHECK(&*b == &x);
+      CHECK(x == 5); // a pointer swap, never a value swap: referents untouched
+      CHECK(y == 9);
+
+      swap(a, b);
+      CHECK(&*a == &x);
+      CHECK(&*b == &y);
+    }
+
+    SECTION("engaged/disengaged")
+    {
+      int x = 5;
+      T a(std::in_place, x);
+      T b(std::nullopt);
+      a.swap(b);
+      CHECK(not a.has_value());
+      CHECK(&*b == &x);
+    }
+
+    SECTION("constexpr")
+    {
+      static_assert([] {
+        int x = 1, y = 2;
+        T a(std::in_place, x);
+        T b(std::in_place, y);
+        a.swap(b);
+        return &*a == &y && &*b == &x && x == 1 && y == 2;
+      }());
+      SUCCEED();
+    }
+  }
+
+  SECTION("observers")
+  {
+    using T = optional<int &>;
+
+    SECTION("const does not propagate to the referent")
+    {
+      int x = 5;
+      T const a(std::in_place, x);
+      static_assert(std::is_same_v<decltype(*a), int &>);             // not int const&
+      static_assert(std::is_same_v<decltype(a.operator->()), int *>); // not int const*
+      static_assert(noexcept(std::declval<T const &>().operator->()));
+      static_assert(noexcept(*std::declval<T const &>()));
+      static_assert(noexcept(std::declval<T const &>().has_value()));
+      static_assert(noexcept(static_cast<bool>(std::declval<T const &>())));
+      *a = 7;
+      CHECK(x == 7); // mutated through a const optional<int&>
+      CHECK(a.has_value());
+      CHECK(static_cast<bool>(a));
+    }
+
+    SECTION("disengaged")
+    {
+      T const a(std::nullopt);
+      CHECK(not a.has_value());
+      CHECK(not static_cast<bool>(a));
+    }
+
+    SECTION("value")
+    {
+      // one overload only: T& regardless of the optional's constness or value category
+      static_assert(std::is_same_v<decltype(std::declval<T &>().value()), int &>);
+      static_assert(std::is_same_v<decltype(std::declval<T const &>().value()), int &>);
+      static_assert(std::is_same_v<decltype(std::declval<T &&>().value()), int &>);
+      static_assert(std::is_same_v<decltype(std::declval<T const &&>().value()), int &>);
+      static_assert(not noexcept(std::declval<T const &>().value()));
+
+      int x = 5;
+      T const a(std::in_place, x);
+      CHECK(&a.value() == &x);
+      a.value() = 7;
+      CHECK(x == 7); // mutated through a const optional<int&>
+
+      SECTION("constexpr")
+      {
+        static_assert([] {
+          int x = 5;
+          T o(std::in_place, x);
+          o.value() = 7;
+          return x == 7 && &o.value() == &x;
+        }());
+        SUCCEED();
+      }
+
+      SECTION("throwing")
+      {
+        T b(std::nullopt);
+        REQUIRE_THROWS_AS(b.value(), std::bad_optional_access);
+        REQUIRE_THROWS_AS(std::as_const(b).value(), std::bad_optional_access);
+        REQUIRE_THROWS_AS(std::move(b).value(), std::bad_optional_access);
+      }
+    }
+
+    SECTION("value_or")
+    {
+      using O = optional<helper &>;
+
+      // returns remove_cv_t<T> by value, and there is only the one const-qualified overload
+      static_assert(std::is_same_v<decltype(std::declval<O &>().value_or(0)), helper>);
+      static_assert(std::is_same_v<decltype(std::declval<O const &>().value_or(0)), helper>);
+      static_assert(std::is_same_v<decltype(std::declval<optional<int const &> &>().value_or(0)), int>);
+      static_assert(not noexcept(std::declval<O const &>().value_or(std::declval<int>())));
+
+      SECTION("default template parameter")
+      {
+        static_assert(requires(optional<int &> &o) { o.value_or({}); });
+        SUCCEED();
+      }
+
+#ifndef _MSC_VER
+      SECTION("engaged")
+      {
+        // copies the referent through T&, NOT T const& like optional<T>'s const& overload:
+        // the optional's constness does not propagate to the referent...
+        helper x(13);
+        O const a(std::in_place, x);
+        CHECK(a.value_or(0) == helper(13 * from_lval));
+
+        // ...unless the referent type itself is const
+        optional<helper const &> const b(std::in_place, x);
+        CHECK(b.value_or(0) == helper(13 * from_lval_const));
+      }
+
+      SECTION("disengaged")
+      {
+        O const a(std::nullopt);
+        CHECK(a.value_or(11) == helper(11));
+
+        helper b(11);
+        CHECK(a.value_or(b) == helper(11 * from_lval));
+        CHECK(a.value_or(std::as_const(b)) == helper(11 * from_lval_const));
+        CHECK(a.value_or(std::move(std::as_const(b))) == helper(11 * from_rval_const));
+        CHECK(a.value_or(std::move(b)) == helper(11 * from_rval));
+      }
+#endif
+
+      SECTION("conversion")
+      {
+        optional<double &> a(std::nullopt);
+        static_assert(std::is_same_v<decltype(a.value_or(3)), double>);
+        CHECK(a.value_or(3) == 3.0);
+
+        double d = 0.5;
+        a.emplace(d);
+        CHECK(a.value_or(3) == 0.5);
+      }
+
+#ifndef _MSC_VER
+      SECTION("constexpr")
+      {
+        static_assert([] {
+          helper c{helper_list_t(), 7};
+          O o(std::in_place, c);
+          return o.value_or(0).v == 7 * from_lval;
+        }());
+        static_assert([] {
+          helper const c{helper_list_t(), 7};
+          O o(std::nullopt);
+          return o.value_or(c).v == 7 * from_lval_const //
+                 && o.value_or(helper(helper_list_t{7.0}, 3)).v == 7 * 3 * from_rval;
+        }());
+        SUCCEED();
+      }
+#endif
+    }
+  }
+
+  SECTION("monadic functions")
+  {
+    using T = optional<int &>;
+
+    SECTION("and_then")
+    {
+      int x = 5;
+      T const a(std::in_place, x);
+      T const e(std::nullopt);
+      // the callable always receives plain int&, even through a const optional<int&>
+      constexpr auto fn = [](int &v) -> optional<double> { return v * 2.0; };
+      static_assert(std::is_same_v<decltype(a.and_then(fn)), optional<double>>);
+      CHECK(a.and_then(fn).value() == 10.0);
+      CHECK(not e.and_then(fn).has_value());
+
+      // the referent itself is passed, not a copy
+      auto same = [&x](int &v) -> optional<bool> { return &v == &x; };
+      CHECK(a.and_then(same).value());
+
+      SECTION("constexpr")
+      {
+        static_assert([] {
+          int y = 5;
+          T const o(std::in_place, y);
+          T const d(std::nullopt);
+          auto f = [](int &v) -> optional<int> { return v + 1; };
+          return o.and_then(f).value() == 6 && not d.and_then(f).has_value();
+        }());
+        SUCCEED();
+      }
+    }
+
+    SECTION("or_else")
+    {
+      int x = 5;
+      int y = 9;
+      T const a(std::in_place, x);
+      T const e(std::nullopt);
+      auto fn = [&y]() -> T { return T(std::in_place, y); };
+      // engaged: rebinds to the same referent; disengaged: the callable's result
+      auto r1 = a.or_else(fn);
+      CHECK(&*r1 == &x);
+      auto r2 = e.or_else(fn);
+      CHECK(&*r2 == &y);
+      // [optional.ref.monadic] Constraints: only invocable F, no copy-constructible arm
+      static_assert(has_or_else<T const &, decltype(fn)>);
+      static_assert(not has_or_else<T const &, int>);
+
+      SECTION("constexpr")
+      {
+        static_assert([] {
+          int v = 1;
+          int w = 2;
+          T const o(std::in_place, v);
+          T const d(std::nullopt);
+          auto f = [&w]() -> T { return T(std::in_place, w); };
+          return &*o.or_else(f) == &v && &*d.or_else(f) == &w;
+        }());
+        SUCCEED();
+      }
+    }
+
+    SECTION("transform")
+    {
+      int x = 5;
+      T const a(std::in_place, x);
+      T const e(std::nullopt);
+
+      SECTION("to value")
+      {
+        constexpr auto fn = [](int &v) { return v * 3; };
+        static_assert(std::is_same_v<decltype(a.transform(fn)), optional<int>>);
+        CHECK(a.transform(fn).value() == 15);
+        CHECK(not e.transform(fn).has_value());
+
+        // direct-non-list-initialized from the invoke result: no witness factor
+        auto r = a.transform([](int &v) { return helper(v); });
+        CHECK(r.value().v == 5);
+      }
+
+      SECTION("to reference")
+      {
+        // a reference-returning callable yields optional<X&>, here still bound to x
+        constexpr auto fn = [](int &v) -> int & { return v; };
+        auto r = a.transform(fn);
+        static_assert(std::is_same_v<decltype(r), optional<int &>>);
+        CHECK(&*r == &x);
+        CHECK(not e.transform(fn).has_value());
+      }
+
+      SECTION("constexpr")
+      {
+        static_assert([] {
+          int y = 7;
+          T const o(std::in_place, y);
+          auto f = [](int &v) { return v * 2; };
+          return o.transform(f).value() == 14;
+        }());
+        SUCCEED();
+      }
+    }
+  }
+
+  SECTION("reset")
+  {
+    using T = optional<int &>;
+    static_assert(noexcept(std::declval<T &>().reset()));
+
+    int x = 5;
+    T a(std::in_place, x);
+    a.reset();
+    CHECK(not a.has_value());
+    CHECK(x == 5); // referent untouched
+    a.reset();     // no effect when already disengaged
+    CHECK(not a.has_value());
+
+    SECTION("constexpr")
+    {
+      static_assert([] {
+        int x = 5;
+        T o(std::in_place, x);
+        o.reset();
+        return not o.has_value() && x == 5;
+      }());
+      SUCCEED();
+    }
+  }
+
+  SECTION("relational operators")
+  {
+    using T = optional<int &>;
+
+    SECTION("with optional")
+    {
+      // compares the referents' values, never their addresses
+      int x = 5;
+      int y = 5;
+      int z = 7;
+      T const a(std::in_place, x);
+      T const b(std::in_place, y);
+      T const c(std::in_place, z);
+      T const e(std::nullopt);
+      CHECK((a == b));
+      CHECK(not(a != b));
+      CHECK((a != c));
+      CHECK((a < c));
+      CHECK((c > a));
+      CHECK((a <= b));
+      CHECK((a >= b));
+      CHECK((e < a));
+      CHECK((e == e));
+      static_assert(std::is_same_v<decltype(std::declval<T const &>() <=> std::declval<T const &>()), //
+                                   std::strong_ordering>);
+      CHECK((a <=> b) == std::strong_ordering::equal);
+      CHECK((e <=> a) == std::strong_ordering::less);
+
+      SECTION("with optional<U>")
+      {
+        // mixed with a value optional, in both argument orders
+        optional<int> const v(5);
+        optional<int> const w(9);
+        CHECK((a == v));
+        CHECK((v == a));
+        CHECK((a < w));
+        CHECK((w > a));
+        CHECK((a <=> v) == std::strong_ordering::equal);
+      }
+
+      SECTION("constexpr")
+      {
+        static_assert([] {
+          int x = 1;
+          int y = 2;
+          T const a(std::in_place, x);
+          T const b(std::in_place, y);
+          T const e(std::nullopt);
+          return a != b && a < b && e < a && (a <=> b) == std::strong_ordering::less;
+        }());
+        SUCCEED();
+      }
+    }
+
+    SECTION("with nullopt")
+    {
+      static_assert(noexcept(std::declval<T const &>() == std::nullopt));
+      static_assert(noexcept(std::declval<T const &>() <=> std::nullopt));
+      int x = 5;
+      T const a(std::in_place, x);
+      T const e(std::nullopt);
+      CHECK((e == std::nullopt));
+      CHECK((a != std::nullopt));
+      CHECK((std::nullopt < a));
+      CHECK((a <=> std::nullopt) == std::strong_ordering::greater);
+    }
+
+    SECTION("with value")
+    {
+      int x = 5;
+      T const a(std::in_place, x);
+      T const e(std::nullopt);
+      CHECK((a == 5));
+      CHECK((5 == a));
+      CHECK((a != 7));
+      CHECK((a < 9));
+      CHECK((9 > a));
+      CHECK((e < 5)); // disengaged orders before any value
+      CHECK(not(5 < e));
+      CHECK((a <=> 5) == std::strong_ordering::equal);
+      CHECK((e <=> 5) == std::strong_ordering::less);
+    }
+  }
+}
+#endif
+
+TEST_CASE("make_optional", "[optional][polyfill][make_optional]")
+{
+#ifndef PFN_TEST_VALIDATION
+  constexpr bool extension = true;
+#else
+  constexpr bool extension = false;
+#endif
+
+  SECTION("deduced")
+  {
+    // decay-copies its argument into an optional<decay_t<T>>
+    static_assert(std::is_same_v<decltype(make_optional(5)), optional<int>>);
+    static_assert(std::is_same_v<decltype(make_optional("abc")), optional<char const *>>);
+    static_assert(not extension || noexcept(make_optional(5)));
+
+    auto const o = make_optional(42);
+    static_assert(std::is_same_v<decltype(o), optional<int> const>);
+    CHECK((o == 42));
+
+    helper x(13);
+    static_assert(std::is_same_v<decltype(make_optional(x)), optional<helper>>); // decayed, no reference
+    CHECK(make_optional(x)->v == 13 * from_lval);
+    CHECK(make_optional(std::move(x))->v == 13 * from_rval);
+
+    SECTION("constexpr")
+    {
+      static_assert(*make_optional(42) == 42);
+      static_assert(make_optional(1.5) == optional<double>(1.5));
+      SUCCEED();
+    }
+  }
+
+  SECTION("in_place")
+  {
+    // an explicit type template-argument always selects the in_place overloads: [optional.specalg]
+    // constrains the deducing overload away from any such call
+    static_assert(std::is_same_v<decltype(make_optional<helper>(3, 4)), optional<helper>>);
+    auto const o = make_optional<helper>(3, 4);
+    CHECK(o->v == 3 * 4);                    // direct construction: no copy/move witness factor
+    CHECK(make_optional<helper>(5)->v == 5); // even with a single argument
+
+    SECTION("initializer_list")
+    {
+      static_assert(std::is_same_v<decltype(make_optional<helper>({3.0}, 4)), optional<helper>>);
+      CHECK(make_optional<helper>({3.0}, 4)->v == 3 * 4);
+    }
+
+    SECTION("constexpr")
+    {
+      static_assert(*make_optional<int>(7) == 7);
+      static_assert(make_optional<helper>({3.0}, 4)->v == 12);
+      SUCCEED();
+    }
+  }
+
+#ifndef PFN_TEST_VALIDATION
+  SECTION("reference")
+  {
+    // make_optional<U&>(u) binds instead of decaying: the [optional.specalg] constraint on the
+    // deducing overload is what routes an explicit type template-argument to in_place
+    int i = 5;
+    static_assert(std::is_same_v<decltype(make_optional<int &>(i)), optional<int &>>);
+    auto const o = make_optional<int &>(i);
+    CHECK(&*o == &i);
+
+    static_assert(std::is_same_v<decltype(make_optional<int const &>(i)), optional<int const &>>);
+    auto const c = make_optional<int const &>(i);
+    CHECK(&*c == &i);
+
+    SECTION("constexpr")
+    {
+      static_assert([] {
+        int i = 5;
+        auto const o = make_optional<int &>(i);
+        return &*o == &i && *o == 5;
+      }());
+      SUCCEED();
+    }
+  }
+#endif
+}
+
+TEST_CASE("optional hash", "[optional][polyfill][hash]")
+{
+#ifndef PFN_TEST_VALIDATION
+  constexpr bool extension = true;
+#else
+  constexpr bool extension = false;
+#endif
+
+  SECTION("enabled")
+  {
+    using T = optional<int>;
+    static_assert(std::is_default_constructible_v<std::hash<T>>);
+    static_assert(std::is_invocable_r_v<std::size_t, std::hash<T> const &, T const &>);
+    static_assert(not extension || noexcept(std::hash<T>{}(std::declval<T const &>())));
+
+    // engaged: hashes to the same value as the underlying hash ([optional.hash])
+    T const a(42);
+    CHECK(std::hash<T>{}(a) == std::hash<int>{}(42));
+
+    SECTION("remove_const")
+    {
+      // enablement and value are both keyed on hash<remove_const_t<T>>
+      optional<int const> const b(std::in_place, 42);
+      static_assert(std::is_default_constructible_v<std::hash<optional<int const>>>);
+      CHECK(std::hash<optional<int const>>{}(b) == std::hash<int>{}(42));
+    }
+
+    SECTION("disengaged")
+    {
+      // an unspecified but consistent value
+      T const d1(std::nullopt);
+      T const d2(std::nullopt);
+      CHECK(std::hash<T>{}(d1) == std::hash<T>{}(d2));
+    }
+  }
+
+  SECTION("disabled")
+  {
+    struct no_hash {};
+    using T = optional<no_hash>;
+    // [unord.hash]: a disabled specialization is not a function object and not constructible
+    static_assert(not std::is_default_constructible_v<std::hash<T>>);
+    static_assert(not std::is_copy_constructible_v<std::hash<T>>);
+    static_assert(not std::is_move_constructible_v<std::hash<T>>);
+    static_assert(not std::is_copy_assignable_v<std::hash<T>>);
+    static_assert(not std::is_move_assignable_v<std::hash<T>>);
+    static_assert(not std::is_invocable_v<std::hash<T>, T const &>);
+    SUCCEED();
+  }
+
+#ifndef PFN_TEST_VALIDATION
+  SECTION("reference")
+  {
+    // keyed on hash<remove_const_t<T>> with T = int&, and no std::hash for a reference type is
+    // ever enabled -- so hash<optional<int&>> is disabled, even though hash<int> is enabled
+    using T = optional<int &>;
+    static_assert(not std::is_default_constructible_v<std::hash<T>>);
+    static_assert(not std::is_invocable_v<std::hash<T>, T const &>);
+    SUCCEED();
+  }
+#endif
+}
diff --git a/tests/pfn/optional_validation.cpp b/tests/pfn/optional_validation.cpp
new file mode 100644
index 00000000..ca25166a
--- /dev/null
+++ b/tests/pfn/optional_validation.cpp
@@ -0,0 +1,12 @@
+// Copyright (c) 2026 Bronek Kozicki
+//
+// Distributed under the ISC License. See accompanying file LICENSE.md
+// or copy at https://opensource.org/licenses/ISC
+
+#include <optional>
+using std::make_optional;
+using std::optional;
+
+#define PFN_TEST_VALIDATION
+#define PFN_TEST_NESTED
+#include "optional.cpp"