From fad0d51322e8d67083c5c9c18fed8d1196f3982f Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Mon, 9 Jun 2025 02:12:26 +0000
Subject: [PATCH] Update format

---
 .clang-format                   |    7 +
 .github/workflows/bvt-clang.yml |    5 +-
 include/proxy/proxy.h           |    2 +-
 include/proxy/proxy_fmt.h       |    2 +-
 include/proxy/v4/proxy.h        | 1834 ++++++++++++++++++-------------
 include/proxy/v4/proxy.ixx      |   50 +-
 include/proxy/v4/proxy_fmt.h    |   51 +-
 include/proxy/v4/proxy_macros.h |  354 +++---
 8 files changed, 1295 insertions(+), 1010 deletions(-)
 create mode 100644 .clang-format

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..5113c807
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,7 @@
+---
+BasedOnStyle: LLVM
+
+AllowShortIfStatementsOnASingleLine: WithoutElse
+BreakTemplateDeclarations: Yes
+IndentWrappedFunctionNames: true
+PointerAlignment: Left
diff --git a/.github/workflows/bvt-clang.yml b/.github/workflows/bvt-clang.yml
index 63b6026a..03643e9e 100644
--- a/.github/workflows/bvt-clang.yml
+++ b/.github/workflows/bvt-clang.yml
@@ -18,7 +18,7 @@ jobs:
         wget https://apt.llvm.org/llvm.sh
         chmod +x llvm.sh
         sudo ./llvm.sh 20
-        sudo apt install libc++-20-dev
+        sudo apt install libc++-20-dev clang-format-20
 
     - name: check compiler version
       run: |
@@ -27,6 +27,9 @@ jobs:
     - name: build and run test with clang 20
       run: |
         cmake -B build -GNinja -DCMAKE_C_COMPILER=clang-20 -DCMAKE_CXX_COMPILER=clang++-20 -DCMAKE_CXX_FLAGS="-stdlib=libc++" -DCMAKE_CXX_STANDARD=23 -DCMAKE_BUILD_TYPE=Release -DPROXY_BUILD_MODULES=TRUE
+        mapfile -t FILES < <(find include -type f \( -name '*.h' -o -name '*.ixx' -o -name '*.cpp' \))
+        echo "Running clang-format on ${#FILES[@]} files"
+        clang-format-20 --dry-run --Werror "${FILES[@]}"
         cmake --build build -j
         ctest --test-dir build -j
         mkdir build/drop
diff --git a/include/proxy/proxy.h b/include/proxy/proxy.h
index 665e2829..a216e342 100644
--- a/include/proxy/proxy.h
+++ b/include/proxy/proxy.h
@@ -6,4 +6,4 @@
 
 #include "v4/proxy.h" // IWYU pragma: export
 
-#endif  // _MSFT_PROXY_
+#endif // _MSFT_PROXY_
diff --git a/include/proxy/proxy_fmt.h b/include/proxy/proxy_fmt.h
index 0c9532ee..56435354 100644
--- a/include/proxy/proxy_fmt.h
+++ b/include/proxy/proxy_fmt.h
@@ -6,4 +6,4 @@
 
 #include "v4/proxy_fmt.h" // IWYU pragma: export
 
-#endif  // _MSFT_PROXY_FMT_
+#endif // _MSFT_PROXY_FMT_
diff --git a/include/proxy/v4/proxy.h b/include/proxy/v4/proxy.h
index 0badc9da..3925740c 100644
--- a/include/proxy/v4/proxy.h
+++ b/include/proxy/v4/proxy.h
@@ -6,11 +6,11 @@
 
 #include "proxy_macros.h"
 
+#include <bit>
 #include <cassert>
+#include <concepts>
 #include <cstddef>
 #include <cstdlib>
-#include <bit>
-#include <concepts>
 #include <exception>
 #include <initializer_list>
 #include <limits>
@@ -24,13 +24,13 @@
 #include <atomic>
 #if __has_include(<format>)
 #include <format>
-#endif  // __has_include(<format>)
-#endif  // __STDC_HOSTED__
+#endif // __has_include(<format>)
+#endif // __STDC_HOSTED__
 
 #if __cpp_rtti >= 199711L
 #include <optional>
 #include <typeinfo>
-#endif  // __cpp_rtti >= 199711L
+#endif // __cpp_rtti >= 199711L
 
 #if __has_cpp_attribute(msvc::no_unique_address)
 #define ___PRO_NO_UNIQUE_ADDRESS_ATTRIBUTE msvc::no_unique_address
@@ -40,20 +40,24 @@
 #error Proxy requires C++20 attribute no_unique_address.
 #endif
 
-// `___PRO4_THROW` is used inside `proxy_fmt.h`, 
+// `___PRO4_THROW` is used inside `proxy_fmt.h`,
 // hence it's not `#undef`-ed at the end.
 #if __cpp_exceptions >= 199711L
 #define ___PRO4_THROW(...) throw __VA_ARGS__
 #else
 #define ___PRO4_THROW(...) std::abort()
-#endif  // __cpp_exceptions >= 199711L
+#endif // __cpp_exceptions >= 199711L
 
 namespace pro::inline v4 {
 
 namespace details {
 
-struct applicable_traits { static constexpr bool applicable = true; };
-struct inapplicable_traits { static constexpr bool applicable = false; };
+struct applicable_traits {
+  static constexpr bool applicable = true;
+};
+struct inapplicable_traits {
+  static constexpr bool applicable = false;
+};
 
 template <template <class, class> class R, class O, class... Is>
 struct recursive_reduction : std::type_identity<O> {};
@@ -70,15 +74,19 @@ struct reduction_traits {
 };
 
 template <class Expr>
-consteval bool is_consteval(Expr)
-    { return requires { typename std::bool_constant<(Expr{}(), false)>; }; }
+consteval bool is_consteval(Expr) {
+  return requires { typename std::bool_constant<(Expr{}(), false)>; };
+}
 
 template <class T, std::size_t I>
 concept has_tuple_element = requires { typename std::tuple_element_t<I, T>; };
 template <class T>
 consteval bool is_tuple_like_well_formed() {
-  if constexpr (requires { { std::tuple_size<T>::value } ->
-      std::same_as<const std::size_t&>; }) {
+  if constexpr (requires {
+                  {
+                    std::tuple_size<T>::value
+                  } -> std::same_as<const std::size_t&>;
+                }) {
     if constexpr (is_consteval([] { return std::tuple_size<T>::value; })) {
       return []<std::size_t... I>(std::index_sequence<I...>) {
         return (has_tuple_element<T, I> && ...);
@@ -91,16 +99,17 @@ consteval bool is_tuple_like_well_formed() {
 template <template <class...> class T, class TL, class Is, class... Args>
 struct instantiated_traits;
 template <template <class...> class T, class TL, std::size_t... Is,
-    class... Args>
+          class... Args>
 struct instantiated_traits<T, TL, std::index_sequence<Is...>, Args...>
     : std::type_identity<T<Args..., std::tuple_element_t<Is, TL>...>> {};
 template <template <class...> class T, class TL, class... Args>
 using instantiated_t = typename instantiated_traits<
     T, TL, std::make_index_sequence<std::tuple_size_v<TL>>, Args...>::type;
 
-template <class F> struct basic_facade_traits;
+template <class F>
+struct basic_facade_traits;
 
-}  // namespace details
+} // namespace details
 
 enum class constraint_level { none, nontrivial, nothrow, trivial };
 
@@ -113,18 +122,23 @@ struct proxiable_ptr_constraints {
 };
 
 template <template <class> class O>
-struct facade_aware_overload_t { facade_aware_overload_t() = delete; };
+struct facade_aware_overload_t {
+  facade_aware_overload_t() = delete;
+};
 
 template <class F>
 concept facade = details::basic_facade_traits<F>::applicable;
 
-template <facade F> struct proxy_indirect_accessor;
-template <facade F> class ___PRO4_ENFORCE_EBO proxy;
+template <facade F>
+struct proxy_indirect_accessor;
+template <facade F>
+class ___PRO4_ENFORCE_EBO proxy;
 
 namespace details {
 
 enum class qualifier_type { lv, const_lv, rv, const_rv };
-template <class T, qualifier_type Q> struct add_qualifier_traits;
+template <class T, qualifier_type Q>
+struct add_qualifier_traits;
 template <class T>
 struct add_qualifier_traits<T, qualifier_type::lv> : std::type_identity<T&> {};
 template <class T>
@@ -143,39 +157,49 @@ using add_qualifier_ptr_t = std::remove_reference_t<add_qualifier_t<T, Q>>*;
 template <class T>
 consteval bool has_copyability(constraint_level level) {
   switch (level) {
-    case constraint_level::none: return true;
-    case constraint_level::nontrivial: return std::is_copy_constructible_v<T>;
-    case constraint_level::nothrow:
-      return std::is_nothrow_copy_constructible_v<T>;
-    case constraint_level::trivial:
-      return std::is_trivially_copy_constructible_v<T> &&
-          std::is_trivially_destructible_v<T>;
-    default: return false;
+  case constraint_level::none:
+    return true;
+  case constraint_level::nontrivial:
+    return std::is_copy_constructible_v<T>;
+  case constraint_level::nothrow:
+    return std::is_nothrow_copy_constructible_v<T>;
+  case constraint_level::trivial:
+    return std::is_trivially_copy_constructible_v<T> &&
+           std::is_trivially_destructible_v<T>;
+  default:
+    return false;
   }
 }
 template <class T>
 consteval bool has_relocatability(constraint_level level) {
   switch (level) {
-    case constraint_level::none: return true;
-    case constraint_level::nontrivial:
-      return std::is_move_constructible_v<T> && std::is_destructible_v<T>;
-    case constraint_level::nothrow:
-      return std::is_nothrow_move_constructible_v<T> &&
-          std::is_nothrow_destructible_v<T>;
-    case constraint_level::trivial:
-      return std::is_trivially_move_constructible_v<T> &&
-          std::is_trivially_destructible_v<T>;
-    default: return false;
+  case constraint_level::none:
+    return true;
+  case constraint_level::nontrivial:
+    return std::is_move_constructible_v<T> && std::is_destructible_v<T>;
+  case constraint_level::nothrow:
+    return std::is_nothrow_move_constructible_v<T> &&
+           std::is_nothrow_destructible_v<T>;
+  case constraint_level::trivial:
+    return std::is_trivially_move_constructible_v<T> &&
+           std::is_trivially_destructible_v<T>;
+  default:
+    return false;
   }
 }
 template <class T>
 consteval bool has_destructibility(constraint_level level) {
   switch (level) {
-    case constraint_level::none: return true;
-    case constraint_level::nontrivial: return std::is_destructible_v<T>;
-    case constraint_level::nothrow: return std::is_nothrow_destructible_v<T>;
-    case constraint_level::trivial: return std::is_trivially_destructible_v<T>;
-    default: return false;
+  case constraint_level::none:
+    return true;
+  case constraint_level::nontrivial:
+    return std::is_destructible_v<T>;
+  case constraint_level::nothrow:
+    return std::is_nothrow_destructible_v<T>;
+  case constraint_level::trivial:
+    return std::is_trivially_destructible_v<T>;
+  default:
+    return false;
   }
 }
 
@@ -199,7 +223,7 @@ struct proxy_helper {
 
 template <class F, class P>
 class proxy_resetting_guard {
- public:
+public:
   explicit proxy_resetting_guard(proxy<F>& p) noexcept : p_(p) {}
   proxy_resetting_guard(const proxy_resetting_guard&) = delete;
   ~proxy_resetting_guard() noexcept(false) {
@@ -212,7 +236,7 @@ class proxy_resetting_guard {
     }
   }
 
- private:
+private:
   proxy<F>& p_;
 };
 
@@ -225,16 +249,17 @@ template <bool IsDirect, class P, qualifier_type Q>
 using operand_t = typename operand_traits<IsDirect, P, Q>::type;
 
 template <class D, bool NE, class R, class... Args>
-concept invocable_dispatch = (NE && std::is_nothrow_invocable_r_v<
-    R, D, Args...>) || (!NE && std::is_invocable_r_v<R, D, Args...>);
+concept invocable_dispatch =
+    (NE && std::is_nothrow_invocable_r_v<R, D, Args...>) ||
+    (!NE && std::is_invocable_r_v<R, D, Args...>);
 template <bool IsDirect, class D, class P, qualifier_type Q, bool NE, class R,
-    class... Args>
+          class... Args>
 concept invocable_dispatch_ptr =
     (IsDirect || (requires { *std::declval<add_qualifier_t<P, Q>>(); } &&
-        (!NE || noexcept(*std::declval<add_qualifier_t<P, Q>>())))) &&
+                  (!NE || noexcept(*std::declval<add_qualifier_t<P, Q>>())))) &&
     invocable_dispatch<D, NE, R, operand_t<IsDirect, P, Q>, Args...> &&
     (Q != qualifier_type::rv || (NE && std::is_nothrow_destructible_v<P>) ||
-        (!NE && std::is_destructible_v<P>));
+     (!NE && std::is_destructible_v<P>));
 
 template <class D, class R, class... Args>
 R invoke_dispatch(Args&&... args) {
@@ -249,19 +274,21 @@ decltype(auto) get_operand(P&& ptr) {
   if constexpr (IsDirect) {
     return std::forward<P>(ptr);
   } else {
-    if constexpr (std::is_constructible_v<bool, P&>) { assert(ptr); }
+    if constexpr (std::is_constructible_v<bool, P&>) {
+      assert(ptr);
+    }
     return *std::forward<P>(ptr);
   }
 }
 template <class F, bool IsDirect, class D, class P, qualifier_type Q, class R,
-    class... Args>
-R conv_dispatcher(add_qualifier_t<proxy<F>, Q> self, Args... args)
-    noexcept(invocable_dispatch_ptr<IsDirect, D, P, Q, true, R, Args...>) {
+          class... Args>
+R conv_dispatcher(add_qualifier_t<proxy<F>, Q> self, Args... args) noexcept(
+    invocable_dispatch_ptr<IsDirect, D, P, Q, true, R, Args...>) {
   if constexpr (Q == qualifier_type::rv) {
     proxy_resetting_guard<F, P> guard{self};
     return invoke_dispatch<D, R>(
-        get_operand<IsDirect>(proxy_helper<F>::template get_ptr<P, Q>(
-            std::move(self))),
+        get_operand<IsDirect>(
+            proxy_helper<F>::template get_ptr<P, Q>(std::move(self))),
         std::forward<Args>(args)...);
   } else {
     return invoke_dispatch<D, R>(
@@ -271,13 +298,14 @@ R conv_dispatcher(add_qualifier_t<proxy<F>, Q> self, Args... args)
   }
 }
 
-template <class O> struct overload_traits : inapplicable_traits {};
+template <class O>
+struct overload_traits : inapplicable_traits {};
 template <qualifier_type Q, bool NE, class R, class... Args>
 struct overload_traits_impl : applicable_traits {
   using return_type = R;
   template <class F>
-  using dispatcher_type =
-      R (*)(add_qualifier_t<proxy<F>, Q>, Args...) noexcept(NE);
+  using dispatcher_type = R (*)(add_qualifier_t<proxy<F>, Q>,
+                                Args...) noexcept(NE);
 
   template <class F, bool IsDirect, class D, class P>
   static consteval bool is_applicable_ptr() {
@@ -326,35 +354,40 @@ template <class R, class... Args>
 struct overload_traits<R(Args...) const&>
     : overload_traits_impl<qualifier_type::const_lv, false, R, Args...> {};
 template <class R, class... Args>
-struct overload_traits<R(Args...) const& noexcept>
+struct overload_traits<R(Args...) const & noexcept>
     : overload_traits_impl<qualifier_type::const_lv, true, R, Args...> {};
 template <class R, class... Args>
 struct overload_traits<R(Args...) const&&>
     : overload_traits_impl<qualifier_type::const_rv, false, R, Args...> {};
 template <class R, class... Args>
-struct overload_traits<R(Args...) const&& noexcept>
+struct overload_traits<R(Args...) const && noexcept>
     : overload_traits_impl<qualifier_type::const_rv, true, R, Args...> {};
 
 template <class O>
-struct overload_substitution_traits
-    : inapplicable_traits { template <class> using type = O; };
+struct overload_substitution_traits : inapplicable_traits {
+  template <class>
+  using type = O;
+};
 template <template <class> class O>
 struct overload_substitution_traits<facade_aware_overload_t<O>>
-    : applicable_traits { template <class F> using type = O<F>; };
+    : applicable_traits {
+  template <class F>
+  using type = O<F>;
+};
 template <class O, class F>
 using substituted_overload_t =
     typename overload_substitution_traits<O>::template type<F>;
 template <class O>
 concept extended_overload = overload_traits<O>::applicable ||
-    overload_substitution_traits<O>::applicable;
+                            overload_substitution_traits<O>::applicable;
 template <class P, class F, bool IsDirect, class D, class O>
 consteval bool diagnose_proxiable_required_convention_not_implemented() {
   constexpr bool verdict =
       overload_traits<substituted_overload_t<O, F>>::applicable &&
-      overload_traits<substituted_overload_t<O, F>>
-          ::template is_applicable_ptr<F, IsDirect, D, P>();
+      overload_traits<substituted_overload_t<O, F>>::template is_applicable_ptr<
+          F, IsDirect, D, P>();
   static_assert(verdict,
-      "not proxiable due to a required convention not implemented");
+                "not proxiable due to a required convention not implemented");
   return verdict;
 }
 
@@ -363,8 +396,8 @@ struct invocation_meta {
   constexpr invocation_meta() noexcept : dispatcher(nullptr) {}
   template <class P>
   constexpr explicit invocation_meta(std::in_place_type_t<P>) noexcept
-      : dispatcher(overload_traits<O>
-            ::template get_dispatcher<F, IsDirect, D, P>()) {}
+      : dispatcher(
+            overload_traits<O>::template get_dispatcher<F, IsDirect, D, P>()) {}
 
   typename overload_traits<O>::template dispatcher_type<F> dispatcher;
 };
@@ -376,20 +409,25 @@ struct composite_meta_impl : Ms... {
   constexpr explicit composite_meta_impl(std::in_place_type_t<P>) noexcept
       : Ms(std::in_place_type<P>)... {}
 };
-template <class O, class I> struct meta_reduction : std::type_identity<O> {};
-template <class... Ms, class I> requires(!std::is_void_v<I>)
+template <class O, class I>
+struct meta_reduction : std::type_identity<O> {};
+template <class... Ms, class I>
+  requires(!std::is_void_v<I>)
 struct meta_reduction<composite_meta_impl<Ms...>, I>
     : std::type_identity<composite_meta_impl<Ms..., I>> {};
 template <class... Ms1, class... Ms2>
 struct meta_reduction<composite_meta_impl<Ms1...>, composite_meta_impl<Ms2...>>
     : std::type_identity<composite_meta_impl<Ms1..., Ms2...>> {};
 template <class... Ms>
-using composite_meta = recursive_reduction_t<reduction_traits<
-    meta_reduction>::template type, composite_meta_impl<>, Ms...>;
+using composite_meta =
+    recursive_reduction_t<reduction_traits<meta_reduction>::template type,
+                          composite_meta_impl<>, Ms...>;
 
 template <class T>
 consteval bool is_is_direct_well_formed() {
-  if constexpr (requires { { T::is_direct } -> std::same_as<const bool&>; }) {
+  if constexpr (requires {
+                  { T::is_direct } -> std::same_as<const bool&>;
+                }) {
     if constexpr (is_consteval([] { return T::is_direct; })) {
       return true;
     }
@@ -399,41 +437,45 @@ consteval bool is_is_direct_well_formed() {
 
 template <class C, class... Os>
 struct basic_conv_traits_impl : inapplicable_traits {};
-template <class C, extended_overload... Os> requires(sizeof...(Os) > 0u)
+template <class C, extended_overload... Os>
+  requires(sizeof...(Os) > 0u)
 struct basic_conv_traits_impl<C, Os...> : applicable_traits {};
-template <class C> struct basic_conv_traits : inapplicable_traits {};
 template <class C>
-    requires(
-        requires {
-          typename C::dispatch_type;
-          typename C::overload_types;
-        } &&
-        is_is_direct_well_formed<C>() &&
-        std::is_trivial_v<typename C::dispatch_type> &&
-        is_tuple_like_well_formed<typename C::overload_types>())
+struct basic_conv_traits : inapplicable_traits {};
+template <class C>
+  requires(requires {
+    typename C::dispatch_type;
+    typename C::overload_types;
+  } && is_is_direct_well_formed<C>() &&
+           std::is_trivial_v<typename C::dispatch_type> &&
+           is_tuple_like_well_formed<typename C::overload_types>())
 struct basic_conv_traits<C>
     : instantiated_t<basic_conv_traits_impl, typename C::overload_types, C> {};
 
 template <class C, class F, class... Os>
 struct conv_traits_impl : inapplicable_traits {};
 template <class C, class F, class... Os>
-    requires(overload_traits<substituted_overload_t<Os, F>>::applicable && ...)
+  requires(overload_traits<substituted_overload_t<Os, F>>::applicable && ...)
 struct conv_traits_impl<C, F, Os...> : applicable_traits {
-  using meta = composite_meta_impl<invocation_meta<F, C::is_direct,
-      typename C::dispatch_type, substituted_overload_t<Os, F>>...>;
+  using meta = composite_meta_impl<
+      invocation_meta<F, C::is_direct, typename C::dispatch_type,
+                      substituted_overload_t<Os, F>>...>;
 
   template <class P>
   static consteval bool diagnose_proxiable() {
     bool verdict = true;
     ((verdict &= diagnose_proxiable_required_convention_not_implemented<
-        P, F, C::is_direct, typename C::dispatch_type, Os>()), ...);
+          P, F, C::is_direct, typename C::dispatch_type, Os>()),
+     ...);
     return verdict;
   }
 
   template <class P>
-  static constexpr bool applicable_ptr = (overload_traits<
-      substituted_overload_t<Os, F>>::template is_applicable_ptr<
-      F, C::is_direct, typename C::dispatch_type, P>() && ...);
+  static constexpr bool applicable_ptr =
+      (overload_traits<substituted_overload_t<Os, F>>::
+           template is_applicable_ptr<F, C::is_direct,
+                                      typename C::dispatch_type, P>() &&
+       ...);
 };
 template <class C, class F>
 struct conv_traits
@@ -441,20 +483,25 @@ struct conv_traits
 
 template <bool IsDirect, class R>
 struct refl_meta {
-  template <class P> requires(IsDirect)
+  template <class P>
+    requires(IsDirect)
   constexpr explicit refl_meta(std::in_place_type_t<P>)
       : reflector(std::in_place_type<P>) {}
-  template <class P> requires(!IsDirect)
-  constexpr explicit refl_meta(std::in_place_type_t<P>) : reflector(
-      std::in_place_type<typename std::pointer_traits<P>::element_type>) {}
+  template <class P>
+    requires(!IsDirect)
+  constexpr explicit refl_meta(std::in_place_type_t<P>)
+      : reflector(
+            std::in_place_type<typename std::pointer_traits<P>::element_type>) {
+  }
 
   R reflector;
 };
 
-template <class R> struct basic_refl_traits : inapplicable_traits {};
 template <class R>
-    requires(requires { typename R::reflector_type; } &&
-        is_is_direct_well_formed<R>())
+struct basic_refl_traits : inapplicable_traits {};
+template <class R>
+  requires(requires { typename R::reflector_type; } &&
+           is_is_direct_well_formed<R>())
 struct basic_refl_traits<R> : applicable_traits {};
 
 template <class T, bool IsDirect, class R>
@@ -475,7 +522,7 @@ template <class P, class F, bool IsDirect, class R>
 consteval bool diagnose_proxiable_required_reflection_not_implemented() {
   constexpr bool verdict = is_reflector_well_formed<P, IsDirect, R>();
   static_assert(verdict,
-      "not proxiable due to a required reflection not implemented");
+                "not proxiable due to a required reflection not implemented");
   return verdict;
 }
 
@@ -496,15 +543,20 @@ struct refl_traits {
 
 struct copy_dispatch {
   template <class T, class F>
-  ___PRO4_STATIC_CALL(void, T&& self, proxy<F>& rhs)
-      noexcept(std::is_nothrow_constructible_v<std::decay_t<T>, T>)
-      requires(std::is_constructible_v<std::decay_t<T>, T>)
-      { std::construct_at(std::addressof(rhs), std::forward<T>(self)); }
+  ___PRO4_STATIC_CALL(void, T&& self, proxy<F>& rhs) noexcept(
+      std::is_nothrow_constructible_v<std::decay_t<T>, T>)
+    requires(std::is_constructible_v<std::decay_t<T>, T>)
+  {
+    std::construct_at(std::addressof(rhs), std::forward<T>(self));
+  }
 };
 struct destroy_dispatch {
   template <class T>
   ___PRO4_STATIC_CALL(void, T& self) noexcept(std::is_nothrow_destructible_v<T>)
-      requires(std::is_destructible_v<T>) { std::destroy_at(&self); }
+    requires(std::is_destructible_v<T>)
+  {
+    std::destroy_at(&self);
+  }
 };
 template <class F, class D, class ONE, class OE, constraint_level C>
 struct lifetime_meta_traits : std::type_identity<void> {};
@@ -519,20 +571,22 @@ using lifetime_meta_t = typename lifetime_meta_traits<F, D, ONE, OE, C>::type;
 
 template <class... As>
 class ___PRO4_ENFORCE_EBO composite_accessor_impl : public As... {
-  template <facade> friend class pro::v4::proxy;
-  template <facade> friend struct pro::v4::proxy_indirect_accessor;
+  template <facade>
+  friend class pro::v4::proxy;
+  template <facade>
+  friend struct pro::v4::proxy_indirect_accessor;
 
   composite_accessor_impl() noexcept = default;
   composite_accessor_impl(const composite_accessor_impl&) noexcept = default;
-  composite_accessor_impl& operator=(const composite_accessor_impl&) noexcept
-      = default;
+  composite_accessor_impl&
+      operator=(const composite_accessor_impl&) noexcept = default;
 };
 
 template <class T>
 struct accessor_traits_impl : std::type_identity<void> {};
 template <class T>
-    requires(std::is_nothrow_default_constructible_v<T> &&
-        std::is_trivially_copyable_v<T> && !std::is_final_v<T>)
+  requires(std::is_nothrow_default_constructible_v<T> &&
+           std::is_trivially_copyable_v<T> && !std::is_final_v<T>)
 struct accessor_traits_impl<T> : std::type_identity<T> {};
 template <class SFINAE, class T, class F>
 struct accessor_traits : std::type_identity<void> {};
@@ -545,30 +599,33 @@ using accessor_t = typename accessor_traits<void, T, F>::type;
 template <class IsDirect, class F, class O, class I>
 struct composite_accessor_reduction : std::type_identity<O> {};
 template <class IsDirect, class F, class... As, class I>
-    requires(IsDirect::value == I::is_direct &&
-        !std::is_void_v<accessor_t<I, F>>)
-struct composite_accessor_reduction<
-    IsDirect, F, composite_accessor_impl<As...>, I>
+  requires(IsDirect::value == I::is_direct && !std::is_void_v<accessor_t<I, F>>)
+struct composite_accessor_reduction<IsDirect, F, composite_accessor_impl<As...>,
+                                    I>
     : std::type_identity<composite_accessor_impl<As..., accessor_t<I, F>>> {};
 template <bool IsDirect, class F, class... Ts>
-using composite_accessor = recursive_reduction_t<reduction_traits<
-    composite_accessor_reduction, std::bool_constant<IsDirect>, F>
-        ::template type, composite_accessor_impl<>, Ts...>;
+using composite_accessor = recursive_reduction_t<
+    reduction_traits<composite_accessor_reduction, std::bool_constant<IsDirect>,
+                     F>::template type,
+    composite_accessor_impl<>, Ts...>;
 
-template <class A1, class A2> struct composite_accessor_merge_traits;
+template <class A1, class A2>
+struct composite_accessor_merge_traits;
 template <class... A1, class... A2>
-struct composite_accessor_merge_traits<
-    composite_accessor_impl<A1...>, composite_accessor_impl<A2...>>
+struct composite_accessor_merge_traits<composite_accessor_impl<A1...>,
+                                       composite_accessor_impl<A2...>>
     : std::type_identity<composite_accessor_impl<A1..., A2...>> {};
 template <class A1, class A2>
 using merged_composite_accessor =
     typename composite_accessor_merge_traits<A1, A2>::type;
 
-template <class P> struct ptr_traits : inapplicable_traits {};
 template <class P>
-    requires(requires { typename std::pointer_traits<P>::element_type; })
+struct ptr_traits : inapplicable_traits {};
+template <class P>
+  requires(requires { typename std::pointer_traits<P>::element_type; })
 struct ptr_traits<P> : applicable_traits {};
-template <class F> struct ptr_traits<proxy<F>> : inapplicable_traits {};
+template <class F>
+struct ptr_traits<proxy<F>> : inapplicable_traits {};
 
 template <class P, class F, std::size_t ActualSize, std::size_t MaxSize>
 consteval bool diagnose_proxiable_size_too_large() {
@@ -604,41 +661,46 @@ consteval bool diagnose_proxiable_insufficient_destructibility() {
 template <class F>
 consteval bool is_facade_constraints_well_formed() {
   if constexpr (requires {
-      { F::constraints } -> std::same_as<const proxiable_ptr_constraints&>; }) {
+                  {
+                    F::constraints
+                  } -> std::same_as<const proxiable_ptr_constraints&>;
+                }) {
     if constexpr (is_consteval([] { return F::constraints; })) {
       return std::has_single_bit(F::constraints.max_align) &&
-          F::constraints.max_size % F::constraints.max_align == 0u;
+             F::constraints.max_size % F::constraints.max_align == 0u;
     }
   }
   return false;
 }
 template <class... Cs>
 struct basic_facade_conv_traits_impl : inapplicable_traits {};
-template <class... Cs> requires(basic_conv_traits<Cs>::applicable && ...)
+template <class... Cs>
+  requires(basic_conv_traits<Cs>::applicable && ...)
 struct basic_facade_conv_traits_impl<Cs...> : applicable_traits {};
 template <class... Rs>
 struct basic_facade_refl_traits_impl : inapplicable_traits {};
-template <class... Rs> requires(basic_refl_traits<Rs>::applicable && ...)
+template <class... Rs>
+  requires(basic_refl_traits<Rs>::applicable && ...)
 struct basic_facade_refl_traits_impl<Rs...> : applicable_traits {};
-template <class F> struct basic_facade_traits : inapplicable_traits {};
 template <class F>
-    requires(
-        requires {
-          typename F::convention_types;
-          typename F::reflection_types;
-        } &&
-        is_facade_constraints_well_formed<F>() &&
-        is_tuple_like_well_formed<typename F::convention_types>() &&
-        instantiated_t<basic_facade_conv_traits_impl,
-            typename F::convention_types>::applicable &&
-        is_tuple_like_well_formed<typename F::reflection_types>() &&
-        instantiated_t<basic_facade_refl_traits_impl,
-            typename F::reflection_types>::applicable)
+struct basic_facade_traits : inapplicable_traits {};
+template <class F>
+  requires(requires {
+    typename F::convention_types;
+    typename F::reflection_types;
+  } && is_facade_constraints_well_formed<F>() &&
+           is_tuple_like_well_formed<typename F::convention_types>() &&
+           instantiated_t<basic_facade_conv_traits_impl,
+                          typename F::convention_types>::applicable &&
+           is_tuple_like_well_formed<typename F::reflection_types>() &&
+           instantiated_t<basic_facade_refl_traits_impl,
+                          typename F::reflection_types>::applicable)
 struct basic_facade_traits<F> : applicable_traits {};
 
 template <class F, class... Cs>
 struct facade_conv_traits_impl : inapplicable_traits {};
-template <class F, class... Cs> requires(conv_traits<Cs, F>::applicable && ...)
+template <class F, class... Cs>
+  requires(conv_traits<Cs, F>::applicable && ...)
 struct facade_conv_traits_impl<F, Cs...> : applicable_traits {
   using conv_meta = composite_meta<typename conv_traits<Cs, F>::meta...>;
   using conv_indirect_accessor = composite_accessor<false, F, Cs...>;
@@ -655,8 +717,8 @@ struct facade_conv_traits_impl<F, Cs...> : applicable_traits {
   static constexpr bool conv_applicable_ptr =
       (conv_traits<Cs, F>::template applicable_ptr<P> && ...);
   template <bool IsDirect, class D, class O>
-  static constexpr bool is_invocable = std::is_base_of_v<
-      invocation_meta<F, IsDirect, D, O>, conv_meta>;
+  static constexpr bool is_invocable =
+      std::is_base_of_v<invocation_meta<F, IsDirect, D, O>, conv_meta>;
 };
 template <class F, class... Rs>
 struct facade_refl_traits_impl {
@@ -675,34 +737,36 @@ struct facade_refl_traits_impl {
   static constexpr bool refl_applicable_ptr =
       (refl_traits<Rs>::template applicable_ptr<P> && ...);
 };
-template <class F> struct facade_traits : inapplicable_traits {};
-template <class F> requires(instantiated_t<
-    facade_conv_traits_impl, typename F::convention_types, F>::applicable)
+template <class F>
+struct facade_traits : inapplicable_traits {};
+template <class F>
+  requires(instantiated_t<facade_conv_traits_impl, typename F::convention_types,
+                          F>::applicable)
 struct facade_traits<F>
     : instantiated_t<facade_conv_traits_impl, typename F::convention_types, F>,
       instantiated_t<facade_refl_traits_impl, typename F::reflection_types, F> {
   using meta = composite_meta<
       lifetime_meta_t<F, copy_dispatch, void(proxy<F>&) const noexcept,
-          void(proxy<F>&) const, F::constraints.copyability>,
+                      void(proxy<F>&) const, F::constraints.copyability>,
       lifetime_meta_t<F, copy_dispatch, void(proxy<F>&) && noexcept,
-          void(proxy<F>&) &&, F::constraints.relocatability>,
+                      void(proxy<F>&) &&, F::constraints.relocatability>,
       lifetime_meta_t<F, destroy_dispatch, void() noexcept, void(),
-          F::constraints.destructibility>, typename facade_traits::conv_meta,
-      typename facade_traits::refl_meta>;
-  using indirect_accessor = merged_composite_accessor<
-      typename facade_traits::conv_indirect_accessor,
-      typename facade_traits::refl_indirect_accessor>;
-  using direct_accessor = merged_composite_accessor<
-      typename facade_traits::conv_direct_accessor,
-      typename facade_traits::refl_direct_accessor>;
+                      F::constraints.destructibility>,
+      typename facade_traits::conv_meta, typename facade_traits::refl_meta>;
+  using indirect_accessor =
+      merged_composite_accessor<typename facade_traits::conv_indirect_accessor,
+                                typename facade_traits::refl_indirect_accessor>;
+  using direct_accessor =
+      merged_composite_accessor<typename facade_traits::conv_direct_accessor,
+                                typename facade_traits::refl_direct_accessor>;
 
   template <class P>
   static consteval void diagnose_proxiable() {
     bool verdict = true;
-    verdict &= diagnose_proxiable_size_too_large<
-        P, F, sizeof(P), F::constraints.max_size>();
-    verdict &= diagnose_proxiable_align_too_large<
-        P, F, alignof(P), F::constraints.max_align>();
+    verdict &= diagnose_proxiable_size_too_large<P, F, sizeof(P),
+                                                 F::constraints.max_size>();
+    verdict &= diagnose_proxiable_align_too_large<P, F, alignof(P),
+                                                  F::constraints.max_align>();
     verdict &= diagnose_proxiable_insufficient_copyability<
         P, F, F::constraints.copyability>();
     verdict &= diagnose_proxiable_insufficient_relocatability<
@@ -711,11 +775,14 @@ struct facade_traits<F>
         P, F, F::constraints.destructibility>();
     verdict &= facade_traits::template diagnose_proxiable_conv<P>();
     verdict &= facade_traits::template diagnose_proxiable_refl<P>();
-    if (!verdict) { std::abort(); }  // Propagate the error to the caller side
+    if (!verdict) {
+      std::abort();
+    } // Propagate the error to the caller side
   }
 
   template <class P>
-  static constexpr bool applicable_ptr = sizeof(P) <= F::constraints.max_size &&
+  static constexpr bool applicable_ptr =
+      sizeof(P) <= F::constraints.max_size &&
       alignof(P) <= F::constraints.max_align &&
       has_copyability<P>(F::constraints.copyability) &&
       has_relocatability<P>(F::constraints.relocatability) &&
@@ -724,7 +791,7 @@ struct facade_traits<F>
       facade_traits::template refl_applicable_ptr<P>;
 };
 
-using ptr_prototype = void*[2];
+using ptr_prototype = void* [2];
 
 template <class M>
 struct meta_ptr_indirect_impl {
@@ -736,9 +803,10 @@ struct meta_ptr_indirect_impl {
   void reset() noexcept { ptr_ = nullptr; }
   const M* operator->() const noexcept { return ptr_; }
 
- private:
+private:
   const M* ptr_;
-  template <class P> static constexpr M storage{std::in_place_type<P>};
+  template <class P>
+  static constexpr M storage{std::in_place_type<P>};
 };
 template <class M, class DM>
 struct meta_ptr_direct_impl : private M {
@@ -752,22 +820,23 @@ struct meta_ptr_traits_impl : std::type_identity<meta_ptr_indirect_impl<M>> {};
 template <class F, bool IsDirect, class D, class O, class... Ms>
 struct meta_ptr_traits_impl<
     composite_meta_impl<invocation_meta<F, IsDirect, D, O>, Ms...>>
-    : std::type_identity<meta_ptr_direct_impl<composite_meta_impl<
-          invocation_meta<F, IsDirect, D, O>, Ms...>,
+    : std::type_identity<meta_ptr_direct_impl<
+          composite_meta_impl<invocation_meta<F, IsDirect, D, O>, Ms...>,
           invocation_meta<F, IsDirect, D, O>>> {};
 template <class M>
 struct meta_ptr_traits : std::type_identity<meta_ptr_indirect_impl<M>> {};
 template <class M>
-    requires(sizeof(M) <= sizeof(ptr_prototype) &&
-        alignof(M) <= alignof(ptr_prototype) &&
-        std::is_nothrow_default_constructible_v<M> &&
-        std::is_trivially_copyable_v<M>)
+  requires(sizeof(M) <= sizeof(ptr_prototype) &&
+           alignof(M) <= alignof(ptr_prototype) &&
+           std::is_nothrow_default_constructible_v<M> &&
+           std::is_trivially_copyable_v<M>)
 struct meta_ptr_traits<M> : meta_ptr_traits_impl<M> {};
-template <class M> using meta_ptr = typename meta_ptr_traits<M>::type;
+template <class M>
+using meta_ptr = typename meta_ptr_traits<M>::type;
 
 template <class T>
 class inplace_ptr {
- public:
+public:
   template <class... Args>
   explicit inplace_ptr(std::in_place_t, Args&&... args)
       : value_(std::forward<Args>(args)...) {}
@@ -784,15 +853,16 @@ class inplace_ptr {
   T&& operator*() && noexcept { return std::move(value_); }
   const T&& operator*() const&& noexcept { return std::move(value_); }
 
- private:
+private:
   [[___PRO_NO_UNIQUE_ADDRESS_ATTRIBUTE]]
   T value_;
 };
 
 template <class F, bool IsDirect, class D, class O, class P, class... Args>
 decltype(auto) invoke_impl(P&& p, Args&&... args) {
-  auto dispatcher = proxy_helper<F>::get_meta(p)
-      .template invocation_meta<F, IsDirect, D, O>::dispatcher;
+  auto dispatcher =
+      proxy_helper<F>::get_meta(p)
+          .template invocation_meta<F, IsDirect, D, O>::dispatcher;
   return dispatcher(std::forward<P>(p), std::forward<Args>(args)...);
 }
 template <class F, class A, qualifier_type Q>
@@ -807,53 +877,57 @@ add_qualifier_t<proxy<F>, Q> access_impl(add_qualifier_t<A, Q> a) {
   }
 }
 
-}  // namespace details
+} // namespace details
 
 template <class P, class F>
 concept proxiable = facade<F> && details::facade_traits<F>::applicable &&
-    details::facade_traits<F>::template applicable_ptr<P>;
+                    details::facade_traits<F>::template applicable_ptr<P>;
 
 template <facade F>
-struct proxy_indirect_accessor : details::facade_traits<F>::indirect_accessor
-    { friend class details::inplace_ptr<proxy_indirect_accessor>; };
+struct proxy_indirect_accessor : details::facade_traits<F>::indirect_accessor {
+  friend class details::inplace_ptr<proxy_indirect_accessor>;
+};
 
 template <bool IsDirect, class D, class O, facade F, class... Args>
-auto proxy_invoke(proxy<F>& p, Args&&... args)
-    -> typename details::overload_traits<O>::return_type {
-  return details::invoke_impl<F, IsDirect, D, O>(
-      p, std::forward<Args>(args)...);
+auto proxy_invoke(proxy<F>& p, Args&&... args) ->
+    typename details::overload_traits<O>::return_type {
+  return details::invoke_impl<F, IsDirect, D, O>(p,
+                                                 std::forward<Args>(args)...);
 }
 template <bool IsDirect, class D, class O, facade F, class... Args>
-auto proxy_invoke(const proxy<F>& p, Args&&... args)
-    -> typename details::overload_traits<O>::return_type {
-  return details::invoke_impl<F, IsDirect, D, O>(
-      p, std::forward<Args>(args)...);
+auto proxy_invoke(const proxy<F>& p, Args&&... args) ->
+    typename details::overload_traits<O>::return_type {
+  return details::invoke_impl<F, IsDirect, D, O>(p,
+                                                 std::forward<Args>(args)...);
 }
 template <bool IsDirect, class D, class O, facade F, class... Args>
-auto proxy_invoke(proxy<F>&& p, Args&&... args)
-    -> typename details::overload_traits<O>::return_type {
-  return details::invoke_impl<F, IsDirect, D, O>(
-      std::move(p), std::forward<Args>(args)...);
+auto proxy_invoke(proxy<F>&& p, Args&&... args) ->
+    typename details::overload_traits<O>::return_type {
+  return details::invoke_impl<F, IsDirect, D, O>(std::move(p),
+                                                 std::forward<Args>(args)...);
 }
 template <bool IsDirect, class D, class O, facade F, class... Args>
-auto proxy_invoke(const proxy<F>&& p, Args&&... args)
-    -> typename details::overload_traits<O>::return_type {
-  return details::invoke_impl<F, IsDirect, D, O>(
-      std::move(p), std::forward<Args>(args)...);
+auto proxy_invoke(const proxy<F>&& p, Args&&... args) ->
+    typename details::overload_traits<O>::return_type {
+  return details::invoke_impl<F, IsDirect, D, O>(std::move(p),
+                                                 std::forward<Args>(args)...);
 }
 
 template <bool IsDirect, class R, facade F>
 const R& proxy_reflect(const proxy<F>& p) noexcept {
   return static_cast<const details::refl_meta<IsDirect, R>&>(
-      details::proxy_helper<F>::get_meta(p)).reflector;
+             details::proxy_helper<F>::get_meta(p))
+      .reflector;
 }
 
 template <facade F, class A>
-proxy<F>& access_proxy(A& a) noexcept
-    { return details::access_impl<F, A, details::qualifier_type::lv>(a); }
+proxy<F>& access_proxy(A& a) noexcept {
+  return details::access_impl<F, A, details::qualifier_type::lv>(a);
+}
 template <facade F, class A>
-const proxy<F>& access_proxy(const A& a) noexcept
-    { return details::access_impl<F, A, details::qualifier_type::const_lv>(a); }
+const proxy<F>& access_proxy(const A& a) noexcept {
+  return details::access_impl<F, A, details::qualifier_type::const_lv>(a);
+}
 template <facade F, class A>
 proxy<F>&& access_proxy(A&& a) noexcept {
   return details::access_impl<F, A, details::qualifier_type::rv>(std::move(a));
@@ -866,77 +940,95 @@ const proxy<F>&& access_proxy(const A&& a) noexcept {
 
 template <facade F>
 class proxy : public details::facade_traits<F>::direct_accessor,
-    public details::inplace_ptr<proxy_indirect_accessor<F>> {
+              public details::inplace_ptr<proxy_indirect_accessor<F>> {
   friend struct details::proxy_helper<F>;
   using _Traits = details::facade_traits<F>;
   static_assert(_Traits::applicable);
 
- public:
+public:
   using facade_type = F;
 
   proxy() noexcept { ___PRO4_DEBUG(std::ignore = &_symbol_guard;) }
   proxy(std::nullptr_t) noexcept : proxy() {}
-  proxy(const proxy&) noexcept requires(F::constraints.copyability ==
-      constraint_level::trivial) = default;
-  proxy(const proxy& rhs)
-      noexcept(F::constraints.copyability == constraint_level::nothrow)
-      requires(F::constraints.copyability == constraint_level::nontrivial ||
-          F::constraints.copyability == constraint_level::nothrow)
-      : details::inplace_ptr<proxy_indirect_accessor<F>>() {  // Make GCC happy
+  proxy(const proxy&) noexcept
+    requires(F::constraints.copyability == constraint_level::trivial)
+  = default;
+  proxy(const proxy& rhs) noexcept(F::constraints.copyability ==
+                                   constraint_level::nothrow)
+    requires(F::constraints.copyability == constraint_level::nontrivial ||
+             F::constraints.copyability == constraint_level::nothrow)
+      : details::inplace_ptr<proxy_indirect_accessor<F>>() { // Make GCC happy
     if (rhs.meta_.has_value()) {
-      proxy_invoke<true, details::copy_dispatch, void(proxy&) const noexcept(
-          F::constraints.copyability == constraint_level::nothrow)>(rhs, *this);
+      proxy_invoke<true, details::copy_dispatch,
+                   void(proxy&) const noexcept(F::constraints.copyability ==
+                                               constraint_level::nothrow)>(
+          rhs, *this);
     }
   }
-  proxy(proxy&& rhs)
-      noexcept(F::constraints.relocatability == constraint_level::nothrow)
-      requires(F::constraints.relocatability >= constraint_level::nontrivial &&
-          F::constraints.copyability != constraint_level::trivial) {
+  proxy(proxy&& rhs) noexcept(F::constraints.relocatability ==
+                              constraint_level::nothrow)
+    requires(F::constraints.relocatability >= constraint_level::nontrivial &&
+             F::constraints.copyability != constraint_level::trivial)
+  {
     if (rhs.meta_.has_value()) {
       if constexpr (F::constraints.relocatability ==
-          constraint_level::trivial) {
+                    constraint_level::trivial) {
         std::ranges::uninitialized_copy(rhs.ptr_, ptr_);
         meta_ = rhs.meta_;
         rhs.meta_.reset();
       } else {
-        proxy_invoke<true, details::copy_dispatch, void(proxy&) && noexcept(
-            F::constraints.relocatability == constraint_level::nothrow)>(
+        proxy_invoke<true, details::copy_dispatch,
+                     void(proxy&) && noexcept(F::constraints.relocatability ==
+                                              constraint_level::nothrow)>(
             std::move(rhs), *this);
       }
     }
   }
   template <class P>
-  constexpr proxy(P&& ptr)
-      noexcept(std::is_nothrow_constructible_v<std::decay_t<P>, P>)
-      requires(details::ptr_traits<std::decay_t<P>>::applicable &&
-          std::is_constructible_v<std::decay_t<P>, P>)
-      : proxy() { initialize<std::decay_t<P>>(std::forward<P>(ptr)); }
+  constexpr proxy(P&& ptr) noexcept(
+      std::is_nothrow_constructible_v<std::decay_t<P>, P>)
+    requires(details::ptr_traits<std::decay_t<P>>::applicable &&
+             std::is_constructible_v<std::decay_t<P>, P>)
+      : proxy() {
+    initialize<std::decay_t<P>>(std::forward<P>(ptr));
+  }
   template <class P, class... Args>
-  constexpr explicit proxy(std::in_place_type_t<P>, Args&&... args)
-      noexcept(std::is_nothrow_constructible_v<P, Args...>)
-      requires(details::ptr_traits<P>::applicable &&
-          std::is_constructible_v<P, Args...>)
-      : proxy() { initialize<P>(std::forward<Args>(args)...); }
+  constexpr explicit proxy(std::in_place_type_t<P>, Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<P, Args...>)
+    requires(details::ptr_traits<P>::applicable &&
+             std::is_constructible_v<P, Args...>)
+      : proxy() {
+    initialize<P>(std::forward<Args>(args)...);
+  }
   template <class P, class U, class... Args>
-  constexpr explicit proxy(std::in_place_type_t<P>, std::initializer_list<U> il,
-          Args&&... args)
-      noexcept(std::is_nothrow_constructible_v<
-          P, std::initializer_list<U>&, Args...>)
-      requires(details::ptr_traits<P>::applicable &&
-          std::is_constructible_v<P, std::initializer_list<U>&, Args...>)
-      : proxy() { initialize<P>(il, std::forward<Args>(args)...); }
-  proxy& operator=(std::nullptr_t)
-      noexcept(F::constraints.destructibility >= constraint_level::nothrow)
-      requires(F::constraints.destructibility >= constraint_level::nontrivial)
-      { reset(); return *this; }
-  proxy& operator=(const proxy&) noexcept requires(F::constraints.copyability ==
-      constraint_level::trivial) = default;
-  proxy& operator=(const proxy& rhs)
-      noexcept(F::constraints.copyability >= constraint_level::nothrow &&
-          F::constraints.destructibility >= constraint_level::nothrow)
-      requires((F::constraints.copyability == constraint_level::nontrivial ||
-          F::constraints.copyability == constraint_level::nothrow) &&
-          F::constraints.destructibility >= constraint_level::nontrivial) {
+  constexpr explicit proxy(
+      std::in_place_type_t<P>, std::initializer_list<U> il,
+      Args&&... args) noexcept(std::
+                                   is_nothrow_constructible_v<
+                                       P, std::initializer_list<U>&, Args...>)
+    requires(details::ptr_traits<P>::applicable &&
+             std::is_constructible_v<P, std::initializer_list<U>&, Args...>)
+      : proxy() {
+    initialize<P>(il, std::forward<Args>(args)...);
+  }
+  proxy& operator=(std::nullptr_t) noexcept(F::constraints.destructibility >=
+                                            constraint_level::nothrow)
+    requires(F::constraints.destructibility >= constraint_level::nontrivial)
+  {
+    reset();
+    return *this;
+  }
+  proxy& operator=(const proxy&) noexcept
+    requires(F::constraints.copyability == constraint_level::trivial)
+  = default;
+  proxy& operator=(const proxy& rhs) noexcept(F::constraints.copyability >=
+                                                  constraint_level::nothrow &&
+                                              F::constraints.destructibility >=
+                                                  constraint_level::nothrow)
+    requires((F::constraints.copyability == constraint_level::nontrivial ||
+              F::constraints.copyability == constraint_level::nothrow) &&
+             F::constraints.destructibility >= constraint_level::nontrivial)
+  {
     if (this != std::addressof(rhs)) [[likely]] {
       if constexpr (F::constraints.copyability == constraint_level::nothrow) {
         std::destroy_at(this);
@@ -947,12 +1039,14 @@ class proxy : public details::facade_traits<F>::direct_accessor,
     }
     return *this;
   }
-  proxy& operator=(proxy&& rhs)
-      noexcept(F::constraints.relocatability >= constraint_level::nothrow &&
-          F::constraints.destructibility >= constraint_level::nothrow)
-      requires(F::constraints.relocatability >= constraint_level::nontrivial &&
-          F::constraints.destructibility >= constraint_level::nontrivial &&
-          F::constraints.copyability != constraint_level::trivial) {
+  proxy& operator=(proxy&& rhs) noexcept(F::constraints.relocatability >=
+                                             constraint_level::nothrow &&
+                                         F::constraints.destructibility >=
+                                             constraint_level::nothrow)
+    requires(F::constraints.relocatability >= constraint_level::nontrivial &&
+             F::constraints.destructibility >= constraint_level::nontrivial &&
+             F::constraints.copyability != constraint_level::trivial)
+  {
     if (this != std::addressof(rhs)) [[likely]] {
       reset();
       std::construct_at(this, std::move(rhs));
@@ -960,12 +1054,13 @@ class proxy : public details::facade_traits<F>::direct_accessor,
     return *this;
   }
   template <class P>
-  constexpr proxy& operator=(P&& ptr)
-      noexcept(std::is_nothrow_constructible_v<std::decay_t<P>, P> &&
-          F::constraints.destructibility >= constraint_level::nothrow)
-      requires(details::ptr_traits<std::decay_t<P>>::applicable &&
-          std::is_constructible_v<std::decay_t<P>, P> &&
-          F::constraints.destructibility >= constraint_level::nontrivial) {
+  constexpr proxy& operator=(P&& ptr) noexcept(
+      std::is_nothrow_constructible_v<std::decay_t<P>, P> &&
+      F::constraints.destructibility >= constraint_level::nothrow)
+    requires(details::ptr_traits<std::decay_t<P>>::applicable &&
+             std::is_constructible_v<std::decay_t<P>, P> &&
+             F::constraints.destructibility >= constraint_level::nontrivial)
+  {
     if constexpr (std::is_nothrow_constructible_v<std::decay_t<P>, P>) {
       std::destroy_at(this);
       initialize<std::decay_t<P>>(std::forward<P>(ptr));
@@ -974,30 +1069,38 @@ class proxy : public details::facade_traits<F>::direct_accessor,
     }
     return *this;
   }
-  ~proxy() requires(F::constraints.destructibility == constraint_level::trivial)
-      = default;
+  ~proxy()
+    requires(F::constraints.destructibility == constraint_level::trivial)
+  = default;
   ~proxy() noexcept(F::constraints.destructibility == constraint_level::nothrow)
-      requires(F::constraints.destructibility == constraint_level::nontrivial ||
-          F::constraints.destructibility == constraint_level::nothrow) {
+    requires(F::constraints.destructibility == constraint_level::nontrivial ||
+             F::constraints.destructibility == constraint_level::nothrow)
+  {
     if (meta_.has_value()) {
-      proxy_invoke<true, details::destroy_dispatch, void() noexcept(
-          F::constraints.destructibility == constraint_level::nothrow)>(*this);
+      proxy_invoke<true, details::destroy_dispatch,
+                   void() noexcept(F::constraints.destructibility ==
+                                   constraint_level::nothrow)>(*this);
     }
   }
 
   bool has_value() const noexcept { return meta_.has_value(); }
   explicit operator bool() const noexcept { return meta_.has_value(); }
-  void reset()
-      noexcept(F::constraints.destructibility >= constraint_level::nothrow)
-      requires(F::constraints.destructibility >= constraint_level::nontrivial)
-      { std::destroy_at(this); meta_.reset(); }
-  void swap(proxy& rhs)
-      noexcept(F::constraints.relocatability >= constraint_level::nothrow ||
-          F::constraints.copyability == constraint_level::trivial)
-      requires(F::constraints.relocatability >= constraint_level::nontrivial ||
-          F::constraints.copyability == constraint_level::trivial) {
+  void reset() noexcept(F::constraints.destructibility >=
+                        constraint_level::nothrow)
+    requires(F::constraints.destructibility >= constraint_level::nontrivial)
+  {
+    std::destroy_at(this);
+    meta_.reset();
+  }
+  void swap(proxy& rhs) noexcept(F::constraints.relocatability >=
+                                     constraint_level::nothrow ||
+                                 F::constraints.copyability ==
+                                     constraint_level::trivial)
+    requires(F::constraints.relocatability >= constraint_level::nontrivial ||
+             F::constraints.copyability == constraint_level::trivial)
+  {
     if constexpr (F::constraints.relocatability == constraint_level::trivial ||
-        F::constraints.copyability == constraint_level::trivial) {
+                  F::constraints.copyability == constraint_level::trivial) {
       std::swap(meta_, rhs.meta_);
       std::swap(ptr_, rhs.ptr_);
     } else {
@@ -1015,33 +1118,40 @@ class proxy : public details::facade_traits<F>::direct_accessor,
     }
   }
   template <class P, class... Args>
-  constexpr P& emplace(Args&&... args)
-      noexcept(std::is_nothrow_constructible_v<P, Args...> &&
-          F::constraints.destructibility >= constraint_level::nothrow)
-      requires(details::ptr_traits<P>::applicable &&
-          std::is_constructible_v<P, Args...> &&
-          F::constraints.destructibility >= constraint_level::nontrivial)
-      { reset(); return initialize<P>(std::forward<Args>(args)...); }
+  constexpr P& emplace(Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<P, Args...> &&
+      F::constraints.destructibility >= constraint_level::nothrow)
+    requires(details::ptr_traits<P>::applicable &&
+             std::is_constructible_v<P, Args...> &&
+             F::constraints.destructibility >= constraint_level::nontrivial)
+  {
+    reset();
+    return initialize<P>(std::forward<Args>(args)...);
+  }
   template <class P, class U, class... Args>
-  constexpr P& emplace(std::initializer_list<U> il, Args&&... args)
-      noexcept(std::is_nothrow_constructible_v<
-          P, std::initializer_list<U>&, Args...> &&
-          F::constraints.destructibility >= constraint_level::nothrow)
-      requires(details::ptr_traits<P>::applicable &&
-          std::is_constructible_v<P, std::initializer_list<U>&, Args...> &&
-          F::constraints.destructibility >= constraint_level::nontrivial)
-      { reset(); return initialize<P>(il, std::forward<Args>(args)...); }
-
-  friend void swap(proxy& lhs, proxy& rhs) noexcept(noexcept(lhs.swap(rhs)))
-      { lhs.swap(rhs); }
-  friend bool operator==(const proxy& lhs, std::nullptr_t) noexcept
-      { return !lhs.has_value(); }
-
- private:
+  constexpr P& emplace(std::initializer_list<U> il, Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<P, std::initializer_list<U>&, Args...> &&
+      F::constraints.destructibility >= constraint_level::nothrow)
+    requires(details::ptr_traits<P>::applicable &&
+             std::is_constructible_v<P, std::initializer_list<U>&, Args...> &&
+             F::constraints.destructibility >= constraint_level::nontrivial)
+  {
+    reset();
+    return initialize<P>(il, std::forward<Args>(args)...);
+  }
+
+  friend void swap(proxy& lhs, proxy& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+    lhs.swap(rhs);
+  }
+  friend bool operator==(const proxy& lhs, std::nullptr_t) noexcept {
+    return !lhs.has_value();
+  }
+
+private:
   template <class P, class... Args>
   constexpr P& initialize(Args&&... args) {
-    P& result = *std::construct_at(
-        reinterpret_cast<P*>(ptr_), std::forward<Args>(args)...);
+    P& result = *std::construct_at(reinterpret_cast<P*>(ptr_),
+                                   std::forward<Args>(args)...);
     if constexpr (proxiable<P, F>) {
       meta_ = details::meta_ptr<typename _Traits::meta>{std::in_place_type<P>};
     } else {
@@ -1050,12 +1160,15 @@ class proxy : public details::facade_traits<F>::direct_accessor,
     return result;
   }
 
-___PRO4_DEBUG(
-  static inline void _symbol_guard(proxy& self, const proxy& cself) noexcept {
-    self.operator->(); *self; *std::move(self);
-    cself.operator->(); *cself; *std::move(cself);
-  }
-)
+  ___PRO4_DEBUG(static inline void _symbol_guard(proxy& self,
+                                                 const proxy& cself) noexcept {
+    self.operator->();
+    *self;
+    *std::move(self);
+    cself.operator->();
+    *cself;
+    *std::move(cself);
+  })
 
   details::meta_ptr<typename _Traits::meta> meta_;
   alignas(F::constraints.max_align) std::byte ptr_[F::constraints.max_size];
@@ -1065,26 +1178,27 @@ namespace details {
 
 template <class LR, class CLR, class RR, class CRR>
 struct observer_ptr {
- public:
+public:
   explicit observer_ptr(LR lr) : lr_(lr) {}
   observer_ptr(const observer_ptr&) = default;
   auto operator->() noexcept { return std::addressof(lr_); }
-  auto operator->() const noexcept
-      { return std::addressof(static_cast<CLR>(lr_)); }
+  auto operator->() const noexcept {
+    return std::addressof(static_cast<CLR>(lr_));
+  }
   LR operator*() & noexcept { return static_cast<LR>(lr_); }
   CLR operator*() const& noexcept { return static_cast<CLR>(lr_); }
   RR operator*() && noexcept { return static_cast<RR>(lr_); }
   CRR operator*() const&& noexcept { return static_cast<CRR>(lr_); }
 
- private:
+private:
   LR lr_;
 };
 
 #if __STDC_HOSTED__
 template <class T, class Alloc, class... Args>
 T* allocate(const Alloc& alloc, Args&&... args) {
-  auto al = typename std::allocator_traits<Alloc>
-      ::template rebind_alloc<T>(alloc);
+  auto al =
+      typename std::allocator_traits<Alloc>::template rebind_alloc<T>(alloc);
   auto deleter = [&](T* ptr) { al.deallocate(ptr, 1); };
   std::unique_ptr<T, decltype(deleter)> result{al.allocate(1), deleter};
   std::construct_at(result.get(), std::forward<Args>(args)...);
@@ -1092,14 +1206,14 @@ T* allocate(const Alloc& alloc, Args&&... args) {
 }
 template <class Alloc, class T>
 void deallocate(const Alloc& alloc, T* ptr) {
-  auto al = typename std::allocator_traits<Alloc>
-      ::template rebind_alloc<T>(alloc);
+  auto al =
+      typename std::allocator_traits<Alloc>::template rebind_alloc<T>(alloc);
   std::destroy_at(ptr);
   al.deallocate(ptr, 1);
 }
 template <class Alloc>
 struct alloc_aware {
- public:
+public:
   explicit alloc_aware(const Alloc& alloc) noexcept : alloc(alloc) {}
   alloc_aware(const alloc_aware&) noexcept = default;
 
@@ -1108,7 +1222,7 @@ struct alloc_aware {
 };
 template <class T>
 class indirect_ptr {
- public:
+public:
   explicit indirect_ptr(T* ptr) noexcept : ptr_(ptr) {}
 
   explicit operator bool() const noexcept { return ptr_ != nullptr; }
@@ -1117,38 +1231,44 @@ class indirect_ptr {
   decltype(auto) operator*() & noexcept { return **ptr_; }
   decltype(auto) operator*() const& noexcept { return *std::as_const(*ptr_); }
   decltype(auto) operator*() && noexcept { return *std::move(*ptr_); }
-  decltype(auto) operator*() const&& noexcept
-      { return *std::move(std::as_const(*ptr_)); }
+  decltype(auto) operator*() const&& noexcept {
+    return *std::move(std::as_const(*ptr_));
+  }
 
- protected:
+protected:
   T* ptr_;
 };
 
 template <class T, class Alloc>
-class ___PRO4_ENFORCE_EBO allocated_ptr
-    : private alloc_aware<Alloc>, public indirect_ptr<inplace_ptr<T>> {
- public:
+class ___PRO4_ENFORCE_EBO allocated_ptr : private alloc_aware<Alloc>,
+                                          public indirect_ptr<inplace_ptr<T>> {
+public:
   template <class... Args>
   allocated_ptr(const Alloc& alloc, Args&&... args)
       : alloc_aware<Alloc>(alloc),
         indirect_ptr<inplace_ptr<T>>(allocate<inplace_ptr<T>>(
             this->alloc, std::in_place, std::forward<Args>(args)...)) {}
   allocated_ptr(const allocated_ptr& rhs)
-      requires(std::is_copy_constructible_v<T>)
-      : alloc_aware<Alloc>(rhs), indirect_ptr<inplace_ptr<T>>(
-            rhs.ptr_ == nullptr ? nullptr : allocate<inplace_ptr<T>>(
-                this->alloc, std::in_place, *rhs)) {}
-  allocated_ptr(allocated_ptr&& rhs)
-      noexcept(std::is_nothrow_move_constructible_v<Alloc>)
+    requires(std::is_copy_constructible_v<T>)
+      : alloc_aware<Alloc>(rhs),
+        indirect_ptr<inplace_ptr<T>>(
+            rhs.ptr_ == nullptr
+                ? nullptr
+                : allocate<inplace_ptr<T>>(this->alloc, std::in_place, *rhs)) {}
+  allocated_ptr(allocated_ptr&& rhs) noexcept(
+      std::is_nothrow_move_constructible_v<Alloc>)
       : alloc_aware<Alloc>(rhs),
         indirect_ptr<inplace_ptr<T>>(std::exchange(rhs.ptr_, nullptr)) {}
-  ~allocated_ptr() noexcept(std::is_nothrow_destructible_v<T>)
-      { if (this->ptr_ != nullptr) { deallocate(this->alloc, this->ptr_); } }
+  ~allocated_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
+    if (this->ptr_ != nullptr) {
+      deallocate(this->alloc, this->ptr_);
+    }
+  }
 };
 
 template <class T, class Alloc>
-struct ___PRO4_ENFORCE_EBO compact_ptr_storage
-    : alloc_aware<Alloc>, inplace_ptr<T> {
+struct ___PRO4_ENFORCE_EBO compact_ptr_storage : alloc_aware<Alloc>,
+                                                 inplace_ptr<T> {
   template <class... Args>
   explicit compact_ptr_storage(const Alloc& alloc, Args&&... args)
       : alloc_aware<Alloc>(alloc),
@@ -1158,25 +1278,34 @@ template <class T, class Alloc>
 class compact_ptr : public indirect_ptr<compact_ptr_storage<T, Alloc>> {
   using Storage = compact_ptr_storage<T, Alloc>;
 
- public:
+public:
   template <class... Args>
   compact_ptr(const Alloc& alloc, Args&&... args)
-      : indirect_ptr<Storage>(allocate<Storage>(
-            alloc, alloc, std::forward<Args>(args)...)) {}
-  compact_ptr(const compact_ptr& rhs) requires(std::is_copy_constructible_v<T>)
-      : indirect_ptr<Storage>(rhs.ptr_ == nullptr ? nullptr :
-            allocate<Storage>(rhs.ptr_->alloc, rhs.ptr_->alloc, *rhs)) {}
+      : indirect_ptr<Storage>(
+            allocate<Storage>(alloc, alloc, std::forward<Args>(args)...)) {}
+  compact_ptr(const compact_ptr& rhs)
+    requires(std::is_copy_constructible_v<T>)
+      : indirect_ptr<Storage>(
+            rhs.ptr_ == nullptr
+                ? nullptr
+                : allocate<Storage>(rhs.ptr_->alloc, rhs.ptr_->alloc, *rhs)) {}
   compact_ptr(compact_ptr&& rhs) noexcept
       : indirect_ptr<Storage>(std::exchange(rhs.ptr_, nullptr)) {}
   ~compact_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
-    if (this->ptr_ != nullptr) { deallocate(this->ptr_->alloc, this->ptr_); }
+    if (this->ptr_ != nullptr) {
+      deallocate(this->ptr_->alloc, this->ptr_);
+    }
   }
 };
 
-struct shared_compact_ptr_storage_base { std::atomic_long ref_count = 1; };
+struct shared_compact_ptr_storage_base {
+  std::atomic_long ref_count = 1;
+};
 template <class T, class Alloc>
 struct ___PRO4_ENFORCE_EBO shared_compact_ptr_storage
-    : shared_compact_ptr_storage_base, alloc_aware<Alloc>, inplace_ptr<T> {
+    : shared_compact_ptr_storage_base,
+      alloc_aware<Alloc>,
+      inplace_ptr<T> {
   template <class... Args>
   explicit shared_compact_ptr_storage(const Alloc& alloc, Args&&... args)
       : alloc_aware<Alloc>(alloc),
@@ -1187,15 +1316,16 @@ class shared_compact_ptr
     : public indirect_ptr<shared_compact_ptr_storage<T, Alloc>> {
   using Storage = shared_compact_ptr_storage<T, Alloc>;
 
- public:
+public:
   template <class... Args>
   shared_compact_ptr(const Alloc& alloc, Args&&... args)
-      : indirect_ptr<Storage>(allocate<Storage>(
-            alloc, alloc, std::forward<Args>(args)...)) {}
+      : indirect_ptr<Storage>(
+            allocate<Storage>(alloc, alloc, std::forward<Args>(args)...)) {}
   shared_compact_ptr(const shared_compact_ptr& rhs) noexcept
       : indirect_ptr<Storage>(rhs.ptr_) {
-    if (this->ptr_ != nullptr)
-        { this->ptr_->ref_count.fetch_add(1, std::memory_order::relaxed); }
+    if (this->ptr_ != nullptr) {
+      this->ptr_->ref_count.fetch_add(1, std::memory_order::relaxed);
+    }
   }
   shared_compact_ptr(shared_compact_ptr&& rhs) noexcept
       : indirect_ptr<Storage>(std::exchange(rhs.ptr_, nullptr)) {}
@@ -1207,95 +1337,104 @@ class shared_compact_ptr
   }
 };
 
-struct strong_weak_compact_ptr_storage_base
-    { std::atomic_long strong_count = 1, weak_count = 1; };
+struct strong_weak_compact_ptr_storage_base {
+  std::atomic_long strong_count = 1, weak_count = 1;
+};
 template <class T, class Alloc>
-struct strong_weak_compact_ptr_storage
-    : strong_weak_compact_ptr_storage_base, alloc_aware<Alloc> {
+struct strong_weak_compact_ptr_storage : strong_weak_compact_ptr_storage_base,
+                                         alloc_aware<Alloc> {
   template <class... Args>
   explicit strong_weak_compact_ptr_storage(const Alloc& alloc, Args&&... args)
       : alloc_aware<Alloc>(alloc) {
-    std::construct_at(
-        reinterpret_cast<T*>(&value), std::forward<Args>(args)...);
+    std::construct_at(reinterpret_cast<T*>(&value),
+                      std::forward<Args>(args)...);
   }
 
   alignas(alignof(T)) std::byte value[sizeof(T)];
 };
-template <class T, class Alloc> class weak_compact_ptr;
+template <class T, class Alloc>
+class weak_compact_ptr;
 template <class T, class Alloc>
 class strong_compact_ptr
     : public indirect_ptr<strong_weak_compact_ptr_storage<T, Alloc>> {
   friend class weak_compact_ptr<T, Alloc>;
   using Storage = strong_weak_compact_ptr_storage<T, Alloc>;
 
- public:
+public:
   using weak_type = weak_compact_ptr<T, Alloc>;
 
   template <class... Args>
   strong_compact_ptr(const Alloc& alloc, Args&&... args)
-      : indirect_ptr<Storage>(allocate<Storage>(
-            alloc, alloc, std::forward<Args>(args)...)) {}
+      : indirect_ptr<Storage>(
+            allocate<Storage>(alloc, alloc, std::forward<Args>(args)...)) {}
   strong_compact_ptr(const strong_compact_ptr& rhs) noexcept
       : indirect_ptr<Storage>(rhs.ptr_) {
-    if (this->ptr_ != nullptr)
-        { this->ptr_->strong_count.fetch_add(1, std::memory_order::relaxed); }
+    if (this->ptr_ != nullptr) {
+      this->ptr_->strong_count.fetch_add(1, std::memory_order::relaxed);
+    }
   }
   strong_compact_ptr(strong_compact_ptr&& rhs) noexcept
       : indirect_ptr<Storage>(std::exchange(rhs.ptr_, nullptr)) {}
   ~strong_compact_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
     if (this->ptr_ != nullptr && this->ptr_->strong_count.fetch_sub(
-        1, std::memory_order::acq_rel) == 1) {
+                                     1, std::memory_order::acq_rel) == 1) {
       std::destroy_at(operator->());
-      if (this->ptr_->weak_count.fetch_sub(
-          1u, std::memory_order::release) == 1) {
+      if (this->ptr_->weak_count.fetch_sub(1u, std::memory_order::release) ==
+          1) {
         deallocate(this->ptr_->alloc, this->ptr_);
       }
     }
   }
   explicit operator bool() const noexcept { return this->ptr_ != nullptr; }
-  T* operator->() noexcept
-      { return std::launder(reinterpret_cast<T*>(&this->ptr_->value)); }
-  const T* operator->() const noexcept
-      { return std::launder(reinterpret_cast<const T*>(&this->ptr_->value)); }
+  T* operator->() noexcept {
+    return std::launder(reinterpret_cast<T*>(&this->ptr_->value));
+  }
+  const T* operator->() const noexcept {
+    return std::launder(reinterpret_cast<const T*>(&this->ptr_->value));
+  }
   T& operator*() & noexcept { return *operator->(); }
   const T& operator*() const& noexcept { return *operator->(); }
   T&& operator*() && noexcept { return std::move(*operator->()); }
   const T&& operator*() const&& noexcept { return std::move(*operator->()); }
 
- private:
+private:
   explicit strong_compact_ptr(Storage* ptr) noexcept
       : indirect_ptr<Storage>(ptr) {}
 };
 template <class T, class Alloc>
 class weak_compact_ptr {
- public:
+public:
   weak_compact_ptr(const strong_compact_ptr<T, Alloc>& rhs) noexcept
       : ptr_(rhs.ptr_) {
-    if (ptr_ != nullptr)
-        { ptr_->weak_count.fetch_add(1, std::memory_order::relaxed); }
+    if (ptr_ != nullptr) {
+      ptr_->weak_count.fetch_add(1, std::memory_order::relaxed);
+    }
   }
   weak_compact_ptr(const weak_compact_ptr& rhs) noexcept : ptr_(rhs.ptr_) {
-    if (ptr_ != nullptr)
-        { ptr_->weak_count.fetch_add(1, std::memory_order::relaxed); }
+    if (ptr_ != nullptr) {
+      ptr_->weak_count.fetch_add(1, std::memory_order::relaxed);
+    }
   }
   weak_compact_ptr(weak_compact_ptr&& rhs) noexcept
       : ptr_(std::exchange(rhs.ptr_, nullptr)) {}
   ~weak_compact_ptr() noexcept {
-    if (ptr_ != nullptr && ptr_->weak_count.fetch_sub(
-        1u, std::memory_order::acq_rel) == 1) {
+    if (ptr_ != nullptr &&
+        ptr_->weak_count.fetch_sub(1u, std::memory_order::acq_rel) == 1) {
       deallocate(ptr_->alloc, ptr_);
     }
   }
   strong_compact_ptr<T, Alloc> lock() const noexcept {
     long ref_count = ptr_->strong_count.load(std::memory_order::relaxed);
     do {
-      if (ref_count == 0) { return strong_compact_ptr<T, Alloc>{nullptr}; }
+      if (ref_count == 0) {
+        return strong_compact_ptr<T, Alloc>{nullptr};
+      }
     } while (!ptr_->strong_count.compare_exchange_weak(
         ref_count, ref_count + 1, std::memory_order::relaxed));
     return strong_compact_ptr<T, Alloc>{ptr_};
   }
 
- private:
+private:
   strong_weak_compact_ptr_storage<T, Alloc>* ptr_;
 };
 
@@ -1303,88 +1442,97 @@ struct weak_conversion_dispatch;
 template <class... Cs>
 struct weak_ownership_support_traits_impl : inapplicable_traits {};
 template <class... Cs>
-    requires(std::is_same_v<
-        typename Cs::dispatch_type, weak_conversion_dispatch> || ...)
+  requires(
+      std::is_same_v<typename Cs::dispatch_type, weak_conversion_dispatch> ||
+      ...)
 struct weak_ownership_support_traits_impl<Cs...> : applicable_traits {};
 template <class F>
-struct weak_ownership_support_traits : instantiated_t<
-    weak_ownership_support_traits_impl, typename F::convention_types> {};
+struct weak_ownership_support_traits
+    : instantiated_t<weak_ownership_support_traits_impl,
+                     typename F::convention_types> {};
 
 template <class F, class T, class Alloc, class... Args>
 constexpr proxy<F> allocate_proxy_impl(const Alloc& alloc, Args&&... args) {
   if constexpr (proxiable<allocated_ptr<T, Alloc>, F>) {
-    return proxy<F>{std::in_place_type<allocated_ptr<T, Alloc>>,
-        alloc, std::forward<Args>(args)...};
+    return proxy<F>{std::in_place_type<allocated_ptr<T, Alloc>>, alloc,
+                    std::forward<Args>(args)...};
   } else {
-    return proxy<F>{std::in_place_type<compact_ptr<T, Alloc>>,
-        alloc, std::forward<Args>(args)...};
+    return proxy<F>{std::in_place_type<compact_ptr<T, Alloc>>, alloc,
+                    std::forward<Args>(args)...};
   }
 }
 template <class F, class T, class... Args>
 constexpr proxy<F> make_proxy_impl(Args&&... args) {
   if constexpr (proxiable<inplace_ptr<T>, F>) {
     return proxy<F>{std::in_place_type<inplace_ptr<T>>, std::in_place,
-        std::forward<Args>(args)...};
+                    std::forward<Args>(args)...};
   } else {
-    return allocate_proxy_impl<F, T>(
-        std::allocator<void>{}, std::forward<Args>(args)...);
+    return allocate_proxy_impl<F, T>(std::allocator<void>{},
+                                     std::forward<Args>(args)...);
   }
 }
 template <class F, class T, class Alloc, class... Args>
-constexpr proxy<F> allocate_proxy_shared_impl(
-    const Alloc& alloc, Args&&... args) {
+constexpr proxy<F> allocate_proxy_shared_impl(const Alloc& alloc,
+                                              Args&&... args) {
   if constexpr (weak_ownership_support_traits<F>::applicable) {
-    return proxy<F>{std::in_place_type<strong_compact_ptr<T, Alloc>>,
-        alloc, std::forward<Args>(args)...};
+    return proxy<F>{std::in_place_type<strong_compact_ptr<T, Alloc>>, alloc,
+                    std::forward<Args>(args)...};
   } else {
-    return proxy<F>{std::in_place_type<shared_compact_ptr<T, Alloc>>,
-        alloc, std::forward<Args>(args)...};
+    return proxy<F>{std::in_place_type<shared_compact_ptr<T, Alloc>>, alloc,
+                    std::forward<Args>(args)...};
   }
 }
 template <class F, class T, class... Args>
 constexpr proxy<F> make_proxy_shared_impl(Args&&... args) {
-  return allocate_proxy_shared_impl<F, T>(
-      std::allocator<void>{}, std::forward<Args>(args)...);
+  return allocate_proxy_shared_impl<F, T>(std::allocator<void>{},
+                                          std::forward<Args>(args)...);
 }
-#endif  // __STDC_HOSTED__
+#endif // __STDC_HOSTED__
 
-}  // namespace details
+} // namespace details
 
-template <facade F> struct observer_facade;
-template <facade F> using proxy_view = proxy<observer_facade<F>>;
+template <facade F>
+struct observer_facade;
+template <facade F>
+using proxy_view = proxy<observer_facade<F>>;
 
-template <facade F> struct weak_facade;
-template <facade F> using weak_proxy = proxy<weak_facade<F>>;
+template <facade F>
+struct weak_facade;
+template <facade F>
+using weak_proxy = proxy<weak_facade<F>>;
 
 template <class T, class F>
 concept inplace_proxiable_target = proxiable<details::inplace_ptr<T>, F>;
 
 template <class T, class F>
-concept proxiable_target = proxiable<
-    details::observer_ptr<T&, const T&, T&&, const T&&>, observer_facade<F>>;
+concept proxiable_target =
+    proxiable<details::observer_ptr<T&, const T&, T&&, const T&&>,
+              observer_facade<F>>;
 
 template <facade F, class T, class... Args>
-constexpr proxy<F> make_proxy_inplace(Args&&... args)
-    noexcept(std::is_nothrow_constructible_v<T, Args...>)
-    requires(std::is_constructible_v<T, Args...>) {
+constexpr proxy<F> make_proxy_inplace(Args&&... args) noexcept(
+    std::is_nothrow_constructible_v<T, Args...>)
+  requires(std::is_constructible_v<T, Args...>)
+{
   return proxy<F>{std::in_place_type<details::inplace_ptr<T>>, std::in_place,
-      std::forward<Args>(args)...};
+                  std::forward<Args>(args)...};
 }
 template <facade F, class T, class U, class... Args>
-constexpr proxy<F> make_proxy_inplace(
-    std::initializer_list<U> il, Args&&... args)
-    noexcept(std::is_nothrow_constructible_v<
-        T, std::initializer_list<U>&, Args...>)
-    requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>) {
+constexpr proxy<F>
+    make_proxy_inplace(std::initializer_list<U> il, Args&&... args) noexcept(
+        std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)
+  requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>)
+{
   return proxy<F>{std::in_place_type<details::inplace_ptr<T>>, std::in_place,
-      il, std::forward<Args>(args)...};
+                  il, std::forward<Args>(args)...};
 }
 template <facade F, class T>
-constexpr proxy<F> make_proxy_inplace(T&& value)
-    noexcept(std::is_nothrow_constructible_v<std::decay_t<T>, T>)
-    requires(std::is_constructible_v<std::decay_t<T>, T>) {
+constexpr proxy<F> make_proxy_inplace(T&& value) noexcept(
+    std::is_nothrow_constructible_v<std::decay_t<T>, T>)
+  requires(std::is_constructible_v<std::decay_t<T>, T>)
+{
   return proxy<F>{std::in_place_type<details::inplace_ptr<std::decay_t<T>>>,
-      std::in_place, std::forward<T>(value)};
+                  std::in_place, std::forward<T>(value)};
 }
 
 template <facade F, class T>
@@ -1396,80 +1544,97 @@ constexpr proxy_view<F> make_proxy_view(T& value) noexcept {
 #if __STDC_HOSTED__
 template <facade F, class T, class Alloc, class... Args>
 constexpr proxy<F> allocate_proxy(const Alloc& alloc, Args&&... args)
-    requires(std::is_constructible_v<T, Args...>) {
+  requires(std::is_constructible_v<T, Args...>)
+{
   return details::allocate_proxy_impl<F, T>(alloc, std::forward<Args>(args)...);
 }
 template <facade F, class T, class Alloc, class U, class... Args>
-constexpr proxy<F> allocate_proxy(
-    const Alloc& alloc, std::initializer_list<U> il, Args&&... args)
-    requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>) {
-  return details::allocate_proxy_impl<F, T>(
-      alloc, il, std::forward<Args>(args)...);
+constexpr proxy<F> allocate_proxy(const Alloc& alloc,
+                                  std::initializer_list<U> il, Args&&... args)
+  requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>)
+{
+  return details::allocate_proxy_impl<F, T>(alloc, il,
+                                            std::forward<Args>(args)...);
 }
 template <facade F, class Alloc, class T>
 constexpr proxy<F> allocate_proxy(const Alloc& alloc, T&& value)
-    requires(std::is_constructible_v<std::decay_t<T>, T>) {
+  requires(std::is_constructible_v<std::decay_t<T>, T>)
+{
   return details::allocate_proxy_impl<F, std::decay_t<T>>(
       alloc, std::forward<T>(value));
 }
 template <facade F, class T, class... Args>
 constexpr proxy<F> make_proxy(Args&&... args)
-    requires(std::is_constructible_v<T, Args...>)
-    { return details::make_proxy_impl<F, T>(std::forward<Args>(args)...); }
+  requires(std::is_constructible_v<T, Args...>)
+{
+  return details::make_proxy_impl<F, T>(std::forward<Args>(args)...);
+}
 template <facade F, class T, class U, class... Args>
 constexpr proxy<F> make_proxy(std::initializer_list<U> il, Args&&... args)
-    requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>)
-    { return details::make_proxy_impl<F, T>(il, std::forward<Args>(args)...); }
+  requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>)
+{
+  return details::make_proxy_impl<F, T>(il, std::forward<Args>(args)...);
+}
 template <facade F, class T>
 constexpr proxy<F> make_proxy(T&& value)
-    requires(std::is_constructible_v<std::decay_t<T>, T>) {
+  requires(std::is_constructible_v<std::decay_t<T>, T>)
+{
   return details::make_proxy_impl<F, std::decay_t<T>>(std::forward<T>(value));
 }
 
 template <facade F, class T, class Alloc, class... Args>
 constexpr proxy<F> allocate_proxy_shared(const Alloc& alloc, Args&&... args)
-    requires(std::is_constructible_v<T, Args...>) {
-  return details::allocate_proxy_shared_impl<F, T>(
-      alloc, std::forward<Args>(args)...);
+  requires(std::is_constructible_v<T, Args...>)
+{
+  return details::allocate_proxy_shared_impl<F, T>(alloc,
+                                                   std::forward<Args>(args)...);
 }
 template <facade F, class T, class Alloc, class U, class... Args>
-constexpr proxy<F> allocate_proxy_shared(
-    const Alloc& alloc, std::initializer_list<U> il, Args&&... args)
-    requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>) {
-  return details::allocate_proxy_shared_impl<F, T>(
-      alloc, il, std::forward<Args>(args)...);
+constexpr proxy<F> allocate_proxy_shared(const Alloc& alloc,
+                                         std::initializer_list<U> il,
+                                         Args&&... args)
+  requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>)
+{
+  return details::allocate_proxy_shared_impl<F, T>(alloc, il,
+                                                   std::forward<Args>(args)...);
 }
 template <facade F, class Alloc, class T>
 constexpr proxy<F> allocate_proxy_shared(const Alloc& alloc, T&& value)
-    requires(std::is_constructible_v<std::decay_t<T>, T>) {
+  requires(std::is_constructible_v<std::decay_t<T>, T>)
+{
   return details::allocate_proxy_shared_impl<F, std::decay_t<T>>(
       alloc, std::forward<T>(value));
 }
 template <facade F, class T, class... Args>
 constexpr proxy<F> make_proxy_shared(Args&&... args)
-    requires(std::is_constructible_v<T, Args...>) {
+  requires(std::is_constructible_v<T, Args...>)
+{
   return details::make_proxy_shared_impl<F, T>(std::forward<Args>(args)...);
 }
 template <facade F, class T, class U, class... Args>
-constexpr proxy<F> make_proxy_shared(
-    std::initializer_list<U> il, Args&&... args)
-    requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>) {
+constexpr proxy<F> make_proxy_shared(std::initializer_list<U> il,
+                                     Args&&... args)
+  requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>)
+{
   return details::make_proxy_shared_impl<F, T>(il, std::forward<Args>(args)...);
 }
 template <facade F, class T>
 constexpr proxy<F> make_proxy_shared(T&& value)
-    requires(std::is_constructible_v<std::decay_t<T>, T>) {
+  requires(std::is_constructible_v<std::decay_t<T>, T>)
+{
   return details::make_proxy_shared_impl<F, std::decay_t<T>>(
       std::forward<T>(value));
 }
-#endif  // __STDC_HOSTED__
+#endif // __STDC_HOSTED__
 
 #if __cpp_rtti >= 199711L
 class bad_proxy_cast : public std::bad_cast {
- public:
-  char const* what() const noexcept override { return "pro::v4::bad_proxy_cast"; }
+public:
+  char const* what() const noexcept override {
+    return "pro::v4::bad_proxy_cast";
+  }
 };
-#endif  // __cpp_rtti >= 199711L
+#endif // __cpp_rtti >= 199711L
 
 namespace details {
 
@@ -1477,7 +1642,8 @@ template <class F, bool IsDirect>
 using adl_accessor_arg_t =
     std::conditional_t<IsDirect, proxy<F>, proxy_indirect_accessor<F>>;
 
-template <class T> struct proxy_arg_traits : inapplicable_traits {};
+template <class T>
+struct proxy_arg_traits : inapplicable_traits {};
 template <class F>
 struct proxy_arg_traits<proxy<F>> : applicable_traits {};
 template <class F>
@@ -1485,27 +1651,32 @@ struct proxy_arg_traits<proxy_indirect_accessor<F>> : applicable_traits {};
 template <class T>
 concept non_proxy_arg = !proxy_arg_traits<std::decay_t<T>>::applicable;
 
-#define ___PRO_DEF_CAST_ACCESSOR(Q, SELF, ...) \
-    template <class __F, bool __IsDirect, class __D, class T> \
-    struct accessor<__F, __IsDirect, __D, T() Q> { \
-      ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(operator T) \
-      explicit(Expl) operator T() Q { \
-        if constexpr (Nullable) { \
-          if (!SELF.has_value()) { return nullptr; } \
-        } \
-        return proxy_invoke<__IsDirect, __D, T() Q>(SELF); \
-      } \
-    }
+#define ___PRO_DEF_CAST_ACCESSOR(Q, SELF, ...)                                 \
+  template <class __F, bool __IsDirect, class __D, class T>                    \
+  struct accessor<__F, __IsDirect, __D, T() Q> {                               \
+    ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(operator T)                      \
+    explicit(Expl) operator T() Q {                                            \
+      if constexpr (Nullable) {                                                \
+        if (!SELF.has_value()) {                                               \
+          return nullptr;                                                      \
+        }                                                                      \
+      }                                                                        \
+      return proxy_invoke<__IsDirect, __D, T() Q>(SELF);                       \
+    }                                                                          \
+  }
 template <bool Expl, bool Nullable>
 struct cast_dispatch_base {
-  ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(___PRO_DEF_CAST_ACCESSOR,
+  ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(
+      ___PRO_DEF_CAST_ACCESSOR,
       operator typename overload_traits<__Os>::return_type)
 };
 #undef ___PRO_DEF_CAST_ACCESSOR
 
 struct upward_conversion_dispatch : cast_dispatch_base<false, true> {
   template <non_proxy_arg T>
-  ___PRO4_STATIC_CALL(T&&, T&& self) noexcept { return std::forward<T>(self); }
+  ___PRO4_STATIC_CALL(T&&, T&& self) noexcept {
+    return std::forward<T>(self);
+  }
 };
 
 template <class T>
@@ -1516,10 +1687,12 @@ struct explicit_conversion_adapter {
 
   template <class U>
   operator U() const noexcept(std::is_nothrow_constructible_v<U, T>)
-      requires(std::is_constructible_v<U, T>)
-      { return U{std::forward<T>(value_)}; }
+    requires(std::is_constructible_v<U, T>)
+  {
+    return U{std::forward<T>(value_)};
+  }
 
- private:
+private:
   T&& value_;
 };
 
@@ -1527,41 +1700,57 @@ constexpr std::size_t invalid_size = std::numeric_limits<std::size_t>::max();
 constexpr constraint_level invalid_cl = static_cast<constraint_level>(
     std::numeric_limits<std::underlying_type_t<constraint_level>>::min());
 consteval auto normalize(proxiable_ptr_constraints value) {
-  if (value.max_size == invalid_size)
-      { value.max_size = sizeof(ptr_prototype); }
-  if (value.max_align == invalid_size)
-      { value.max_align = alignof(ptr_prototype); }
-  if (value.copyability == invalid_cl)
-      { value.copyability = constraint_level::none; }
-  if (value.relocatability == invalid_cl)
-      { value.relocatability = constraint_level::nothrow; }
-  if (value.destructibility == invalid_cl)
-      { value.destructibility = constraint_level::nothrow; }
+  if (value.max_size == invalid_size) {
+    value.max_size = sizeof(ptr_prototype);
+  }
+  if (value.max_align == invalid_size) {
+    value.max_align = alignof(ptr_prototype);
+  }
+  if (value.copyability == invalid_cl) {
+    value.copyability = constraint_level::none;
+  }
+  if (value.relocatability == invalid_cl) {
+    value.relocatability = constraint_level::nothrow;
+  }
+  if (value.destructibility == invalid_cl) {
+    value.destructibility = constraint_level::nothrow;
+  }
   return value;
 }
 consteval auto make_restricted_layout(proxiable_ptr_constraints value,
-    std::size_t max_size, std::size_t max_align) {
-  if (value.max_size > max_size) { value.max_size = max_size; }
-  if (value.max_align > max_align) { value.max_align = max_align; }
+                                      std::size_t max_size,
+                                      std::size_t max_align) {
+  if (value.max_size > max_size) {
+    value.max_size = max_size;
+  }
+  if (value.max_align > max_align) {
+    value.max_align = max_align;
+  }
   return value;
 }
 consteval auto make_copyable(proxiable_ptr_constraints value,
-    constraint_level cl) {
-  if (value.copyability < cl) { value.copyability = cl; }
+                             constraint_level cl) {
+  if (value.copyability < cl) {
+    value.copyability = cl;
+  }
   return value;
 }
 consteval auto make_relocatable(proxiable_ptr_constraints value,
-    constraint_level cl) {
-  if (value.relocatability < cl) { value.relocatability = cl; }
+                                constraint_level cl) {
+  if (value.relocatability < cl) {
+    value.relocatability = cl;
+  }
   return value;
 }
 consteval auto make_destructible(proxiable_ptr_constraints value,
-    constraint_level cl) {
-  if (value.destructibility < cl) { value.destructibility = cl; }
+                                 constraint_level cl) {
+  if (value.destructibility < cl) {
+    value.destructibility = cl;
+  }
   return value;
 }
 consteval auto merge_constraints(proxiable_ptr_constraints a,
-    proxiable_ptr_constraints b) {
+                                 proxiable_ptr_constraints b) {
   a = make_restricted_layout(a, b.max_size, b.max_align);
   a = make_copyable(a, b.copyability);
   a = make_relocatable(a, b.relocatability);
@@ -1576,10 +1765,11 @@ consteval std::size_t max_align_of(std::size_t value) {
 template <class SFINAE, class T, class F, bool IsDirect, class... Args>
 struct accessor_instantiation_traits : std::type_identity<void> {};
 template <class T, class F, bool IsDirect, class... Args>
-struct accessor_instantiation_traits<std::void_t<typename T::template accessor<
-    F, IsDirect, T, Args...>>, T, F, IsDirect, Args...>
-    : std::type_identity<typename T::template accessor<
-          F, IsDirect, T, Args...>> {};
+struct accessor_instantiation_traits<
+    std::void_t<typename T::template accessor<F, IsDirect, T, Args...>>, T, F,
+    IsDirect, Args...>
+    : std::type_identity<
+          typename T::template accessor<F, IsDirect, T, Args...>> {};
 template <class T, class F, bool IsDirect, class... Args>
 using instantiated_accessor_t =
     typename accessor_instantiation_traits<void, T, F, IsDirect, Args...>::type;
@@ -1590,8 +1780,8 @@ struct conv_impl {
   using dispatch_type = D;
   using overload_types = std::tuple<Os...>;
   template <class F>
-  using accessor = instantiated_accessor_t<
-      D, F, IsDirect, substituted_overload_t<Os, F>...>;
+  using accessor =
+      instantiated_accessor_t<D, F, IsDirect, substituted_overload_t<Os, F>...>;
 };
 template <bool IsDirect, class R>
 struct refl_impl {
@@ -1609,7 +1799,8 @@ struct facade_impl {
 
 template <class O, class I>
 struct add_tuple_reduction : std::type_identity<O> {};
-template <class... Os, class I> requires(!std::is_same_v<I, Os> && ...)
+template <class... Os, class I>
+  requires(!std::is_same_v<I, Os> && ...)
 struct add_tuple_reduction<std::tuple<Os...>, I>
     : std::type_identity<std::tuple<Os..., I>> {};
 template <class T, class U>
@@ -1620,26 +1811,32 @@ template <class T, class U>
 using merge_tuple_t = instantiated_t<merge_tuple_impl_t, U, T>;
 
 template <bool IsDirect, class D>
-struct merge_conv_traits
-    { template <class... Os> using type = conv_impl<IsDirect, D, Os...>; };
+struct merge_conv_traits {
+  template <class... Os>
+  using type = conv_impl<IsDirect, D, Os...>;
+};
 template <class C1, class C2>
 using merge_conv_t = instantiated_t<
     merge_conv_traits<C1::is_direct, typename C1::dispatch_type>::template type,
     merge_tuple_t<typename C1::overload_types, typename C2::overload_types>>;
 
-template <class Cs1, class C2, class C> struct add_conv_reduction;
+template <class Cs1, class C2, class C>
+struct add_conv_reduction;
 template <class... Cs1, class C2, class... Cs3, class C>
 struct add_conv_reduction<std::tuple<Cs1...>, std::tuple<C2, Cs3...>, C>
     : add_conv_reduction<std::tuple<Cs1..., C2>, std::tuple<Cs3...>, C> {};
 template <class... Cs1, class C2, class... Cs3, class C>
-    requires(C::is_direct == C2::is_direct && std::is_same_v<
-        typename C::dispatch_type, typename C2::dispatch_type>)
+  requires(
+      C::is_direct == C2::is_direct &&
+      std::is_same_v<typename C::dispatch_type, typename C2::dispatch_type>)
 struct add_conv_reduction<std::tuple<Cs1...>, std::tuple<C2, Cs3...>, C>
     : std::type_identity<std::tuple<Cs1..., merge_conv_t<C2, C>, Cs3...>> {};
 template <class... Cs, class C>
 struct add_conv_reduction<std::tuple<Cs...>, std::tuple<>, C>
-    : std::type_identity<std::tuple<Cs..., merge_conv_t<
-          conv_impl<C::is_direct, typename C::dispatch_type>, C>>> {};
+    : std::type_identity<std::tuple<
+          Cs..., merge_conv_t<
+                     conv_impl<C::is_direct, typename C::dispatch_type>, C>>> {
+};
 template <class Cs, class C>
 using add_conv_t = typename add_conv_reduction<std::tuple<>, Cs, C>::type;
 
@@ -1651,20 +1848,23 @@ using move_conversion_overload =
     proxy<F>() && noexcept(CL >= constraint_level::nothrow);
 template <class Cs, class F, constraint_level CCL, constraint_level RCL>
 struct add_upward_conversion_conv
-    : std::type_identity<add_conv_t<Cs, conv_impl<true,
-          upward_conversion_dispatch, copy_conversion_overload<F, CCL>,
-          move_conversion_overload<F, RCL>>>> {};
+    : std::type_identity<
+          add_conv_t<Cs, conv_impl<true, upward_conversion_dispatch,
+                                   copy_conversion_overload<F, CCL>,
+                                   move_conversion_overload<F, RCL>>>> {};
 template <class Cs, class F, constraint_level RCL>
 struct add_upward_conversion_conv<Cs, F, constraint_level::none, RCL>
-    : std::type_identity<add_conv_t<Cs, conv_impl<true,
-          upward_conversion_dispatch, move_conversion_overload<F, RCL>>>> {};
+    : std::type_identity<
+          add_conv_t<Cs, conv_impl<true, upward_conversion_dispatch,
+                                   move_conversion_overload<F, RCL>>>> {};
 template <class Cs, class F, constraint_level CCL>
 struct add_upward_conversion_conv<Cs, F, CCL, constraint_level::none>
-    : std::type_identity<add_conv_t<Cs, conv_impl<true,
-          upward_conversion_dispatch, copy_conversion_overload<F, CCL>>>> {};
+    : std::type_identity<
+          add_conv_t<Cs, conv_impl<true, upward_conversion_dispatch,
+                                   copy_conversion_overload<F, CCL>>>> {};
 template <class Cs, class F>
-struct add_upward_conversion_conv<
-    Cs, F, constraint_level::none, constraint_level::none>
+struct add_upward_conversion_conv<Cs, F, constraint_level::none,
+                                  constraint_level::none>
     : std::type_identity<Cs> {};
 
 template <class Cs1, class... Cs2>
@@ -1674,20 +1874,22 @@ using merge_facade_conv_t = typename add_upward_conversion_conv<
     instantiated_t<merge_conv_tuple_t, typename F::convention_types, Cs>, F,
     WithUpwardConversion ? F::constraints.copyability : constraint_level::none,
     (WithUpwardConversion &&
-        F::constraints.copyability != constraint_level::trivial) ?
-        F::constraints.relocatability : constraint_level::none>::type;
+     F::constraints.copyability != constraint_level::trivial)
+        ? F::constraints.relocatability
+        : constraint_level::none>::type;
 
 template <class O>
-using observer_upward_conversion_overload = proxy_view<
-    typename overload_traits<O>::return_type::facade_type>() const noexcept;
+using observer_upward_conversion_overload =
+    proxy_view<typename overload_traits<O>::return_type::facade_type>()
+        const noexcept;
 template <class O, class I>
 struct observer_upward_conversion_conv_reduction : std::type_identity<O> {};
 template <class... Os, class O>
-    requires(!std::is_same_v<Os, observer_upward_conversion_overload<O>> && ...)
+  requires(!std::is_same_v<Os, observer_upward_conversion_overload<O>> && ...)
 struct observer_upward_conversion_conv_reduction<
     conv_impl<true, upward_conversion_dispatch, Os...>, O>
     : std::type_identity<conv_impl<true, upward_conversion_dispatch, Os...,
-          observer_upward_conversion_overload<O>>> {};
+                                   observer_upward_conversion_overload<O>>> {};
 template <class... Os>
 using observer_upward_conversion_conv = recursive_reduction_t<
     reduction_traits<observer_upward_conversion_conv_reduction>::template type,
@@ -1700,46 +1902,50 @@ using observer_indirect_conv =
 template <class C, class F>
 struct observer_conv_traits : inapplicable_traits {};
 template <class C, class F>
-    requires(C::is_direct &&
-        std::is_same_v<typename C::dispatch_type, upward_conversion_dispatch>)
+  requires(C::is_direct && std::is_same_v<typename C::dispatch_type,
+                                          upward_conversion_dispatch>)
 struct observer_conv_traits<C, F>
-    : applicable_traits, std::type_identity<instantiated_t<
-          observer_upward_conversion_conv, typename C::overload_types>> {};
-template <class C, class F> requires(!C::is_direct)
+    : applicable_traits,
+      std::type_identity<instantiated_t<observer_upward_conversion_conv,
+                                        typename C::overload_types>> {};
+template <class C, class F>
+  requires(!C::is_direct)
 struct observer_conv_traits<C, F>
-    : applicable_traits, std::type_identity<instantiated_t<
-          observer_indirect_conv, typename C::overload_types,
-          typename C::dispatch_type, F>> {};
+    : applicable_traits,
+      std::type_identity<
+          instantiated_t<observer_indirect_conv, typename C::overload_types,
+                         typename C::dispatch_type, F>> {};
 
 template <class F, class O, class I>
 struct observer_conv_reduction : std::type_identity<O> {};
 template <class F, class... Cs, class I>
-    requires(observer_conv_traits<I, F>::applicable)
+  requires(observer_conv_traits<I, F>::applicable)
 struct observer_conv_reduction<F, std::tuple<Cs...>, I>
     : std::type_identity<
           std::tuple<Cs..., typename observer_conv_traits<I, F>::type>> {};
 template <class F, class... Cs>
 struct observer_facade_conv_impl {
   using convention_types = recursive_reduction_t<
-      reduction_traits<observer_conv_reduction, F>::template type,
-      std::tuple<>, Cs...>;
+      reduction_traits<observer_conv_reduction, F>::template type, std::tuple<>,
+      Cs...>;
 };
 
 template <class O, class I>
 struct observer_refl_reduction : std::type_identity<O> {};
-template <class... Rs, class R> requires(!R::is_direct)
+template <class... Rs, class R>
+  requires(!R::is_direct)
 struct observer_refl_reduction<std::tuple<Rs...>, R>
     : std::type_identity<std::tuple<Rs..., R>> {};
 template <class... Rs>
 struct observer_facade_refl_impl {
   using reflection_types = recursive_reduction_t<
-      reduction_traits<observer_refl_reduction>::template type,
-      std::tuple<>, Rs...>;
+      reduction_traits<observer_refl_reduction>::template type, std::tuple<>,
+      Rs...>;
 };
 
 template <class P>
 class nullable_ptr_adapter {
- public:
+public:
   explicit nullable_ptr_adapter(P&& ptr) : ptr_(std::move(ptr)) {}
   nullable_ptr_adapter(const nullable_ptr_adapter&) = delete;
   template <class F>
@@ -1751,22 +1957,25 @@ class nullable_ptr_adapter {
     }
   }
 
- private:
+private:
   P ptr_;
 };
 template <class P>
 auto weak_lock_impl(const P& self) noexcept
-    requires(requires { static_cast<bool>(self.lock()); })
-    { return nullable_ptr_adapter{self.lock()}; }
+  requires(requires { static_cast<bool>(self.lock()); })
+{
+  return nullable_ptr_adapter{self.lock()};
+}
 PRO4_DEF_FREE_AS_MEM_DISPATCH(weak_mem_lock, weak_lock_impl, lock);
 
-template <class O> struct weak_upward_conversion_overload_traits;
+template <class O>
+struct weak_upward_conversion_overload_traits;
 template <class F>
 struct weak_upward_conversion_overload_traits<proxy<F>() const&>
     : std::type_identity<weak_proxy<F>() const&> {};
 template <class F>
-struct weak_upward_conversion_overload_traits<proxy<F>() const& noexcept>
-    : std::type_identity<weak_proxy<F>() const& noexcept> {};
+struct weak_upward_conversion_overload_traits<proxy<F>() const & noexcept>
+    : std::type_identity<weak_proxy<F>() const & noexcept> {};
 template <class F>
 struct weak_upward_conversion_overload_traits<proxy<F>() &&>
     : std::type_identity<weak_proxy<F>() &&> {};
@@ -1774,17 +1983,20 @@ template <class F>
 struct weak_upward_conversion_overload_traits<proxy<F>() && noexcept>
     : std::type_identity<weak_proxy<F>() && noexcept> {};
 template <class... Os>
-using weak_upward_conversion_conv = conv_impl<true, upward_conversion_dispatch,
-    typename weak_upward_conversion_overload_traits<Os>::type...>;
+using weak_upward_conversion_conv =
+    conv_impl<true, upward_conversion_dispatch,
+              typename weak_upward_conversion_overload_traits<Os>::type...>;
 
 template <class O, class I>
 struct weak_conv_reduction : std::type_identity<O> {};
 template <class... Cs, class I>
-    requires(I::is_direct &&
-        std::is_same_v<typename I::dispatch_type, upward_conversion_dispatch>)
+  requires(
+      I::is_direct &&
+      std::is_same_v<typename I::dispatch_type, upward_conversion_dispatch>)
 struct weak_conv_reduction<std::tuple<Cs...>, I>
-    : std::type_identity<std::tuple<Cs..., instantiated_t<
-          weak_upward_conversion_conv, typename I::overload_types>>> {};
+    : std::type_identity<
+          std::tuple<Cs..., instantiated_t<weak_upward_conversion_conv,
+                                           typename I::overload_types>>> {};
 template <class F, class... Cs>
 struct weak_facade_impl {
   using convention_types = recursive_reduction_t<
@@ -1795,37 +2007,39 @@ struct weak_facade_impl {
   static constexpr auto constraints = F::constraints;
 };
 
-}  // namespace details
+} // namespace details
 
 template <facade F>
 struct observer_facade
     : details::instantiated_t<details::observer_facade_conv_impl,
-          typename F::convention_types, F>,
+                              typename F::convention_types, F>,
       details::instantiated_t<details::observer_facade_refl_impl,
-          typename F::reflection_types> {
+                              typename F::reflection_types> {
   static constexpr proxiable_ptr_constraints constraints{
-      .max_size = sizeof(void*), .max_align = alignof(void*),
+      .max_size = sizeof(void*),
+      .max_align = alignof(void*),
       .copyability = constraint_level::trivial,
       .relocatability = constraint_level::trivial,
       .destructibility = constraint_level::trivial};
 };
 
 template <facade F>
-struct weak_facade : details::instantiated_t<
-    details::weak_facade_impl, typename F::convention_types, F> {};
+struct weak_facade : details::instantiated_t<details::weak_facade_impl,
+                                             typename F::convention_types, F> {
+};
 
 template <class Cs, class Rs, proxiable_ptr_constraints C>
 struct basic_facade_builder {
   template <class D, details::extended_overload... Os>
-      requires(sizeof...(Os) > 0u)
+    requires(sizeof...(Os) > 0u)
   using add_indirect_convention = basic_facade_builder<
       details::add_conv_t<Cs, details::conv_impl<false, D, Os...>>, Rs, C>;
   template <class D, details::extended_overload... Os>
-      requires(sizeof...(Os) > 0u)
+    requires(sizeof...(Os) > 0u)
   using add_direct_convention = basic_facade_builder<
       details::add_conv_t<Cs, details::conv_impl<true, D, Os...>>, Rs, C>;
   template <class D, details::extended_overload... Os>
-      requires(sizeof...(Os) > 0u)
+    requires(sizeof...(Os) > 0u)
   using add_convention = add_indirect_convention<D, Os...>;
   template <class R>
   using add_indirect_reflection = basic_facade_builder<
@@ -1841,41 +2055,45 @@ struct basic_facade_builder {
       details::merge_tuple_t<Rs, typename F::reflection_types>,
       details::merge_constraints(C, F::constraints)>;
   template <std::size_t PtrSize,
-      std::size_t PtrAlign = details::max_align_of(PtrSize)>
-      requires(std::has_single_bit(PtrAlign) && PtrSize % PtrAlign == 0u)
+            std::size_t PtrAlign = details::max_align_of(PtrSize)>
+    requires(std::has_single_bit(PtrAlign) && PtrSize % PtrAlign == 0u)
   using restrict_layout = basic_facade_builder<
       Cs, Rs, details::make_restricted_layout(C, PtrSize, PtrAlign)>;
   template <constraint_level CL>
-  using support_copy = basic_facade_builder<
-      Cs, Rs, details::make_copyable(C, CL)>;
+  using support_copy =
+      basic_facade_builder<Cs, Rs, details::make_copyable(C, CL)>;
   template <constraint_level CL>
-  using support_relocation = basic_facade_builder<
-      Cs, Rs, details::make_relocatable(C, CL)>;
+  using support_relocation =
+      basic_facade_builder<Cs, Rs, details::make_relocatable(C, CL)>;
   template <constraint_level CL>
-  using support_destruction = basic_facade_builder<
-      Cs, Rs, details::make_destructible(C, CL)>;
+  using support_destruction =
+      basic_facade_builder<Cs, Rs, details::make_destructible(C, CL)>;
   template <template <class> class Skill>
   using support = Skill<basic_facade_builder>;
   using build = details::facade_impl<Cs, Rs, details::normalize(C)>;
   basic_facade_builder() = delete;
 };
-using facade_builder = basic_facade_builder<std::tuple<>, std::tuple<>,
-    proxiable_ptr_constraints{
-        .max_size = details::invalid_size,
-        .max_align = details::invalid_size,
-        .copyability = details::invalid_cl,
-        .relocatability = details::invalid_cl,
-        .destructibility = details::invalid_cl}>;
+using facade_builder =
+    basic_facade_builder<std::tuple<>, std::tuple<>,
+                         proxiable_ptr_constraints{
+                             .max_size = details::invalid_size,
+                             .max_align = details::invalid_size,
+                             .copyability = details::invalid_cl,
+                             .relocatability = details::invalid_cl,
+                             .destructibility = details::invalid_cl}>;
 
 namespace details {
 
 struct view_conversion_dispatch : cast_dispatch_base<false, true> {
   template <non_proxy_arg T>
   ___PRO4_STATIC_CALL(auto, T& value) noexcept
-      requires(requires { { std::addressof(*value) } noexcept; }) {
+    requires(requires {
+      { std::addressof(*value) } noexcept;
+    })
+  {
     return observer_ptr<decltype(*value), decltype(*std::as_const(value)),
-        decltype(*std::move(value)), decltype(*std::move(std::as_const(value)))>
-        {*value};
+                        decltype(*std::move(value)),
+                        decltype(*std::move(std::as_const(value)))>{*value};
   }
 };
 template <class F>
@@ -1884,17 +2102,19 @@ using view_conversion_overload = proxy_view<F>() noexcept;
 struct weak_conversion_dispatch : cast_dispatch_base<false, true> {
   template <non_proxy_arg P>
   ___PRO4_STATIC_CALL(auto, const P& self) noexcept
-      requires(
-          requires(const typename P::weak_type& w)
-              { { w.lock() } noexcept -> std::same_as<P>; } &&
-          std::is_convertible_v<const P&, typename P::weak_type>)
-      { return typename P::weak_type{self}; }
+    requires(requires(const typename P::weak_type& w) {
+      { w.lock() } noexcept -> std::same_as<P>;
+    } && std::is_convertible_v<const P&, typename P::weak_type>)
+  {
+    return typename P::weak_type{self};
+  }
 };
 template <class F>
 using weak_conversion_overload = weak_proxy<F>() const noexcept;
 
 #if __STDC_HOSTED__ && __has_include(<format>)
-template <class CharT> struct format_overload_traits;
+template <class CharT>
+struct format_overload_traits;
 template <>
 struct format_overload_traits<char>
     : std::type_identity<std::format_context::iterator(
@@ -1916,14 +2136,15 @@ struct format_dispatch {
   // [format.formatter.spec].
   template <class T, class CharT, class OutIt>
   ___PRO4_STATIC_CALL(OutIt, const T& self, std::basic_string_view<CharT> spec,
-      std::basic_format_context<OutIt, CharT>& fc)
-      requires(
+                      std::basic_format_context<OutIt, CharT>& fc)
+    requires(
 #if __cpp_lib_format_ranges >= 202207L
-          std::formattable<T, CharT>
+        std::formattable<T, CharT>
 #else
-          std::is_default_constructible_v<std::formatter<T, CharT>>
-#endif  // __cpp_lib_format_ranges >= 202207L
-      ) {
+        std::is_default_constructible_v<std::formatter<T, CharT>>
+#endif // __cpp_lib_format_ranges >= 202207L
+    )
+  {
     std::formatter<T, CharT> impl;
     {
       std::basic_format_parse_context<CharT> pc{spec};
@@ -1932,7 +2153,7 @@ struct format_dispatch {
     return impl.format(self, fc);
   }
 };
-#endif  // __STDC_HOSTED__ && __has_include(<format>)
+#endif // __STDC_HOSTED__ && __has_include(<format>)
 
 #if __cpp_rtti >= 199711L
 struct proxy_cast_context {
@@ -1945,49 +2166,63 @@ struct proxy_cast_context {
 struct proxy_cast_dispatch;
 template <class F, bool IsDirect, class D, class O>
 struct proxy_cast_accessor_impl {
-  using _Self = add_qualifier_t<
-      adl_accessor_arg_t<F, IsDirect>, overload_traits<O>::qualifier>;
+  using _Self = add_qualifier_t<adl_accessor_arg_t<F, IsDirect>,
+                                overload_traits<O>::qualifier>;
   template <class T>
   friend T proxy_cast(_Self self) {
     static_assert(!std::is_rvalue_reference_v<T>);
-    if (!access_proxy<F>(self).has_value()) [[unlikely]]
-        { ___PRO4_THROW(bad_proxy_cast{}); }
+    if (!access_proxy<F>(self).has_value()) [[unlikely]] {
+      ___PRO4_THROW(bad_proxy_cast{});
+    }
     if constexpr (std::is_lvalue_reference_v<T>) {
       using U = std::remove_reference_t<T>;
       void* result = nullptr;
-      proxy_cast_context ctx{.type_ptr = &typeid(T), .is_ref = true,
-          .is_const = std::is_const_v<U>, .result_ptr = &result};
-      proxy_invoke<IsDirect, D, O>(
-          access_proxy<F>(std::forward<_Self>(self)), ctx);
-      if (result == nullptr) [[unlikely]] { ___PRO4_THROW(bad_proxy_cast{}); }
+      proxy_cast_context ctx{.type_ptr = &typeid(T),
+                             .is_ref = true,
+                             .is_const = std::is_const_v<U>,
+                             .result_ptr = &result};
+      proxy_invoke<IsDirect, D, O>(access_proxy<F>(std::forward<_Self>(self)),
+                                   ctx);
+      if (result == nullptr) [[unlikely]] {
+        ___PRO4_THROW(bad_proxy_cast{});
+      }
       return *static_cast<U*>(result);
     } else {
       std::optional<std::remove_const_t<T>> result;
-      proxy_cast_context ctx{.type_ptr = &typeid(T), .is_ref = false,
-          .is_const = false, .result_ptr = &result};
-      proxy_invoke<IsDirect, D, O>(
-          access_proxy<F>(std::forward<_Self>(self)), ctx);
-      if (!result.has_value()) [[unlikely]] { ___PRO4_THROW(bad_proxy_cast{}); }
+      proxy_cast_context ctx{.type_ptr = &typeid(T),
+                             .is_ref = false,
+                             .is_const = false,
+                             .result_ptr = &result};
+      proxy_invoke<IsDirect, D, O>(access_proxy<F>(std::forward<_Self>(self)),
+                                   ctx);
+      if (!result.has_value()) [[unlikely]] {
+        ___PRO4_THROW(bad_proxy_cast{});
+      }
       return std::move(*result);
     }
   }
   template <class T>
   friend T* proxy_cast(std::remove_reference_t<_Self>* self) noexcept
-      requires(std::is_lvalue_reference_v<_Self>) {
-    if (!access_proxy<F>(*self).has_value()) [[unlikely]] { return nullptr; }
+    requires(std::is_lvalue_reference_v<_Self>)
+  {
+    if (!access_proxy<F>(*self).has_value()) [[unlikely]] {
+      return nullptr;
+    }
     void* result = nullptr;
-    proxy_cast_context ctx{.type_ptr = &typeid(T), .is_ref = true,
-        .is_const = std::is_const_v<T>, .result_ptr = &result};
+    proxy_cast_context ctx{.type_ptr = &typeid(T),
+                           .is_ref = true,
+                           .is_const = std::is_const_v<T>,
+                           .result_ptr = &result};
     proxy_invoke<IsDirect, D, O>(access_proxy<F>(*self), ctx);
     return static_cast<T*>(result);
   }
 };
 
-#define ___PRO_DEF_PROXY_CAST_ACCESSOR(Q, ...) \
-    template <class F, bool IsDirect, class D> \
-    struct accessor<F, IsDirect, D, void(proxy_cast_context) Q> \
-        : proxy_cast_accessor_impl<F, IsDirect, D, \
-              void(proxy_cast_context) Q> {}
+#define ___PRO_DEF_PROXY_CAST_ACCESSOR(Q, ...)                                 \
+  template <class F, bool IsDirect, class D>                                   \
+  struct accessor<F, IsDirect, D, void(proxy_cast_context) Q>                  \
+      : proxy_cast_accessor_impl<F, IsDirect, D, void(proxy_cast_context) Q> { \
+  }
 struct proxy_cast_dispatch {
   template <non_proxy_arg T>
   ___PRO4_STATIC_CALL(void, T&& self, proxy_cast_context ctx) {
@@ -2018,31 +2253,34 @@ struct proxy_typeid_reflector {
 
   template <class F, bool IsDirect, class R>
   struct accessor {
-    friend const std::type_info& proxy_typeid(
-        const adl_accessor_arg_t<F, IsDirect>& self) noexcept {
+    friend const std::type_info&
+        proxy_typeid(const adl_accessor_arg_t<F, IsDirect>& self) noexcept {
       const proxy<F>& p = access_proxy<F>(self);
-      if (!p.has_value()) [[unlikely]] { return typeid(void); }
+      if (!p.has_value()) [[unlikely]] {
+        return typeid(void);
+      }
       const proxy_typeid_reflector& refl = proxy_reflect<IsDirect, R>(p);
       return *refl.info;
     }
-___PRO4_DEBUG(
-    accessor() noexcept { std::ignore = &_symbol_guard; }
-
-   private:
-    static inline const std::type_info& _symbol_guard(
-        const adl_accessor_arg_t<F, IsDirect>& self) noexcept
-        { return proxy_typeid(self); }
-)
+    ___PRO4_DEBUG(
+        accessor() noexcept { std::ignore = &_symbol_guard; }
+
+        private : static inline const std::type_info& _symbol_guard(
+            const adl_accessor_arg_t<F, IsDirect>&
+                self) noexcept { return proxy_typeid(self); })
   };
 
   const std::type_info* info;
 };
-#endif  // __cpp_rtti >= 199711L
+#endif // __cpp_rtti >= 199711L
 
 template <std::size_t N>
 struct sign {
-  consteval sign(const char (&str)[N])
-      { for (std::size_t i = 0; i < N; ++i) { value[i] = str[i]; } }
+  consteval sign(const char (&str)[N]) {
+    for (std::size_t i = 0; i < N; ++i) {
+      value[i] = str[i];
+    }
+  }
 
   char value[N];
 };
@@ -2058,188 +2296,187 @@ struct wildcard {
     std::unreachable();
 #else
     std::abort();
-#endif  // __cpp_lib_unreachable >= 202202L
+#endif // __cpp_lib_unreachable >= 202202L
   }
 };
 
-}  // namespace details
+} // namespace details
 
 namespace skills {
 
 #if __STDC_HOSTED__ && __has_include(<format>)
 template <class FB>
-using format = typename FB::template add_convention<
-    details::format_dispatch, details::format_overload_t<char>>;
+using format =
+    typename FB::template add_convention<details::format_dispatch,
+                                         details::format_overload_t<char>>;
 
 template <class FB>
-using wformat = typename FB::template add_convention<
-    details::format_dispatch, details::format_overload_t<wchar_t>>;
-#endif  // __STDC_HOSTED__ && __has_include(<format>)
+using wformat =
+    typename FB::template add_convention<details::format_dispatch,
+                                         details::format_overload_t<wchar_t>>;
+#endif // __STDC_HOSTED__ && __has_include(<format>)
 
 #if __cpp_rtti >= 199711L
 template <class FB>
-using indirect_rtti = typename FB
-    ::template add_indirect_convention<details::proxy_cast_dispatch,
-        void(details::proxy_cast_context) &,
-        void(details::proxy_cast_context) const&,
-        void(details::proxy_cast_context) &&>
-    ::template add_indirect_reflection<details::proxy_typeid_reflector>;
+using indirect_rtti = typename FB::template add_indirect_convention<
+    details::proxy_cast_dispatch, void(details::proxy_cast_context) &,
+    void(details::proxy_cast_context) const&,
+    void(details::proxy_cast_context) &&>::
+    template add_indirect_reflection<details::proxy_typeid_reflector>;
 
 template <class FB>
-using direct_rtti = typename FB
-    ::template add_direct_convention<details::proxy_cast_dispatch,
-        void(details::proxy_cast_context) &,
-        void(details::proxy_cast_context) const&,
-        void(details::proxy_cast_context) &&>
-    ::template add_direct_reflection<details::proxy_typeid_reflector>;
+using direct_rtti = typename FB::template add_direct_convention<
+    details::proxy_cast_dispatch, void(details::proxy_cast_context) &,
+    void(details::proxy_cast_context) const&,
+    void(details::proxy_cast_context) &&>::
+    template add_direct_reflection<details::proxy_typeid_reflector>;
 
 template <class FB>
 using rtti = indirect_rtti<FB>;
-#endif  // __cpp_rtti >= 199711L
+#endif // __cpp_rtti >= 199711L
 
 template <class FB>
-using as_view = typename FB
-    ::template add_direct_convention<details::view_conversion_dispatch,
-        facade_aware_overload_t<details::view_conversion_overload>>;
+using as_view = typename FB::template add_direct_convention<
+    details::view_conversion_dispatch,
+    facade_aware_overload_t<details::view_conversion_overload>>;
 
 template <class FB>
-using as_weak = typename FB
-    ::template add_direct_convention<details::weak_conversion_dispatch,
-        facade_aware_overload_t<details::weak_conversion_overload>>;
+using as_weak = typename FB::template add_direct_convention<
+    details::weak_conversion_dispatch,
+    facade_aware_overload_t<details::weak_conversion_overload>>;
 
-}  // namespace skills
+} // namespace skills
 
 template <details::sign Sign, bool Rhs = false>
 struct operator_dispatch;
 
-#define ___PRO_DEF_LHS_LEFT_OP_ACCESSOR(Q, SELF, ...) \
-    template <class __F, bool __IsDirect, class __D, class R> \
-    struct accessor<__F, __IsDirect, __D, R() Q> { \
-      ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__) \
-      R __VA_ARGS__() Q { return proxy_invoke<__IsDirect, __D, R() Q>(SELF); } \
-    }
-#define ___PRO_DEF_LHS_ANY_OP_ACCESSOR(Q, SELF, ...) \
-    template <class __F, bool __IsDirect, class __D, class R, class... Args> \
-    struct accessor<__F, __IsDirect, __D, R(Args...) Q> { \
-      ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__) \
-      R __VA_ARGS__(Args... args) Q { \
-        return proxy_invoke<__IsDirect, __D, R(Args...) Q>( \
-            SELF, std::forward<Args>(args)...); \
-      } \
-    }
+#define ___PRO_DEF_LHS_LEFT_OP_ACCESSOR(Q, SELF, ...)                          \
+  template <class __F, bool __IsDirect, class __D, class R>                    \
+  struct accessor<__F, __IsDirect, __D, R() Q> {                               \
+    ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                     \
+    R __VA_ARGS__() Q { return proxy_invoke<__IsDirect, __D, R() Q>(SELF); }   \
+  }
+#define ___PRO_DEF_LHS_ANY_OP_ACCESSOR(Q, SELF, ...)                           \
+  template <class __F, bool __IsDirect, class __D, class R, class... Args>     \
+  struct accessor<__F, __IsDirect, __D, R(Args...) Q> {                        \
+    ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                     \
+    R __VA_ARGS__(Args... args) Q {                                            \
+      return proxy_invoke<__IsDirect, __D, R(Args...) Q>(                      \
+          SELF, std::forward<Args>(args)...);                                  \
+    }                                                                          \
+  }
 #define ___PRO_DEF_LHS_UNARY_OP_ACCESSOR ___PRO_DEF_LHS_ANY_OP_ACCESSOR
 #define ___PRO_DEF_LHS_BINARY_OP_ACCESSOR ___PRO_DEF_LHS_ANY_OP_ACCESSOR
 #define ___PRO_DEF_LHS_ALL_OP_ACCESSOR ___PRO_DEF_LHS_ANY_OP_ACCESSOR
-#define ___PRO_LHS_LEFT_OP_DISPATCH_BODY_IMPL(...) \
-    template <details::non_proxy_arg T> \
-    ___PRO4_STATIC_CALL(decltype(auto), T&& self) \
-        ___PRO4_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self))
-#define ___PRO_LHS_UNARY_OP_DISPATCH_BODY_IMPL(...) \
-    template <details::non_proxy_arg T> \
-    ___PRO4_STATIC_CALL(decltype(auto), T&& self) \
-        ___PRO4_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self)) \
-    template <details::non_proxy_arg T> \
-    ___PRO4_STATIC_CALL(decltype(auto), T&& self, int) \
-        ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self) __VA_ARGS__)
-#define ___PRO_LHS_BINARY_OP_DISPATCH_BODY_IMPL(...) \
-    template <details::non_proxy_arg T, class Arg> \
-    ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg) \
-        ___PRO4_DIRECT_FUNC_IMPL( \
-            std::forward<T>(self) __VA_ARGS__ std::forward<Arg>(arg))
-#define ___PRO_LHS_ALL_OP_DISPATCH_BODY_IMPL(...) \
-    ___PRO_LHS_LEFT_OP_DISPATCH_BODY_IMPL(__VA_ARGS__) \
-    ___PRO_LHS_BINARY_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)
-#define ___PRO_LHS_OP_DISPATCH_IMPL(TYPE, ...) \
-    template <> \
-    struct operator_dispatch<#__VA_ARGS__, false> { \
-      ___PRO_LHS_##TYPE##_OP_DISPATCH_BODY_IMPL(__VA_ARGS__) \
-      ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE( \
-          ___PRO_DEF_LHS_##TYPE##_OP_ACCESSOR, operator __VA_ARGS__) \
-    };
-
-#define ___PRO_DEF_RHS_OP_ACCESSOR(Q, NE, SELF_ARG, SELF, ...) \
-    template <class __F, bool __IsDirect, class __D, class R, class Arg> \
-    struct accessor<__F, __IsDirect, __D, R(Arg) Q> { \
-      friend R operator __VA_ARGS__(Arg arg, SELF_ARG) NE { \
-        return proxy_invoke<__IsDirect, __D, R(Arg) Q>( \
-            SELF, std::forward<Arg>(arg)); \
-      } \
-___PRO4_DEBUG( \
+#define ___PRO_LHS_LEFT_OP_DISPATCH_BODY_IMPL(...)                             \
+  template <details::non_proxy_arg T>                                          \
+  ___PRO4_STATIC_CALL(decltype(auto), T&& self)                                \
+  ___PRO4_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self))
+#define ___PRO_LHS_UNARY_OP_DISPATCH_BODY_IMPL(...)                            \
+  template <details::non_proxy_arg T>                                          \
+  ___PRO4_STATIC_CALL(decltype(auto), T&& self)                                \
+  ___PRO4_DIRECT_FUNC_IMPL(                                                    \
+      __VA_ARGS__ std::forward<T>(self)) template <details::non_proxy_arg T>   \
+  ___PRO4_STATIC_CALL(decltype(auto), T&& self, int)                           \
+  ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self) __VA_ARGS__)
+#define ___PRO_LHS_BINARY_OP_DISPATCH_BODY_IMPL(...)                           \
+  template <details::non_proxy_arg T, class Arg>                               \
+  ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
+  ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self)                               \
+                               __VA_ARGS__ std::forward<Arg>(arg))
+#define ___PRO_LHS_ALL_OP_DISPATCH_BODY_IMPL(...)                              \
+  ___PRO_LHS_LEFT_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                           \
+  ___PRO_LHS_BINARY_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)
+#define ___PRO_LHS_OP_DISPATCH_IMPL(TYPE, ...)                                 \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, false> {                              \
+    ___PRO_LHS_##TYPE##_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                     \
+        ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(                                     \
+            ___PRO_DEF_LHS_##TYPE##_OP_ACCESSOR, operator __VA_ARGS__)         \
+  };
+
+#define ___PRO_DEF_RHS_OP_ACCESSOR(Q, NE, SELF_ARG, SELF, ...)                 \
+  template <class __F, bool __IsDirect, class __D, class R, class Arg>         \
+  struct accessor<__F, __IsDirect, __D, R(Arg) Q> {                            \
+    friend R operator __VA_ARGS__(Arg arg, SELF_ARG) NE {                      \
+      return proxy_invoke<__IsDirect, __D, R(Arg) Q>(SELF,                     \
+                                                     std::forward<Arg>(arg));  \
+    }                                                                          \
+    ___PRO4_DEBUG(                                          \
       accessor() noexcept { std::ignore = &_symbol_guard; } \
-    \
-     private: \
+                                                            \
+    private:                                                \
       static inline R _symbol_guard(Arg arg, SELF_ARG) NE { \
-        return std::forward<Arg>(arg) __VA_ARGS__ \
-            std::forward<decltype(__self)>(__self); \
-      } \
-) \
-    }
-#define ___PRO_RHS_OP_DISPATCH_IMPL(...) \
-    template <> \
-    struct operator_dispatch<#__VA_ARGS__, true> { \
-      template <details::non_proxy_arg T, class Arg> \
-      ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg) \
-          ___PRO4_DIRECT_FUNC_IMPL( \
-              std::forward<Arg>(arg) __VA_ARGS__ std::forward<T>(self)) \
-      ___PRO4_DEF_FREE_ACCESSOR_TEMPLATE( \
-          ___PRO_DEF_RHS_OP_ACCESSOR, __VA_ARGS__) \
-    };
-
-#define ___PRO_EXTENDED_BINARY_OP_DISPATCH_IMPL(...) \
-    ___PRO_LHS_OP_DISPATCH_IMPL(ALL, __VA_ARGS__) \
-    ___PRO_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
-
-#define ___PRO_BINARY_OP_DISPATCH_IMPL(...) \
-    ___PRO_LHS_OP_DISPATCH_IMPL(BINARY, __VA_ARGS__) \
-    ___PRO_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
-
-#define ___PRO_DEF_LHS_ASSIGNMENT_OP_ACCESSOR(Q, SELF, ...) \
-    template <class __F, bool __IsDirect, class __D, class R, class Arg> \
-    struct accessor<__F, __IsDirect, __D, R(Arg) Q> { \
-      ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__) \
-      decltype(auto) __VA_ARGS__(Arg arg) Q { \
-        proxy_invoke<__IsDirect, __D, R(Arg) Q>(SELF, std::forward<Arg>(arg)); \
-        if constexpr (__IsDirect) { \
-          return SELF; \
-        } else { \
-          return *SELF; \
-        } \
-      } \
-    }
-#define ___PRO_DEF_RHS_ASSIGNMENT_OP_ACCESSOR(Q, NE, SELF_ARG, SELF, ...) \
-    template <class __F, bool __IsDirect, class __D, class R, class Arg> \
-    struct accessor<__F, __IsDirect, __D, R(Arg&) Q> { \
-      friend Arg& operator __VA_ARGS__(Arg& arg, SELF_ARG) NE { \
-        proxy_invoke<__IsDirect, __D, R(Arg&) Q>(SELF, arg); \
-        return arg; \
-      } \
-___PRO4_DEBUG( \
-      accessor() noexcept { std::ignore = &_symbol_guard; } \
-    \
-     private: \
-      static inline Arg& _symbol_guard(Arg& arg, SELF_ARG) NE \
-          { return arg __VA_ARGS__ std::forward<decltype(__self)>(__self); } \
-) \
-    }
-#define ___PRO_ASSIGNMENT_OP_DISPATCH_IMPL(...) \
-    template <> \
-    struct operator_dispatch<#__VA_ARGS__, false> { \
-      template <details::non_proxy_arg T, class Arg> \
-      ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg) \
-          ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self) __VA_ARGS__ \
-              std::forward<Arg>(arg)) \
-      ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(___PRO_DEF_LHS_ASSIGNMENT_OP_ACCESSOR, \
-          operator __VA_ARGS__) \
-    }; \
-    template <> \
-    struct operator_dispatch<#__VA_ARGS__, true> { \
-      template <details::non_proxy_arg T, class Arg> \
-      ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg) \
-          ___PRO4_DIRECT_FUNC_IMPL( \
-              std::forward<Arg>(arg) __VA_ARGS__ std::forward<T>(self)) \
-      ___PRO4_DEF_FREE_ACCESSOR_TEMPLATE(___PRO_DEF_RHS_ASSIGNMENT_OP_ACCESSOR, \
-          __VA_ARGS__) \
-    };
+        return std::forward<Arg>(arg) __VA_ARGS__           \
+            std::forward<decltype(__self)>(__self);         \
+      }                                                     \
+    )                  \
+  }
+#define ___PRO_RHS_OP_DISPATCH_IMPL(...)                                       \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, true> {                               \
+    template <details::non_proxy_arg T, class Arg>                             \
+    ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                   \
+    ___PRO4_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                            \
+                                 __VA_ARGS__ std::forward<T>(self))            \
+        ___PRO4_DEF_FREE_ACCESSOR_TEMPLATE(___PRO_DEF_RHS_OP_ACCESSOR,         \
+                                           __VA_ARGS__)                        \
+  };
+
+#define ___PRO_EXTENDED_BINARY_OP_DISPATCH_IMPL(...)                           \
+  ___PRO_LHS_OP_DISPATCH_IMPL(ALL, __VA_ARGS__)                                \
+  ___PRO_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
+
+#define ___PRO_BINARY_OP_DISPATCH_IMPL(...)                                    \
+  ___PRO_LHS_OP_DISPATCH_IMPL(BINARY, __VA_ARGS__)                             \
+  ___PRO_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
+
+#define ___PRO_DEF_LHS_ASSIGNMENT_OP_ACCESSOR(Q, SELF, ...)                    \
+  template <class __F, bool __IsDirect, class __D, class R, class Arg>         \
+  struct accessor<__F, __IsDirect, __D, R(Arg) Q> {                            \
+    ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                     \
+    decltype(auto) __VA_ARGS__(Arg arg) Q {                                    \
+      proxy_invoke<__IsDirect, __D, R(Arg) Q>(SELF, std::forward<Arg>(arg));   \
+      if constexpr (__IsDirect) {                                              \
+        return SELF;                                                           \
+      } else {                                                                 \
+        return *SELF;                                                          \
+      }                                                                        \
+    }                                                                          \
+  }
+#define ___PRO_DEF_RHS_ASSIGNMENT_OP_ACCESSOR(Q, NE, SELF_ARG, SELF, ...)          \
+  template <class __F, bool __IsDirect, class __D, class R, class Arg>             \
+  struct accessor<__F, __IsDirect, __D, R(Arg&) Q> {                               \
+    friend Arg& operator __VA_ARGS__(Arg & arg, SELF_ARG) NE {                     \
+      proxy_invoke<__IsDirect, __D, R(Arg&) Q>(SELF, arg);                         \
+      return arg;                                                                  \
+    }                                                                              \
+    ___PRO4_DEBUG(                                                                 \
+        accessor() noexcept { std::ignore = &_symbol_guard; }                      \
+                                                                                   \
+        private : static inline Arg& _symbol_guard(Arg& arg, SELF_ARG)             \
+            NE { return arg __VA_ARGS__ std::forward<decltype(__self)>(            \
+                     __self); }) \
+  }
+#define ___PRO_ASSIGNMENT_OP_DISPATCH_IMPL(...)                                \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, false> {                              \
+    template <details::non_proxy_arg T, class Arg>                             \
+    ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                   \
+    ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self)                             \
+                                 __VA_ARGS__ std::forward<Arg>(arg))           \
+        ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(                                     \
+            ___PRO_DEF_LHS_ASSIGNMENT_OP_ACCESSOR, operator __VA_ARGS__)       \
+  };                                                                           \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, true> {                               \
+    template <details::non_proxy_arg T, class Arg>                             \
+    ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                   \
+    ___PRO4_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                            \
+                                 __VA_ARGS__ std::forward<T>(self))            \
+        ___PRO4_DEF_FREE_ACCESSOR_TEMPLATE(                                    \
+            ___PRO_DEF_RHS_ASSIGNMENT_OP_ACCESSOR, __VA_ARGS__)                \
+  };
 
 ___PRO_EXTENDED_BINARY_OP_DISPATCH_IMPL(+)
 ___PRO_EXTENDED_BINARY_OP_DISPATCH_IMPL(-)
@@ -2273,30 +2510,30 @@ ___PRO_ASSIGNMENT_OP_DISPATCH_IMPL(|=)
 ___PRO_ASSIGNMENT_OP_DISPATCH_IMPL(^=)
 ___PRO_ASSIGNMENT_OP_DISPATCH_IMPL(<<=)
 ___PRO_ASSIGNMENT_OP_DISPATCH_IMPL(>>=)
-___PRO_BINARY_OP_DISPATCH_IMPL(,)
+___PRO_BINARY_OP_DISPATCH_IMPL(, )
 ___PRO_BINARY_OP_DISPATCH_IMPL(->*)
 
 template <>
 struct operator_dispatch<"()", false> {
   template <details::non_proxy_arg T, class... Args>
   ___PRO4_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
-      ___PRO4_DIRECT_FUNC_IMPL(
-          std::forward<T>(self)(std::forward<Args>(args)...))
-  ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(___PRO_DEF_LHS_ANY_OP_ACCESSOR, operator())
+  ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self)(std::forward<Args>(args)...))
+      ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(
+          ___PRO_DEF_LHS_ANY_OP_ACCESSOR, operator())
 };
 template <>
 struct operator_dispatch<"[]", false> {
 #if __cpp_multidimensional_subscript >= 202110L
   template <details::non_proxy_arg T, class... Args>
   ___PRO4_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
-      ___PRO4_DIRECT_FUNC_IMPL(
-          std::forward<T>(self)[std::forward<Args>(args)...])
+  ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Args>(args)...])
 #else
   template <details::non_proxy_arg T, class Arg>
   ___PRO4_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)
-      ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Arg>(arg)])
-#endif  // __cpp_multidimensional_subscript >= 202110L
-  ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(___PRO_DEF_LHS_ANY_OP_ACCESSOR, operator[])
+  ___PRO4_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Arg>(arg)])
+#endif // __cpp_multidimensional_subscript >= 202110L
+      ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(
+          ___PRO_DEF_LHS_ANY_OP_ACCESSOR, operator[])
 };
 
 #undef ___PRO_ASSIGNMENT_OP_DISPATCH_IMPL
@@ -2320,36 +2557,43 @@ struct operator_dispatch<"[]", false> {
 struct implicit_conversion_dispatch
     : details::cast_dispatch_base<false, false> {
   template <details::non_proxy_arg T>
-  ___PRO4_STATIC_CALL(T&&, T&& self) noexcept { return std::forward<T>(self); }
+  ___PRO4_STATIC_CALL(T&&, T&& self) noexcept {
+    return std::forward<T>(self);
+  }
 };
 struct explicit_conversion_dispatch : details::cast_dispatch_base<true, false> {
   template <details::non_proxy_arg T>
-  ___PRO4_STATIC_CALL(auto, T&& self) noexcept
-      { return details::explicit_conversion_adapter<T>{std::forward<T>(self)}; }
+  ___PRO4_STATIC_CALL(auto, T&& self) noexcept {
+    return details::explicit_conversion_adapter<T>{std::forward<T>(self)};
+  }
 };
 using conversion_dispatch = explicit_conversion_dispatch;
 
 class not_implemented : public std::exception {
- public:
-  char const* what() const noexcept override { return "pro::v4::not_implemented"; }
+public:
+  char const* what() const noexcept override {
+    return "pro::v4::not_implemented";
+  }
 };
 
 template <class D>
 struct weak_dispatch : D {
   using D::operator();
   template <class... Args>
-  [[noreturn]] ___PRO4_STATIC_CALL(details::wildcard, Args&&...)
-      { ___PRO4_THROW(not_implemented{}); }
+  [[noreturn]] ___PRO4_STATIC_CALL(details::wildcard, Args&&...) {
+    ___PRO4_THROW(not_implemented{});
+  }
 };
 
-}  // namespace pro::v4
+} // namespace pro::inline v4
 
 #if __STDC_HOSTED__ && __has_include(<format>)
 namespace std {
 
 template <pro::v4::facade F, class CharT>
-    requires(pro::v4::details::facade_traits<F>::template is_invocable<false,
-        pro::v4::details::format_dispatch, pro::v4::details::format_overload_t<CharT>>)
+  requires(pro::v4::details::facade_traits<F>::template is_invocable<
+           false, pro::v4::details::format_dispatch,
+           pro::v4::details::format_overload_t<CharT>>)
 struct formatter<pro::v4::proxy_indirect_accessor<F>, CharT> {
   constexpr auto parse(basic_format_parse_context<CharT>& pc) {
     for (auto it = pc.begin(); it != pc.end(); ++it) {
@@ -2363,21 +2607,23 @@ struct formatter<pro::v4::proxy_indirect_accessor<F>, CharT> {
 
   template <class OutIt>
   OutIt format(const pro::v4::proxy_indirect_accessor<F>& ia,
-      basic_format_context<OutIt, CharT>& fc) const {
+               basic_format_context<OutIt, CharT>& fc) const {
     auto& p = pro::v4::access_proxy<F>(ia);
-    if (!p.has_value()) [[unlikely]]
-        { ___PRO4_THROW(format_error{"null proxy"}); }
+    if (!p.has_value()) [[unlikely]] {
+      ___PRO4_THROW(format_error{"null proxy"});
+    }
     return pro::v4::proxy_invoke<false, pro::v4::details::format_dispatch,
-        pro::v4::details::format_overload_t<CharT>>(p, spec_, fc);
+                                 pro::v4::details::format_overload_t<CharT>>(
+        p, spec_, fc);
   }
 
- private:
+private:
   basic_string_view<CharT> spec_;
 };
 
-}  // namespace std
-#endif  // __STDC_HOSTED__ && __has_include(<format>)
+} // namespace std
+#endif // __STDC_HOSTED__ && __has_include(<format>)
 
 #undef ___PRO_NO_UNIQUE_ADDRESS_ATTRIBUTE
 
-#endif  // _MSFT_PROXY4_
+#endif // _MSFT_PROXY4_
diff --git a/include/proxy/v4/proxy.ixx b/include/proxy/v4/proxy.ixx
index 6d5b9309..0b5cb9a1 100644
--- a/include/proxy/v4/proxy.ixx
+++ b/include/proxy/v4/proxy.ixx
@@ -6,39 +6,37 @@ export module proxy.v4;
 
 export namespace pro::inline v4 {
 
-using v4::constraint_level;
-using v4::proxiable_ptr_constraints;
-using v4::facade_aware_overload_t;
-using v4::facade;
-using v4::proxy_indirect_accessor;
-using v4::proxy;
-using v4::proxiable;
-using v4::proxy_indirect_accessor;
-using v4::proxy_invoke;
-using v4::proxy_reflect;
 using v4::access_proxy;
-using v4::observer_facade;
-using v4::proxy_view;
-using v4::weak_proxy;
-using v4::inplace_proxiable_target;
-using v4::proxiable_target;
-using v4::make_proxy_inplace;
-using v4::make_proxy_view;
 using v4::allocate_proxy;
-using v4::make_proxy;
 using v4::allocate_proxy_shared;
-using v4::make_proxy_shared;
 using v4::bad_proxy_cast;
-using v4::observer_facade;
-using v4::weak_facade;
 using v4::basic_facade_builder;
-using v4::operator_dispatch;
-using v4::implicit_conversion_dispatch;
-using v4::explicit_conversion_dispatch;
+using v4::constraint_level;
 using v4::conversion_dispatch;
+using v4::explicit_conversion_dispatch;
+using v4::facade;
+using v4::facade_aware_overload_t;
+using v4::facade_builder;
+using v4::implicit_conversion_dispatch;
+using v4::inplace_proxiable_target;
+using v4::make_proxy;
+using v4::make_proxy_inplace;
+using v4::make_proxy_shared;
+using v4::make_proxy_view;
 using v4::not_implemented;
+using v4::observer_facade;
+using v4::operator_dispatch;
+using v4::proxiable;
+using v4::proxiable_ptr_constraints;
+using v4::proxiable_target;
+using v4::proxy;
+using v4::proxy_indirect_accessor;
+using v4::proxy_invoke;
+using v4::proxy_reflect;
+using v4::proxy_view;
 using v4::weak_dispatch;
-using v4::facade_builder;
+using v4::weak_facade;
+using v4::weak_proxy;
 
 namespace skills {
 using skills::direct_rtti;
@@ -53,7 +51,7 @@ using details::adl_accessor_arg_t;
 using details::non_proxy_arg;
 } // namespace details
 
-} // namespace pro::v4
+} // namespace pro::inline v4
 
 export namespace std {
 using std::formatter;
diff --git a/include/proxy/v4/proxy_fmt.h b/include/proxy/v4/proxy_fmt.h
index 7a8103ab..406db8ea 100644
--- a/include/proxy/v4/proxy_fmt.h
+++ b/include/proxy/v4/proxy_fmt.h
@@ -9,22 +9,23 @@
 
 #ifndef __msft_lib_proxy4
 #error Please ensure that proxy.h is included before proxy_fmt.h.
-#endif  // __msft_lib_proxy4
+#endif // __msft_lib_proxy4
 
 #if FMT_VERSION >= 60100
 static_assert(fmt::is_char<wchar_t>::value,
-    "The {fmt} library must have wchar_t support enabled. "
-    "Include fmt/xchar.h before including proxy_fmt.h.");
+              "The {fmt} library must have wchar_t support enabled. "
+              "Include fmt/xchar.h before including proxy_fmt.h.");
 #else
 #error Please ensure that the appropriate {fmt} headers (version 6.1.0 or \
 later) are included before proxy_fmt.h.
-#endif  // FMT_VERSION >= 60100
+#endif // FMT_VERSION >= 60100
 
 namespace pro::inline v4 {
 
 namespace details {
 
-template <class CharT> struct fmt_format_overload_traits;
+template <class CharT>
+struct fmt_format_overload_traits;
 template <>
 struct fmt_format_overload_traits<char>
     : std::type_identity<fmt::format_context::iterator(
@@ -39,8 +40,9 @@ using fmt_format_overload_t = typename fmt_format_overload_traits<CharT>::type;
 struct fmt_format_dispatch {
   template <class T, class CharT, class FormatContext>
   ___PRO4_STATIC_CALL(auto, const T& self, std::basic_string_view<CharT> spec,
-      FormatContext& fc)
-      requires(std::is_default_constructible_v<fmt::formatter<T, CharT>>) {
+                      FormatContext& fc)
+    requires(std::is_default_constructible_v<fmt::formatter<T, CharT>>)
+  {
     fmt::formatter<T, CharT> impl;
     {
       fmt::basic_format_parse_context<CharT> pc{spec};
@@ -50,28 +52,29 @@ struct fmt_format_dispatch {
   }
 };
 
-}  // namespace details
+} // namespace details
 
 namespace skills {
 
 template <class FB>
-using fmt_format = typename FB::template add_convention<
-    details::fmt_format_dispatch, details::fmt_format_overload_t<char>>;
+using fmt_format =
+    typename FB::template add_convention<details::fmt_format_dispatch,
+                                         details::fmt_format_overload_t<char>>;
 
 template <class FB>
 using fmt_wformat = typename FB::template add_convention<
     details::fmt_format_dispatch, details::fmt_format_overload_t<wchar_t>>;
 
-}  // namespace skills
+} // namespace skills
 
-}  // namespace pro::v4
+} // namespace pro::inline v4
 
 namespace fmt {
 
 template <pro::v4::facade F, class CharT>
-    requires(pro::v4::details::facade_traits<F>::template is_invocable<
-        false, pro::v4::details::fmt_format_dispatch,
-        pro::v4::details::fmt_format_overload_t<CharT>>)
+  requires(pro::v4::details::facade_traits<F>::template is_invocable<
+           false, pro::v4::details::fmt_format_dispatch,
+           pro::v4::details::fmt_format_overload_t<CharT>>)
 struct formatter<pro::v4::proxy_indirect_accessor<F>, CharT> {
   constexpr auto parse(basic_format_parse_context<CharT>& pc) {
     for (auto it = pc.begin(); it != pc.end(); ++it) {
@@ -84,19 +87,21 @@ struct formatter<pro::v4::proxy_indirect_accessor<F>, CharT> {
   }
 
   template <class FormatContext>
-  auto format(const pro::v4::proxy_indirect_accessor<F>& ia, FormatContext& fc)
-      const -> typename FormatContext::iterator {
+  auto format(const pro::v4::proxy_indirect_accessor<F>& ia,
+              FormatContext& fc) const -> typename FormatContext::iterator {
     auto& p = pro::v4::access_proxy<F>(ia);
-    if (!p.has_value()) [[unlikely]]
-        { ___PRO4_THROW(format_error{"null proxy"}); }
-    return pro::v4::proxy_invoke<false, pro::v4::details::fmt_format_dispatch,
+    if (!p.has_value()) [[unlikely]] {
+      ___PRO4_THROW(format_error{"null proxy"});
+    }
+    return pro::v4::proxy_invoke<
+        false, pro::v4::details::fmt_format_dispatch,
         pro::v4::details::fmt_format_overload_t<CharT>>(p, spec_, fc);
   }
 
- private:
+private:
   std::basic_string_view<CharT> spec_;
 };
 
-}  // namespace fmt
+} // namespace fmt
 
-#endif  // _MSFT_PROXY4_FMT_
+#endif // _MSFT_PROXY4_FMT_
diff --git a/include/proxy/v4/proxy_macros.h b/include/proxy/v4/proxy_macros.h
index db44f273..5852d5c7 100644
--- a/include/proxy/v4/proxy_macros.h
+++ b/include/proxy/v4/proxy_macros.h
@@ -8,218 +8,244 @@
 #define ___PRO4_STATIC_CALL(__R, ...) static __R operator()(__VA_ARGS__)
 #else
 #define ___PRO4_STATIC_CALL(__R, ...) __R operator()(__VA_ARGS__) const
-#endif  // __cpp_static_call_operator >= 202207L
+#endif // __cpp_static_call_operator >= 202207L
 
 #ifdef _MSC_VER
 #define ___PRO4_ENFORCE_EBO __declspec(empty_bases)
 #else
 #define ___PRO4_ENFORCE_EBO
-#endif  // _MSC_VER
+#endif // _MSC_VER
 
 #ifdef NDEBUG
 #define ___PRO4_DEBUG(...)
 #else
 #define ___PRO4_DEBUG(...) __VA_ARGS__
-#endif  // NDEBUG
+#endif // NDEBUG
 
 #define __msft_lib_proxy4 202503L
 
 ////////
 
-#define ___PRO4_DIRECT_FUNC_IMPL(...) \
-    noexcept(noexcept(__VA_ARGS__)) requires(requires { __VA_ARGS__; }) \
-    { return __VA_ARGS__; }
-
-#define ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(__MACRO, ...) \
-    template <class __F, bool __IsDirect, class __D, class... __Os> \
-    struct ___PRO4_ENFORCE_EBO accessor { accessor() = delete; }; \
-    template <class __F, bool __IsDirect, class __D, class... __Os> \
-        requires(sizeof...(__Os) > 1u && (::std::is_constructible_v< \
-            accessor<__F, __IsDirect, __D, __Os>> && ...)) \
-    struct accessor<__F, __IsDirect, __D, __Os...> \
-        : accessor<__F, __IsDirect, __D, __Os>... \
-        { using accessor<__F, __IsDirect, __D, __Os>::__VA_ARGS__...; }; \
-    __MACRO(, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__); \
-    __MACRO(noexcept, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__); \
-    __MACRO(&, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__); \
-    __MACRO(& noexcept, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__); \
-    __MACRO(&&, ::pro::v4::access_proxy<__F>(::std::move(*this)), __VA_ARGS__); \
-    __MACRO(&& noexcept, ::pro::v4::access_proxy<__F>(::std::move(*this)), \
-        __VA_ARGS__); \
-    __MACRO(const, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__); \
-    __MACRO(const noexcept, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__); \
-    __MACRO(const&, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__); \
-    __MACRO(const& noexcept, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__); \
-    __MACRO(const&&, ::pro::v4::access_proxy<__F>(::std::move(*this)), \
-        __VA_ARGS__); \
-    __MACRO(const&& noexcept, ::pro::v4::access_proxy<__F>(::std::move(*this)), \
-        __VA_ARGS__);
+#define ___PRO4_DIRECT_FUNC_IMPL(...)                                          \
+  noexcept(noexcept(__VA_ARGS__))                                              \
+    requires(requires { __VA_ARGS__; })                                        \
+  {                                                                            \
+    return __VA_ARGS__;                                                        \
+  }
+
+#define ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(__MACRO, ...)                        \
+  template <class __F, bool __IsDirect, class __D, class... __Os>              \
+  struct ___PRO4_ENFORCE_EBO accessor {                                        \
+    accessor() = delete;                                                       \
+  };                                                                           \
+  template <class __F, bool __IsDirect, class __D, class... __Os>              \
+    requires(                                                                  \
+        sizeof...(__Os) > 1u &&                                                \
+        (::std::is_constructible_v<accessor<__F, __IsDirect, __D, __Os>> &&    \
+         ...))                                                                 \
+  struct accessor<__F, __IsDirect, __D, __Os...>                               \
+      : accessor<__F, __IsDirect, __D, __Os>... {                              \
+    using accessor<__F, __IsDirect, __D, __Os>::__VA_ARGS__...;                \
+  };                                                                           \
+  __MACRO(, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__);                 \
+  __MACRO(noexcept, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__);         \
+  __MACRO(&, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__);                \
+  __MACRO(& noexcept, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__);       \
+  __MACRO(&&, ::pro::v4::access_proxy<__F>(::std::move(*this)), __VA_ARGS__);  \
+  __MACRO(&& noexcept, ::pro::v4::access_proxy<__F>(::std::move(*this)),       \
+          __VA_ARGS__);                                                        \
+  __MACRO(const, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__);            \
+  __MACRO(const noexcept, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__);   \
+  __MACRO(const&, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__);           \
+  __MACRO(const& noexcept, ::pro::v4::access_proxy<__F>(*this), __VA_ARGS__);  \
+  __MACRO(const&&, ::pro::v4::access_proxy<__F>(::std::move(*this)),           \
+          __VA_ARGS__);                                                        \
+  __MACRO(const&& noexcept, ::pro::v4::access_proxy<__F>(::std::move(*this)),  \
+          __VA_ARGS__);
 
 #define ___PRO4_ADL_ARG ::pro::v4::details::adl_accessor_arg_t<__F, __IsDirect>
-#define ___PRO4_DEF_FREE_ACCESSOR_TEMPLATE(__MACRO, ...) \
-    template <class __F, bool __IsDirect, class __D, class... __Os> \
-    struct ___PRO4_ENFORCE_EBO accessor { accessor() = delete; }; \
-    template <class __F, bool __IsDirect, class __D, class... __Os> \
-        requires(sizeof...(__Os) > 1u && (::std::is_constructible_v< \
-            accessor<__F, __IsDirect, __D, __Os>> && ...)) \
-    struct accessor<__F, __IsDirect, __D, __Os...> \
-        : accessor<__F, __IsDirect, __D, __Os>... {}; \
-    __MACRO(,, ___PRO4_ADL_ARG& __self, ::pro::v4::access_proxy<__F>(__self), \
-        __VA_ARGS__); \
-    __MACRO(noexcept, noexcept, ___PRO4_ADL_ARG& __self, \
-        ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__); \
-    __MACRO(&,, ___PRO4_ADL_ARG& __self, ::pro::v4::access_proxy<__F>(__self), \
-        __VA_ARGS__); \
-    __MACRO(& noexcept, noexcept, ___PRO4_ADL_ARG& __self, \
-        ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__); \
-    __MACRO(&&,, ___PRO4_ADL_ARG&& __self, ::pro::v4::access_proxy<__F>( \
-        ::std::forward<decltype(__self)>(__self)), __VA_ARGS__); \
-    __MACRO(&& noexcept, noexcept, ___PRO4_ADL_ARG&& __self, \
-        ::pro::v4::access_proxy<__F>(::std::forward<decltype(__self)>(__self)), \
-        __VA_ARGS__); \
-    __MACRO(const,, const ___PRO4_ADL_ARG& __self, \
-        ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__); \
-    __MACRO(const noexcept, noexcept, const ___PRO4_ADL_ARG& __self, \
-        ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__); \
-    __MACRO(const&,, const ___PRO4_ADL_ARG& __self, \
-        ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__); \
-    __MACRO(const& noexcept, noexcept, const ___PRO4_ADL_ARG& __self, \
-        ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__); \
-    __MACRO(const&&,, const ___PRO4_ADL_ARG&& __self, ::pro::v4::access_proxy<__F>( \
-        ::std::forward<decltype(__self)>(__self)), __VA_ARGS__); \
-    __MACRO(const&& noexcept, noexcept, const ___PRO4_ADL_ARG&& __self, \
-        ::pro::v4::access_proxy<__F>(::std::forward<decltype(__self)>(__self)), \
-        __VA_ARGS__);
-
-#define ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(...) \
-    ___PRO4_DEBUG( \
-        accessor() noexcept { ::std::ignore = &accessor::__VA_ARGS__; })
+#define ___PRO4_DEF_FREE_ACCESSOR_TEMPLATE(__MACRO, ...)                       \
+  template <class __F, bool __IsDirect, class __D, class... __Os>              \
+  struct ___PRO4_ENFORCE_EBO accessor {                                        \
+    accessor() = delete;                                                       \
+  };                                                                           \
+  template <class __F, bool __IsDirect, class __D, class... __Os>              \
+    requires(                                                                  \
+        sizeof...(__Os) > 1u &&                                                \
+        (::std::is_constructible_v<accessor<__F, __IsDirect, __D, __Os>> &&    \
+         ...))                                                                 \
+  struct accessor<__F, __IsDirect, __D, __Os...>                               \
+      : accessor<__F, __IsDirect, __D, __Os>... {};                            \
+  __MACRO(, , ___PRO4_ADL_ARG& __self, ::pro::v4::access_proxy<__F>(__self),   \
+          __VA_ARGS__);                                                        \
+  __MACRO(noexcept, noexcept, ___PRO4_ADL_ARG& __self,                         \
+          ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__);                  \
+  __MACRO(&, , ___PRO4_ADL_ARG& __self, ::pro::v4::access_proxy<__F>(__self),  \
+          __VA_ARGS__);                                                        \
+  __MACRO(& noexcept, noexcept, ___PRO4_ADL_ARG& __self,                       \
+          ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__);                  \
+  __MACRO(&&, , ___PRO4_ADL_ARG&& __self,                                      \
+          ::pro::v4::access_proxy<__F>(                                        \
+              ::std::forward<decltype(__self)>(__self)),                       \
+          __VA_ARGS__);                                                        \
+  __MACRO(&& noexcept, noexcept, ___PRO4_ADL_ARG&& __self,                     \
+          ::pro::v4::access_proxy<__F>(                                        \
+              ::std::forward<decltype(__self)>(__self)),                       \
+          __VA_ARGS__);                                                        \
+  __MACRO(const, , const ___PRO4_ADL_ARG& __self,                              \
+          ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__);                  \
+  __MACRO(const noexcept, noexcept, const ___PRO4_ADL_ARG& __self,             \
+          ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__);                  \
+  __MACRO(const&, , const ___PRO4_ADL_ARG& __self,                             \
+          ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__);                  \
+  __MACRO(const& noexcept, noexcept, const ___PRO4_ADL_ARG& __self,            \
+          ::pro::v4::access_proxy<__F>(__self), __VA_ARGS__);                  \
+  __MACRO(                                                                     \
+      const&&, , const ___PRO4_ADL_ARG&& __self,                               \
+      ::pro::v4::access_proxy<__F>(::std::forward<decltype(__self)>(__self)),  \
+      __VA_ARGS__);                                                            \
+  __MACRO(                                                                     \
+      const&& noexcept, noexcept, const ___PRO4_ADL_ARG&& __self,              \
+      ::pro::v4::access_proxy<__F>(::std::forward<decltype(__self)>(__self)),  \
+      __VA_ARGS__);
+
+#define ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(...)                         \
+  ___PRO4_DEBUG(accessor() noexcept { ::std::ignore = &accessor::__VA_ARGS__; })
 
 #define ___PRO4_EXPAND_IMPL(__X) __X
 
-#define ___PRO4_EXPAND_MACRO_IMPL(__MACRO, __1, __2, __3, __NAME, ...) \
-    __MACRO##_##__NAME
-#define ___PRO4_EXPAND_MACRO(__MACRO, ...) \
-    ___PRO4_EXPAND_IMPL(___PRO4_EXPAND_MACRO_IMPL( \
-        __MACRO, __VA_ARGS__, 3, 2)(__VA_ARGS__))
+#define ___PRO4_EXPAND_MACRO_IMPL(__MACRO, __1, __2, __3, __NAME, ...)         \
+  __MACRO##_##__NAME
+#define ___PRO4_EXPAND_MACRO(__MACRO, ...)                                     \
+  ___PRO4_EXPAND_IMPL(                                                         \
+      ___PRO4_EXPAND_MACRO_IMPL(__MACRO, __VA_ARGS__, 3, 2)(__VA_ARGS__))
 
 ////////
 
-#define ___PRO4_DEF_MEM_ACCESSOR(__Q, __SELF, ...) \
-    template <class __F, bool __IsDirect, class __D, class __R, \
-        class... __Args> \
-    struct accessor<__F, __IsDirect, __D, __R(__Args...) __Q> { \
-      ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__) \
-      __R __VA_ARGS__(__Args... __args) __Q { \
-        return ::pro::v4::proxy_invoke<__IsDirect, __D, __R(__Args...) __Q>( \
-            __SELF, ::std::forward<__Args>(__args)...); \
-      } \
-    }
-#define ___PRO4_DEF_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FNAME, __TTYPE) \
-    struct __NAME { \
-      template <__TTYPE __T, class... __Args> \
-      ___PRO4_STATIC_CALL(decltype(auto), __T&& __self, __Args&&... __args) \
-          ___PRO4_DIRECT_FUNC_IMPL(::std::forward<__T>(__self) \
-              .__FUNC(::std::forward<__Args>(__args)...)) \
-      ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(___PRO4_DEF_MEM_ACCESSOR, __FNAME) \
-    }
-#define ___PRO4_DEF_MEM_DISPATCH_2(__NAME, __FUNC) \
-    ___PRO4_DEF_MEM_DISPATCH_IMPL( \
-        __NAME, __FUNC, __FUNC, ::pro::v4::details::non_proxy_arg)
-#define ___PRO4_DEF_MEM_DISPATCH_3(__NAME, __FUNC, __FNAME) \
-    ___PRO4_DEF_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FNAME, class)
-#define PRO4_DEF_MEM_DISPATCH(__NAME, ...) \
-    ___PRO4_EXPAND_MACRO(___PRO4_DEF_MEM_DISPATCH, __NAME, __VA_ARGS__)
-
-#define ___PRO4_DEF_FREE_ACCESSOR(__Q, __NE, __SELF_ARG, __SELF, ...) \
-    template <class __F, bool __IsDirect, class __D, class __R, \
-        class... __Args> \
-    struct accessor<__F, __IsDirect, __D, __R(__Args...) __Q> { \
-      friend __R __VA_ARGS__(__SELF_ARG, __Args... __args) __NE { \
-        return ::pro::v4::proxy_invoke<__IsDirect, __D, __R(__Args...) __Q>( \
-            __SELF, ::std::forward<__Args>(__args)...); \
-      } \
-___PRO4_DEBUG( \
-      accessor() noexcept { ::std::ignore = &_symbol_guard; } \
-    \
-     private: \
+#define ___PRO4_DEF_MEM_ACCESSOR(__Q, __SELF, ...)                             \
+  template <class __F, bool __IsDirect, class __D, class __R, class... __Args> \
+  struct accessor<__F, __IsDirect, __D, __R(__Args...) __Q> {                  \
+    ___PRO4_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                     \
+    __R __VA_ARGS__(__Args... __args) __Q {                                    \
+      return ::pro::v4::proxy_invoke<__IsDirect, __D, __R(__Args...) __Q>(     \
+          __SELF, ::std::forward<__Args>(__args)...);                          \
+    }                                                                          \
+  }
+#define ___PRO4_DEF_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FNAME, __TTYPE)        \
+  struct __NAME {                                                              \
+    template <__TTYPE __T, class... __Args>                                    \
+    ___PRO4_STATIC_CALL(decltype(auto), __T&& __self, __Args&&... __args)      \
+    ___PRO4_DIRECT_FUNC_IMPL(                                                  \
+        ::std::forward<__T>(__self).__FUNC(::std::forward<__Args>(__args)...)) \
+        ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(___PRO4_DEF_MEM_ACCESSOR, __FNAME)   \
+  }
+#define ___PRO4_DEF_MEM_DISPATCH_2(__NAME, __FUNC)                             \
+  ___PRO4_DEF_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FUNC,                        \
+                                ::pro::v4::details::non_proxy_arg)
+#define ___PRO4_DEF_MEM_DISPATCH_3(__NAME, __FUNC, __FNAME)                    \
+  ___PRO4_DEF_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FNAME, class)
+#define PRO4_DEF_MEM_DISPATCH(__NAME, ...)                                     \
+  ___PRO4_EXPAND_MACRO(___PRO4_DEF_MEM_DISPATCH, __NAME, __VA_ARGS__)
+
+#define ___PRO4_DEF_FREE_ACCESSOR(__Q, __NE, __SELF_ARG, __SELF, ...)          \
+  template <class __F, bool __IsDirect, class __D, class __R, class... __Args> \
+  struct accessor<__F, __IsDirect, __D, __R(__Args...) __Q> {                  \
+    friend __R __VA_ARGS__(__SELF_ARG, __Args... __args) __NE {                \
+      return ::pro::v4::proxy_invoke<__IsDirect, __D, __R(__Args...) __Q>(     \
+          __SELF, ::std::forward<__Args>(__args)...);                          \
+    }                                                                          \
+    ___PRO4_DEBUG(                                                         \
+      accessor() noexcept { ::std::ignore = &_symbol_guard; }              \
+                                                                           \
+    private:                                                               \
       static inline __R _symbol_guard(__SELF_ARG, __Args... __args) __NE { \
-        return __VA_ARGS__(::std::forward<decltype(__self)>(__self), \
-            ::std::forward<__Args>(__args)...); \
-      } \
-) \
-    }
-#define ___PRO4_DEF_FREE_DISPATCH_IMPL(__NAME, __FUNC, __FNAME, __TTYPE) \
-    struct __NAME { \
-      template <__TTYPE __T, class... __Args> \
-      ___PRO4_STATIC_CALL(decltype(auto), __T&& __self, __Args&&... __args) \
-          ___PRO4_DIRECT_FUNC_IMPL(__FUNC(::std::forward<__T>(__self), \
-              ::std::forward<__Args>(__args)...)) \
-      ___PRO4_DEF_FREE_ACCESSOR_TEMPLATE(___PRO4_DEF_FREE_ACCESSOR, __FNAME) \
-    }
-#define ___PRO4_DEF_FREE_DISPATCH_2(__NAME, __FUNC) \
-    ___PRO4_DEF_FREE_DISPATCH_IMPL( \
-        __NAME, __FUNC, __FUNC, ::pro::v4::details::non_proxy_arg)
-#define ___PRO4_DEF_FREE_DISPATCH_3(__NAME, __FUNC, __FNAME) \
-    ___PRO4_DEF_FREE_DISPATCH_IMPL(__NAME, __FUNC, __FNAME, class)
-#define PRO4_DEF_FREE_DISPATCH(__NAME, ...) \
-    ___PRO4_EXPAND_MACRO(___PRO4_DEF_FREE_DISPATCH, __NAME, __VA_ARGS__)
-
-#define ___PRO4_DEF_FREE_AS_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FNAME) \
-    struct __NAME { \
-      template <class __T, class... __Args> \
-      ___PRO4_STATIC_CALL(decltype(auto), __T&& __self, __Args&&... __args) \
-          ___PRO4_DIRECT_FUNC_IMPL(__FUNC(::std::forward<__T>(__self), \
-              ::std::forward<__Args>(__args)...)) \
-      ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(___PRO4_DEF_MEM_ACCESSOR, __FNAME) \
-    }
-#define ___PRO4_DEF_FREE_AS_MEM_DISPATCH_2(__NAME, __FUNC) \
-    ___PRO4_DEF_FREE_AS_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FUNC)
-#define ___PRO4_DEF_FREE_AS_MEM_DISPATCH_3(__NAME, __FUNC, __FNAME) \
-    ___PRO4_DEF_FREE_AS_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FNAME)
-#define PRO4_DEF_FREE_AS_MEM_DISPATCH(__NAME, ...) \
-    ___PRO4_EXPAND_MACRO(___PRO4_DEF_FREE_AS_MEM_DISPATCH, __NAME, __VA_ARGS__)
+        return __VA_ARGS__(::std::forward<decltype(__self)>(__self),       \
+            ::std::forward<__Args>(__args)...);                            \
+      }                                                                    \
+    )   \
+  }
+#define ___PRO4_DEF_FREE_DISPATCH_IMPL(__NAME, __FUNC, __FNAME, __TTYPE)       \
+  struct __NAME {                                                              \
+    template <__TTYPE __T, class... __Args>                                    \
+    ___PRO4_STATIC_CALL(decltype(auto), __T&& __self, __Args&&... __args)      \
+    ___PRO4_DIRECT_FUNC_IMPL(__FUNC(::std::forward<__T>(__self),               \
+                                    ::std::forward<__Args>(__args)...))        \
+        ___PRO4_DEF_FREE_ACCESSOR_TEMPLATE(___PRO4_DEF_FREE_ACCESSOR, __FNAME) \
+  }
+#define ___PRO4_DEF_FREE_DISPATCH_2(__NAME, __FUNC)                            \
+  ___PRO4_DEF_FREE_DISPATCH_IMPL(__NAME, __FUNC, __FUNC,                       \
+                                 ::pro::v4::details::non_proxy_arg)
+#define ___PRO4_DEF_FREE_DISPATCH_3(__NAME, __FUNC, __FNAME)                   \
+  ___PRO4_DEF_FREE_DISPATCH_IMPL(__NAME, __FUNC, __FNAME, class)
+#define PRO4_DEF_FREE_DISPATCH(__NAME, ...)                                    \
+  ___PRO4_EXPAND_MACRO(___PRO4_DEF_FREE_DISPATCH, __NAME, __VA_ARGS__)
+
+#define ___PRO4_DEF_FREE_AS_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FNAME)         \
+  struct __NAME {                                                              \
+    template <class __T, class... __Args>                                      \
+    ___PRO4_STATIC_CALL(decltype(auto), __T&& __self, __Args&&... __args)      \
+    ___PRO4_DIRECT_FUNC_IMPL(__FUNC(::std::forward<__T>(__self),               \
+                                    ::std::forward<__Args>(__args)...))        \
+        ___PRO4_DEF_MEM_ACCESSOR_TEMPLATE(___PRO4_DEF_MEM_ACCESSOR, __FNAME)   \
+  }
+#define ___PRO4_DEF_FREE_AS_MEM_DISPATCH_2(__NAME, __FUNC)                     \
+  ___PRO4_DEF_FREE_AS_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FUNC)
+#define ___PRO4_DEF_FREE_AS_MEM_DISPATCH_3(__NAME, __FUNC, __FNAME)            \
+  ___PRO4_DEF_FREE_AS_MEM_DISPATCH_IMPL(__NAME, __FUNC, __FNAME)
+#define PRO4_DEF_FREE_AS_MEM_DISPATCH(__NAME, ...)                             \
+  ___PRO4_EXPAND_MACRO(___PRO4_DEF_FREE_AS_MEM_DISPATCH, __NAME, __VA_ARGS__)
 
 // Version-less macro aliases
 
-#define ___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(__NAME, __VERSION_QUALIFIED_NAME) \
-    static_assert(false, "The use of macro `" #__NAME "` is ambiguous. \
+#define ___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(__NAME,                      \
+                                                  __VERSION_QUALIFIED_NAME)    \
+  static_assert(false, "The use of macro `" #__NAME "` is ambiguous. \
 Are multiple different versions of Proxy library included at the same time?\n\
 Note: To resolve this error: \n\
 - Either make sure that only one version of Proxy library is included within this file.\n\
-- Or use the `" #__VERSION_QUALIFIED_NAME "` macro (note the `4` suffix) to explicitly \
+- Or use the `" #__VERSION_QUALIFIED_NAME                                      \
+                       "` macro (note the `4` suffix) to explicitly \
 stick to a specific major version of the Proxy library.")
 
 #ifdef __msft_lib_proxy
 #undef __msft_lib_proxy
-#define __msft_lib_proxy \
-[] { ___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(__msft_lib_proxy, __msft_lib_proxy4); return 0L; } ()
+#define __msft_lib_proxy                                                       \
+  [] {                                                                         \
+    ___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(__msft_lib_proxy,                \
+                                              __msft_lib_proxy4);              \
+    return 0L;                                                                 \
+  }()
 #else
 #define __msft_lib_proxy __msft_lib_proxy4
-#endif
+#endif // __msft_lib_proxy
 
 #ifdef PRO_DEF_MEM_DISPATCH
 #undef PRO_DEF_MEM_DISPATCH
-#define PRO_DEF_MEM_DISPATCH(...) \
-___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(PRO_DEF_MEM_DISPATCH, PRO4_DEF_MEM_DISPATCH)
+#define PRO_DEF_MEM_DISPATCH(...)                                              \
+  ___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(PRO_DEF_MEM_DISPATCH,              \
+                                            PRO4_DEF_MEM_DISPATCH)
 #else
 #define PRO_DEF_MEM_DISPATCH(name, ...) PRO4_DEF_MEM_DISPATCH(name, __VA_ARGS__)
-#endif
+#endif // PRO_DEF_MEM_DISPATCH
 
 #ifdef PRO_DEF_FREE_DISPATCH
 #undef PRO_DEF_FREE_DISPATCH
-#define PRO_DEF_FREE_DISPATCH(...) \
-___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(PRO_DEF_FREE_DISPATCH, PRO4_DEF_FREE_DISPATCH)
+#define PRO_DEF_FREE_DISPATCH(...)                                             \
+  ___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(PRO_DEF_FREE_DISPATCH,             \
+                                            PRO4_DEF_FREE_DISPATCH)
 #else
-#define PRO_DEF_FREE_DISPATCH(name, ...) PRO4_DEF_FREE_DISPATCH(name, __VA_ARGS__)
-#endif
+#define PRO_DEF_FREE_DISPATCH(name, ...)                                       \
+  PRO4_DEF_FREE_DISPATCH(name, __VA_ARGS__)
+#endif // PRO_DEF_FREE_DISPATCH
 
 #ifdef PRO_DEF_FREE_AS_MEM_DISPATCH
 #undef PRO_DEF_FREE_AS_MEM_DISPATCH
-#define PRO_DEF_FREE_AS_MEM_DISPATCH(...) \
-___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(PRO_DEF_FREE_AS_MEM_DISPATCH, PRO4_DEF_FREE_AS_MEM_DISPATCH)
+#define PRO_DEF_FREE_AS_MEM_DISPATCH(...)                                      \
+  ___PRO4_AMBIGUOUS_MACRO_DIAGNOSTIC_ASSERT(PRO_DEF_FREE_AS_MEM_DISPATCH,      \
+                                            PRO4_DEF_FREE_AS_MEM_DISPATCH)
 #else
-#define PRO_DEF_FREE_AS_MEM_DISPATCH(name, ...) PRO4_DEF_FREE_AS_MEM_DISPATCH(name, __VA_ARGS__)
-#endif
+#define PRO_DEF_FREE_AS_MEM_DISPATCH(name, ...)                                \
+  PRO4_DEF_FREE_AS_MEM_DISPATCH(name, __VA_ARGS__)
+#endif // PRO_DEF_FREE_AS_MEM_DISPATCH
 
 #endif // _MSFT_PROXY4_MACROS_