From 32cf6bb504a49b0e948a88462ab5bfdc6598a353 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@outlook.com>
Date: Wed, 10 Jun 2026 22:17:45 +0800
Subject: [PATCH 1/2] Split proxy into multiple header files

---
 CMakeLists.txt                            |   19 +-
 include/proxy/v4/detail/core.h            | 1541 ++++++++++++
 include/proxy/v4/detail/dispatch.h        |  305 +++
 include/proxy/v4/detail/facade_creation.h |  195 ++
 include/proxy/v4/detail/proxy_creation.h  |  433 ++++
 include/proxy/v4/detail/skills.h          |  310 +++
 include/proxy/v4/proxy.h                  | 2751 +--------------------
 include/proxy/v4/proxy_fmt.h              |   16 +-
 meson.build                               |   27 +-
 tests/BUILD.bazel                         |    2 +-
 tests/CMakeLists.txt                      |    2 +-
 tests/meson.build                         |    2 +-
 tests/proxy_creation_tests.cpp            |  248 +-
 tests/proxy_detail_tests.cpp              |   30 +
 tests/proxy_details_tests.cpp             |   31 -
 tests/proxy_dispatch_tests.cpp            |   22 +-
 tests/proxy_fmt_format_no_wchar_tests.cpp |    8 +-
 tests/proxy_fmt_format_tests.cpp          |   10 +-
 tests/proxy_format_tests.cpp              |   10 +-
 tests/proxy_integration_tests.cpp         |   24 +-
 tests/proxy_invocation_tests.cpp          |   93 +-
 tests/proxy_lifetime_tests.cpp            |  180 +-
 tests/proxy_reflection_tests.cpp          |   14 +-
 tests/proxy_regression_tests.cpp          |   12 +-
 tests/proxy_rtti_tests.cpp                |   58 +-
 tests/proxy_traits_tests.cpp              |   30 +-
 tests/proxy_view_tests.cpp                |   39 +-
 27 files changed, 3213 insertions(+), 3199 deletions(-)
 create mode 100644 include/proxy/v4/detail/core.h
 create mode 100644 include/proxy/v4/detail/dispatch.h
 create mode 100644 include/proxy/v4/detail/facade_creation.h
 create mode 100644 include/proxy/v4/detail/proxy_creation.h
 create mode 100644 include/proxy/v4/detail/skills.h
 create mode 100644 tests/proxy_detail_tests.cpp
 delete mode 100644 tests/proxy_details_tests.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index defa6e5..c29405d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,20 +24,15 @@ if(PROJECT_IS_TOP_LEVEL)
   )
 endif()
 
-target_sources(
-  msft_proxy4
+file(GLOB_RECURSE proxy_public_headers CONFIGURE_DEPENDS
+     "${CMAKE_CURRENT_SOURCE_DIR}/include/proxy/*.h"
+     "${CMAKE_CURRENT_SOURCE_DIR}/include/proxy/*.ixx")
+target_sources(msft_proxy4
   INTERFACE
     FILE_SET public_headers
-      TYPE HEADERS
-      BASE_DIRS include
-      FILES
-        include/proxy/proxy.h
-        include/proxy/proxy_macros.h
-        include/proxy/proxy_fmt.h
-        include/proxy/v4/proxy.ixx
-        include/proxy/v4/proxy.h
-        include/proxy/v4/proxy_macros.h
-        include/proxy/v4/proxy_fmt.h
+    TYPE HEADERS
+    BASE_DIRS include
+    FILES ${proxy_public_headers}
 )
 
 target_compile_features(msft_proxy4 INTERFACE cxx_std_20)
diff --git a/include/proxy/v4/detail/core.h b/include/proxy/v4/detail/core.h
new file mode 100644
index 0000000..a1a0f00
--- /dev/null
+++ b/include/proxy/v4/detail/core.h
@@ -0,0 +1,1541 @@
+// Copyright (c) 2022-2026 Microsoft Corporation.
+// Copyright (c) 2026-Present Next Gen C++ Foundation.
+// Licensed under the MIT License.
+
+#ifndef MSFT_PROXY_V4_DETAIL_CORE_H_
+#define MSFT_PROXY_V4_DETAIL_CORE_H_
+
+#include <bit>
+#include <cassert>
+#include <cstddef>
+#include <cstdlib>
+#include <initializer_list>
+#include <memory>
+#include <new>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <version>
+
+#include "../proxy_macros.h"
+
+#if __has_cpp_attribute(msvc::no_unique_address)
+#define PRO4D_NO_UNIQUE_ADDRESS_ATTRIBUTE msvc::no_unique_address
+#elif __has_cpp_attribute(no_unique_address)
+#define PRO4D_NO_UNIQUE_ADDRESS_ATTRIBUTE no_unique_address
+#else
+#error Proxy requires C++20 attribute no_unique_address.
+#endif // __has_cpp_attribute(msvc::no_unique_address)
+
+#if __cpp_lib_unreachable >= 202202L
+#define PRO4D_UNREACHABLE() std::unreachable()
+#else
+#define PRO4D_UNREACHABLE() std::abort()
+#endif // __cpp_lib_unreachable >= 202202L
+
+namespace pro::inline v4 {
+
+namespace detail {
+
+template <class F>
+struct basic_facade_traits;
+
+} // namespace detail
+
+enum class constraint_level { none, nontrivial, nothrow, trivial };
+
+template <template <class> class O>
+struct facade_aware_overload_t {
+  facade_aware_overload_t() = delete;
+};
+
+template <class F>
+concept facade = detail::basic_facade_traits<F>::applicable;
+
+template <facade F>
+class proxy_indirect_accessor;
+template <facade F>
+class PRO4D_ENFORCE_EBO proxy;
+
+template <class T>
+struct is_bitwise_trivially_relocatable
+    : std::bool_constant<std::is_trivially_move_constructible_v<T> &&
+                         std::is_trivially_destructible_v<T>> {};
+template <class T>
+constexpr bool is_bitwise_trivially_relocatable_v =
+    is_bitwise_trivially_relocatable<T>::value;
+
+namespace detail {
+
+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> {};
+template <template <class, class> class R, class O, class I, class... Is>
+struct recursive_reduction<R, O, I, Is...>
+    : recursive_reduction<R, R<O, I>, Is...> {};
+template <template <class, class> class R, class O, class... Is>
+using recursive_reduction_t = typename recursive_reduction<R, O, Is...>::type;
+
+template <template <class...> class R, class... Args>
+struct reduction_traits {
+  template <class O, class I>
+  using type = typename R<Args..., O, I>::type;
+};
+
+template <class O, class I>
+struct composition_reduction : std::type_identity<O> {};
+template <template <class...> class T, class... Os, class I>
+  requires(!std::is_void_v<I>)
+struct composition_reduction<T<Os...>, I> : std::type_identity<T<Os..., I>> {};
+template <template <class...> class T, class... Os, class... Is>
+struct composition_reduction<T<Os...>, T<Is...>>
+    : std::type_identity<T<Os..., Is...>> {};
+template <class T, class... Us>
+using composite_t = recursive_reduction_t<
+    reduction_traits<composition_reduction>::template type, T, Us...>;
+
+template <class Expr>
+consteval bool is_consteval(Expr) {
+  return requires { typename std::bool_constant<(Expr{}(), false)>; };
+}
+template <class T, class U>
+concept static_prop = std::is_same_v<T, const U&>;
+
+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 } -> static_prop<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> && ...);
+      }(std::make_index_sequence<std::tuple_size_v<T>>{});
+    }
+  }
+  return false;
+}
+
+template <template <class...> class T, class TL, class Is, class... Args>
+struct specialization_type_traits_impl;
+template <template <class...> class T, class TL, std::size_t... Is,
+          class... Args>
+struct specialization_type_traits_impl<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>
+struct specialization_type_traits
+    : specialization_type_traits_impl<
+          T, TL, std::make_index_sequence<std::tuple_size_v<TL>>, Args...> {};
+template <template <class...> class T, class... Ts, class... Args>
+struct specialization_type_traits<T, std::tuple<Ts...>, Args...>
+    : std::type_identity<T<Args..., Ts...>> {};
+template <template <class...> class T, class TL, class... Args>
+using specialization_t =
+    typename specialization_type_traits<T, TL, Args...>::type;
+
+enum class qualifier_type { lv, const_lv, rv, const_rv };
+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>
+struct add_qualifier_traits<T, qualifier_type::const_lv>
+    : std::type_identity<const T&> {};
+template <class T>
+struct add_qualifier_traits<T, qualifier_type::rv> : std::type_identity<T&&> {};
+template <class T>
+struct add_qualifier_traits<T, qualifier_type::const_rv>
+    : std::type_identity<const T&&> {};
+template <class T, qualifier_type Q>
+using add_qualifier_t = typename add_qualifier_traits<T, Q>::type;
+template <class T, qualifier_type Q>
+using add_qualifier_ptr_t = std::remove_reference_t<add_qualifier_t<T, Q>>*;
+
+template <class T, constraint_level CL>
+struct copyability_traits : inapplicable_traits {};
+template <class T>
+struct copyability_traits<T, constraint_level::none> : applicable_traits {};
+template <class T>
+  requires(std::is_copy_constructible_v<T>)
+struct copyability_traits<T, constraint_level::nontrivial> : applicable_traits {
+};
+template <class T>
+  requires(std::is_nothrow_copy_constructible_v<T>)
+struct copyability_traits<T, constraint_level::nothrow> : applicable_traits {};
+template <class T>
+  requires(std::is_trivially_copy_constructible_v<T>)
+struct copyability_traits<T, constraint_level::trivial> : applicable_traits {};
+
+template <class T, constraint_level CL>
+struct relocatability_traits : inapplicable_traits {};
+template <class T>
+struct relocatability_traits<T, constraint_level::none> : applicable_traits {};
+template <class T>
+  requires((std::is_move_constructible_v<T> && std::is_destructible_v<T>) ||
+           is_bitwise_trivially_relocatable_v<T>)
+struct relocatability_traits<T, constraint_level::nontrivial>
+    : applicable_traits {};
+template <class T>
+  requires((std::is_nothrow_move_constructible_v<T> &&
+            std::is_nothrow_destructible_v<T>) ||
+           is_bitwise_trivially_relocatable_v<T>)
+struct relocatability_traits<T, constraint_level::nothrow> : applicable_traits {
+};
+template <class T>
+  requires(is_bitwise_trivially_relocatable_v<T>)
+struct relocatability_traits<T, constraint_level::trivial> : applicable_traits {
+};
+
+template <class T, constraint_level CL>
+struct destructibility_traits : inapplicable_traits {};
+template <class T>
+struct destructibility_traits<T, constraint_level::none> : applicable_traits {};
+template <class T>
+  requires(std::is_destructible_v<T>)
+struct destructibility_traits<T, constraint_level::nontrivial>
+    : applicable_traits {};
+template <class T>
+  requires(std::is_nothrow_destructible_v<T>)
+struct destructibility_traits<T, constraint_level::nothrow>
+    : applicable_traits {};
+template <class T>
+  requires(std::is_trivially_destructible_v<T>)
+struct destructibility_traits<T, constraint_level::trivial>
+    : applicable_traits {};
+
+template <class F, bool IsDirect, qualifier_type Q>
+using proxy_accessor = add_qualifier_t<
+    std::conditional_t<IsDirect, proxy<F>, proxy_indirect_accessor<F>>, Q>;
+template <class F, qualifier_type Q>
+add_qualifier_t<proxy<F>, Q>
+    as_proxy(add_qualifier_t<proxy_indirect_accessor<F>, Q> p);
+
+struct proxy_helper {
+  template <class P, class F>
+  struct resetting_guard {
+    explicit resetting_guard(proxy<F>& p) noexcept : p_(p) {}
+    explicit resetting_guard(proxy_indirect_accessor<F>& p) noexcept
+        : p_(as_proxy<F, qualifier_type::lv>(p)) {}
+    ~resetting_guard() noexcept(std::is_nothrow_destructible_v<P>) {
+      std::destroy_at(std::addressof(get_ptr<P, F, qualifier_type::lv>(p_)));
+      p_.meta_.reset();
+    }
+
+  private:
+    proxy<F>& p_;
+  };
+
+  template <class M, class F>
+  static const M& get_meta(const proxy<F>& p) noexcept {
+    assert(p.has_value());
+    return static_cast<const M&>(*p.meta_.operator->());
+  }
+  template <class M, class F>
+  static const M& get_meta(const proxy_indirect_accessor<F>& p) noexcept {
+    return get_meta<M>(as_proxy<F, qualifier_type::const_lv>(p));
+  }
+  template <class P, class F, qualifier_type Q>
+  static add_qualifier_t<P, Q> get_ptr(add_qualifier_t<proxy<F>, Q> p) {
+    return static_cast<add_qualifier_t<P, Q>>(
+        *std::launder(reinterpret_cast<add_qualifier_ptr_t<P, Q>>(p.ptr_)));
+  }
+  template <class P, class F1, class F2>
+  static void trivially_relocate(proxy<F1>& from, proxy<F2>& to) noexcept {
+    std::uninitialized_copy_n(from.ptr_, sizeof(P), to.ptr_);
+    to.meta_ = decltype(proxy<F2>::meta_){std::in_place_type<P>};
+    from.meta_.reset();
+  }
+};
+
+template <class P, bool IsDirect, qualifier_type Q>
+struct operand_traits : add_qualifier_traits<P, Q> {};
+template <class P, qualifier_type Q>
+struct operand_traits<P, false, Q>
+    : std::type_identity<decltype(*std::declval<add_qualifier_t<P, Q>>())> {};
+template <class P, bool IsDirect, qualifier_type Q>
+using operand_t = typename operand_traits<P, IsDirect, Q>::type;
+template <class P, bool IsDirect, class D, qualifier_type Q, bool NE, class R,
+          class... Args>
+concept invocable_dispatch =
+    (IsDirect || (requires { *std::declval<add_qualifier_t<P, Q>>(); } &&
+                  (!NE || noexcept(*std::declval<add_qualifier_t<P, Q>>())))) &&
+    ((NE && std::is_nothrow_invocable_r_v<R, D, operand_t<P, IsDirect, Q>,
+                                          Args...>) ||
+     (!NE &&
+      std::is_invocable_r_v<R, D, operand_t<P, IsDirect, Q>, Args...>)) &&
+    (Q != qualifier_type::rv || (NE && std::is_nothrow_destructible_v<P>) ||
+     (!NE && std::is_destructible_v<P>));
+
+struct internal_dispatch {};
+
+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 P, bool IsDirect, class D>
+  static constexpr bool applicable_ptr =
+      invocable_dispatch<P, IsDirect, D, Q, NE, R, Args...>;
+};
+template <class R, class... Args>
+struct overload_traits<R(Args...)>
+    : overload_traits_impl<qualifier_type::lv, false, R, Args...> {};
+template <class R, class... Args>
+struct overload_traits<R(Args...) noexcept>
+    : overload_traits_impl<qualifier_type::lv, true, R, Args...> {};
+template <class R, class... Args>
+struct overload_traits<R(Args...) &>
+    : overload_traits_impl<qualifier_type::lv, false, R, Args...> {};
+template <class R, class... Args>
+struct overload_traits<R(Args...) & noexcept>
+    : overload_traits_impl<qualifier_type::lv, true, R, Args...> {};
+template <class R, class... Args>
+struct overload_traits<R(Args...) &&>
+    : overload_traits_impl<qualifier_type::rv, false, R, Args...> {};
+template <class R, class... Args>
+struct overload_traits<R(Args...) && noexcept>
+    : overload_traits_impl<qualifier_type::rv, true, R, Args...> {};
+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>
+    : 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_lv, false, R, Args...> {};
+template <class R, class... Args>
+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>
+    : overload_traits_impl<qualifier_type::const_rv, true, R, Args...> {};
+template <class O>
+using ret_t = typename overload_traits<O>::return_type;
+
+template <class 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>;
+};
+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;
+template <class P, class F, bool IsDirect, class D, class O>
+consteval void diagnose_proxiable_required_convention_not_implemented() {
+  static_assert(overload_traits<O>::applicable &&
+                    overload_traits<O>::template applicable_ptr<P, IsDirect, D>,
+                "not proxiable due to a required convention not implemented");
+}
+
+template <class ProP, class D, class O>
+struct conv_meta;
+#define PRO4D_DEF_CONV_META(oq, pq, ne, ...)                                   \
+  template <class ProP, class D, class R, class... Args>                       \
+  struct conv_meta<ProP, D, R(Args...) oq ne> {                                \
+    conv_meta() = default;                                                     \
+    template <class P>                                                         \
+    constexpr explicit conv_meta(std::in_place_type_t<P>)                      \
+        : invoke([](ProP pq self, Args... args) ne -> R {                      \
+            return reinterpret_invoke<P, D, R>(static_cast<ProP pq>(self),     \
+                                               std::forward<Args>(args)...);   \
+          }) {}                                                                \
+                                                                               \
+    R (*invoke)(ProP pq, Args...) ne;                                          \
+  }
+PRO4D_DEF_OVERLOAD_SPECIALIZATIONS(PRO4D_DEF_CONV_META)
+#undef PRO4D_DEF_CONV_META
+
+template <class... Ms>
+struct PRO4D_ENFORCE_EBO composite_meta : Ms... {
+  composite_meta() = default;
+  template <class P>
+  constexpr explicit composite_meta(std::in_place_type_t<P>)
+      : Ms(std::in_place_type<P>)... {}
+};
+
+template <class T>
+consteval bool is_is_direct_well_formed() {
+  if constexpr (requires {
+                  { T::is_direct } -> static_prop<bool>;
+                }) {
+    if constexpr (is_consteval([] { return T::is_direct; })) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template <class C, class... Os>
+struct basic_conv_traits_impl : inapplicable_traits {};
+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() } noexcept;
+    typename C::overload_types;
+  } && is_is_direct_well_formed<C>() &&
+           is_tuple_like_well_formed<typename C::overload_types>())
+struct basic_conv_traits<C>
+    : specialization_t<basic_conv_traits_impl, typename C::overload_types, C> {
+};
+
+template <class T>
+struct a11y_traits_impl
+    : std::conditional<std::is_nothrow_default_constructible_v<T> &&
+                           std::is_trivially_copyable_v<T> &&
+                           !std::is_final_v<T>,
+                       T, void> {};
+template <class SFINAE, class T, class... Args>
+struct a11y_traits : std::type_identity<void> {};
+template <class T, class... Args>
+struct a11y_traits<std::void_t<typename T::template accessor<Args...>>, T,
+                   Args...>
+    : a11y_traits_impl<typename T::template accessor<Args...>> {};
+template <class T, class... Args>
+using accessor_t = typename a11y_traits<void, T, Args...>::type;
+
+template <class C, class F, class... Os>
+struct conv_traits_impl {
+  static_assert((overload_traits<substituted_overload_t<Os, F>>::applicable &&
+                 ...));
+  using meta = composite_meta<conv_meta<
+      std::conditional_t<C::is_direct, proxy<F>, proxy_indirect_accessor<F>>,
+      typename C::dispatch_type, substituted_overload_t<Os, F>>...>;
+  template <class T>
+  using accessor =
+      accessor_t<typename C::dispatch_type, T, typename C::dispatch_type,
+                 substituted_overload_t<Os, F>...>;
+
+  template <class P>
+  static consteval void diagnose_proxiable() {
+    ((diagnose_proxiable_required_convention_not_implemented<
+         P, F, C::is_direct, typename C::dispatch_type,
+         substituted_overload_t<Os, F>>()),
+     ...);
+  }
+
+  template <class P>
+  static constexpr bool applicable_ptr =
+      (overload_traits<substituted_overload_t<Os, F>>::template applicable_ptr<
+           P, C::is_direct, typename C::dispatch_type> &&
+       ...);
+};
+template <class C, class F>
+struct conv_traits
+    : specialization_t<conv_traits_impl, typename C::overload_types, C, F> {};
+
+template <bool IsDirect, class R>
+struct reflection_meta {
+  reflection_meta() = default;
+  template <class P>
+    requires(IsDirect)
+  constexpr explicit reflection_meta(std::in_place_type_t<P>)
+      : reflector(std::in_place_type<P>) {}
+  template <class P>
+    requires(!IsDirect)
+  constexpr explicit reflection_meta(std::in_place_type_t<P>)
+      : reflector(
+            std::in_place_type<typename std::pointer_traits<P>::element_type>) {
+  }
+
+  [[PRO4D_NO_UNIQUE_ADDRESS_ATTRIBUTE]]
+  R reflector;
+};
+
+template <class T, bool IsDirect, class R>
+consteval bool is_reflector_well_formed() {
+  if constexpr (IsDirect) {
+    if constexpr (std::is_constructible_v<R, std::in_place_type_t<T>>) {
+      if constexpr (is_consteval([] { return R(std::in_place_type<T>); })) {
+        return true;
+      }
+    }
+  } else {
+    return is_reflector_well_formed<
+        typename std::pointer_traits<T>::element_type, true, R>();
+  }
+  return false;
+}
+template <class P, class F, bool IsDirect, class R>
+consteval void diagnose_proxiable_required_reflection_not_implemented() {
+  static_assert(is_reflector_well_formed<P, IsDirect, R>(),
+                "not proxiable due to a required reflection not implemented");
+}
+
+struct copy_dispatch {
+  template <class T, class F>
+  PRO4D_STATIC_CALL(void, const T& self, proxy<F>& rhs) noexcept(
+      std::is_nothrow_copy_constructible_v<T>) {
+    std::construct_at(std::addressof(rhs), self);
+  }
+};
+struct relocate_dispatch : internal_dispatch {
+  template <class P, class F>
+  PRO4D_STATIC_CALL(void, std::in_place_type_t<P>, proxy<F>&& self,
+                    proxy<F>& rhs) noexcept {
+    proxy_helper::trivially_relocate<P>(self, rhs);
+  }
+  template <class T, class F>
+  PRO4D_STATIC_CALL(void, T&& self, proxy<F>& rhs) noexcept(
+      relocatability_traits<T, constraint_level::nothrow>::applicable) {
+    std::construct_at(std::addressof(rhs), std::forward<T>(self));
+  }
+};
+struct destroy_dispatch {
+  template <class T>
+  PRO4D_STATIC_CALL(void, T& self) noexcept(std::is_nothrow_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> {};
+template <class F, class D, class ONE, class OE>
+struct lifetime_meta_traits<F, D, ONE, OE, constraint_level::nothrow>
+    : std::type_identity<conv_meta<proxy<F>, D, ONE>> {};
+template <class F, class D, class ONE, class OE>
+struct lifetime_meta_traits<F, D, ONE, OE, constraint_level::nontrivial>
+    : std::type_identity<conv_meta<proxy<F>, D, OE>> {};
+template <class F, class D, class ONE, class OE, constraint_level C>
+using lifetime_meta_t = typename lifetime_meta_traits<F, D, ONE, OE, C>::type;
+
+template <class... As>
+struct PRO4D_ENFORCE_EBO composite_accessor : As... {};
+
+template <class C, class F, bool IsDirect>
+struct conv_accessor_traits : std::type_identity<void> {};
+template <class C, class F>
+  requires(!C::is_direct)
+struct conv_accessor_traits<C, F, false>
+    : std::type_identity<typename conv_traits<C, F>::template accessor<
+          proxy_indirect_accessor<F>>> {};
+template <class C, class F>
+  requires(C::is_direct)
+struct conv_accessor_traits<C, F, true>
+    : std::type_identity<
+          typename conv_traits<C, F>::template accessor<proxy<F>>> {};
+template <class C, class F, bool IsDirect>
+using conv_accessor_t = typename conv_accessor_traits<C, F, IsDirect>::type;
+
+template <class R, class F, bool IsDirect>
+struct refl_accessor_traits : std::type_identity<void> {};
+template <class R, class F>
+  requires(!R::is_direct)
+struct refl_accessor_traits<R, F, false>
+    : std::type_identity<
+          accessor_t<typename R::reflector_type, proxy_indirect_accessor<F>,
+                     typename R::reflector_type>> {};
+template <class R, class F>
+  requires(R::is_direct)
+struct refl_accessor_traits<R, F, true>
+    : std::type_identity<accessor_t<typename R::reflector_type, proxy<F>,
+                                    typename R::reflector_type>> {};
+template <class R, class F, bool IsDirect>
+using refl_accessor_t = typename refl_accessor_traits<R, F, IsDirect>::type;
+
+template <class T>
+concept pointer_like = (std::is_pointer_v<T> ||
+    requires { typename T::element_type; } || requires(T val) { *val; }) &&
+    requires { typename std::pointer_traits<T>::element_type; };
+
+template <class T, template <class...> class TT>
+struct specialization_traits : inapplicable_traits {};
+template <template <class...> class TT, class... Args>
+struct specialization_traits<TT<Args...>, TT> : applicable_traits {};
+template <class T, template <class...> class TT>
+concept specialization_of = specialization_traits<T, TT>::applicable;
+
+template <class P, class F, std::size_t ActualSize, std::size_t MaxSize>
+consteval void diagnose_proxiable_size_too_large() {
+  static_assert(ActualSize <= MaxSize, "not proxiable due to size too large");
+}
+template <class P, class F, std::size_t ActualAlign, std::size_t MaxAlign>
+consteval void diagnose_proxiable_align_too_large() {
+  static_assert(ActualAlign <= MaxAlign,
+                "not proxiable due to alignment too large");
+}
+template <class P, class F, constraint_level RequiredCopyability>
+consteval void diagnose_proxiable_insufficient_copyability() {
+  static_assert(copyability_traits<P, RequiredCopyability>::applicable,
+                "not proxiable due to insufficient copyability");
+}
+template <class P, class F, constraint_level RequiredRelocatability>
+consteval void diagnose_proxiable_insufficient_relocatability() {
+  static_assert(relocatability_traits<P, RequiredRelocatability>::applicable,
+                "not proxiable due to insufficient relocatability");
+}
+template <class P, class F, constraint_level RequiredDestructibility>
+consteval void diagnose_proxiable_insufficient_destructibility() {
+  static_assert(destructibility_traits<P, RequiredDestructibility>::applicable,
+                "not proxiable due to insufficient destructibility");
+}
+
+consteval bool is_layout_well_formed(std::size_t size, std::size_t align) {
+  return size > 0u && std::has_single_bit(align) && size % align == 0u;
+}
+consteval bool is_cl_well_formed(constraint_level cl) {
+  return cl >= constraint_level::none && cl <= constraint_level::trivial;
+}
+template <class F>
+consteval bool is_facade_constraints_well_formed() {
+  if constexpr (requires {
+                  { F::max_size } -> static_prop<std::size_t>;
+                  { F::max_align } -> static_prop<std::size_t>;
+                  { F::copyability } -> static_prop<constraint_level>;
+                  { F::relocatability } -> static_prop<constraint_level>;
+                  { F::destructibility } -> static_prop<constraint_level>;
+                }) {
+    if constexpr (is_consteval([] {
+                    return std::tuple{F::max_size, F::max_align, F::copyability,
+                                      F::relocatability, F::destructibility};
+                  })) {
+      return is_layout_well_formed(F::max_size, F::max_align) &&
+             is_cl_well_formed(F::copyability) &&
+             is_cl_well_formed(F::relocatability) &&
+             is_cl_well_formed(F::destructibility);
+    }
+  }
+  return false;
+}
+template <class... Cs>
+struct basic_facade_conv_traits_impl : inapplicable_traits {};
+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((requires {
+             typename Rs::reflector_type;
+           } && is_is_direct_well_formed<Rs>()) && ...)
+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>() &&
+           specialization_t<basic_facade_conv_traits_impl,
+                            typename F::convention_types>::applicable &&
+           is_tuple_like_well_formed<typename F::reflection_types>() &&
+           specialization_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 {
+  using conv_meta =
+      composite_t<composite_meta<>, typename conv_traits<Cs, F>::meta...>;
+  using conv_indirect_accessor =
+      composite_t<composite_accessor<>, conv_accessor_t<Cs, F, false>...>;
+  using conv_direct_accessor =
+      composite_t<composite_accessor<>, conv_accessor_t<Cs, F, true>...>;
+
+  template <class P>
+  static consteval void diagnose_proxiable_conv() {
+    (conv_traits<Cs, F>::template diagnose_proxiable<P>(), ...);
+  }
+
+  template <class P>
+  static constexpr bool conv_applicable_ptr =
+      (conv_traits<Cs, F>::template applicable_ptr<P> && ...);
+};
+template <class F, class... Rs>
+struct facade_refl_traits_impl {
+  using refl_meta = composite_meta<
+      reflection_meta<Rs::is_direct, typename Rs::reflector_type>...>;
+  using refl_indirect_accessor =
+      composite_t<composite_accessor<>, refl_accessor_t<Rs, F, false>...>;
+  using refl_direct_accessor =
+      composite_t<composite_accessor<>, refl_accessor_t<Rs, F, true>...>;
+
+  template <class P>
+  static consteval void diagnose_proxiable_refl() {
+    (diagnose_proxiable_required_reflection_not_implemented<
+         P, F, Rs::is_direct, typename Rs::reflector_type>(),
+     ...);
+  }
+
+  template <class P>
+  static constexpr bool refl_applicable_ptr =
+      (is_reflector_well_formed<P, Rs::is_direct,
+                                typename Rs::reflector_type>() &&
+       ...);
+};
+template <class F>
+struct facade_traits : specialization_t<facade_conv_traits_impl,
+                                        typename F::convention_types, F>,
+                       specialization_t<facade_refl_traits_impl,
+                                        typename F::reflection_types, F> {
+  using meta = composite_t<
+      composite_meta<>,
+      lifetime_meta_t<F, copy_dispatch, void(proxy<F>&) const noexcept,
+                      void(proxy<F>&) const, F::copyability>,
+      lifetime_meta_t<F, relocate_dispatch, void(proxy<F>&) && noexcept,
+                      void(proxy<F>&) &&, F::relocatability>,
+      lifetime_meta_t<F, destroy_dispatch, void() noexcept, void(),
+                      F::destructibility>,
+      typename facade_traits::conv_meta, typename facade_traits::refl_meta>;
+  using indirect_accessor =
+      composite_t<typename facade_traits::conv_indirect_accessor,
+                  typename facade_traits::refl_indirect_accessor>;
+  using direct_accessor =
+      composite_t<typename facade_traits::conv_direct_accessor,
+                  typename facade_traits::refl_direct_accessor>;
+
+  template <class P>
+  [[noreturn]] static consteval void diagnose_proxiable_noreturn() {
+    diagnose_proxiable_size_too_large<P, F, sizeof(P), F::max_size>();
+    diagnose_proxiable_align_too_large<P, F, alignof(P), F::max_align>();
+    diagnose_proxiable_insufficient_copyability<P, F, F::copyability>();
+    diagnose_proxiable_insufficient_relocatability<P, F, F::relocatability>();
+    diagnose_proxiable_insufficient_destructibility<P, F, F::destructibility>();
+    facade_traits::template diagnose_proxiable_conv<P>();
+    facade_traits::template diagnose_proxiable_refl<P>();
+    PRO4D_UNREACHABLE(); // Propagate the error to the caller side
+  }
+
+  template <class P>
+  static constexpr bool applicable_ptr =
+      sizeof(P) <= F::max_size && alignof(P) <= F::max_align &&
+      copyability_traits<P, F::copyability>::applicable &&
+      relocatability_traits<P, F::relocatability>::applicable &&
+      destructibility_traits<P, F::destructibility>::applicable &&
+      facade_traits::template conv_applicable_ptr<P> &&
+      facade_traits::template refl_applicable_ptr<P>;
+};
+
+using ptr_prototype = void* [2];
+
+template <class M>
+struct meta_ptr_indirect_impl {
+  meta_ptr_indirect_impl() = default;
+  template <class P>
+  explicit meta_ptr_indirect_impl(std::in_place_type_t<P>)
+      : ptr_(&storage<P>) {}
+  bool has_value() const noexcept { return ptr_ != nullptr; }
+  void reset() noexcept { ptr_ = nullptr; }
+  const M* operator->() const noexcept { return ptr_; }
+
+private:
+  const M* ptr_;
+  template <class P>
+  static constexpr M storage{std::in_place_type<P>};
+};
+template <class M, class DM>
+struct meta_ptr_direct_impl : private M {
+  using M::M;
+  bool has_value() const noexcept { return this->DM::invoke != nullptr; }
+  void reset() noexcept { this->DM::invoke = nullptr; }
+  const M* operator->() const noexcept { return this; }
+};
+template <class M>
+struct meta_ptr_traits_impl : std::type_identity<meta_ptr_indirect_impl<M>> {};
+template <class ProP, class D, class O, class... Ms>
+struct meta_ptr_traits_impl<composite_meta<conv_meta<ProP, D, O>, Ms...>>
+    : std::type_identity<
+          meta_ptr_direct_impl<composite_meta<conv_meta<ProP, D, O>, Ms...>,
+                               conv_meta<ProP, 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>)
+struct meta_ptr_traits<M> : meta_ptr_traits_impl<M> {};
+template <class M>
+using meta_ptr = typename meta_ptr_traits<M>::type;
+
+template <class T>
+class inplace_ptr {
+public:
+  template <class... Args>
+  explicit inplace_ptr(std::in_place_t, Args&&... args)
+      : value_(std::forward<Args>(args)...) {}
+  inplace_ptr() = default;
+  inplace_ptr(const inplace_ptr&) = default;
+  inplace_ptr(inplace_ptr&&) = default;
+  inplace_ptr& operator=(const inplace_ptr&) = default;
+  inplace_ptr& operator=(inplace_ptr&&) = default;
+
+  T* operator->() noexcept { return std::addressof(value_); }
+  const T* operator->() const noexcept { return std::addressof(value_); }
+  T& operator*() & noexcept { return value_; }
+  const T& operator*() const& noexcept { return value_; }
+  T&& operator*() && noexcept { return std::move(value_); }
+  const T&& operator*() const&& noexcept { return std::move(value_); }
+
+private:
+  [[PRO4D_NO_UNIQUE_ADDRESS_ATTRIBUTE]]
+  T value_;
+};
+
+template <class D, class O, class P, class... Args>
+ret_t<O> invoke_impl(P&& p, Args&&... args) {
+  return proxy_helper::get_meta<conv_meta<std::remove_cvref_t<P>, D, O>>(p)
+      .invoke(std::forward<P>(p), std::forward<Args>(args)...);
+}
+template <class F, qualifier_type Q>
+add_qualifier_t<proxy<F>, Q>
+    as_proxy(add_qualifier_t<proxy_indirect_accessor<F>, Q> p) {
+  return static_cast<add_qualifier_t<proxy<F>, Q>>(
+      *reinterpret_cast<
+          add_qualifier_ptr_t<inplace_ptr<proxy_indirect_accessor<F>>, Q>>(
+          std::addressof(p)));
+}
+template <class P, class F, bool IsDirect, qualifier_type Q>
+operand_t<P, IsDirect, Q> get_operand(proxy_accessor<F, IsDirect, Q> p) {
+  if constexpr (IsDirect) {
+    return proxy_helper::get_ptr<P, F, Q>(
+        std::forward<proxy_accessor<F, IsDirect, Q>>(p));
+  } else {
+    add_qualifier_t<P, Q> ptr = proxy_helper::get_ptr<P, F, Q>(
+        as_proxy<F, Q>(std::forward<proxy_accessor<F, IsDirect, Q>>(p)));
+    if constexpr (std::is_constructible_v<bool, P&>) {
+      assert(ptr);
+    }
+    return *std::forward<add_qualifier_t<P, Q>>(ptr);
+  }
+}
+template <class D, class R, class... Args>
+R invoke_dispatch(Args&&... args) {
+  if constexpr (std::is_void_v<R>) {
+    D()(std::forward<Args>(args)...);
+  } else {
+    return D()(std::forward<Args>(args)...);
+  }
+}
+template <class P, class F, bool IsDirect, qualifier_type Q, class D, class R,
+          class... Args>
+R reinterpret_invoke(proxy_accessor<F, IsDirect, Q> self, Args&&... args) {
+  if constexpr (Q == qualifier_type::rv) {
+    if constexpr (std::is_base_of_v<internal_dispatch, D> &&
+                  is_bitwise_trivially_relocatable_v<P>) {
+      return D()(std::in_place_type<P>, std::move(self),
+                 std::forward<Args>(args)...);
+    } else {
+      proxy_helper::resetting_guard<P, F> guard{self};
+      return invoke_dispatch<D, R>(
+          get_operand<P, F, IsDirect, Q>(std::move(self)),
+          std::forward<Args>(args)...);
+    }
+  } else {
+    return invoke_dispatch<D, R>(
+        get_operand<P, F, IsDirect, Q>(
+            std::forward<proxy_accessor<F, IsDirect, Q>>(self)),
+        std::forward<Args>(args)...);
+  }
+}
+
+} // namespace detail
+
+template <class P, class F>
+concept proxiable = facade<F> && detail::pointer_like<P> &&
+                    detail::facade_traits<F>::template applicable_ptr<P>;
+
+template <facade F>
+class proxy_indirect_accessor
+    : public detail::facade_traits<F>::indirect_accessor {
+  friend class detail::inplace_ptr<proxy_indirect_accessor>;
+  proxy_indirect_accessor() = default;
+  proxy_indirect_accessor(const proxy_indirect_accessor&) = default;
+  proxy_indirect_accessor& operator=(const proxy_indirect_accessor&) = default;
+
+public:
+  template <class D, class O, class... Args>
+  friend detail::ret_t<O> invoke(proxy_indirect_accessor& p, Args&&... args) {
+    return detail::invoke_impl<D, O>(p, std::forward<Args>(args)...);
+  }
+  template <class D, class O, class... Args>
+  friend detail::ret_t<O> invoke(const proxy_indirect_accessor& p,
+                                 Args&&... args) {
+    return detail::invoke_impl<D, O>(p, std::forward<Args>(args)...);
+  }
+  template <class D, class O, class... Args>
+  friend detail::ret_t<O> invoke(proxy_indirect_accessor&& p, Args&&... args) {
+    return detail::invoke_impl<D, O>(std::move(p), std::forward<Args>(args)...);
+  }
+  template <class D, class O, class... Args>
+  friend detail::ret_t<O> invoke(const proxy_indirect_accessor&& p,
+                                 Args&&... args) {
+    return detail::invoke_impl<D, O>(std::move(p), std::forward<Args>(args)...);
+  }
+  template <class P, class D, class R, class... Args>
+  friend R reinterpret_invoke(proxy_indirect_accessor& p, Args&&... args) {
+    return detail::reinterpret_invoke<P, F, false, detail::qualifier_type::lv,
+                                      D, R>(p, std::forward<Args>(args)...);
+  }
+  template <class P, class D, class R, class... Args>
+  friend R reinterpret_invoke(const proxy_indirect_accessor& p,
+                              Args&&... args) {
+    return detail::reinterpret_invoke<P, F, false,
+                                      detail::qualifier_type::const_lv, D, R>(
+        p, std::forward<Args>(args)...);
+  }
+  template <class P, class D, class R, class... Args>
+  friend R reinterpret_invoke(proxy_indirect_accessor&& p, Args&&... args) {
+    return detail::reinterpret_invoke<P, F, false, detail::qualifier_type::rv,
+                                      D, R>(std::move(p),
+                                            std::forward<Args>(args)...);
+  }
+  template <class P, class D, class R, class... Args>
+  friend R reinterpret_invoke(const proxy_indirect_accessor&& p,
+                              Args&&... args) {
+    return detail::reinterpret_invoke<P, F, false,
+                                      detail::qualifier_type::const_rv, D, R>(
+        std::move(p), std::forward<Args>(args)...);
+  }
+  template <class R>
+  friend const R& reflect(const proxy_indirect_accessor& p) noexcept {
+    return detail::proxy_helper::get_meta<detail::reflection_meta<false, R>>(p)
+        .reflector;
+  }
+};
+
+template <facade F>
+class proxy : public detail::facade_traits<F>::direct_accessor,
+              public detail::inplace_ptr<proxy_indirect_accessor<F>> {
+  friend struct detail::proxy_helper;
+
+public:
+  using facade_type = F;
+
+  proxy() noexcept { initialize(); }
+  proxy(std::nullptr_t) noexcept : proxy() {}
+  proxy(const proxy&) noexcept
+    requires(F::copyability == constraint_level::trivial)
+  = default;
+  proxy(const proxy& rhs) noexcept(F::copyability == constraint_level::nothrow)
+    requires(F::copyability == constraint_level::nontrivial ||
+             F::copyability == constraint_level::nothrow)
+      : detail::inplace_ptr<proxy_indirect_accessor<F>>() /* Make GCC happy */ {
+    initialize(rhs);
+  }
+  proxy(proxy&& rhs) noexcept(F::relocatability >= constraint_level::nothrow)
+    requires(F::relocatability >= constraint_level::nontrivial &&
+             F::copyability != constraint_level::trivial)
+  {
+    initialize(std::move(rhs));
+  }
+  template <class P>
+  constexpr proxy(P&& ptr) noexcept(
+      std::is_nothrow_constructible_v<std::decay_t<P>, P>)
+    requires(!detail::specialization_of<std::decay_t<P>, proxy> &&
+             detail::pointer_like<std::decay_t<P>> &&
+             std::is_constructible_v<std::decay_t<P>, P>)
+  {
+    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(detail::pointer_like<P> && std::is_constructible_v<P, Args...>)
+  {
+    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(detail::pointer_like<P> &&
+             std::is_constructible_v<P, std::initializer_list<U>&, Args...>)
+  {
+    initialize<P>(il, std::forward<Args>(args)...);
+  }
+  proxy& operator=(std::nullptr_t) noexcept(F::destructibility >=
+                                            constraint_level::nothrow)
+    requires(F::destructibility >= constraint_level::nontrivial)
+  {
+    reset();
+    return *this;
+  }
+  proxy& operator=(const proxy&) noexcept
+    requires(F::copyability == constraint_level::trivial)
+  = default;
+  proxy& operator=(const proxy& rhs) noexcept(F::copyability >=
+                                                  constraint_level::nothrow &&
+                                              F::destructibility >=
+                                                  constraint_level::nothrow)
+    requires((F::copyability == constraint_level::nontrivial ||
+              F::copyability == constraint_level::nothrow) &&
+             F::destructibility >= constraint_level::nontrivial)
+  {
+    if (this != std::addressof(rhs)) [[likely]] {
+      if constexpr (F::copyability == constraint_level::nothrow) {
+        destroy();
+        initialize(rhs);
+      } else {
+        *this = proxy{rhs};
+      }
+    }
+    return *this;
+  }
+  proxy& operator=(proxy&& rhs) noexcept(F::relocatability >=
+                                             constraint_level::nothrow &&
+                                         F::destructibility >=
+                                             constraint_level::nothrow)
+    requires(F::relocatability >= constraint_level::nontrivial &&
+             F::destructibility >= constraint_level::nontrivial &&
+             F::copyability != constraint_level::trivial)
+  {
+    if (this != std::addressof(rhs)) [[likely]] {
+      reset();
+      initialize(std::move(rhs));
+    }
+    return *this;
+  }
+  template <class P>
+  constexpr proxy& operator=(P&& ptr) noexcept(
+      std::is_nothrow_constructible_v<std::decay_t<P>, P> &&
+      F::destructibility >= constraint_level::nothrow)
+    requires(!detail::specialization_of<std::decay_t<P>, proxy> &&
+             detail::pointer_like<std::decay_t<P>> &&
+             std::is_constructible_v<std::decay_t<P>, P> &&
+             F::destructibility >= constraint_level::nontrivial)
+  {
+    if constexpr (std::is_nothrow_constructible_v<std::decay_t<P>, P>) {
+      destroy();
+      initialize<std::decay_t<P>>(std::forward<P>(ptr));
+    } else {
+      *this = proxy{std::forward<P>(ptr)};
+    }
+    return *this;
+  }
+  ~proxy()
+    requires(F::destructibility == constraint_level::trivial)
+  = default;
+  ~proxy() noexcept(F::destructibility == constraint_level::nothrow)
+    requires(F::destructibility == constraint_level::nontrivial ||
+             F::destructibility == constraint_level::nothrow)
+  {
+    destroy();
+  }
+
+  bool has_value() const noexcept { return meta_.has_value(); }
+  explicit operator bool() const noexcept { return meta_.has_value(); }
+  void reset() noexcept(F::destructibility >= constraint_level::nothrow)
+    requires(F::destructibility >= constraint_level::nontrivial)
+  {
+    destroy();
+    initialize();
+  }
+  void swap(proxy& rhs) noexcept(F::relocatability >=
+                                     constraint_level::nothrow ||
+                                 F::copyability == constraint_level::trivial)
+    requires(F::relocatability >= constraint_level::nontrivial ||
+             F::copyability == constraint_level::trivial)
+  {
+    if constexpr (F::relocatability == constraint_level::trivial ||
+                  F::copyability == constraint_level::trivial) {
+      std::swap(meta_, rhs.meta_);
+#ifdef __INTEL_LLVM_COMPILER
+      // Workaround: Intel oneAPI compiler (as of 2025.2.0) may over-optimize
+      // the swap below, causing unit tests failure
+      std::byte temp[F::max_size];
+      std::ranges::uninitialized_copy(ptr_, temp);
+      std::ranges::uninitialized_copy(rhs.ptr_, ptr_);
+      std::ranges::uninitialized_copy(temp, rhs.ptr_);
+#else
+      std::swap(ptr_, rhs.ptr_);
+#endif // __INTEL_LLVM_COMPILER
+    } else {
+      if (meta_.has_value()) {
+        if (rhs.meta_.has_value()) {
+          proxy temp = std::move(*this);
+          initialize(std::move(rhs));
+          rhs.initialize(std::move(temp));
+        } else {
+          rhs.initialize(std::move(*this));
+        }
+      } else if (rhs.meta_.has_value()) {
+        initialize(std::move(rhs));
+      }
+    }
+  }
+  template <class P, class... Args>
+  constexpr P& emplace(Args&&... args) noexcept(
+      std::is_nothrow_constructible_v<P, Args...> &&
+      F::destructibility >= constraint_level::nothrow)
+    requires(detail::pointer_like<P> && std::is_constructible_v<P, Args...> &&
+             F::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::destructibility >= constraint_level::nothrow)
+    requires(detail::pointer_like<P> &&
+             std::is_constructible_v<P, std::initializer_list<U>&, Args...> &&
+             F::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)))
+    requires(requires { lhs.swap(rhs); })
+  {
+    lhs.swap(rhs);
+  }
+  friend bool operator==(const proxy& lhs, std::nullptr_t) noexcept {
+    return !lhs.has_value();
+  }
+  template <class D, class O, class... Args>
+  friend detail::ret_t<O> invoke(proxy& p, Args&&... args) {
+    return detail::invoke_impl<D, O>(p, std::forward<Args>(args)...);
+  }
+  template <class D, class O, class... Args>
+  friend detail::ret_t<O> invoke(const proxy& p, Args&&... args) {
+    return detail::invoke_impl<D, O>(p, std::forward<Args>(args)...);
+  }
+  template <class D, class O, class... Args>
+  friend detail::ret_t<O> invoke(proxy&& p, Args&&... args) {
+    return detail::invoke_impl<D, O>(std::move(p), std::forward<Args>(args)...);
+  }
+  template <class D, class O, class... Args>
+  friend detail::ret_t<O> invoke(const proxy&& p, Args&&... args) {
+    return detail::invoke_impl<D, O>(std::move(p), std::forward<Args>(args)...);
+  }
+  template <class P, class D, class R, class... Args>
+  friend R reinterpret_invoke(proxy& p, Args&&... args) {
+    return detail::reinterpret_invoke<P, F, true, detail::qualifier_type::lv, D,
+                                      R>(p, std::forward<Args>(args)...);
+  }
+  template <class P, class D, class R, class... Args>
+  friend R reinterpret_invoke(const proxy& p, Args&&... args) {
+    return detail::reinterpret_invoke<P, F, true,
+                                      detail::qualifier_type::const_lv, D, R>(
+        p, std::forward<Args>(args)...);
+  }
+  template <class P, class D, class R, class... Args>
+  friend R reinterpret_invoke(proxy&& p, Args&&... args) {
+    return detail::reinterpret_invoke<P, F, true, detail::qualifier_type::rv, D,
+                                      R>(std::move(p),
+                                         std::forward<Args>(args)...);
+  }
+  template <class P, class D, class R, class... Args>
+  friend R reinterpret_invoke(const proxy&& p, Args&&... args) {
+    return detail::reinterpret_invoke<P, F, true,
+                                      detail::qualifier_type::const_rv, D, R>(
+        std::move(p), std::forward<Args>(args)...);
+  }
+  template <class R>
+  friend const R& reflect(const proxy& p) noexcept {
+    return detail::proxy_helper::get_meta<detail::reflection_meta<true, R>>(p)
+        .reflector;
+  }
+
+private:
+  void initialize() {
+    PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
+    meta_.reset();
+  }
+  void initialize(const proxy& rhs)
+    requires(F::copyability != constraint_level::none)
+  {
+    PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
+    if (rhs.meta_.has_value()) {
+      if constexpr (F::copyability == constraint_level::trivial) {
+        std::ranges::uninitialized_copy(rhs.ptr_, ptr_);
+        meta_ = rhs.meta_;
+      } else {
+        invoke<detail::copy_dispatch,
+               void(proxy&) const noexcept(
+                   F::copyability == constraint_level::nothrow)>(rhs, *this);
+      }
+    } else {
+      meta_.reset();
+    }
+  }
+  void initialize(proxy&& rhs)
+    requires(F::relocatability != constraint_level::none)
+  {
+    PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
+    if (rhs.meta_.has_value()) {
+      if constexpr (F::relocatability == constraint_level::trivial) {
+        std::ranges::uninitialized_copy(rhs.ptr_, ptr_);
+        meta_ = rhs.meta_;
+        rhs.meta_.reset();
+      } else {
+        invoke<detail::relocate_dispatch,
+               void(proxy&) &&
+                   noexcept(F::relocatability == constraint_level::nothrow)>(
+            std::move(rhs), *this);
+      }
+    } else {
+      meta_.reset();
+    }
+  }
+  template <class P, class... Args>
+  constexpr P& initialize(Args&&... args) {
+    PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
+    P& result = *std::construct_at(reinterpret_cast<P*>(ptr_),
+                                   std::forward<Args>(args)...);
+    if constexpr (proxiable<P, F>) {
+      meta_ = detail::meta_ptr<typename detail::facade_traits<F>::meta>{
+          std::in_place_type<P>};
+    } else {
+      detail::facade_traits<F>::template diagnose_proxiable_noreturn<P>();
+    }
+    return result;
+  }
+  void destroy()
+    requires(F::destructibility != constraint_level::none)
+  {
+    if constexpr (F::destructibility != constraint_level::trivial) {
+      if (meta_.has_value()) {
+        invoke<detail::destroy_dispatch,
+               void() noexcept(F::destructibility ==
+                               constraint_level::nothrow)>(*this);
+      }
+    }
+  }
+  PRO4D_DEBUG(static inline void pro_symbol_guard(proxy& self,
+                                                  const proxy& cself) {
+    self.operator->();
+    *self;
+    *std::move(self);
+    cself.operator->();
+    *cself;
+    *std::move(cself);
+  })
+
+  detail::meta_ptr<typename detail::facade_traits<F>::meta> meta_;
+  alignas(F::max_align) std::byte ptr_[F::max_size];
+};
+
+template <class D, class O, facade F, class... Args>
+[[deprecated("Use unqualified invoke instead")]] detail::ret_t<O>
+    proxy_invoke(proxy_indirect_accessor<F>& p, Args&&... args) {
+  return invoke<D, O>(p, std::forward<Args>(args)...);
+}
+template <class D, class O, facade F, class... Args>
+[[deprecated("Use unqualified invoke instead")]] detail::ret_t<O>
+    proxy_invoke(const proxy_indirect_accessor<F>& p, Args&&... args) {
+  return invoke<D, O>(p, std::forward<Args>(args)...);
+}
+template <class D, class O, facade F, class... Args>
+[[deprecated("Use unqualified invoke instead")]] detail::ret_t<O>
+    proxy_invoke(proxy_indirect_accessor<F>&& p, Args&&... args) {
+  return invoke<D, O>(std::move(p), std::forward<Args>(args)...);
+}
+template <class D, class O, facade F, class... Args>
+[[deprecated("Use unqualified invoke instead")]] detail::ret_t<O>
+    proxy_invoke(const proxy_indirect_accessor<F>&& p, Args&&... args) {
+  return invoke<D, O>(std::move(p), std::forward<Args>(args)...);
+}
+template <class D, class O, facade F, class... Args>
+[[deprecated("Use unqualified invoke instead")]] detail::ret_t<O>
+    proxy_invoke(proxy<F>& p, Args&&... args) {
+  return invoke<D, O>(p, std::forward<Args>(args)...);
+}
+template <class D, class O, facade F, class... Args>
+[[deprecated("Use unqualified invoke instead")]] detail::ret_t<O>
+    proxy_invoke(const proxy<F>& p, Args&&... args) {
+  return invoke<D, O>(p, std::forward<Args>(args)...);
+}
+template <class D, class O, facade F, class... Args>
+[[deprecated("Use unqualified invoke instead")]] detail::ret_t<O>
+    proxy_invoke(proxy<F>&& p, Args&&... args) {
+  return invoke<D, O>(std::move(p), std::forward<Args>(args)...);
+}
+template <class D, class O, facade F, class... Args>
+[[deprecated("Use unqualified invoke instead")]] detail::ret_t<O>
+    proxy_invoke(const proxy<F>&& p, Args&&... args) {
+  return invoke<D, O>(std::move(p), std::forward<Args>(args)...);
+}
+
+template <class R, facade F>
+[[deprecated("Use unqualified reflect instead")]] const R&
+    proxy_reflect(const proxy_indirect_accessor<F>& p) noexcept {
+  return reflect<R>(p);
+}
+template <class R, facade F>
+[[deprecated("Use unqualified reflect instead")]] const R&
+    proxy_reflect(const proxy<F>& p) noexcept {
+  return reflect<R>(p);
+}
+
+struct substitution_dispatch;
+
+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>>;
+
+namespace detail {
+
+template <class F>
+struct converter {
+  explicit converter(F f) noexcept : f_(std::move(f)) {}
+  converter(const converter&) = delete;
+  template <class T>
+  operator T() && noexcept(
+      std::is_nothrow_invocable_r_v<T, F, std::in_place_type_t<T>>)
+    requires(std::is_invocable_r_v<T, F, std::in_place_type_t<T>> &&
+             !std::is_invocable_r_v<T, F, std::in_place_type_t<T&>> &&
+             !std::is_invocable_r_v<T, F, std::in_place_type_t<T &&>>)
+  {
+    return std::move(f_)(std::in_place_type<T>);
+  }
+  template <class T>
+  operator T&() && noexcept(
+      std::is_nothrow_invocable_r_v<T&, F, std::in_place_type_t<T&>>)
+    requires(std::is_invocable_r_v<T&, F, std::in_place_type_t<T&>>)
+  {
+    return std::move(f_)(std::in_place_type<T&>);
+  }
+  template <class T>
+  operator T&&() && noexcept(
+      std::is_nothrow_invocable_r_v<T&&, F, std::in_place_type_t<T&&>>)
+    requires(std::is_invocable_r_v<T &&, F, std::in_place_type_t<T &&>>)
+  {
+    return std::move(f_)(std::in_place_type<T&&>);
+  }
+
+private:
+  F f_;
+};
+
+#define PRO4D_DEF_CAST_ACCESSOR(oq, pq, ne, ...)                               \
+  template <class P, class D, class T>                                         \
+  struct accessor<P, D, T() oq ne> {                                           \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(operator T)                        \
+    explicit(Expl) operator T() oq ne {                                        \
+      if constexpr (Nullable) {                                                \
+        if (!static_cast<const P&>(*this).has_value()) {                       \
+          return nullptr;                                                      \
+        }                                                                      \
+      }                                                                        \
+      return invoke<D, T() oq ne>(static_cast<P pq>(*this));                   \
+    }                                                                          \
+  }
+template <bool Expl, bool Nullable>
+struct cast_dispatch_base {
+  PRO4D_DEF_ACCESSOR_TEMPLATE(
+      MEM, PRO4D_DEF_CAST_ACCESSOR,
+      operator typename overload_traits<ProOs>::return_type)
+};
+#undef PRO4D_DEF_CAST_ACCESSOR
+
+template <bool IsDirect, class D, class... Os>
+struct conv_impl {
+  static constexpr bool is_direct = IsDirect;
+  using dispatch_type = D;
+  using overload_types = std::tuple<Os...>;
+};
+template <bool IsDirect, class R>
+struct refl_impl {
+  static constexpr bool is_direct = IsDirect;
+  using reflector_type = R;
+};
+template <class Cs, class Rs, std::size_t MaxSize, std::size_t MaxAlign,
+          constraint_level Copyability, constraint_level Relocatability,
+          constraint_level Destructibility>
+struct facade_impl {
+  using convention_types = Cs;
+  using reflection_types = Rs;
+  static constexpr std::size_t max_size = MaxSize;
+  static constexpr std::size_t max_align = MaxAlign;
+  static constexpr constraint_level copyability = Copyability;
+  static constexpr constraint_level relocatability = Relocatability;
+  static constexpr constraint_level destructibility = Destructibility;
+};
+
+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> && ...)
+struct add_tuple_reduction<std::tuple<Os...>, I>
+    : std::type_identity<std::tuple<Os..., I>> {};
+template <class O, class... Is>
+using add_tuple_t =
+    recursive_reduction_t<reduction_traits<add_tuple_reduction>::template type,
+                          O, Is...>;
+
+template <bool IsDirect, class D>
+struct conv_specialization_helper {
+  template <class... Os>
+  using type = conv_impl<IsDirect, D, Os...>;
+};
+template <bool IsDirect, class D, class Os>
+using conv_specialization_t =
+    specialization_t<conv_specialization_helper<IsDirect, D>::template type,
+                     Os>;
+
+template <class LR, class CLR, class RR, class CRR>
+class observer_ptr {
+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_));
+  }
+  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:
+  LR lr_;
+};
+
+template <class O>
+using observer_substitution_overload =
+    proxy_view<typename ret_t<O>::facade_type>() const noexcept;
+template <class... Os>
+using observer_substitution_conv = conv_specialization_t<
+    true, substitution_dispatch,
+    add_tuple_t<std::tuple<>, observer_substitution_overload<Os>...>>;
+
+template <class C>
+struct observer_conv_traits : std::type_identity<void> {};
+template <class C>
+  requires(C::is_direct &&
+           std::is_same_v<typename C::dispatch_type, substitution_dispatch>)
+struct observer_conv_traits<C>
+    : std::type_identity<specialization_t<observer_substitution_conv,
+                                          typename C::overload_types>> {};
+template <class C>
+  requires(!C::is_direct)
+struct observer_conv_traits<C> : std::type_identity<C> {};
+template <class... Cs>
+using observer_conv_types =
+    composite_t<std::tuple<>, typename observer_conv_traits<Cs>::type...>;
+template <class... Rs>
+using observer_refl_types =
+    composite_t<std::tuple<>, std::conditional_t<Rs::is_direct, void, Rs>...>;
+
+template <class P>
+auto weak_lock_impl(const P& self) noexcept
+  requires(requires { self.lock(); })
+{
+  if constexpr (std::is_constructible_v<bool, decltype(self.lock())>) {
+    return converter{
+        [&self]<class F>(std::in_place_type_t<proxy<F>>) noexcept -> proxy<F> {
+          auto strong = self.lock();
+          return strong ? proxy<F>{std::move(strong)} : proxy<F>{};
+        }};
+  } else {
+    return self.lock();
+  }
+}
+PRO4_DEF_FREE_AS_MEM_DISPATCH(weak_mem_lock, weak_lock_impl, lock);
+
+template <class O>
+struct weak_substitution_overload_traits;
+#define PRO4D_DEF_WEAK_SUBSTITUTION_OVERLOAD_TRAITS(oq, pq, ne, ...)           \
+  template <class F>                                                           \
+  struct weak_substitution_overload_traits<proxy<F>() oq ne>                   \
+      : std::type_identity<weak_proxy<F>() oq ne> {};
+PRO4D_DEF_OVERLOAD_SPECIALIZATIONS(PRO4D_DEF_WEAK_SUBSTITUTION_OVERLOAD_TRAITS)
+#undef PRO4D_DEF_WEAK_SUBSTITUTION_OVERLOAD_TRAITS
+template <class... Os>
+using weak_substitution_conv =
+    conv_impl<true, substitution_dispatch,
+              typename weak_substitution_overload_traits<Os>::type...>;
+
+template <class C>
+struct weak_conv_traits : std::type_identity<void> {};
+template <class C>
+  requires(C::is_direct &&
+           std::is_same_v<typename C::dispatch_type, substitution_dispatch>)
+struct weak_conv_traits<C>
+    : std::type_identity<specialization_t<weak_substitution_conv,
+                                          typename C::overload_types>> {};
+template <class F, class... Cs>
+using weak_conv_types = composite_t<
+    std::tuple<conv_impl<true, weak_mem_lock, proxy<F>() const noexcept>>,
+    typename weak_conv_traits<Cs>::type...>;
+
+} // namespace detail
+
+struct PRO4D_ENFORCE_EBO substitution_dispatch
+    : detail::cast_dispatch_base<false, true>,
+      detail::internal_dispatch {
+  template <class P, class F1>
+  PRO4D_STATIC_CALL(auto, std::in_place_type_t<P>, proxy<F1>&& self) noexcept {
+    return detail::converter{
+        [&self]<class F2>(std::in_place_type_t<proxy<F2>>) noexcept {
+          proxy<F2> ret;
+          detail::proxy_helper::trivially_relocate<P>(self, ret);
+          return ret;
+        }};
+  }
+  template <class T>
+  PRO4D_STATIC_CALL(T&&, T&& self) noexcept {
+    return std::forward<T>(self);
+  }
+
+  // This overload is not reachable at runtime, but is necessary to ensure
+  // substitution_dispatch is SFINAE-friendly.
+  template <class T>
+  PRO4D_STATIC_CALL(auto, T&&) noexcept
+    requires(std::is_same_v<T, std::remove_cvref_t<T>> &&
+             is_bitwise_trivially_relocatable_v<T>)
+  {
+    return detail::converter{
+        []<class F2>(std::in_place_type_t<proxy<F2>>) noexcept -> proxy<F2>
+          requires(proxiable<T, F2>)
+        { PRO4D_UNREACHABLE(); }};
+  }
+};
+
+template <facade F>
+struct observer_facade
+    : detail::facade_impl<
+          detail::specialization_t<detail::observer_conv_types,
+                                   typename F::convention_types>,
+          detail::specialization_t<detail::observer_refl_types,
+                                   typename F::reflection_types>,
+          sizeof(void*), alignof(void*), constraint_level::trivial,
+          constraint_level::trivial, constraint_level::trivial> {};
+
+template <facade F>
+struct weak_facade
+    : detail::facade_impl<
+          detail::specialization_t<detail::weak_conv_types,
+                                   typename F::convention_types, F>,
+          std::tuple<>, F::max_size, F::max_align, F::copyability,
+          F::relocatability, F::destructibility> {};
+
+} // namespace pro::inline v4
+
+#endif // MSFT_PROXY_V4_DETAIL_CORE_H_
diff --git a/include/proxy/v4/detail/dispatch.h b/include/proxy/v4/detail/dispatch.h
new file mode 100644
index 0000000..9c25dc6
--- /dev/null
+++ b/include/proxy/v4/detail/dispatch.h
@@ -0,0 +1,305 @@
+// Copyright (c) 2022-2026 Microsoft Corporation.
+// Copyright (c) 2026-Present Next Gen C++ Foundation.
+// Licensed under the MIT License.
+
+#ifndef MSFT_PROXY_V4_DETAIL_DISPATCH_H_
+#define MSFT_PROXY_V4_DETAIL_DISPATCH_H_
+
+#include <exception>
+
+#include "core.h"
+
+namespace pro::inline v4 {
+
+namespace detail {
+
+template <std::size_t N>
+struct sign {
+  consteval sign(const char (&str)[N + 1]) {
+    if (str[N] != '\0') {
+      PRO4D_UNREACHABLE();
+    }
+    for (std::size_t i = 0; i < N; ++i) {
+      value[i] = str[i];
+    }
+  }
+
+  char value[N];
+};
+template <std::size_t N>
+sign(const char (&str)[N]) -> sign<N - 1u>;
+
+// When std::reference_constructs_from_temporary_v (C++23) is not available, we
+// fall back to a conservative approximation that disallows binding a temporary
+// to a reference type if the source type is not a reference or if the source
+// and target reference types are not compatible.
+template <class T, class U>
+concept explicitly_convertible =
+    std::is_constructible_v<U, T> &&
+#if __cpp_lib_reference_from_temporary >= 202202L
+    !std::reference_constructs_from_temporary_v<U, T>;
+#else
+    (!std::is_reference_v<U> ||
+     (std::is_reference_v<T> &&
+      std::is_convertible_v<std::add_pointer_t<std::remove_reference_t<T>>,
+                            std::add_pointer_t<std::remove_reference_t<U>>>));
+#endif // __cpp_lib_reference_from_temporary >= 202202L
+
+struct noreturn_conversion {
+  template <class T>
+  [[noreturn]] PRO4D_STATIC_CALL(T, std::in_place_type_t<T>) {
+    PRO4D_UNREACHABLE();
+  }
+};
+using wildcard = converter<noreturn_conversion>;
+
+} // namespace detail
+
+template <detail::sign Sign, bool Rhs = false>
+struct operator_dispatch;
+
+#define PRO4D_DEF_LHS_LEFT_OP_ACCESSOR(oq, pq, ne, ...)                        \
+  template <class P, class D, class R>                                         \
+  struct accessor<P, D, R() oq ne> {                                           \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
+    R __VA_ARGS__() oq ne {                                                    \
+      return invoke<D, R() oq ne>(static_cast<P pq>(*this));                   \
+    }                                                                          \
+  }
+#define PRO4D_DEF_LHS_UNARY_OP_ACCESSOR(oq, pq, ne, ...)                       \
+  template <class P, class D, class R>                                         \
+  struct accessor<P, D, R() oq ne> {                                           \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
+    decltype(auto) __VA_ARGS__() oq ne {                                       \
+      invoke<D, R() oq ne>(static_cast<P pq>(*this));                          \
+      return static_cast<P pq>(*this);                                         \
+    }                                                                          \
+  };                                                                           \
+  template <class P, class D, class R>                                         \
+  struct accessor<P, D, R(int) oq ne> {                                        \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
+    R __VA_ARGS__(int) oq ne {                                                 \
+      return invoke<D, R(int) oq ne>(static_cast<P pq>(*this), 0);             \
+    }                                                                          \
+  }
+#define PRO4D_DEF_LHS_BINARY_OP_ACCESSOR PRO4D_DEF_MEM_ACCESSOR
+#define PRO4D_DEF_LHS_ALL_OP_ACCESSOR PRO4D_DEF_MEM_ACCESSOR
+#define PRO4D_LHS_LEFT_OP_DISPATCH_BODY_IMPL(...)                              \
+  template <class T>                                                           \
+  PRO4D_STATIC_CALL(decltype(auto), T&& self)                                  \
+  PRO4D_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self))
+#define PRO4D_LHS_UNARY_OP_DISPATCH_BODY_IMPL(...)                             \
+  template <class T>                                                           \
+  PRO4D_STATIC_CALL(decltype(auto), T&& self)                                  \
+  PRO4D_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self)) template <class T> \
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, int)                             \
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self) __VA_ARGS__)
+#define PRO4D_LHS_BINARY_OP_DISPATCH_BODY_IMPL(...)                            \
+  template <class T, class Arg>                                                \
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                       \
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)                                 \
+                             __VA_ARGS__ std::forward<Arg>(arg))
+#define PRO4D_LHS_ALL_OP_DISPATCH_BODY_IMPL(...)                               \
+  PRO4D_LHS_LEFT_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                            \
+  PRO4D_LHS_BINARY_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)
+#define PRO4D_LHS_OP_DISPATCH_IMPL(type, ...)                                  \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, false> {                              \
+    PRO4D_LHS_##type##_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                      \
+        PRO4D_DEF_ACCESSOR_TEMPLATE(                                           \
+            MEM, PRO4D_DEF_LHS_##type##_OP_ACCESSOR, operator __VA_ARGS__)     \
+  };
+
+#define PRO4D_DEF_RHS_OP_ACCESSOR(oq, pq, ne, ...)                             \
+  template <class P, class D, class R, class Arg>                              \
+  struct accessor<P, D, R(Arg) oq ne> {                                        \
+    friend R operator __VA_ARGS__(Arg arg, P pq self) ne {                     \
+      return invoke<D, R(Arg) oq ne>(static_cast<P pq>(self),                  \
+                                     std::forward<Arg>(arg));                  \
+    }                                                                          \
+    PRO4D_DEBUG(                                                             \
+      accessor() noexcept { std::ignore = &pro_symbol_guard; }               \
+                                                                             \
+    private:                                                                 \
+      static inline R pro_symbol_guard(Arg arg, P pq self) {                 \
+        return std::forward<Arg>(arg) __VA_ARGS__ static_cast<P pq>(self);   \
+      }                                                                      \
+    ) \
+  }
+#define PRO4D_RHS_OP_DISPATCH_IMPL(...)                                        \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, true> {                               \
+    template <class T, class Arg>                                              \
+    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
+    PRO4D_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                              \
+                               __VA_ARGS__ std::forward<T>(self))              \
+        PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PRO4D_DEF_RHS_OP_ACCESSOR,           \
+                                    __VA_ARGS__)                               \
+  };
+
+#define PRO4D_EXTENDED_BINARY_OP_DISPATCH_IMPL(...)                            \
+  PRO4D_LHS_OP_DISPATCH_IMPL(ALL, __VA_ARGS__)                                 \
+  PRO4D_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
+
+#define PRO4D_BINARY_OP_DISPATCH_IMPL(...)                                     \
+  PRO4D_LHS_OP_DISPATCH_IMPL(BINARY, __VA_ARGS__)                              \
+  PRO4D_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
+
+#define PRO4D_DEF_LHS_ASSIGNMENT_OP_ACCESSOR(oq, pq, ne, ...)                  \
+  template <class P, class D, class R, class Arg>                              \
+  struct accessor<P, D, R(Arg) oq ne> {                                        \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
+    decltype(auto) __VA_ARGS__(Arg arg) oq ne {                                \
+      invoke<D, R(Arg) oq ne>(static_cast<P pq>(*this),                        \
+                              std::forward<Arg>(arg));                         \
+      return static_cast<P pq>(*this);                                         \
+    }                                                                          \
+  }
+#define PRO4D_DEF_RHS_ASSIGNMENT_OP_ACCESSOR(oq, pq, ne, ...)                  \
+  template <class P, class D, class R, class Arg>                              \
+  struct accessor<P, D, R(Arg&) oq ne> {                                       \
+    friend Arg& operator __VA_ARGS__(Arg& arg, P pq self) ne {                 \
+      invoke<D, R(Arg&) oq ne>(static_cast<P pq>(self), arg);                  \
+      return arg;                                                              \
+    }                                                                          \
+    PRO4D_DEBUG(                                                               \
+        accessor() noexcept { std::ignore = &pro_symbol_guard; }               \
+                                                                               \
+        private : static inline Arg& pro_symbol_guard(                         \
+            Arg& arg,                                                          \
+            P pq self) { return arg __VA_ARGS__ static_cast<P pq>(self); })    \
+  }
+#define PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(...)                                 \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, false> {                              \
+    template <class T, class Arg>                                              \
+    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
+    PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)                               \
+                               __VA_ARGS__ std::forward<Arg>(arg))             \
+        PRO4D_DEF_ACCESSOR_TEMPLATE(                                           \
+            MEM, PRO4D_DEF_LHS_ASSIGNMENT_OP_ACCESSOR, operator __VA_ARGS__)   \
+  };                                                                           \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, true> {                               \
+    template <class T, class Arg>                                              \
+    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
+    PRO4D_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                              \
+                               __VA_ARGS__ std::forward<T>(self))              \
+        PRO4D_DEF_ACCESSOR_TEMPLATE(FREE,                                      \
+                                    PRO4D_DEF_RHS_ASSIGNMENT_OP_ACCESSOR,      \
+                                    __VA_ARGS__)                               \
+  };
+
+PRO4D_EXTENDED_BINARY_OP_DISPATCH_IMPL(+)
+PRO4D_EXTENDED_BINARY_OP_DISPATCH_IMPL(-)
+PRO4D_EXTENDED_BINARY_OP_DISPATCH_IMPL(*)
+PRO4D_BINARY_OP_DISPATCH_IMPL(/)
+PRO4D_BINARY_OP_DISPATCH_IMPL(%)
+PRO4D_LHS_OP_DISPATCH_IMPL(UNARY, ++)
+PRO4D_LHS_OP_DISPATCH_IMPL(UNARY, --)
+PRO4D_BINARY_OP_DISPATCH_IMPL(==)
+PRO4D_BINARY_OP_DISPATCH_IMPL(!=)
+PRO4D_BINARY_OP_DISPATCH_IMPL(>)
+PRO4D_BINARY_OP_DISPATCH_IMPL(<)
+PRO4D_BINARY_OP_DISPATCH_IMPL(>=)
+PRO4D_BINARY_OP_DISPATCH_IMPL(<=)
+PRO4D_BINARY_OP_DISPATCH_IMPL(<=>)
+PRO4D_LHS_OP_DISPATCH_IMPL(LEFT, !)
+PRO4D_BINARY_OP_DISPATCH_IMPL(&&)
+PRO4D_BINARY_OP_DISPATCH_IMPL(||)
+PRO4D_LHS_OP_DISPATCH_IMPL(LEFT, ~)
+PRO4D_EXTENDED_BINARY_OP_DISPATCH_IMPL(&)
+PRO4D_BINARY_OP_DISPATCH_IMPL(|)
+PRO4D_BINARY_OP_DISPATCH_IMPL(^)
+PRO4D_BINARY_OP_DISPATCH_IMPL(<<)
+PRO4D_BINARY_OP_DISPATCH_IMPL(>>)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(+=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(-=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(*=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(/=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(%=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(&=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(|=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(^=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(<<=)
+PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL(>>=)
+PRO4D_BINARY_OP_DISPATCH_IMPL(, )
+PRO4D_BINARY_OP_DISPATCH_IMPL(->*)
+
+template <>
+struct operator_dispatch<"()", false> {
+  template <class T, class... Args>
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)(std::forward<Args>(args)...))
+      PRO4D_DEF_ACCESSOR_TEMPLATE(MEM, PRO4D_DEF_MEM_ACCESSOR, operator())
+};
+template <>
+struct operator_dispatch<"[]", false> {
+#if __cpp_multidimensional_subscript >= 202110L
+  template <class T, class... Args>
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Args>(args)...])
+#else
+  template <class T, class Arg>
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Arg>(arg)])
+#endif // __cpp_multidimensional_subscript >= 202110L
+      PRO4D_DEF_ACCESSOR_TEMPLATE(MEM, PRO4D_DEF_MEM_ACCESSOR, operator[])
+};
+
+#undef PRO4D_ASSIGNMENT_OP_DISPATCH_IMPL
+#undef PRO4D_DEF_RHS_ASSIGNMENT_OP_ACCESSOR
+#undef PRO4D_DEF_LHS_ASSIGNMENT_OP_ACCESSOR
+#undef PRO4D_BINARY_OP_DISPATCH_IMPL
+#undef PRO4D_EXTENDED_BINARY_OP_DISPATCH_IMPL
+#undef PRO4D_RHS_OP_DISPATCH_IMPL
+#undef PRO4D_DEF_RHS_OP_ACCESSOR
+#undef PRO4D_LHS_OP_DISPATCH_IMPL
+#undef PRO4D_LHS_ALL_OP_DISPATCH_BODY_IMPL
+#undef PRO4D_LHS_BINARY_OP_DISPATCH_BODY_IMPL
+#undef PRO4D_LHS_UNARY_OP_DISPATCH_BODY_IMPL
+#undef PRO4D_LHS_LEFT_OP_DISPATCH_BODY_IMPL
+#undef PRO4D_DEF_LHS_ALL_OP_ACCESSOR
+#undef PRO4D_DEF_LHS_BINARY_OP_ACCESSOR
+#undef PRO4D_DEF_LHS_UNARY_OP_ACCESSOR
+#undef PRO4D_DEF_LHS_LEFT_OP_ACCESSOR
+
+struct implicit_conversion_dispatch : detail::cast_dispatch_base<false, false> {
+  template <class T>
+  PRO4D_STATIC_CALL(T&&, T&& self) noexcept {
+    return std::forward<T>(self);
+  }
+};
+struct explicit_conversion_dispatch : detail::cast_dispatch_base<true, false> {
+  template <class T>
+  PRO4D_STATIC_CALL(auto, T&& self) noexcept {
+    return detail::converter{
+        [&self]<class U>(std::in_place_type_t<U>) noexcept(
+            std::is_nothrow_constructible_v<U, T>) -> U
+          requires(detail::explicitly_convertible < T &&, U >)
+        { return static_cast<U>(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";
+  }
+};
+
+template <class D>
+struct weak_dispatch : D {
+  using D::operator();
+  template <class... Args>
+  [[noreturn]] PRO4D_STATIC_CALL(detail::wildcard, Args&&...)
+    requires(!std::is_invocable_v<D, Args...>)
+  {
+    PRO4D_THROW(not_implemented{});
+  }
+};
+
+} // namespace pro::inline v4
+
+#endif // MSFT_PROXY_V4_DETAIL_DISPATCH_H_
diff --git a/include/proxy/v4/detail/facade_creation.h b/include/proxy/v4/detail/facade_creation.h
new file mode 100644
index 0000000..870fb2d
--- /dev/null
+++ b/include/proxy/v4/detail/facade_creation.h
@@ -0,0 +1,195 @@
+// Copyright (c) 2022-2026 Microsoft Corporation.
+// Copyright (c) 2026-Present Next Gen C++ Foundation.
+// Licensed under the MIT License.
+
+#ifndef MSFT_PROXY_V4_DETAIL_FACADE_CREATION_H_
+#define MSFT_PROXY_V4_DETAIL_FACADE_CREATION_H_
+
+#include <limits>
+
+#include "core.h"
+
+namespace pro::inline v4 {
+
+namespace detail {
+
+inline constexpr std::size_t invalid_size =
+    std::numeric_limits<std::size_t>::max();
+inline constexpr constraint_level invalid_cl = static_cast<constraint_level>(
+    std::numeric_limits<std::underlying_type_t<constraint_level>>::min());
+consteval std::size_t merge_size(std::size_t a, std::size_t b) {
+  return a < b ? a : b;
+}
+consteval constraint_level merge_constraint(constraint_level a,
+                                            constraint_level b) {
+  return a < b ? b : a;
+}
+consteval std::size_t max_align_of(std::size_t value) {
+  value &= ~value + 1u;
+  return value < alignof(std::max_align_t) ? value : alignof(std::max_align_t);
+}
+
+template <class T, class U>
+using merge_tuple_t = specialization_t<add_tuple_t, U, T>;
+template <class C1, class C2>
+using merge_conv_t = conv_specialization_t<
+    C1::is_direct, typename C1::dispatch_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... 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>)
+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>>> {
+};
+template <class Cs, class C>
+using add_conv_t = typename add_conv_reduction<std::tuple<>, Cs, C>::type;
+
+template <class F, constraint_level CL>
+using copy_conversion_overload =
+    proxy<F>() const& noexcept(CL >= constraint_level::nothrow);
+template <class F, constraint_level CL>
+using move_conversion_overload =
+    proxy<F>() && noexcept(CL >= constraint_level::nothrow);
+template <class Cs, class F, constraint_level CCL, constraint_level RCL>
+struct add_substitution_conv
+    : std::type_identity<add_conv_t<
+          Cs, conv_specialization_t<
+                  true, substitution_dispatch,
+                  composite_t<
+                      std::tuple<>,
+                      std::conditional_t<CCL == constraint_level::none, void,
+                                         copy_conversion_overload<F, CCL>>,
+                      std::conditional_t<RCL == constraint_level::none, void,
+                                         move_conversion_overload<F, RCL>>>>>> {
+};
+template <class Cs, class F>
+struct add_substitution_conv<Cs, F, constraint_level::none,
+                             constraint_level::none> : std::type_identity<Cs> {
+};
+
+template <class Cs1, class... Cs2>
+using merge_conv_tuple_t = recursive_reduction_t<add_conv_t, Cs1, Cs2...>;
+template <class Cs, class F, bool WithSubstitution>
+using merge_facade_conv_t = typename add_substitution_conv<
+    specialization_t<merge_conv_tuple_t, typename F::convention_types, Cs>, F,
+    WithSubstitution ? F::copyability : constraint_level::none,
+    (WithSubstitution && F::copyability != constraint_level::trivial)
+        ? F::relocatability
+        : constraint_level::none>::type;
+
+template <bool WithSubstitution>
+struct add_facade_deprecation_traits : std::bool_constant<WithSubstitution> {};
+template <>
+struct [[deprecated(
+    "basic_facade_builder::add_facade<F, true> is deprecated; use "
+    "basic_facade_builder::add_facade_with_substitution<F> instead.")]]
+add_facade_deprecation_traits<true> : std::bool_constant<true> {};
+
+} // namespace detail
+
+template <class Cs, class Rs, std::size_t MaxSize, std::size_t MaxAlign,
+          constraint_level Copyability, constraint_level Relocatability,
+          constraint_level Destructibility>
+struct basic_facade_builder {
+  template <class D, detail::extended_overload... Os>
+    requires(sizeof...(Os) > 0u)
+  using add_indirect_convention = basic_facade_builder<
+      detail::add_conv_t<Cs, detail::conv_impl<false, D, Os...>>, Rs, MaxSize,
+      MaxAlign, Copyability, Relocatability, Destructibility>;
+  template <class D, detail::extended_overload... Os>
+    requires(sizeof...(Os) > 0u)
+  using add_direct_convention = basic_facade_builder<
+      detail::add_conv_t<Cs, detail::conv_impl<true, D, Os...>>, Rs, MaxSize,
+      MaxAlign, Copyability, Relocatability, Destructibility>;
+  template <class D, detail::extended_overload... Os>
+    requires(sizeof...(Os) > 0u)
+  using add_convention = add_indirect_convention<D, Os...>;
+  template <class R>
+  using add_indirect_reflection = basic_facade_builder<
+      Cs, detail::add_tuple_t<Rs, detail::refl_impl<false, R>>, MaxSize,
+      MaxAlign, Copyability, Relocatability, Destructibility>;
+  template <class R>
+  using add_direct_reflection = basic_facade_builder<
+      Cs, detail::add_tuple_t<Rs, detail::refl_impl<true, R>>, MaxSize,
+      MaxAlign, Copyability, Relocatability, Destructibility>;
+  template <class R>
+  using add_reflection = add_indirect_reflection<R>;
+  template <facade F, bool WithSubstitution = false>
+  using add_facade = basic_facade_builder<
+      detail::merge_facade_conv_t<
+          Cs, F,
+          detail::add_facade_deprecation_traits<WithSubstitution>::value>,
+      detail::merge_tuple_t<Rs, typename F::reflection_types>,
+      detail::merge_size(MaxSize, F::max_size),
+      detail::merge_size(MaxAlign, F::max_align),
+      detail::merge_constraint(Copyability, F::copyability),
+      detail::merge_constraint(Relocatability, F::relocatability),
+      detail::merge_constraint(Destructibility, F::destructibility)>;
+  template <facade F>
+  using add_facade_with_substitution = basic_facade_builder<
+      detail::merge_facade_conv_t<Cs, F, true>,
+      detail::merge_tuple_t<Rs, typename F::reflection_types>,
+      detail::merge_size(MaxSize, F::max_size),
+      detail::merge_size(MaxAlign, F::max_align),
+      detail::merge_constraint(Copyability, F::copyability),
+      detail::merge_constraint(Relocatability, F::relocatability),
+      detail::merge_constraint(Destructibility, F::destructibility)>;
+  template <std::size_t PtrSize,
+            std::size_t PtrAlign = detail::max_align_of(PtrSize)>
+    requires(detail::is_layout_well_formed(PtrSize, PtrAlign))
+  using restrict_layout =
+      basic_facade_builder<Cs, Rs, detail::merge_size(MaxSize, PtrSize),
+                           detail::merge_size(MaxAlign, PtrAlign), Copyability,
+                           Relocatability, Destructibility>;
+  template <constraint_level CL>
+    requires(detail::is_cl_well_formed(CL))
+  using support_copy =
+      basic_facade_builder<Cs, Rs, MaxSize, MaxAlign,
+                           detail::merge_constraint(Copyability, CL),
+                           Relocatability, Destructibility>;
+  template <constraint_level CL>
+    requires(detail::is_cl_well_formed(CL))
+  using support_relocation =
+      basic_facade_builder<Cs, Rs, MaxSize, MaxAlign, Copyability,
+                           detail::merge_constraint(Relocatability, CL),
+                           Destructibility>;
+  template <constraint_level CL>
+    requires(detail::is_cl_well_formed(CL))
+  using support_destruction =
+      basic_facade_builder<Cs, Rs, MaxSize, MaxAlign, Copyability,
+                           Relocatability,
+                           detail::merge_constraint(Destructibility, CL)>;
+  template <template <class> class Skill>
+  using add_skill = Skill<basic_facade_builder>;
+  using build = detail::facade_impl<
+      Cs, Rs,
+      MaxSize == detail::invalid_size ? sizeof(detail::ptr_prototype) : MaxSize,
+      MaxAlign == detail::invalid_size ? alignof(detail::ptr_prototype)
+                                       : MaxAlign,
+      Copyability == detail::invalid_cl ? constraint_level::none : Copyability,
+      Relocatability == detail::invalid_cl ? constraint_level::trivial
+                                           : Relocatability,
+      Destructibility == detail::invalid_cl ? constraint_level::nothrow
+                                            : Destructibility>;
+  basic_facade_builder() = delete;
+};
+using facade_builder =
+    basic_facade_builder<std::tuple<>, std::tuple<>, detail::invalid_size,
+                         detail::invalid_size, detail::invalid_cl,
+                         detail::invalid_cl, detail::invalid_cl>;
+
+} // namespace pro::inline v4
+
+#endif // MSFT_PROXY_V4_DETAIL_FACADE_CREATION_H_
diff --git a/include/proxy/v4/detail/proxy_creation.h b/include/proxy/v4/detail/proxy_creation.h
new file mode 100644
index 0000000..6134cc8
--- /dev/null
+++ b/include/proxy/v4/detail/proxy_creation.h
@@ -0,0 +1,433 @@
+// Copyright (c) 2022-2026 Microsoft Corporation.
+// Copyright (c) 2026-Present Next Gen C++ Foundation.
+// Licensed under the MIT License.
+
+#ifndef MSFT_PROXY_V4_DETAIL_PROXY_CREATION_H_
+#define MSFT_PROXY_V4_DETAIL_PROXY_CREATION_H_
+
+#include <initializer_list>
+#include <memory>
+#include <new>
+
+#if __STDC_HOSTED__
+#include <atomic>
+#endif // __STDC_HOSTED__
+
+#include "core.h"
+
+namespace pro::inline v4 {
+
+template <class T, class F>
+concept inplace_proxiable_target = proxiable<detail::inplace_ptr<T>, F>;
+
+template <class T, class F>
+concept proxiable_target =
+    proxiable<detail::observer_ptr<T&, const T&, T&&, const T&&>,
+              observer_facade<F>>;
+
+template <class T>
+  requires(is_bitwise_trivially_relocatable_v<T>)
+struct is_bitwise_trivially_relocatable<detail::inplace_ptr<T>>
+    : std::true_type {};
+
+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...>)
+{
+  return proxy<F>{std::in_place_type<detail::inplace_ptr<T>>, std::in_place,
+                  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...>)
+{
+  return proxy<F>{std::in_place_type<detail::inplace_ptr<T>>, std::in_place, 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>)
+{
+  return proxy<F>{std::in_place_type<detail::inplace_ptr<std::decay_t<T>>>,
+                  std::in_place, std::forward<T>(value)};
+}
+
+template <facade F, class T>
+constexpr proxy_view<F> make_proxy_view(T& value) noexcept {
+  return proxy_view<F>{
+      detail::observer_ptr<T&, const T&, T&&, const T&&>{value}};
+}
+
+#if __STDC_HOSTED__
+namespace detail {
+
+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 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)...);
+  return result.release();
+}
+template <class Alloc, class T>
+void deallocate(const Alloc& alloc, T* ptr) {
+  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 {
+  explicit alloc_aware(const Alloc& alloc) noexcept : alloc(alloc) {}
+  alloc_aware(const alloc_aware&) noexcept = default;
+
+  [[PRO4D_NO_UNIQUE_ADDRESS_ATTRIBUTE]]
+  Alloc alloc;
+};
+template <class T>
+class indirect_ptr {
+public:
+  explicit indirect_ptr(T* ptr) noexcept : ptr_(ptr) {}
+  auto operator->() noexcept { return std::addressof(**ptr_); }
+  auto operator->() const noexcept { return std::addressof(**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_));
+  }
+
+protected:
+  T* ptr_;
+};
+
+template <class T, class Alloc>
+class PRO4D_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>>(
+            allocate<inplace_ptr<T>>(this->alloc, std::in_place, *rhs)) {}
+  allocated_ptr(allocated_ptr&& rhs) = delete;
+  ~allocated_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
+    deallocate(this->alloc, this->ptr_);
+  }
+};
+
+template <class T, class Alloc>
+struct PRO4D_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),
+        inplace_ptr<T>(std::in_place, std::forward<Args>(args)...) {}
+};
+template <class T, class Alloc>
+class compact_ptr : public indirect_ptr<compact_ptr_storage<T, Alloc>> {
+  using Storage = compact_ptr_storage<T, Alloc>;
+
+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>(
+            allocate<Storage>(rhs.ptr_->alloc, rhs.ptr_->alloc, *rhs)) {}
+  compact_ptr(compact_ptr&& rhs) = delete;
+  ~compact_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
+    deallocate(this->ptr_->alloc, this->ptr_);
+  }
+};
+
+struct shared_compact_ptr_storage_base {
+  std::atomic_long ref_count = 1;
+};
+template <class T, class Alloc>
+struct PRO4D_ENFORCE_EBO shared_compact_ptr_storage
+    : 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),
+        inplace_ptr<T>(std::in_place, std::forward<Args>(args)...) {}
+};
+template <class T, class Alloc>
+class shared_compact_ptr
+    : public indirect_ptr<shared_compact_ptr_storage<T, Alloc>> {
+  using Storage = shared_compact_ptr_storage<T, Alloc>;
+
+public:
+  template <class... Args>
+  shared_compact_ptr(const Alloc& alloc, 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_) {
+    this->ptr_->ref_count.fetch_add(1, std::memory_order::relaxed);
+  }
+  shared_compact_ptr(shared_compact_ptr&& rhs) = delete;
+  ~shared_compact_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
+    if (this->ptr_->ref_count.fetch_sub(1, std::memory_order::acq_rel) == 1) {
+      deallocate(this->ptr_->alloc, this->ptr_);
+    }
+  }
+};
+
+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> {
+  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)...);
+  }
+
+  alignas(alignof(T)) std::byte value[sizeof(T)];
+};
+template <class T, class Alloc>
+class weak_compact_ptr;
+template <class T, class Alloc>
+class strong_compact_ptr {
+  using Storage = strong_weak_compact_ptr_storage<T, Alloc>;
+  friend class weak_compact_ptr<T, Alloc>;
+
+public:
+  using weak_type = weak_compact_ptr<T, Alloc>;
+
+  explicit strong_compact_ptr(Storage* ptr) noexcept : ptr_(ptr) {}
+  template <class... Args>
+  strong_compact_ptr(const Alloc& alloc, Args&&... args)
+      : ptr_(allocate<Storage>(alloc, alloc, std::forward<Args>(args)...)) {}
+  strong_compact_ptr(const strong_compact_ptr& rhs) noexcept : ptr_(rhs.ptr_) {
+    ptr_->strong_count.fetch_add(1, std::memory_order::relaxed);
+  }
+  strong_compact_ptr(strong_compact_ptr&& rhs) = delete;
+  ~strong_compact_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
+    if (ptr_->strong_count.fetch_sub(1, std::memory_order::acq_rel) == 1) {
+      std::destroy_at(operator->());
+      if (ptr_->weak_count.fetch_sub(1u, std::memory_order::release) == 1) {
+        deallocate(ptr_->alloc, ptr_);
+      }
+    }
+  }
+  T* operator->() noexcept {
+    return std::launder(reinterpret_cast<T*>(&ptr_->value));
+  }
+  const T* operator->() const noexcept {
+    return std::launder(reinterpret_cast<const T*>(&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:
+  strong_weak_compact_ptr_storage<T, Alloc>* ptr_;
+};
+template <class T, class Alloc>
+class weak_compact_ptr {
+public:
+  using element_type = T;
+
+  weak_compact_ptr(const strong_compact_ptr<T, Alloc>& rhs) noexcept
+      : ptr_(rhs.ptr_) {
+    ptr_->weak_count.fetch_add(1, std::memory_order::relaxed);
+  }
+  weak_compact_ptr(const weak_compact_ptr& rhs) noexcept : ptr_(rhs.ptr_) {
+    ptr_->weak_count.fetch_add(1, std::memory_order::relaxed);
+  }
+  weak_compact_ptr(weak_compact_ptr&& rhs) = delete;
+  ~weak_compact_ptr() noexcept {
+    if (ptr_->weak_count.fetch_sub(1u, std::memory_order::acq_rel) == 1) {
+      deallocate(ptr_->alloc, ptr_);
+    }
+  }
+  auto lock() const noexcept {
+    return converter{[ptr = this->ptr_]<class F>(
+                         std::in_place_type_t<proxy<F>>) noexcept -> proxy<F> {
+      long ref_count = ptr->strong_count.load(std::memory_order::relaxed);
+      do {
+        if (ref_count == 0) {
+          return proxy<F>{};
+        }
+      } while (!ptr->strong_count.compare_exchange_weak(
+          ref_count, ref_count + 1, std::memory_order::relaxed));
+      return proxy<F>{std::in_place_type<strong_compact_ptr<T, Alloc>>, ptr};
+    }};
+  }
+
+private:
+  strong_weak_compact_ptr_storage<T, Alloc>* ptr_;
+};
+
+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)...};
+  } else {
+    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)...};
+  } else {
+    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) {
+  if constexpr (std::is_convertible_v<proxy<F>, weak_proxy<F>>) {
+    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)...};
+  }
+}
+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)...);
+}
+
+} // namespace detail
+
+template <class T, class D>
+  requires(is_bitwise_trivially_relocatable_v<D>)
+struct is_bitwise_trivially_relocatable<std::unique_ptr<T, D>>
+    : std::true_type {};
+template <class T>
+struct is_bitwise_trivially_relocatable<std::shared_ptr<T>> : std::true_type {};
+template <class T>
+struct is_bitwise_trivially_relocatable<std::weak_ptr<T>> : std::true_type {};
+template <class T, class Alloc>
+  requires(is_bitwise_trivially_relocatable_v<Alloc>)
+struct is_bitwise_trivially_relocatable<detail::allocated_ptr<T, Alloc>>
+    : std::true_type {};
+template <class T, class Alloc>
+struct is_bitwise_trivially_relocatable<detail::compact_ptr<T, Alloc>>
+    : std::true_type {};
+template <class T, class Alloc>
+struct is_bitwise_trivially_relocatable<detail::shared_compact_ptr<T, Alloc>>
+    : std::true_type {};
+template <class T, class Alloc>
+struct is_bitwise_trivially_relocatable<detail::strong_compact_ptr<T, Alloc>>
+    : std::true_type {};
+template <class T, class Alloc>
+struct is_bitwise_trivially_relocatable<detail::weak_compact_ptr<T, Alloc>>
+    : std::true_type {};
+
+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...>)
+{
+  return detail::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 detail::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>)
+{
+  return detail::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 detail::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 detail::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>)
+{
+  return detail::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 detail::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 detail::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>)
+{
+  return detail::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...>)
+{
+  return detail::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...>)
+{
+  return detail::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>)
+{
+  return detail::make_proxy_shared_impl<F, std::decay_t<T>>(
+      std::forward<T>(value));
+}
+#endif // __STDC_HOSTED__
+
+} // namespace pro::inline v4
+
+#endif // MSFT_PROXY_V4_DETAIL_PROXY_CREATION_H_
diff --git a/include/proxy/v4/detail/skills.h b/include/proxy/v4/detail/skills.h
new file mode 100644
index 0000000..8f0f357
--- /dev/null
+++ b/include/proxy/v4/detail/skills.h
@@ -0,0 +1,310 @@
+// Copyright (c) 2022-2026 Microsoft Corporation.
+// Copyright (c) 2026-Present Next Gen C++ Foundation.
+// Licensed under the MIT License.
+
+#ifndef MSFT_PROXY_V4_DETAIL_SKILLS_H_
+#define MSFT_PROXY_V4_DETAIL_SKILLS_H_
+
+#include <memory>
+
+#if __STDC_HOSTED__
+// LLVM libc++ 17 has usable <format> despite lacking __cpp_lib_format until 19.
+#if __cpp_lib_format >= 201907L || _LIBCPP_VERSION >= 170000
+#include <format>
+#include <string_view>
+#define PRO4D_HAS_FORMAT
+#endif // __cpp_lib_format || _LIBCPP_VERSION >= 170000
+#endif // __STDC_HOSTED__
+
+#if __cpp_rtti >= 199711L
+#include <optional>
+#include <typeinfo>
+#endif // __cpp_rtti >= 199711L
+
+#include "core.h"
+
+namespace pro::inline v4 {
+
+#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";
+  }
+};
+#endif // __cpp_rtti >= 199711L
+
+namespace detail {
+
+template <template <class...> class TT, class... Ctx>
+struct enabled_t {};
+template <class T, template <class...> class TT, class... Ctx>
+concept enabled_for = std::is_base_of_v<enabled_t<TT, Ctx...>, T>;
+
+struct view_conversion_dispatch : cast_dispatch_base<false, true> {
+  template <class T>
+  PRO4D_STATIC_CALL(auto, T& 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};
+  }
+};
+template <class F>
+using view_conversion_overload = proxy_view<F>() & noexcept;
+
+struct weak_conversion_dispatch : cast_dispatch_base<false, true> {
+  template <class P>
+  PRO4D_STATIC_CALL(auto, const P& self) noexcept
+    requires(requires(const typename P::weak_type& w) {
+      { w.lock() } noexcept;
+    } && std::is_convertible_v<const P&, typename P::weak_type>)
+  {
+    return converter{
+        [&self]<class F>(std::in_place_type_t<proxy<F>>) noexcept
+          requires(proxiable<typename P::weak_type, F>)
+        { return proxy<F>{std::in_place_type<typename P::weak_type>, self}; }};
+  }
+};
+template <class F>
+using weak_conversion_overload = weak_proxy<F>() const noexcept;
+
+template <template <class...> class Formatter,
+          template <class...> class StringView,
+          template <class...> class ParseContext,
+          template <class...> class FormatContext>
+struct format_traits {
+  template <class CharT>
+  using overload = typename FormatContext<CharT>::iterator(
+      StringView<CharT> spec, FormatContext<CharT>& fc) const;
+
+  struct dispatch {
+    template <class T, class CharT>
+    PRO4D_STATIC_CALL(auto, const T& self, StringView<CharT> spec,
+                      FormatContext<CharT>& fc)
+      requires(std::is_default_constructible_v<Formatter<T, CharT>>)
+    {
+      Formatter<T, CharT> impl;
+      {
+        ParseContext<CharT> pc{spec};
+        impl.parse(pc);
+      }
+      return impl.format(self, fc);
+    }
+
+    template <class P, class D, class... Os>
+    struct PRO4D_ENFORCE_EBO accessor : accessor<P, D, Os>... {};
+    template <class P, class D>
+    struct accessor<P, D, overload<char>> : enabled_t<Formatter, char> {};
+    template <class P, class D>
+    struct accessor<P, D, overload<wchar_t>> : enabled_t<Formatter, wchar_t> {};
+  };
+
+  template <class CharT>
+  struct formatter {
+    constexpr auto parse(ParseContext<CharT>& pc) {
+      for (auto it = pc.begin(); it != pc.end(); ++it) {
+        if (*it == '}') {
+          spec_ = StringView<CharT>{pc.begin(), it + 1};
+          return it;
+        }
+      }
+      return pc.end();
+    }
+
+    template <class P, class CompatibleFormatContext>
+    auto format(const P& p, CompatibleFormatContext& fc) const ->
+        typename CompatibleFormatContext::iterator {
+      return invoke<dispatch, overload<CharT>>(p, spec_, fc);
+    }
+
+  private:
+    StringView<CharT> spec_;
+  };
+};
+
+#ifdef PRO4D_HAS_FORMAT
+template <class CharT>
+struct std_format_context_traits;
+template <>
+struct std_format_context_traits<char>
+    : std::type_identity<std::format_context> {};
+template <>
+struct std_format_context_traits<wchar_t>
+    : std::type_identity<std::wformat_context> {};
+template <class CharT>
+using std_format_context = typename std_format_context_traits<CharT>::type;
+struct std_format_traits
+    : format_traits<std::formatter, std::basic_string_view,
+                    std::basic_format_parse_context, std_format_context> {};
+#endif // PRO4D_HAS_FORMAT
+
+#if __cpp_rtti >= 199711L
+struct proxy_cast_context {
+  const std::type_info* type_ptr;
+  bool is_ref;
+  bool is_const;
+  void* result_ptr;
+};
+
+template <class Self, class D, class O>
+struct proxy_cast_accessor_impl {
+  template <class T>
+  friend T proxy_cast(Self self) {
+    static_assert(!std::is_rvalue_reference_v<T>);
+    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};
+      invoke<D, O>(static_cast<Self>(self), ctx);
+      if (result == nullptr) [[unlikely]] {
+        PRO4D_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};
+      invoke<D, O>(static_cast<Self>(self), ctx);
+      if (!result.has_value()) [[unlikely]] {
+        PRO4D_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<Self>::value)
+  {
+    void* result = nullptr;
+    proxy_cast_context ctx{.type_ptr = &typeid(T),
+                           .is_ref = true,
+                           .is_const = std::is_const_v<T>,
+                           .result_ptr = &result};
+    invoke<D, O>(*self, ctx);
+    return static_cast<T*>(result);
+  }
+};
+
+#define PRO4D_DEF_PROXY_CAST_ACCESSOR(oq, pq, ne, ...)                         \
+  template <class P, class D>                                                  \
+  struct accessor<P, D, void(proxy_cast_context) oq ne>                        \
+      : proxy_cast_accessor_impl<P pq, D, void(proxy_cast_context) oq ne> {}
+struct proxy_cast_dispatch {
+  template <class T>
+  PRO4D_STATIC_CALL(void, T&& self, proxy_cast_context ctx) {
+    if (typeid(T) == *ctx.type_ptr) [[likely]] {
+      if (ctx.is_ref) {
+        if constexpr (std::is_lvalue_reference_v<T>) {
+          if (ctx.is_const || !std::is_const_v<T>) [[likely]] {
+            *static_cast<void**>(ctx.result_ptr) = (void*)std::addressof(self);
+          }
+        }
+      } else {
+        if constexpr (std::is_constructible_v<std::decay_t<T>, T>) {
+          static_cast<std::optional<std::decay_t<T>>*>(ctx.result_ptr)
+              ->emplace(std::forward<T>(self));
+        }
+      }
+    }
+  }
+  PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PRO4D_DEF_PROXY_CAST_ACCESSOR)
+};
+#undef PRO4D_DEF_PROXY_CAST_ACCESSOR
+
+struct proxy_typeid_reflector {
+  proxy_typeid_reflector() = default;
+  template <class T>
+  constexpr explicit proxy_typeid_reflector(std::in_place_type_t<T>)
+      : info(&typeid(T)) {}
+
+  template <class Self, class R>
+  struct accessor {
+    friend const std::type_info& proxy_typeid(const Self& self) noexcept {
+      const proxy_typeid_reflector& refl = reflect<R>(self);
+      return *refl.info;
+    }
+    PRO4D_DEBUG(
+        accessor() noexcept { std::ignore = &pro_symbol_guard; }
+
+        private : static inline const std::type_info& pro_symbol_guard(
+            const Self& self) { return proxy_typeid(self); })
+  };
+
+  const std::type_info* info;
+};
+#endif // __cpp_rtti >= 199711L
+
+} // namespace detail
+
+namespace skills {
+
+#ifdef PRO4D_HAS_FORMAT
+template <class FB>
+using format = typename FB::template add_convention<
+    detail::std_format_traits::dispatch,
+    detail::std_format_traits::overload<char>>;
+
+template <class FB>
+using wformat = typename FB::template add_convention<
+    detail::std_format_traits::dispatch,
+    detail::std_format_traits::overload<wchar_t>>;
+#endif // PRO4D_HAS_FORMAT
+
+#if __cpp_rtti >= 199711L
+template <class FB>
+using indirect_rtti = typename FB::template add_indirect_convention<
+    detail::proxy_cast_dispatch, void(detail::proxy_cast_context) &,
+    void(detail::proxy_cast_context) const&,
+    void(detail::proxy_cast_context) &&>::
+    template add_indirect_reflection<detail::proxy_typeid_reflector>;
+
+template <class FB>
+using direct_rtti = typename FB::template add_direct_convention<
+    detail::proxy_cast_dispatch, void(detail::proxy_cast_context) &,
+    void(detail::proxy_cast_context) const&,
+    void(detail::proxy_cast_context) &&>::
+    template add_direct_reflection<detail::proxy_typeid_reflector>;
+
+template <class FB>
+using rtti = indirect_rtti<FB>;
+#endif // __cpp_rtti >= 199711L
+
+template <class FB>
+using slim =
+    typename FB::template restrict_layout<sizeof(void*), alignof(void*)>;
+
+template <class FB>
+using as_view = typename FB::template add_direct_convention<
+    detail::view_conversion_dispatch,
+    facade_aware_overload_t<detail::view_conversion_overload>>;
+
+template <class FB>
+using as_weak = typename FB::template add_direct_convention<
+    detail::weak_conversion_dispatch,
+    facade_aware_overload_t<detail::weak_conversion_overload>>;
+
+} // namespace skills
+
+} // namespace pro::inline v4
+
+#ifdef PRO4D_HAS_FORMAT
+namespace std {
+
+template <class T, class CharT>
+  requires(pro::v4::detail::enabled_for<T, std::formatter, CharT>)
+struct formatter<T, CharT>
+    : pro::v4::detail::std_format_traits::formatter<CharT> {};
+
+} // namespace std
+#endif // PRO4D_HAS_FORMAT
+
+#endif // MSFT_PROXY_V4_DETAIL_SKILLS_H_
diff --git a/include/proxy/v4/proxy.h b/include/proxy/v4/proxy.h
index 9ca6e15..84735c4 100644
--- a/include/proxy/v4/proxy.h
+++ b/include/proxy/v4/proxy.h
@@ -5,2751 +5,10 @@
 #ifndef MSFT_PROXY_V4_PROXY_H_
 #define MSFT_PROXY_V4_PROXY_H_
 
-#include <bit>
-#include <cassert>
-#include <concepts>
-#include <cstddef>
-#include <cstdlib>
-#include <exception>
-#include <initializer_list>
-#include <limits>
-#include <memory>
-#include <new>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <version>
-
-#if __STDC_HOSTED__
-#include <atomic>
-
-// LLVM libc++ 17 has usable <format> despite lacking __cpp_lib_format until 19.
-#if __cpp_lib_format >= 201907L || _LIBCPP_VERSION >= 170000
-#include <format>
-#define PRO4D_HAS_FORMAT
-#endif // __cpp_lib_format || _LIBCPP_VERSION >= 170000
-#endif // __STDC_HOSTED__
-
-#if __cpp_rtti >= 199711L
-#include <optional>
-#include <typeinfo>
-#endif // __cpp_rtti >= 199711L
-
-#include "proxy_macros.h"
-
-#if __has_cpp_attribute(msvc::no_unique_address)
-#define PROD_NO_UNIQUE_ADDRESS_ATTRIBUTE msvc::no_unique_address
-#elif __has_cpp_attribute(no_unique_address)
-#define PROD_NO_UNIQUE_ADDRESS_ATTRIBUTE no_unique_address
-#else
-#error Proxy requires C++20 attribute no_unique_address.
-#endif
-
-#if __cpp_lib_unreachable >= 202202L
-#define PROD_UNREACHABLE() std::unreachable()
-#else
-#define PROD_UNREACHABLE() std::abort()
-#endif // __cpp_lib_unreachable >= 202202L
-
-namespace pro::inline v4 {
-
-// =============================================================================
-// == Core Components (facade, proxy, etc.)                                   ==
-// =============================================================================
-
-namespace details {
-
-template <class F>
-struct basic_facade_traits;
-
-} // namespace details
-
-enum class constraint_level { none, nontrivial, nothrow, trivial };
-
-template <template <class> class O>
-struct facade_aware_overload_t {
-  facade_aware_overload_t() = delete;
-};
-
-template <class F>
-concept facade = details::basic_facade_traits<F>::applicable;
-
-template <facade F>
-class proxy_indirect_accessor;
-template <facade F>
-class PRO4D_ENFORCE_EBO proxy;
-
-template <class T>
-struct is_bitwise_trivially_relocatable
-    : std::bool_constant<std::is_trivially_move_constructible_v<T> &&
-                         std::is_trivially_destructible_v<T>> {};
-template <class T>
-constexpr bool is_bitwise_trivially_relocatable_v =
-    is_bitwise_trivially_relocatable<T>::value;
-
-namespace details {
-
-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> {};
-template <template <class, class> class R, class O, class I, class... Is>
-struct recursive_reduction<R, O, I, Is...>
-    : recursive_reduction<R, R<O, I>, Is...> {};
-template <template <class, class> class R, class O, class... Is>
-using recursive_reduction_t = typename recursive_reduction<R, O, Is...>::type;
-
-template <template <class...> class R, class... Args>
-struct reduction_traits {
-  template <class O, class I>
-  using type = typename R<Args..., O, I>::type;
-};
-
-template <class O, class I>
-struct composition_reduction : std::type_identity<O> {};
-template <template <class...> class T, class... Os, class I>
-  requires(!std::is_void_v<I>)
-struct composition_reduction<T<Os...>, I> : std::type_identity<T<Os..., I>> {};
-template <template <class...> class T, class... Os, class... Is>
-struct composition_reduction<T<Os...>, T<Is...>>
-    : std::type_identity<T<Os..., Is...>> {};
-template <class T, class... Us>
-using composite_t = recursive_reduction_t<
-    reduction_traits<composition_reduction>::template type, T, Us...>;
-
-template <class Expr>
-consteval bool is_consteval(Expr) {
-  return requires { typename std::bool_constant<(Expr{}(), false)>; };
-}
-template <class T, class U>
-concept static_prop = std::is_same_v<T, const U&>;
-
-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 } -> static_prop<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> && ...);
-      }(std::make_index_sequence<std::tuple_size_v<T>>{});
-    }
-  }
-  return false;
-}
-
-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>
-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>
-struct instantiated_traits_helper
-    : instantiated_traits<
-          T, TL, std::make_index_sequence<std::tuple_size_v<TL>>, Args...> {};
-template <template <class...> class T, class... Ts, class... Args>
-struct instantiated_traits_helper<T, std::tuple<Ts...>, Args...>
-    : std::type_identity<T<Args..., Ts...>> {};
-template <template <class...> class T, class TL, class... Args>
-using instantiated_t =
-    typename instantiated_traits_helper<T, TL, Args...>::type;
-
-enum class qualifier_type { lv, const_lv, rv, const_rv };
-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>
-struct add_qualifier_traits<T, qualifier_type::const_lv>
-    : std::type_identity<const T&> {};
-template <class T>
-struct add_qualifier_traits<T, qualifier_type::rv> : std::type_identity<T&&> {};
-template <class T>
-struct add_qualifier_traits<T, qualifier_type::const_rv>
-    : std::type_identity<const T&&> {};
-template <class T, qualifier_type Q>
-using add_qualifier_t = typename add_qualifier_traits<T, Q>::type;
-template <class T, qualifier_type Q>
-using add_qualifier_ptr_t = std::remove_reference_t<add_qualifier_t<T, Q>>*;
-
-template <class T, constraint_level CL>
-struct copyability_traits : inapplicable_traits {};
-template <class T>
-struct copyability_traits<T, constraint_level::none> : applicable_traits {};
-template <class T>
-  requires(std::is_copy_constructible_v<T>)
-struct copyability_traits<T, constraint_level::nontrivial> : applicable_traits {
-};
-template <class T>
-  requires(std::is_nothrow_copy_constructible_v<T>)
-struct copyability_traits<T, constraint_level::nothrow> : applicable_traits {};
-template <class T>
-  requires(std::is_trivially_copy_constructible_v<T>)
-struct copyability_traits<T, constraint_level::trivial> : applicable_traits {};
-
-template <class T, constraint_level CL>
-struct relocatability_traits : inapplicable_traits {};
-template <class T>
-struct relocatability_traits<T, constraint_level::none> : applicable_traits {};
-template <class T>
-  requires((std::is_move_constructible_v<T> && std::is_destructible_v<T>) ||
-           is_bitwise_trivially_relocatable_v<T>)
-struct relocatability_traits<T, constraint_level::nontrivial>
-    : applicable_traits {};
-template <class T>
-  requires((std::is_nothrow_move_constructible_v<T> &&
-            std::is_nothrow_destructible_v<T>) ||
-           is_bitwise_trivially_relocatable_v<T>)
-struct relocatability_traits<T, constraint_level::nothrow> : applicable_traits {
-};
-template <class T>
-  requires(is_bitwise_trivially_relocatable_v<T>)
-struct relocatability_traits<T, constraint_level::trivial> : applicable_traits {
-};
-
-template <class T, constraint_level CL>
-struct destructibility_traits : inapplicable_traits {};
-template <class T>
-struct destructibility_traits<T, constraint_level::none> : applicable_traits {};
-template <class T>
-  requires(std::is_destructible_v<T>)
-struct destructibility_traits<T, constraint_level::nontrivial>
-    : applicable_traits {};
-template <class T>
-  requires(std::is_nothrow_destructible_v<T>)
-struct destructibility_traits<T, constraint_level::nothrow>
-    : applicable_traits {};
-template <class T>
-  requires(std::is_trivially_destructible_v<T>)
-struct destructibility_traits<T, constraint_level::trivial>
-    : applicable_traits {};
-
-template <class F, bool IsDirect, qualifier_type Q>
-using proxy_accessor = add_qualifier_t<
-    std::conditional_t<IsDirect, proxy<F>, proxy_indirect_accessor<F>>, Q>;
-template <class F, qualifier_type Q>
-add_qualifier_t<proxy<F>, Q>
-    as_proxy(add_qualifier_t<proxy_indirect_accessor<F>, Q> p);
-
-struct proxy_helper {
-  template <class P, class F>
-  struct resetting_guard {
-    explicit resetting_guard(proxy<F>& p) noexcept : p_(p) {}
-    explicit resetting_guard(proxy_indirect_accessor<F>& p) noexcept
-        : p_(as_proxy<F, qualifier_type::lv>(p)) {}
-    ~resetting_guard() noexcept(std::is_nothrow_destructible_v<P>) {
-      std::destroy_at(std::addressof(get_ptr<P, F, qualifier_type::lv>(p_)));
-      p_.meta_.reset();
-    }
-
-  private:
-    proxy<F>& p_;
-  };
-
-  template <class M, class F>
-  static const M& get_meta(const proxy<F>& p) noexcept {
-    assert(p.has_value());
-    return static_cast<const M&>(*p.meta_.operator->());
-  }
-  template <class M, class F>
-  static const M& get_meta(const proxy_indirect_accessor<F>& p) noexcept {
-    return get_meta<M>(as_proxy<F, qualifier_type::const_lv>(p));
-  }
-  template <class P, class F, qualifier_type Q>
-  static add_qualifier_t<P, Q> get_ptr(add_qualifier_t<proxy<F>, Q> p) {
-    return static_cast<add_qualifier_t<P, Q>>(
-        *std::launder(reinterpret_cast<add_qualifier_ptr_t<P, Q>>(p.ptr_)));
-  }
-  template <class P, class F1, class F2>
-  static void trivially_relocate(proxy<F1>& from, proxy<F2>& to) noexcept {
-    std::uninitialized_copy_n(from.ptr_, sizeof(P), to.ptr_);
-    to.meta_ = decltype(proxy<F2>::meta_){std::in_place_type<P>};
-    from.meta_.reset();
-  }
-};
-
-template <class P, bool IsDirect, qualifier_type Q>
-struct operand_traits : add_qualifier_traits<P, Q> {};
-template <class P, qualifier_type Q>
-struct operand_traits<P, false, Q>
-    : std::type_identity<decltype(*std::declval<add_qualifier_t<P, Q>>())> {};
-template <class P, bool IsDirect, qualifier_type Q>
-using operand_t = typename operand_traits<P, IsDirect, Q>::type;
-template <class P, bool IsDirect, class D, qualifier_type Q, bool NE, class R,
-          class... Args>
-concept invocable_dispatch =
-    (IsDirect || (requires { *std::declval<add_qualifier_t<P, Q>>(); } &&
-                  (!NE || noexcept(*std::declval<add_qualifier_t<P, Q>>())))) &&
-    ((NE && std::is_nothrow_invocable_r_v<R, D, operand_t<P, IsDirect, Q>,
-                                          Args...>) ||
-     (!NE &&
-      std::is_invocable_r_v<R, D, operand_t<P, IsDirect, Q>, Args...>)) &&
-    (Q != qualifier_type::rv || (NE && std::is_nothrow_destructible_v<P>) ||
-     (!NE && std::is_destructible_v<P>));
-
-struct internal_dispatch {};
-
-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 P, bool IsDirect, class D>
-  static constexpr bool applicable_ptr =
-      invocable_dispatch<P, IsDirect, D, Q, NE, R, Args...>;
-};
-template <class R, class... Args>
-struct overload_traits<R(Args...)>
-    : overload_traits_impl<qualifier_type::lv, false, R, Args...> {};
-template <class R, class... Args>
-struct overload_traits<R(Args...) noexcept>
-    : overload_traits_impl<qualifier_type::lv, true, R, Args...> {};
-template <class R, class... Args>
-struct overload_traits<R(Args...) &>
-    : overload_traits_impl<qualifier_type::lv, false, R, Args...> {};
-template <class R, class... Args>
-struct overload_traits<R(Args...) & noexcept>
-    : overload_traits_impl<qualifier_type::lv, true, R, Args...> {};
-template <class R, class... Args>
-struct overload_traits<R(Args...) &&>
-    : overload_traits_impl<qualifier_type::rv, false, R, Args...> {};
-template <class R, class... Args>
-struct overload_traits<R(Args...) && noexcept>
-    : overload_traits_impl<qualifier_type::rv, true, R, Args...> {};
-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>
-    : 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_lv, false, R, Args...> {};
-template <class R, class... Args>
-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>
-    : overload_traits_impl<qualifier_type::const_rv, true, R, Args...> {};
-template <class O>
-using ret_t = typename overload_traits<O>::return_type;
-
-template <class 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>;
-};
-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;
-template <class P, class F, bool IsDirect, class D, class O>
-consteval void diagnose_proxiable_required_convention_not_implemented() {
-  static_assert(overload_traits<O>::applicable &&
-                    overload_traits<O>::template applicable_ptr<P, IsDirect, D>,
-                "not proxiable due to a required convention not implemented");
-}
-
-template <class ProP, class D, class O>
-struct conv_meta;
-#define PROD_DEF_CONV_META(oq, pq, ne, ...)                                    \
-  template <class ProP, class D, class R, class... Args>                       \
-  struct conv_meta<ProP, D, R(Args...) oq ne> {                                \
-    conv_meta() = default;                                                     \
-    template <class P>                                                         \
-    constexpr explicit conv_meta(std::in_place_type_t<P>)                      \
-        : invoke([](ProP pq self, Args... args) ne -> R {                      \
-            return reinterpret_invoke<P, D, R>(static_cast<ProP pq>(self),     \
-                                               std::forward<Args>(args)...);   \
-          }) {}                                                                \
-                                                                               \
-    R (*invoke)(ProP pq, Args...) ne;                                          \
-  }
-PRO4D_DEF_OVERLOAD_SPECIALIZATIONS(PROD_DEF_CONV_META)
-#undef PROD_DEF_CONV_META
-
-template <class... Ms>
-struct PRO4D_ENFORCE_EBO composite_meta : Ms... {
-  composite_meta() = default;
-  template <class P>
-  constexpr explicit composite_meta(std::in_place_type_t<P>)
-      : Ms(std::in_place_type<P>)... {}
-};
-
-template <class T>
-consteval bool is_is_direct_well_formed() {
-  if constexpr (requires {
-                  { T::is_direct } -> static_prop<bool>;
-                }) {
-    if constexpr (is_consteval([] { return T::is_direct; })) {
-      return true;
-    }
-  }
-  return false;
-}
-
-template <class C, class... Os>
-struct basic_conv_traits_impl : inapplicable_traits {};
-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() } noexcept;
-    typename C::overload_types;
-  } && is_is_direct_well_formed<C>() &&
-           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 T>
-struct a11y_traits_impl
-    : std::conditional<std::is_nothrow_default_constructible_v<T> &&
-                           std::is_trivially_copyable_v<T> &&
-                           !std::is_final_v<T>,
-                       T, void> {};
-template <class SFINAE, class T, class... Args>
-struct a11y_traits : std::type_identity<void> {};
-template <class T, class... Args>
-struct a11y_traits<std::void_t<typename T::template accessor<Args...>>, T,
-                   Args...>
-    : a11y_traits_impl<typename T::template accessor<Args...>> {};
-template <class T, class... Args>
-using accessor_t = typename a11y_traits<void, T, Args...>::type;
-
-template <class C, class F, class... Os>
-struct conv_traits_impl {
-  static_assert((overload_traits<substituted_overload_t<Os, F>>::applicable &&
-                 ...));
-  using meta = composite_meta<conv_meta<
-      std::conditional_t<C::is_direct, proxy<F>, proxy_indirect_accessor<F>>,
-      typename C::dispatch_type, substituted_overload_t<Os, F>>...>;
-  template <class T>
-  using accessor =
-      accessor_t<typename C::dispatch_type, T, typename C::dispatch_type,
-                 substituted_overload_t<Os, F>...>;
-
-  template <class P>
-  static consteval void diagnose_proxiable() {
-    ((diagnose_proxiable_required_convention_not_implemented<
-         P, F, C::is_direct, typename C::dispatch_type,
-         substituted_overload_t<Os, F>>()),
-     ...);
-  }
-
-  template <class P>
-  static constexpr bool applicable_ptr =
-      (overload_traits<substituted_overload_t<Os, F>>::template applicable_ptr<
-           P, C::is_direct, typename C::dispatch_type> &&
-       ...);
-};
-template <class C, class F>
-struct conv_traits
-    : instantiated_t<conv_traits_impl, typename C::overload_types, C, F> {};
-
-template <bool IsDirect, class R>
-struct reflection_meta {
-  reflection_meta() = default;
-  template <class P>
-    requires(IsDirect)
-  constexpr explicit reflection_meta(std::in_place_type_t<P>)
-      : reflector(std::in_place_type<P>) {}
-  template <class P>
-    requires(!IsDirect)
-  constexpr explicit reflection_meta(std::in_place_type_t<P>)
-      : reflector(
-            std::in_place_type<typename std::pointer_traits<P>::element_type>) {
-  }
-
-  [[PROD_NO_UNIQUE_ADDRESS_ATTRIBUTE]]
-  R reflector;
-};
-
-template <class T, bool IsDirect, class R>
-consteval bool is_reflector_well_formed() {
-  if constexpr (IsDirect) {
-    if constexpr (std::is_constructible_v<R, std::in_place_type_t<T>>) {
-      if constexpr (is_consteval([] { return R(std::in_place_type<T>); })) {
-        return true;
-      }
-    }
-  } else {
-    return is_reflector_well_formed<
-        typename std::pointer_traits<T>::element_type, true, R>();
-  }
-  return false;
-}
-template <class P, class F, bool IsDirect, class R>
-consteval void diagnose_proxiable_required_reflection_not_implemented() {
-  static_assert(is_reflector_well_formed<P, IsDirect, R>(),
-                "not proxiable due to a required reflection not implemented");
-}
-
-struct copy_dispatch {
-  template <class T, class F>
-  PRO4D_STATIC_CALL(void, const T& self, proxy<F>& rhs) noexcept(
-      std::is_nothrow_copy_constructible_v<T>) {
-    std::construct_at(std::addressof(rhs), self);
-  }
-};
-struct relocate_dispatch : internal_dispatch {
-  template <class P, class F>
-  PRO4D_STATIC_CALL(void, std::in_place_type_t<P>, proxy<F>&& self,
-                    proxy<F>& rhs) noexcept {
-    proxy_helper::trivially_relocate<P>(self, rhs);
-  }
-  template <class T, class F>
-  PRO4D_STATIC_CALL(void, T&& self, proxy<F>& rhs) noexcept(
-      relocatability_traits<T, constraint_level::nothrow>::applicable) {
-    std::construct_at(std::addressof(rhs), std::forward<T>(self));
-  }
-};
-struct destroy_dispatch {
-  template <class T>
-  PRO4D_STATIC_CALL(void, T& self) noexcept(std::is_nothrow_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> {};
-template <class F, class D, class ONE, class OE>
-struct lifetime_meta_traits<F, D, ONE, OE, constraint_level::nothrow>
-    : std::type_identity<conv_meta<proxy<F>, D, ONE>> {};
-template <class F, class D, class ONE, class OE>
-struct lifetime_meta_traits<F, D, ONE, OE, constraint_level::nontrivial>
-    : std::type_identity<conv_meta<proxy<F>, D, OE>> {};
-template <class F, class D, class ONE, class OE, constraint_level C>
-using lifetime_meta_t = typename lifetime_meta_traits<F, D, ONE, OE, C>::type;
-
-template <class... As>
-struct PRO4D_ENFORCE_EBO composite_accessor : As... {};
-
-template <class C, class F, bool IsDirect>
-struct conv_accessor_traits : std::type_identity<void> {};
-template <class C, class F>
-  requires(!C::is_direct)
-struct conv_accessor_traits<C, F, false>
-    : std::type_identity<typename conv_traits<C, F>::template accessor<
-          proxy_indirect_accessor<F>>> {};
-template <class C, class F>
-  requires(C::is_direct)
-struct conv_accessor_traits<C, F, true>
-    : std::type_identity<
-          typename conv_traits<C, F>::template accessor<proxy<F>>> {};
-template <class C, class F, bool IsDirect>
-using conv_accessor_t = typename conv_accessor_traits<C, F, IsDirect>::type;
-
-template <class R, class F, bool IsDirect>
-struct refl_accessor_traits : std::type_identity<void> {};
-template <class R, class F>
-  requires(!R::is_direct)
-struct refl_accessor_traits<R, F, false>
-    : std::type_identity<
-          accessor_t<typename R::reflector_type, proxy_indirect_accessor<F>,
-                     typename R::reflector_type>> {};
-template <class R, class F>
-  requires(R::is_direct)
-struct refl_accessor_traits<R, F, true>
-    : std::type_identity<accessor_t<typename R::reflector_type, proxy<F>,
-                                    typename R::reflector_type>> {};
-template <class R, class F, bool IsDirect>
-using refl_accessor_t = typename refl_accessor_traits<R, F, IsDirect>::type;
-
-template <class T>
-concept pointer_like = (std::is_pointer_v<T> ||
-    requires { typename T::element_type; } || requires(T val) { *val; }) &&
-    requires { typename std::pointer_traits<T>::element_type; };
-
-template <class T, template <class...> class TT>
-struct specialization_traits : inapplicable_traits {};
-template <template <class...> class TT, class... Args>
-struct specialization_traits<TT<Args...>, TT> : applicable_traits {};
-template <class T, template <class...> class TT>
-concept specialization_of = specialization_traits<T, TT>::applicable;
-
-template <class P, class F, std::size_t ActualSize, std::size_t MaxSize>
-consteval void diagnose_proxiable_size_too_large() {
-  static_assert(ActualSize <= MaxSize, "not proxiable due to size too large");
-}
-template <class P, class F, std::size_t ActualAlign, std::size_t MaxAlign>
-consteval void diagnose_proxiable_align_too_large() {
-  static_assert(ActualAlign <= MaxAlign,
-                "not proxiable due to alignment too large");
-}
-template <class P, class F, constraint_level RequiredCopyability>
-consteval void diagnose_proxiable_insufficient_copyability() {
-  static_assert(copyability_traits<P, RequiredCopyability>::applicable,
-                "not proxiable due to insufficient copyability");
-}
-template <class P, class F, constraint_level RequiredRelocatability>
-consteval void diagnose_proxiable_insufficient_relocatability() {
-  static_assert(relocatability_traits<P, RequiredRelocatability>::applicable,
-                "not proxiable due to insufficient relocatability");
-}
-template <class P, class F, constraint_level RequiredDestructibility>
-consteval void diagnose_proxiable_insufficient_destructibility() {
-  static_assert(destructibility_traits<P, RequiredDestructibility>::applicable,
-                "not proxiable due to insufficient destructibility");
-}
-
-consteval bool is_layout_well_formed(std::size_t size, std::size_t align) {
-  return size > 0u && std::has_single_bit(align) && size % align == 0u;
-}
-consteval bool is_cl_well_formed(constraint_level cl) {
-  return cl >= constraint_level::none && cl <= constraint_level::trivial;
-}
-template <class F>
-consteval bool is_facade_constraints_well_formed() {
-  if constexpr (requires {
-                  { F::max_size } -> static_prop<std::size_t>;
-                  { F::max_align } -> static_prop<std::size_t>;
-                  { F::copyability } -> static_prop<constraint_level>;
-                  { F::relocatability } -> static_prop<constraint_level>;
-                  { F::destructibility } -> static_prop<constraint_level>;
-                }) {
-    if constexpr (is_consteval([] {
-                    return std::tuple{F::max_size, F::max_align, F::copyability,
-                                      F::relocatability, F::destructibility};
-                  })) {
-      return is_layout_well_formed(F::max_size, F::max_align) &&
-             is_cl_well_formed(F::copyability) &&
-             is_cl_well_formed(F::relocatability) &&
-             is_cl_well_formed(F::destructibility);
-    }
-  }
-  return false;
-}
-template <class... Cs>
-struct basic_facade_conv_traits_impl : inapplicable_traits {};
-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((requires {
-             typename Rs::reflector_type;
-           } && is_is_direct_well_formed<Rs>()) && ...)
-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<F> : applicable_traits {};
-
-template <class F, class... Cs>
-struct facade_conv_traits_impl {
-  using conv_meta =
-      composite_t<composite_meta<>, typename conv_traits<Cs, F>::meta...>;
-  using conv_indirect_accessor =
-      composite_t<composite_accessor<>, conv_accessor_t<Cs, F, false>...>;
-  using conv_direct_accessor =
-      composite_t<composite_accessor<>, conv_accessor_t<Cs, F, true>...>;
-
-  template <class P>
-  static consteval void diagnose_proxiable_conv() {
-    (conv_traits<Cs, F>::template diagnose_proxiable<P>(), ...);
-  }
-
-  template <class P>
-  static constexpr bool conv_applicable_ptr =
-      (conv_traits<Cs, F>::template applicable_ptr<P> && ...);
-};
-template <class F, class... Rs>
-struct facade_refl_traits_impl {
-  using refl_meta = composite_meta<
-      reflection_meta<Rs::is_direct, typename Rs::reflector_type>...>;
-  using refl_indirect_accessor =
-      composite_t<composite_accessor<>, refl_accessor_t<Rs, F, false>...>;
-  using refl_direct_accessor =
-      composite_t<composite_accessor<>, refl_accessor_t<Rs, F, true>...>;
-
-  template <class P>
-  static consteval void diagnose_proxiable_refl() {
-    (diagnose_proxiable_required_reflection_not_implemented<
-         P, F, Rs::is_direct, typename Rs::reflector_type>(),
-     ...);
-  }
-
-  template <class P>
-  static constexpr bool refl_applicable_ptr =
-      (is_reflector_well_formed<P, Rs::is_direct,
-                                typename Rs::reflector_type>() &&
-       ...);
-};
-template <class F>
-struct facade_traits
-    : 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_t<
-      composite_meta<>,
-      lifetime_meta_t<F, copy_dispatch, void(proxy<F>&) const noexcept,
-                      void(proxy<F>&) const, F::copyability>,
-      lifetime_meta_t<F, relocate_dispatch, void(proxy<F>&) && noexcept,
-                      void(proxy<F>&) &&, F::relocatability>,
-      lifetime_meta_t<F, destroy_dispatch, void() noexcept, void(),
-                      F::destructibility>,
-      typename facade_traits::conv_meta, typename facade_traits::refl_meta>;
-  using indirect_accessor =
-      composite_t<typename facade_traits::conv_indirect_accessor,
-                  typename facade_traits::refl_indirect_accessor>;
-  using direct_accessor =
-      composite_t<typename facade_traits::conv_direct_accessor,
-                  typename facade_traits::refl_direct_accessor>;
-
-  template <class P>
-  [[noreturn]] static consteval void diagnose_proxiable_noreturn() {
-    diagnose_proxiable_size_too_large<P, F, sizeof(P), F::max_size>();
-    diagnose_proxiable_align_too_large<P, F, alignof(P), F::max_align>();
-    diagnose_proxiable_insufficient_copyability<P, F, F::copyability>();
-    diagnose_proxiable_insufficient_relocatability<P, F, F::relocatability>();
-    diagnose_proxiable_insufficient_destructibility<P, F, F::destructibility>();
-    facade_traits::template diagnose_proxiable_conv<P>();
-    facade_traits::template diagnose_proxiable_refl<P>();
-    PROD_UNREACHABLE(); // Propagate the error to the caller side
-  }
-
-  template <class P>
-  static constexpr bool applicable_ptr =
-      sizeof(P) <= F::max_size && alignof(P) <= F::max_align &&
-      copyability_traits<P, F::copyability>::applicable &&
-      relocatability_traits<P, F::relocatability>::applicable &&
-      destructibility_traits<P, F::destructibility>::applicable &&
-      facade_traits::template conv_applicable_ptr<P> &&
-      facade_traits::template refl_applicable_ptr<P>;
-};
-
-using ptr_prototype = void* [2];
-
-template <class M>
-struct meta_ptr_indirect_impl {
-  meta_ptr_indirect_impl() = default;
-  template <class P>
-  explicit meta_ptr_indirect_impl(std::in_place_type_t<P>)
-      : ptr_(&storage<P>) {}
-  bool has_value() const noexcept { return ptr_ != nullptr; }
-  void reset() noexcept { ptr_ = nullptr; }
-  const M* operator->() const noexcept { return ptr_; }
-
-private:
-  const M* ptr_;
-  template <class P>
-  static constexpr M storage{std::in_place_type<P>};
-};
-template <class M, class DM>
-struct meta_ptr_direct_impl : private M {
-  using M::M;
-  bool has_value() const noexcept { return this->DM::invoke != nullptr; }
-  void reset() noexcept { this->DM::invoke = nullptr; }
-  const M* operator->() const noexcept { return this; }
-};
-template <class M>
-struct meta_ptr_traits_impl : std::type_identity<meta_ptr_indirect_impl<M>> {};
-template <class ProP, class D, class O, class... Ms>
-struct meta_ptr_traits_impl<composite_meta<conv_meta<ProP, D, O>, Ms...>>
-    : std::type_identity<
-          meta_ptr_direct_impl<composite_meta<conv_meta<ProP, D, O>, Ms...>,
-                               conv_meta<ProP, 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>)
-struct meta_ptr_traits<M> : meta_ptr_traits_impl<M> {};
-template <class M>
-using meta_ptr = typename meta_ptr_traits<M>::type;
-
-template <class T>
-class inplace_ptr {
-public:
-  template <class... Args>
-  explicit inplace_ptr(std::in_place_t, Args&&... args)
-      : value_(std::forward<Args>(args)...) {}
-  inplace_ptr() = default;
-  inplace_ptr(const inplace_ptr&) = default;
-  inplace_ptr(inplace_ptr&&) = default;
-  inplace_ptr& operator=(const inplace_ptr&) = default;
-  inplace_ptr& operator=(inplace_ptr&&) = default;
-
-  T* operator->() noexcept { return std::addressof(value_); }
-  const T* operator->() const noexcept { return std::addressof(value_); }
-  T& operator*() & noexcept { return value_; }
-  const T& operator*() const& noexcept { return value_; }
-  T&& operator*() && noexcept { return std::move(value_); }
-  const T&& operator*() const&& noexcept { return std::move(value_); }
-
-private:
-  [[PROD_NO_UNIQUE_ADDRESS_ATTRIBUTE]]
-  T value_;
-};
-
-template <class D, class O, class P, class... Args>
-ret_t<O> invoke_impl(P&& p, Args&&... args) {
-  return proxy_helper::get_meta<conv_meta<std::remove_cvref_t<P>, D, O>>(p)
-      .invoke(std::forward<P>(p), std::forward<Args>(args)...);
-}
-template <class F, qualifier_type Q>
-add_qualifier_t<proxy<F>, Q>
-    as_proxy(add_qualifier_t<proxy_indirect_accessor<F>, Q> p) {
-  return static_cast<add_qualifier_t<proxy<F>, Q>>(
-      *reinterpret_cast<
-          add_qualifier_ptr_t<inplace_ptr<proxy_indirect_accessor<F>>, Q>>(
-          std::addressof(p)));
-}
-template <class P, class F, bool IsDirect, qualifier_type Q>
-operand_t<P, IsDirect, Q> get_operand(proxy_accessor<F, IsDirect, Q> p) {
-  if constexpr (IsDirect) {
-    return proxy_helper::get_ptr<P, F, Q>(
-        std::forward<proxy_accessor<F, IsDirect, Q>>(p));
-  } else {
-    add_qualifier_t<P, Q> ptr = proxy_helper::get_ptr<P, F, Q>(
-        as_proxy<F, Q>(std::forward<proxy_accessor<F, IsDirect, Q>>(p)));
-    if constexpr (std::is_constructible_v<bool, P&>) {
-      assert(ptr);
-    }
-    return *std::forward<add_qualifier_t<P, Q>>(ptr);
-  }
-}
-template <class D, class R, class... Args>
-R invoke_dispatch(Args&&... args) {
-  if constexpr (std::is_void_v<R>) {
-    D()(std::forward<Args>(args)...);
-  } else {
-    return D()(std::forward<Args>(args)...);
-  }
-}
-template <class P, class F, bool IsDirect, qualifier_type Q, class D, class R,
-          class... Args>
-R reinterpret_invoke(proxy_accessor<F, IsDirect, Q> self, Args&&... args) {
-  if constexpr (Q == qualifier_type::rv) {
-    if constexpr (std::is_base_of_v<internal_dispatch, D> &&
-                  is_bitwise_trivially_relocatable_v<P>) {
-      return D()(std::in_place_type<P>, std::move(self),
-                 std::forward<Args>(args)...);
-    } else {
-      proxy_helper::resetting_guard<P, F> guard{self};
-      return invoke_dispatch<D, R>(
-          get_operand<P, F, IsDirect, Q>(std::move(self)),
-          std::forward<Args>(args)...);
-    }
-  } else {
-    return invoke_dispatch<D, R>(
-        get_operand<P, F, IsDirect, Q>(
-            std::forward<proxy_accessor<F, IsDirect, Q>>(self)),
-        std::forward<Args>(args)...);
-  }
-}
-
-} // namespace details
-
-template <class P, class F>
-concept proxiable = facade<F> && details::pointer_like<P> &&
-                    details::facade_traits<F>::template applicable_ptr<P>;
-
-template <facade F>
-class proxy_indirect_accessor
-    : public details::facade_traits<F>::indirect_accessor {
-  friend class details::inplace_ptr<proxy_indirect_accessor>;
-  proxy_indirect_accessor() = default;
-  proxy_indirect_accessor(const proxy_indirect_accessor&) = default;
-  proxy_indirect_accessor& operator=(const proxy_indirect_accessor&) = default;
-
-public:
-  template <class D, class O, class... Args>
-  friend details::ret_t<O> invoke(proxy_indirect_accessor& p, Args&&... args) {
-    return details::invoke_impl<D, O>(p, std::forward<Args>(args)...);
-  }
-  template <class D, class O, class... Args>
-  friend details::ret_t<O> invoke(const proxy_indirect_accessor& p,
-                                  Args&&... args) {
-    return details::invoke_impl<D, O>(p, std::forward<Args>(args)...);
-  }
-  template <class D, class O, class... Args>
-  friend details::ret_t<O> invoke(proxy_indirect_accessor&& p, Args&&... args) {
-    return details::invoke_impl<D, O>(std::move(p),
-                                      std::forward<Args>(args)...);
-  }
-  template <class D, class O, class... Args>
-  friend details::ret_t<O> invoke(const proxy_indirect_accessor&& p,
-                                  Args&&... args) {
-    return details::invoke_impl<D, O>(std::move(p),
-                                      std::forward<Args>(args)...);
-  }
-  template <class P, class D, class R, class... Args>
-  friend R reinterpret_invoke(proxy_indirect_accessor& p, Args&&... args) {
-    return details::reinterpret_invoke<P, F, false, details::qualifier_type::lv,
-                                       D, R>(p, std::forward<Args>(args)...);
-  }
-  template <class P, class D, class R, class... Args>
-  friend R reinterpret_invoke(const proxy_indirect_accessor& p,
-                              Args&&... args) {
-    return details::reinterpret_invoke<P, F, false,
-                                       details::qualifier_type::const_lv, D, R>(
-        p, std::forward<Args>(args)...);
-  }
-  template <class P, class D, class R, class... Args>
-  friend R reinterpret_invoke(proxy_indirect_accessor&& p, Args&&... args) {
-    return details::reinterpret_invoke<P, F, false, details::qualifier_type::rv,
-                                       D, R>(std::move(p),
-                                             std::forward<Args>(args)...);
-  }
-  template <class P, class D, class R, class... Args>
-  friend R reinterpret_invoke(const proxy_indirect_accessor&& p,
-                              Args&&... args) {
-    return details::reinterpret_invoke<P, F, false,
-                                       details::qualifier_type::const_rv, D, R>(
-        std::move(p), std::forward<Args>(args)...);
-  }
-  template <class R>
-  friend const R& reflect(const proxy_indirect_accessor& p) noexcept {
-    return details::proxy_helper::get_meta<details::reflection_meta<false, R>>(
-               p)
-        .reflector;
-  }
-};
-
-template <facade F>
-class proxy : public details::facade_traits<F>::direct_accessor,
-              public details::inplace_ptr<proxy_indirect_accessor<F>> {
-  friend struct details::proxy_helper;
-
-public:
-  using facade_type = F;
-
-  proxy() noexcept { initialize(); }
-  proxy(std::nullptr_t) noexcept : proxy() {}
-  proxy(const proxy&) noexcept
-    requires(F::copyability == constraint_level::trivial)
-  = default;
-  proxy(const proxy& rhs) noexcept(F::copyability == constraint_level::nothrow)
-    requires(F::copyability == constraint_level::nontrivial ||
-             F::copyability == constraint_level::nothrow)
-      : details::inplace_ptr<
-            proxy_indirect_accessor<F>>() /* Make GCC happy */ {
-    initialize(rhs);
-  }
-  proxy(proxy&& rhs) noexcept(F::relocatability >= constraint_level::nothrow)
-    requires(F::relocatability >= constraint_level::nontrivial &&
-             F::copyability != constraint_level::trivial)
-  {
-    initialize(std::move(rhs));
-  }
-  template <class P>
-  constexpr proxy(P&& ptr) noexcept(
-      std::is_nothrow_constructible_v<std::decay_t<P>, P>)
-    requires(!details::specialization_of<std::decay_t<P>, proxy> &&
-             details::pointer_like<std::decay_t<P>> &&
-             std::is_constructible_v<std::decay_t<P>, P>)
-  {
-    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::pointer_like<P> && std::is_constructible_v<P, Args...>)
-  {
-    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::pointer_like<P> &&
-             std::is_constructible_v<P, std::initializer_list<U>&, Args...>)
-  {
-    initialize<P>(il, std::forward<Args>(args)...);
-  }
-  proxy& operator=(std::nullptr_t) noexcept(F::destructibility >=
-                                            constraint_level::nothrow)
-    requires(F::destructibility >= constraint_level::nontrivial)
-  {
-    reset();
-    return *this;
-  }
-  proxy& operator=(const proxy&) noexcept
-    requires(F::copyability == constraint_level::trivial)
-  = default;
-  proxy& operator=(const proxy& rhs) noexcept(F::copyability >=
-                                                  constraint_level::nothrow &&
-                                              F::destructibility >=
-                                                  constraint_level::nothrow)
-    requires((F::copyability == constraint_level::nontrivial ||
-              F::copyability == constraint_level::nothrow) &&
-             F::destructibility >= constraint_level::nontrivial)
-  {
-    if (this != std::addressof(rhs)) [[likely]] {
-      if constexpr (F::copyability == constraint_level::nothrow) {
-        destroy();
-        initialize(rhs);
-      } else {
-        *this = proxy{rhs};
-      }
-    }
-    return *this;
-  }
-  proxy& operator=(proxy&& rhs) noexcept(F::relocatability >=
-                                             constraint_level::nothrow &&
-                                         F::destructibility >=
-                                             constraint_level::nothrow)
-    requires(F::relocatability >= constraint_level::nontrivial &&
-             F::destructibility >= constraint_level::nontrivial &&
-             F::copyability != constraint_level::trivial)
-  {
-    if (this != std::addressof(rhs)) [[likely]] {
-      reset();
-      initialize(std::move(rhs));
-    }
-    return *this;
-  }
-  template <class P>
-  constexpr proxy& operator=(P&& ptr) noexcept(
-      std::is_nothrow_constructible_v<std::decay_t<P>, P> &&
-      F::destructibility >= constraint_level::nothrow)
-    requires(!details::specialization_of<std::decay_t<P>, proxy> &&
-             details::pointer_like<std::decay_t<P>> &&
-             std::is_constructible_v<std::decay_t<P>, P> &&
-             F::destructibility >= constraint_level::nontrivial)
-  {
-    if constexpr (std::is_nothrow_constructible_v<std::decay_t<P>, P>) {
-      destroy();
-      initialize<std::decay_t<P>>(std::forward<P>(ptr));
-    } else {
-      *this = proxy{std::forward<P>(ptr)};
-    }
-    return *this;
-  }
-  ~proxy()
-    requires(F::destructibility == constraint_level::trivial)
-  = default;
-  ~proxy() noexcept(F::destructibility == constraint_level::nothrow)
-    requires(F::destructibility == constraint_level::nontrivial ||
-             F::destructibility == constraint_level::nothrow)
-  {
-    destroy();
-  }
-
-  bool has_value() const noexcept { return meta_.has_value(); }
-  explicit operator bool() const noexcept { return meta_.has_value(); }
-  void reset() noexcept(F::destructibility >= constraint_level::nothrow)
-    requires(F::destructibility >= constraint_level::nontrivial)
-  {
-    destroy();
-    initialize();
-  }
-  void swap(proxy& rhs) noexcept(F::relocatability >=
-                                     constraint_level::nothrow ||
-                                 F::copyability == constraint_level::trivial)
-    requires(F::relocatability >= constraint_level::nontrivial ||
-             F::copyability == constraint_level::trivial)
-  {
-    if constexpr (F::relocatability == constraint_level::trivial ||
-                  F::copyability == constraint_level::trivial) {
-      std::swap(meta_, rhs.meta_);
-#ifdef __INTEL_LLVM_COMPILER
-      // Workaround: Intel oneAPI compiler (as of 2025.2.0) may over-optimize
-      // the swap below, causing unit tests failure
-      std::byte temp[F::max_size];
-      std::ranges::uninitialized_copy(ptr_, temp);
-      std::ranges::uninitialized_copy(rhs.ptr_, ptr_);
-      std::ranges::uninitialized_copy(temp, rhs.ptr_);
-#else
-      std::swap(ptr_, rhs.ptr_);
-#endif // __INTEL_LLVM_COMPILER
-    } else {
-      if (meta_.has_value()) {
-        if (rhs.meta_.has_value()) {
-          proxy temp = std::move(*this);
-          initialize(std::move(rhs));
-          rhs.initialize(std::move(temp));
-        } else {
-          rhs.initialize(std::move(*this));
-        }
-      } else if (rhs.meta_.has_value()) {
-        initialize(std::move(rhs));
-      }
-    }
-  }
-  template <class P, class... Args>
-  constexpr P& emplace(Args&&... args) noexcept(
-      std::is_nothrow_constructible_v<P, Args...> &&
-      F::destructibility >= constraint_level::nothrow)
-    requires(details::pointer_like<P> && std::is_constructible_v<P, Args...> &&
-             F::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::destructibility >= constraint_level::nothrow)
-    requires(details::pointer_like<P> &&
-             std::is_constructible_v<P, std::initializer_list<U>&, Args...> &&
-             F::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)))
-    requires(requires { lhs.swap(rhs); })
-  {
-    lhs.swap(rhs);
-  }
-  friend bool operator==(const proxy& lhs, std::nullptr_t) noexcept {
-    return !lhs.has_value();
-  }
-  template <class D, class O, class... Args>
-  friend details::ret_t<O> invoke(proxy& p, Args&&... args) {
-    return details::invoke_impl<D, O>(p, std::forward<Args>(args)...);
-  }
-  template <class D, class O, class... Args>
-  friend details::ret_t<O> invoke(const proxy& p, Args&&... args) {
-    return details::invoke_impl<D, O>(p, std::forward<Args>(args)...);
-  }
-  template <class D, class O, class... Args>
-  friend details::ret_t<O> invoke(proxy&& p, Args&&... args) {
-    return details::invoke_impl<D, O>(std::move(p),
-                                      std::forward<Args>(args)...);
-  }
-  template <class D, class O, class... Args>
-  friend details::ret_t<O> invoke(const proxy&& p, Args&&... args) {
-    return details::invoke_impl<D, O>(std::move(p),
-                                      std::forward<Args>(args)...);
-  }
-  template <class P, class D, class R, class... Args>
-  friend R reinterpret_invoke(proxy& p, Args&&... args) {
-    return details::reinterpret_invoke<P, F, true, details::qualifier_type::lv,
-                                       D, R>(p, std::forward<Args>(args)...);
-  }
-  template <class P, class D, class R, class... Args>
-  friend R reinterpret_invoke(const proxy& p, Args&&... args) {
-    return details::reinterpret_invoke<P, F, true,
-                                       details::qualifier_type::const_lv, D, R>(
-        p, std::forward<Args>(args)...);
-  }
-  template <class P, class D, class R, class... Args>
-  friend R reinterpret_invoke(proxy&& p, Args&&... args) {
-    return details::reinterpret_invoke<P, F, true, details::qualifier_type::rv,
-                                       D, R>(std::move(p),
-                                             std::forward<Args>(args)...);
-  }
-  template <class P, class D, class R, class... Args>
-  friend R reinterpret_invoke(const proxy&& p, Args&&... args) {
-    return details::reinterpret_invoke<P, F, true,
-                                       details::qualifier_type::const_rv, D, R>(
-        std::move(p), std::forward<Args>(args)...);
-  }
-  template <class R>
-  friend const R& reflect(const proxy& p) noexcept {
-    return details::proxy_helper::get_meta<details::reflection_meta<true, R>>(p)
-        .reflector;
-  }
-
-private:
-  void initialize() {
-    PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
-    meta_.reset();
-  }
-  void initialize(const proxy& rhs)
-    requires(F::copyability != constraint_level::none)
-  {
-    PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
-    if (rhs.meta_.has_value()) {
-      if constexpr (F::copyability == constraint_level::trivial) {
-        std::ranges::uninitialized_copy(rhs.ptr_, ptr_);
-        meta_ = rhs.meta_;
-      } else {
-        invoke<details::copy_dispatch,
-               void(proxy&) const noexcept(
-                   F::copyability == constraint_level::nothrow)>(rhs, *this);
-      }
-    } else {
-      meta_.reset();
-    }
-  }
-  void initialize(proxy&& rhs)
-    requires(F::relocatability != constraint_level::none)
-  {
-    PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
-    if (rhs.meta_.has_value()) {
-      if constexpr (F::relocatability == constraint_level::trivial) {
-        std::ranges::uninitialized_copy(rhs.ptr_, ptr_);
-        meta_ = rhs.meta_;
-        rhs.meta_.reset();
-      } else {
-        invoke<details::relocate_dispatch,
-               void(proxy&) &&
-                   noexcept(F::relocatability == constraint_level::nothrow)>(
-            std::move(rhs), *this);
-      }
-    } else {
-      meta_.reset();
-    }
-  }
-  template <class P, class... Args>
-  constexpr P& initialize(Args&&... args) {
-    PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
-    P& result = *std::construct_at(reinterpret_cast<P*>(ptr_),
-                                   std::forward<Args>(args)...);
-    if constexpr (proxiable<P, F>) {
-      meta_ = details::meta_ptr<typename details::facade_traits<F>::meta>{
-          std::in_place_type<P>};
-    } else {
-      details::facade_traits<F>::template diagnose_proxiable_noreturn<P>();
-    }
-    return result;
-  }
-  void destroy()
-    requires(F::destructibility != constraint_level::none)
-  {
-    if constexpr (F::destructibility != constraint_level::trivial) {
-      if (meta_.has_value()) {
-        invoke<details::destroy_dispatch,
-               void() noexcept(F::destructibility ==
-                               constraint_level::nothrow)>(*this);
-      }
-    }
-  }
-  PRO4D_DEBUG(static inline void pro_symbol_guard(proxy& self,
-                                                  const proxy& cself) {
-    self.operator->();
-    *self;
-    *std::move(self);
-    cself.operator->();
-    *cself;
-    *std::move(cself);
-  })
-
-  details::meta_ptr<typename details::facade_traits<F>::meta> meta_;
-  alignas(F::max_align) std::byte ptr_[F::max_size];
-};
-
-template <class D, class O, facade F, class... Args>
-[[deprecated("Use unqualified invoke instead")]] details::ret_t<O>
-    proxy_invoke(proxy_indirect_accessor<F>& p, Args&&... args) {
-  return invoke<D, O>(p, std::forward<Args>(args)...);
-}
-template <class D, class O, facade F, class... Args>
-[[deprecated("Use unqualified invoke instead")]] details::ret_t<O>
-    proxy_invoke(const proxy_indirect_accessor<F>& p, Args&&... args) {
-  return invoke<D, O>(p, std::forward<Args>(args)...);
-}
-template <class D, class O, facade F, class... Args>
-[[deprecated("Use unqualified invoke instead")]] details::ret_t<O>
-    proxy_invoke(proxy_indirect_accessor<F>&& p, Args&&... args) {
-  return invoke<D, O>(std::move(p), std::forward<Args>(args)...);
-}
-template <class D, class O, facade F, class... Args>
-[[deprecated("Use unqualified invoke instead")]] details::ret_t<O>
-    proxy_invoke(const proxy_indirect_accessor<F>&& p, Args&&... args) {
-  return invoke<D, O>(std::move(p), std::forward<Args>(args)...);
-}
-template <class D, class O, facade F, class... Args>
-[[deprecated("Use unqualified invoke instead")]] details::ret_t<O>
-    proxy_invoke(proxy<F>& p, Args&&... args) {
-  return invoke<D, O>(p, std::forward<Args>(args)...);
-}
-template <class D, class O, facade F, class... Args>
-[[deprecated("Use unqualified invoke instead")]] details::ret_t<O>
-    proxy_invoke(const proxy<F>& p, Args&&... args) {
-  return invoke<D, O>(p, std::forward<Args>(args)...);
-}
-template <class D, class O, facade F, class... Args>
-[[deprecated("Use unqualified invoke instead")]] details::ret_t<O>
-    proxy_invoke(proxy<F>&& p, Args&&... args) {
-  return invoke<D, O>(std::move(p), std::forward<Args>(args)...);
-}
-template <class D, class O, facade F, class... Args>
-[[deprecated("Use unqualified invoke instead")]] details::ret_t<O>
-    proxy_invoke(const proxy<F>&& p, Args&&... args) {
-  return invoke<D, O>(std::move(p), std::forward<Args>(args)...);
-}
-
-template <class R, facade F>
-[[deprecated("Use unqualified reflect instead")]] const R&
-    proxy_reflect(const proxy_indirect_accessor<F>& p) noexcept {
-  return reflect<R>(p);
-}
-template <class R, facade F>
-[[deprecated("Use unqualified reflect instead")]] const R&
-    proxy_reflect(const proxy<F>& p) noexcept {
-  return reflect<R>(p);
-}
-
-// =============================================================================
-// == Core Extensions (substitution_dispatch, proxy_view, weak_proxy)         ==
-// =============================================================================
-
-struct substitution_dispatch;
-
-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>>;
-
-namespace details {
-
-template <class F>
-struct converter {
-  explicit converter(F f) noexcept : f_(std::move(f)) {}
-  converter(const converter&) = delete;
-  template <class T>
-  operator T() && noexcept(
-      std::is_nothrow_invocable_r_v<T, F, std::in_place_type_t<T>>)
-    requires(std::is_invocable_r_v<T, F, std::in_place_type_t<T>> &&
-             !std::is_invocable_r_v<T, F, std::in_place_type_t<T&>> &&
-             !std::is_invocable_r_v<T, F, std::in_place_type_t<T &&>>)
-  {
-    return std::move(f_)(std::in_place_type<T>);
-  }
-  template <class T>
-  operator T&() && noexcept(
-      std::is_nothrow_invocable_r_v<T&, F, std::in_place_type_t<T&>>)
-    requires(std::is_invocable_r_v<T&, F, std::in_place_type_t<T&>>)
-  {
-    return std::move(f_)(std::in_place_type<T&>);
-  }
-  template <class T>
-  operator T&&() && noexcept(
-      std::is_nothrow_invocable_r_v<T&&, F, std::in_place_type_t<T&&>>)
-    requires(std::is_invocable_r_v<T &&, F, std::in_place_type_t<T &&>>)
-  {
-    return std::move(f_)(std::in_place_type<T&&>);
-  }
-
-private:
-  F f_;
-};
-
-#define PROD_DEF_CAST_ACCESSOR(oq, pq, ne, ...)                                \
-  template <class P, class D, class T>                                         \
-  struct accessor<P, D, T() oq ne> {                                           \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(operator T)                        \
-    explicit(Expl) operator T() oq ne {                                        \
-      if constexpr (Nullable) {                                                \
-        if (!static_cast<const P&>(*this).has_value()) {                       \
-          return nullptr;                                                      \
-        }                                                                      \
-      }                                                                        \
-      return invoke<D, T() oq ne>(static_cast<P pq>(*this));                   \
-    }                                                                          \
-  }
-template <bool Expl, bool Nullable>
-struct cast_dispatch_base {
-  PRO4D_DEF_ACCESSOR_TEMPLATE(
-      MEM, PROD_DEF_CAST_ACCESSOR,
-      operator typename overload_traits<ProOs>::return_type)
-};
-#undef PROD_DEF_CAST_ACCESSOR
-
-template <bool IsDirect, class D, class... Os>
-struct conv_impl {
-  static constexpr bool is_direct = IsDirect;
-  using dispatch_type = D;
-  using overload_types = std::tuple<Os...>;
-};
-template <bool IsDirect, class R>
-struct refl_impl {
-  static constexpr bool is_direct = IsDirect;
-  using reflector_type = R;
-};
-template <class Cs, class Rs, std::size_t MaxSize, std::size_t MaxAlign,
-          constraint_level Copyability, constraint_level Relocatability,
-          constraint_level Destructibility>
-struct facade_impl {
-  using convention_types = Cs;
-  using reflection_types = Rs;
-  static constexpr std::size_t max_size = MaxSize;
-  static constexpr std::size_t max_align = MaxAlign;
-  static constexpr constraint_level copyability = Copyability;
-  static constexpr constraint_level relocatability = Relocatability;
-  static constexpr constraint_level destructibility = Destructibility;
-};
-
-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> && ...)
-struct add_tuple_reduction<std::tuple<Os...>, I>
-    : std::type_identity<std::tuple<Os..., I>> {};
-template <class O, class... Is>
-using add_tuple_t =
-    recursive_reduction_t<reduction_traits<add_tuple_reduction>::template type,
-                          O, Is...>;
-
-template <bool IsDirect, class D>
-struct conv_instantiation_helper {
-  template <class... Os>
-  using type = conv_impl<IsDirect, D, Os...>;
-};
-template <bool IsDirect, class D, class Os>
-using instantiated_conv_t =
-    instantiated_t<conv_instantiation_helper<IsDirect, D>::template type, Os>;
-
-template <class O>
-using observer_substitution_overload =
-    proxy_view<typename ret_t<O>::facade_type>() const noexcept;
-template <class... Os>
-using observer_substitution_conv = instantiated_conv_t<
-    true, substitution_dispatch,
-    add_tuple_t<std::tuple<>, observer_substitution_overload<Os>...>>;
-
-template <class C>
-struct observer_conv_traits : std::type_identity<void> {};
-template <class C>
-  requires(C::is_direct &&
-           std::is_same_v<typename C::dispatch_type, substitution_dispatch>)
-struct observer_conv_traits<C>
-    : std::type_identity<instantiated_t<observer_substitution_conv,
-                                        typename C::overload_types>> {};
-template <class C>
-  requires(!C::is_direct)
-struct observer_conv_traits<C> : std::type_identity<C> {};
-template <class... Cs>
-using observer_conv_types =
-    composite_t<std::tuple<>, typename observer_conv_traits<Cs>::type...>;
-template <class... Rs>
-using observer_refl_types =
-    composite_t<std::tuple<>, std::conditional_t<Rs::is_direct, void, Rs>...>;
-
-template <class P>
-auto weak_lock_impl(const P& self) noexcept
-  requires(requires { self.lock(); })
-{
-  if constexpr (std::is_constructible_v<bool, decltype(self.lock())>) {
-    return converter{
-        [&self]<class F>(std::in_place_type_t<proxy<F>>) noexcept -> proxy<F> {
-          auto strong = self.lock();
-          return strong ? proxy<F>{std::move(strong)} : proxy<F>{};
-        }};
-  } else {
-    return self.lock();
-  }
-}
-PRO4_DEF_FREE_AS_MEM_DISPATCH(weak_mem_lock, weak_lock_impl, lock);
-
-template <class O>
-struct weak_substitution_overload_traits;
-#define PROD_DEF_WEAK_SUBSTITUTION_OVERLOAD_TRAITS(oq, pq, ne, ...)            \
-  template <class F>                                                           \
-  struct weak_substitution_overload_traits<proxy<F>() oq ne>                   \
-      : std::type_identity<weak_proxy<F>() oq ne> {};
-PRO4D_DEF_OVERLOAD_SPECIALIZATIONS(PROD_DEF_WEAK_SUBSTITUTION_OVERLOAD_TRAITS)
-#undef PROD_DEF_WEAK_SUBSTITUTION_OVERLOAD_TRAITS
-template <class... Os>
-using weak_substitution_conv =
-    conv_impl<true, substitution_dispatch,
-              typename weak_substitution_overload_traits<Os>::type...>;
-
-template <class C>
-struct weak_conv_traits : std::type_identity<void> {};
-template <class C>
-  requires(C::is_direct &&
-           std::is_same_v<typename C::dispatch_type, substitution_dispatch>)
-struct weak_conv_traits<C>
-    : std::type_identity<
-          instantiated_t<weak_substitution_conv, typename C::overload_types>> {
-};
-template <class F, class... Cs>
-using weak_conv_types = composite_t<
-    std::tuple<conv_impl<true, weak_mem_lock, proxy<F>() const noexcept>>,
-    typename weak_conv_traits<Cs>::type...>;
-
-} // namespace details
-
-struct PRO4D_ENFORCE_EBO substitution_dispatch
-    : details::cast_dispatch_base<false, true>,
-      details::internal_dispatch {
-  template <class P, class F1>
-  PRO4D_STATIC_CALL(auto, std::in_place_type_t<P>, proxy<F1>&& self) noexcept {
-    return details::converter{
-        [&self]<class F2>(std::in_place_type_t<proxy<F2>>) noexcept {
-          proxy<F2> ret;
-          details::proxy_helper::trivially_relocate<P>(self, ret);
-          return ret;
-        }};
-  }
-  template <class T>
-  PRO4D_STATIC_CALL(T&&, T&& self) noexcept {
-    return std::forward<T>(self);
-  }
-
-  // This overload is not reachable at runtime, but is necessary to ensure
-  // substitution_dispatch is SFINAE-friendly.
-  template <class T>
-  PRO4D_STATIC_CALL(auto, T&&) noexcept
-    requires(std::is_same_v<T, std::remove_cvref_t<T>> &&
-             is_bitwise_trivially_relocatable_v<T>)
-  {
-    return details::converter{
-        []<class F2>(std::in_place_type_t<proxy<F2>>) noexcept -> proxy<F2>
-          requires(proxiable<T, F2>)
-        { PROD_UNREACHABLE(); }};
-  }
-};
-
-template <facade F>
-struct observer_facade
-    : details::facade_impl<
-          details::instantiated_t<details::observer_conv_types,
-                                  typename F::convention_types>,
-          details::instantiated_t<details::observer_refl_types,
-                                  typename F::reflection_types>,
-          sizeof(void*), alignof(void*), constraint_level::trivial,
-          constraint_level::trivial, constraint_level::trivial> {};
-
-template <facade F>
-struct weak_facade
-    : details::facade_impl<
-          details::instantiated_t<details::weak_conv_types,
-                                  typename F::convention_types, F>,
-          std::tuple<>, F::max_size, F::max_align, F::copyability,
-          F::relocatability, F::destructibility> {};
-
-// =============================================================================
-// == Proxy Creation (make_proxy, proxiable_target, etc.)                     ==
-// =============================================================================
-
-namespace details {
-
-template <class LR, class CLR, class RR, class CRR>
-class observer_ptr {
-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_));
-  }
-  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:
-  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 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)...);
-  return result.release();
-}
-template <class Alloc, class T>
-void deallocate(const Alloc& alloc, T* ptr) {
-  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 {
-  explicit alloc_aware(const Alloc& alloc) noexcept : alloc(alloc) {}
-  alloc_aware(const alloc_aware&) noexcept = default;
-
-  [[PROD_NO_UNIQUE_ADDRESS_ATTRIBUTE]]
-  Alloc alloc;
-};
-template <class T>
-class indirect_ptr {
-public:
-  explicit indirect_ptr(T* ptr) noexcept : ptr_(ptr) {}
-  auto operator->() noexcept { return std::addressof(**ptr_); }
-  auto operator->() const noexcept { return std::addressof(**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_));
-  }
-
-protected:
-  T* ptr_;
-};
-
-template <class T, class Alloc>
-class PRO4D_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>>(
-            allocate<inplace_ptr<T>>(this->alloc, std::in_place, *rhs)) {}
-  allocated_ptr(allocated_ptr&& rhs) = delete;
-  ~allocated_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
-    deallocate(this->alloc, this->ptr_);
-  }
-};
-
-template <class T, class Alloc>
-struct PRO4D_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),
-        inplace_ptr<T>(std::in_place, std::forward<Args>(args)...) {}
-};
-template <class T, class Alloc>
-class compact_ptr : public indirect_ptr<compact_ptr_storage<T, Alloc>> {
-  using Storage = compact_ptr_storage<T, Alloc>;
-
-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>(
-            allocate<Storage>(rhs.ptr_->alloc, rhs.ptr_->alloc, *rhs)) {}
-  compact_ptr(compact_ptr&& rhs) = delete;
-  ~compact_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
-    deallocate(this->ptr_->alloc, this->ptr_);
-  }
-};
-
-struct shared_compact_ptr_storage_base {
-  std::atomic_long ref_count = 1;
-};
-template <class T, class Alloc>
-struct PRO4D_ENFORCE_EBO shared_compact_ptr_storage
-    : 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),
-        inplace_ptr<T>(std::in_place, std::forward<Args>(args)...) {}
-};
-template <class T, class Alloc>
-class shared_compact_ptr
-    : public indirect_ptr<shared_compact_ptr_storage<T, Alloc>> {
-  using Storage = shared_compact_ptr_storage<T, Alloc>;
-
-public:
-  template <class... Args>
-  shared_compact_ptr(const Alloc& alloc, 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_) {
-    this->ptr_->ref_count.fetch_add(1, std::memory_order::relaxed);
-  }
-  shared_compact_ptr(shared_compact_ptr&& rhs) = delete;
-  ~shared_compact_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
-    if (this->ptr_->ref_count.fetch_sub(1, std::memory_order::acq_rel) == 1) {
-      deallocate(this->ptr_->alloc, this->ptr_);
-    }
-  }
-};
-
-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> {
-  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)...);
-  }
-
-  alignas(alignof(T)) std::byte value[sizeof(T)];
-};
-template <class T, class Alloc>
-class weak_compact_ptr;
-template <class T, class Alloc>
-class strong_compact_ptr {
-  using Storage = strong_weak_compact_ptr_storage<T, Alloc>;
-  friend class weak_compact_ptr<T, Alloc>;
-
-public:
-  using weak_type = weak_compact_ptr<T, Alloc>;
-
-  explicit strong_compact_ptr(Storage* ptr) noexcept : ptr_(ptr) {}
-  template <class... Args>
-  strong_compact_ptr(const Alloc& alloc, Args&&... args)
-      : ptr_(allocate<Storage>(alloc, alloc, std::forward<Args>(args)...)) {}
-  strong_compact_ptr(const strong_compact_ptr& rhs) noexcept : ptr_(rhs.ptr_) {
-    ptr_->strong_count.fetch_add(1, std::memory_order::relaxed);
-  }
-  strong_compact_ptr(strong_compact_ptr&& rhs) = delete;
-  ~strong_compact_ptr() noexcept(std::is_nothrow_destructible_v<T>) {
-    if (ptr_->strong_count.fetch_sub(1, std::memory_order::acq_rel) == 1) {
-      std::destroy_at(operator->());
-      if (ptr_->weak_count.fetch_sub(1u, std::memory_order::release) == 1) {
-        deallocate(ptr_->alloc, ptr_);
-      }
-    }
-  }
-  T* operator->() noexcept {
-    return std::launder(reinterpret_cast<T*>(&ptr_->value));
-  }
-  const T* operator->() const noexcept {
-    return std::launder(reinterpret_cast<const T*>(&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:
-  strong_weak_compact_ptr_storage<T, Alloc>* ptr_;
-};
-template <class T, class Alloc>
-class weak_compact_ptr {
-public:
-  using element_type = T;
-
-  weak_compact_ptr(const strong_compact_ptr<T, Alloc>& rhs) noexcept
-      : ptr_(rhs.ptr_) {
-    ptr_->weak_count.fetch_add(1, std::memory_order::relaxed);
-  }
-  weak_compact_ptr(const weak_compact_ptr& rhs) noexcept : ptr_(rhs.ptr_) {
-    ptr_->weak_count.fetch_add(1, std::memory_order::relaxed);
-  }
-  weak_compact_ptr(weak_compact_ptr&& rhs) = delete;
-  ~weak_compact_ptr() noexcept {
-    if (ptr_->weak_count.fetch_sub(1u, std::memory_order::acq_rel) == 1) {
-      deallocate(ptr_->alloc, ptr_);
-    }
-  }
-  auto lock() const noexcept {
-    return converter{[ptr = this->ptr_]<class F>(
-                         std::in_place_type_t<proxy<F>>) noexcept -> proxy<F> {
-      long ref_count = ptr->strong_count.load(std::memory_order::relaxed);
-      do {
-        if (ref_count == 0) {
-          return proxy<F>{};
-        }
-      } while (!ptr->strong_count.compare_exchange_weak(
-          ref_count, ref_count + 1, std::memory_order::relaxed));
-      return proxy<F>{std::in_place_type<strong_compact_ptr<T, Alloc>>, ptr};
-    }};
-  }
-
-private:
-  strong_weak_compact_ptr_storage<T, Alloc>* ptr_;
-};
-
-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)...};
-  } else {
-    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)...};
-  } else {
-    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) {
-  if constexpr (std::is_convertible_v<proxy<F>, weak_proxy<F>>) {
-    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)...};
-  }
-}
-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)...);
-}
-#endif // __STDC_HOSTED__
-
-} // namespace details
-
-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>>;
-
-template <class T>
-  requires(is_bitwise_trivially_relocatable_v<T>)
-struct is_bitwise_trivially_relocatable<details::inplace_ptr<T>>
-    : std::true_type {};
-
-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...>)
-{
-  return proxy<F>{std::in_place_type<details::inplace_ptr<T>>, std::in_place,
-                  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...>)
-{
-  return proxy<F>{std::in_place_type<details::inplace_ptr<T>>, std::in_place,
-                  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>)
-{
-  return proxy<F>{std::in_place_type<details::inplace_ptr<std::decay_t<T>>>,
-                  std::in_place, std::forward<T>(value)};
-}
-
-template <facade F, class T>
-constexpr proxy_view<F> make_proxy_view(T& value) noexcept {
-  return proxy_view<F>{
-      details::observer_ptr<T&, const T&, T&&, const T&&>{value}};
-}
-
-#if __STDC_HOSTED__
-template <class T, class D>
-  requires(is_bitwise_trivially_relocatable_v<D>)
-struct is_bitwise_trivially_relocatable<std::unique_ptr<T, D>>
-    : std::true_type {};
-template <class T>
-struct is_bitwise_trivially_relocatable<std::shared_ptr<T>> : std::true_type {};
-template <class T>
-struct is_bitwise_trivially_relocatable<std::weak_ptr<T>> : std::true_type {};
-template <class T, class Alloc>
-  requires(is_bitwise_trivially_relocatable_v<Alloc>)
-struct is_bitwise_trivially_relocatable<details::allocated_ptr<T, Alloc>>
-    : std::true_type {};
-template <class T, class Alloc>
-struct is_bitwise_trivially_relocatable<details::compact_ptr<T, Alloc>>
-    : std::true_type {};
-template <class T, class Alloc>
-struct is_bitwise_trivially_relocatable<details::shared_compact_ptr<T, Alloc>>
-    : std::true_type {};
-template <class T, class Alloc>
-struct is_bitwise_trivially_relocatable<details::strong_compact_ptr<T, Alloc>>
-    : std::true_type {};
-template <class T, class Alloc>
-struct is_bitwise_trivially_relocatable<details::weak_compact_ptr<T, Alloc>>
-    : std::true_type {};
-
-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...>)
-{
-  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)...);
-}
-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>)
-{
-  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)...);
-}
-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)...);
-}
-template <facade F, class T>
-constexpr proxy<F> make_proxy(T&& value)
-  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)...);
-}
-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)...);
-}
-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>)
-{
-  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...>)
-{
-  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...>)
-{
-  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>)
-{
-  return details::make_proxy_shared_impl<F, std::decay_t<T>>(
-      std::forward<T>(value));
-}
-#endif // __STDC_HOSTED__
-
-// =============================================================================
-// == Facade Creation (facade_builder)                                        ==
-// =============================================================================
-
-namespace details {
-
-inline constexpr std::size_t invalid_size =
-    std::numeric_limits<std::size_t>::max();
-inline constexpr constraint_level invalid_cl = static_cast<constraint_level>(
-    std::numeric_limits<std::underlying_type_t<constraint_level>>::min());
-consteval std::size_t merge_size(std::size_t a, std::size_t b) {
-  return a < b ? a : b;
-}
-consteval constraint_level merge_constraint(constraint_level a,
-                                            constraint_level b) {
-  return a < b ? b : a;
-}
-consteval std::size_t max_align_of(std::size_t value) {
-  value &= ~value + 1u;
-  return value < alignof(std::max_align_t) ? value : alignof(std::max_align_t);
-}
-
-template <class T, class U>
-using merge_tuple_t = instantiated_t<add_tuple_t, U, T>;
-template <class C1, class C2>
-using merge_conv_t = instantiated_conv_t<
-    C1::is_direct, typename C1::dispatch_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... 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>)
-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>>> {
-};
-template <class Cs, class C>
-using add_conv_t = typename add_conv_reduction<std::tuple<>, Cs, C>::type;
-
-template <class F, constraint_level CL>
-using copy_conversion_overload =
-    proxy<F>() const& noexcept(CL >= constraint_level::nothrow);
-template <class F, constraint_level CL>
-using move_conversion_overload =
-    proxy<F>() && noexcept(CL >= constraint_level::nothrow);
-template <class Cs, class F, constraint_level CCL, constraint_level RCL>
-struct add_substitution_conv
-    : std::type_identity<add_conv_t<
-          Cs, instantiated_conv_t<
-                  true, substitution_dispatch,
-                  composite_t<
-                      std::tuple<>,
-                      std::conditional_t<CCL == constraint_level::none, void,
-                                         copy_conversion_overload<F, CCL>>,
-                      std::conditional_t<RCL == constraint_level::none, void,
-                                         move_conversion_overload<F, RCL>>>>>> {
-};
-template <class Cs, class F>
-struct add_substitution_conv<Cs, F, constraint_level::none,
-                             constraint_level::none> : std::type_identity<Cs> {
-};
-
-template <class Cs1, class... Cs2>
-using merge_conv_tuple_t = recursive_reduction_t<add_conv_t, Cs1, Cs2...>;
-template <class Cs, class F, bool WithSubstitution>
-using merge_facade_conv_t = typename add_substitution_conv<
-    instantiated_t<merge_conv_tuple_t, typename F::convention_types, Cs>, F,
-    WithSubstitution ? F::copyability : constraint_level::none,
-    (WithSubstitution && F::copyability != constraint_level::trivial)
-        ? F::relocatability
-        : constraint_level::none>::type;
-
-template <bool WithSubstitution>
-struct add_facade_deprecation_traits : std::bool_constant<WithSubstitution> {};
-template <>
-struct [[deprecated(
-    "basic_facade_builder::add_facade<F, true> is deprecated; use "
-    "basic_facade_builder::add_facade_with_substitution<F> instead.")]]
-add_facade_deprecation_traits<true> : std::bool_constant<true> {};
-
-} // namespace details
-
-template <class Cs, class Rs, std::size_t MaxSize, std::size_t MaxAlign,
-          constraint_level Copyability, constraint_level Relocatability,
-          constraint_level Destructibility>
-struct basic_facade_builder {
-  template <class D, details::extended_overload... Os>
-    requires(sizeof...(Os) > 0u)
-  using add_indirect_convention = basic_facade_builder<
-      details::add_conv_t<Cs, details::conv_impl<false, D, Os...>>, Rs, MaxSize,
-      MaxAlign, Copyability, Relocatability, Destructibility>;
-  template <class D, details::extended_overload... Os>
-    requires(sizeof...(Os) > 0u)
-  using add_direct_convention = basic_facade_builder<
-      details::add_conv_t<Cs, details::conv_impl<true, D, Os...>>, Rs, MaxSize,
-      MaxAlign, Copyability, Relocatability, Destructibility>;
-  template <class D, details::extended_overload... Os>
-    requires(sizeof...(Os) > 0u)
-  using add_convention = add_indirect_convention<D, Os...>;
-  template <class R>
-  using add_indirect_reflection = basic_facade_builder<
-      Cs, details::add_tuple_t<Rs, details::refl_impl<false, R>>, MaxSize,
-      MaxAlign, Copyability, Relocatability, Destructibility>;
-  template <class R>
-  using add_direct_reflection = basic_facade_builder<
-      Cs, details::add_tuple_t<Rs, details::refl_impl<true, R>>, MaxSize,
-      MaxAlign, Copyability, Relocatability, Destructibility>;
-  template <class R>
-  using add_reflection = add_indirect_reflection<R>;
-  template <facade F, bool WithSubstitution = false>
-  using add_facade = basic_facade_builder<
-      details::merge_facade_conv_t<
-          Cs, F,
-          details::add_facade_deprecation_traits<WithSubstitution>::value>,
-      details::merge_tuple_t<Rs, typename F::reflection_types>,
-      details::merge_size(MaxSize, F::max_size),
-      details::merge_size(MaxAlign, F::max_align),
-      details::merge_constraint(Copyability, F::copyability),
-      details::merge_constraint(Relocatability, F::relocatability),
-      details::merge_constraint(Destructibility, F::destructibility)>;
-  template <facade F>
-  using add_facade_with_substitution = basic_facade_builder<
-      details::merge_facade_conv_t<Cs, F, true>,
-      details::merge_tuple_t<Rs, typename F::reflection_types>,
-      details::merge_size(MaxSize, F::max_size),
-      details::merge_size(MaxAlign, F::max_align),
-      details::merge_constraint(Copyability, F::copyability),
-      details::merge_constraint(Relocatability, F::relocatability),
-      details::merge_constraint(Destructibility, F::destructibility)>;
-  template <std::size_t PtrSize,
-            std::size_t PtrAlign = details::max_align_of(PtrSize)>
-    requires(details::is_layout_well_formed(PtrSize, PtrAlign))
-  using restrict_layout =
-      basic_facade_builder<Cs, Rs, details::merge_size(MaxSize, PtrSize),
-                           details::merge_size(MaxAlign, PtrAlign), Copyability,
-                           Relocatability, Destructibility>;
-  template <constraint_level CL>
-    requires(details::is_cl_well_formed(CL))
-  using support_copy =
-      basic_facade_builder<Cs, Rs, MaxSize, MaxAlign,
-                           details::merge_constraint(Copyability, CL),
-                           Relocatability, Destructibility>;
-  template <constraint_level CL>
-    requires(details::is_cl_well_formed(CL))
-  using support_relocation =
-      basic_facade_builder<Cs, Rs, MaxSize, MaxAlign, Copyability,
-                           details::merge_constraint(Relocatability, CL),
-                           Destructibility>;
-  template <constraint_level CL>
-    requires(details::is_cl_well_formed(CL))
-  using support_destruction =
-      basic_facade_builder<Cs, Rs, MaxSize, MaxAlign, Copyability,
-                           Relocatability,
-                           details::merge_constraint(Destructibility, CL)>;
-  template <template <class> class Skill>
-  using add_skill = Skill<basic_facade_builder>;
-  using build = details::facade_impl<
-      Cs, Rs,
-      MaxSize == details::invalid_size ? sizeof(details::ptr_prototype)
-                                       : MaxSize,
-      MaxAlign == details::invalid_size ? alignof(details::ptr_prototype)
-                                        : MaxAlign,
-      Copyability == details::invalid_cl ? constraint_level::none : Copyability,
-      Relocatability == details::invalid_cl ? constraint_level::trivial
-                                            : Relocatability,
-      Destructibility == details::invalid_cl ? constraint_level::nothrow
-                                             : Destructibility>;
-  basic_facade_builder() = delete;
-};
-using facade_builder =
-    basic_facade_builder<std::tuple<>, std::tuple<>, details::invalid_size,
-                         details::invalid_size, details::invalid_cl,
-                         details::invalid_cl, details::invalid_cl>;
-
-// =============================================================================
-// == Dispatch Extensions (operator_dispatch, weak_dispatch, etc.)            ==
-// =============================================================================
-
-namespace details {
-
-template <std::size_t N>
-struct sign {
-  consteval sign(const char (&str)[N + 1]) {
-    if (str[N] != '\0') {
-      PROD_UNREACHABLE();
-    }
-    for (std::size_t i = 0; i < N; ++i) {
-      value[i] = str[i];
-    }
-  }
-
-  char value[N];
-};
-template <std::size_t N>
-sign(const char (&str)[N]) -> sign<N - 1u>;
-
-// When std::reference_constructs_from_temporary_v (C++23) is not available, we
-// fall back to a conservative approximation that disallows binding a temporary
-// to a reference type if the source type is not a reference or if the source
-// and target reference types are not compatible.
-template <class T, class U>
-concept explicitly_convertible =
-    std::is_constructible_v<U, T> &&
-#if __cpp_lib_reference_from_temporary >= 202202L
-    !std::reference_constructs_from_temporary_v<U, T>;
-#else
-    (!std::is_reference_v<U> ||
-     (std::is_reference_v<T> &&
-      std::is_convertible_v<std::add_pointer_t<std::remove_reference_t<T>>,
-                            std::add_pointer_t<std::remove_reference_t<U>>>));
-#endif // __cpp_lib_reference_from_temporary >= 202202L
-
-struct noreturn_conversion {
-  template <class T>
-  [[noreturn]] PRO4D_STATIC_CALL(T, std::in_place_type_t<T>) {
-    PROD_UNREACHABLE();
-  }
-};
-using wildcard = converter<noreturn_conversion>;
-
-} // namespace details
-
-template <details::sign Sign, bool Rhs = false>
-struct operator_dispatch;
-
-#define PROD_DEF_LHS_LEFT_OP_ACCESSOR(oq, pq, ne, ...)                         \
-  template <class P, class D, class R>                                         \
-  struct accessor<P, D, R() oq ne> {                                           \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
-    R __VA_ARGS__() oq ne {                                                    \
-      return invoke<D, R() oq ne>(static_cast<P pq>(*this));                   \
-    }                                                                          \
-  }
-#define PROD_DEF_LHS_UNARY_OP_ACCESSOR(oq, pq, ne, ...)                        \
-  template <class P, class D, class R>                                         \
-  struct accessor<P, D, R() oq ne> {                                           \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
-    decltype(auto) __VA_ARGS__() oq ne {                                       \
-      invoke<D, R() oq ne>(static_cast<P pq>(*this));                          \
-      return static_cast<P pq>(*this);                                         \
-    }                                                                          \
-  };                                                                           \
-  template <class P, class D, class R>                                         \
-  struct accessor<P, D, R(int) oq ne> {                                        \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
-    R __VA_ARGS__(int) oq ne {                                                 \
-      return invoke<D, R(int) oq ne>(static_cast<P pq>(*this), 0);             \
-    }                                                                          \
-  }
-#define PROD_DEF_LHS_BINARY_OP_ACCESSOR PRO4D_DEF_MEM_ACCESSOR
-#define PROD_DEF_LHS_ALL_OP_ACCESSOR PRO4D_DEF_MEM_ACCESSOR
-#define PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL(...)                               \
-  template <class T>                                                           \
-  PRO4D_STATIC_CALL(decltype(auto), T&& self)                                  \
-  PRO4D_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self))
-#define PROD_LHS_UNARY_OP_DISPATCH_BODY_IMPL(...)                              \
-  template <class T>                                                           \
-  PRO4D_STATIC_CALL(decltype(auto), T&& self)                                  \
-  PRO4D_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self)) template <class T> \
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, int)                             \
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self) __VA_ARGS__)
-#define PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL(...)                             \
-  template <class T, class Arg>                                                \
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                       \
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)                                 \
-                             __VA_ARGS__ std::forward<Arg>(arg))
-#define PROD_LHS_ALL_OP_DISPATCH_BODY_IMPL(...)                                \
-  PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                             \
-  PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)
-#define PROD_LHS_OP_DISPATCH_IMPL(type, ...)                                   \
-  template <>                                                                  \
-  struct operator_dispatch<#__VA_ARGS__, false> {                              \
-    PROD_LHS_##type##_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                       \
-        PRO4D_DEF_ACCESSOR_TEMPLATE(                                           \
-            MEM, PROD_DEF_LHS_##type##_OP_ACCESSOR, operator __VA_ARGS__)      \
-  };
-
-#define PROD_DEF_RHS_OP_ACCESSOR(oq, pq, ne, ...)                              \
-  template <class P, class D, class R, class Arg>                              \
-  struct accessor<P, D, R(Arg) oq ne> {                                        \
-    friend R operator __VA_ARGS__(Arg arg, P pq self) ne {                     \
-      return invoke<D, R(Arg) oq ne>(static_cast<P pq>(self),                  \
-                                     std::forward<Arg>(arg));                  \
-    }                                                                          \
-    PRO4D_DEBUG(                                                             \
-      accessor() noexcept { std::ignore = &pro_symbol_guard; }               \
-                                                                             \
-    private:                                                                 \
-      static inline R pro_symbol_guard(Arg arg, P pq self) {                 \
-        return std::forward<Arg>(arg) __VA_ARGS__ static_cast<P pq>(self);   \
-      }                                                                      \
-    ) \
-  }
-#define PROD_RHS_OP_DISPATCH_IMPL(...)                                         \
-  template <>                                                                  \
-  struct operator_dispatch<#__VA_ARGS__, true> {                               \
-    template <class T, class Arg>                                              \
-    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
-    PRO4D_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                              \
-                               __VA_ARGS__ std::forward<T>(self))              \
-        PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PROD_DEF_RHS_OP_ACCESSOR,            \
-                                    __VA_ARGS__)                               \
-  };
-
-#define PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(...)                             \
-  PROD_LHS_OP_DISPATCH_IMPL(ALL, __VA_ARGS__)                                  \
-  PROD_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
-
-#define PROD_BINARY_OP_DISPATCH_IMPL(...)                                      \
-  PROD_LHS_OP_DISPATCH_IMPL(BINARY, __VA_ARGS__)                               \
-  PROD_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
-
-#define PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR(oq, pq, ne, ...)                   \
-  template <class P, class D, class R, class Arg>                              \
-  struct accessor<P, D, R(Arg) oq ne> {                                        \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
-    decltype(auto) __VA_ARGS__(Arg arg) oq ne {                                \
-      invoke<D, R(Arg) oq ne>(static_cast<P pq>(*this),                        \
-                              std::forward<Arg>(arg));                         \
-      return static_cast<P pq>(*this);                                         \
-    }                                                                          \
-  }
-#define PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR(oq, pq, ne, ...)                   \
-  template <class P, class D, class R, class Arg>                              \
-  struct accessor<P, D, R(Arg&) oq ne> {                                       \
-    friend Arg& operator __VA_ARGS__(Arg& arg, P pq self) ne {                 \
-      invoke<D, R(Arg&) oq ne>(static_cast<P pq>(self), arg);                  \
-      return arg;                                                              \
-    }                                                                          \
-    PRO4D_DEBUG(                                                               \
-        accessor() noexcept { std::ignore = &pro_symbol_guard; }               \
-                                                                               \
-        private : static inline Arg& pro_symbol_guard(                         \
-            Arg& arg,                                                          \
-            P pq self) { return arg __VA_ARGS__ static_cast<P pq>(self); })    \
-  }
-#define PROD_ASSIGNMENT_OP_DISPATCH_IMPL(...)                                  \
-  template <>                                                                  \
-  struct operator_dispatch<#__VA_ARGS__, false> {                              \
-    template <class T, class Arg>                                              \
-    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
-    PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)                               \
-                               __VA_ARGS__ std::forward<Arg>(arg))             \
-        PRO4D_DEF_ACCESSOR_TEMPLATE(                                           \
-            MEM, PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR, operator __VA_ARGS__)    \
-  };                                                                           \
-  template <>                                                                  \
-  struct operator_dispatch<#__VA_ARGS__, true> {                               \
-    template <class T, class Arg>                                              \
-    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
-    PRO4D_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                              \
-                               __VA_ARGS__ std::forward<T>(self))              \
-        PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR, \
-                                    __VA_ARGS__)                               \
-  };
-
-PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(+)
-PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(-)
-PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(*)
-PROD_BINARY_OP_DISPATCH_IMPL(/)
-PROD_BINARY_OP_DISPATCH_IMPL(%)
-PROD_LHS_OP_DISPATCH_IMPL(UNARY, ++)
-PROD_LHS_OP_DISPATCH_IMPL(UNARY, --)
-PROD_BINARY_OP_DISPATCH_IMPL(==)
-PROD_BINARY_OP_DISPATCH_IMPL(!=)
-PROD_BINARY_OP_DISPATCH_IMPL(>)
-PROD_BINARY_OP_DISPATCH_IMPL(<)
-PROD_BINARY_OP_DISPATCH_IMPL(>=)
-PROD_BINARY_OP_DISPATCH_IMPL(<=)
-PROD_BINARY_OP_DISPATCH_IMPL(<=>)
-PROD_LHS_OP_DISPATCH_IMPL(LEFT, !)
-PROD_BINARY_OP_DISPATCH_IMPL(&&)
-PROD_BINARY_OP_DISPATCH_IMPL(||)
-PROD_LHS_OP_DISPATCH_IMPL(LEFT, ~)
-PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(&)
-PROD_BINARY_OP_DISPATCH_IMPL(|)
-PROD_BINARY_OP_DISPATCH_IMPL(^)
-PROD_BINARY_OP_DISPATCH_IMPL(<<)
-PROD_BINARY_OP_DISPATCH_IMPL(>>)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(+=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(-=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(*=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(/=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(%=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(&=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(|=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(^=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(<<=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(>>=)
-PROD_BINARY_OP_DISPATCH_IMPL(, )
-PROD_BINARY_OP_DISPATCH_IMPL(->*)
-
-template <>
-struct operator_dispatch<"()", false> {
-  template <class T, class... Args>
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)(std::forward<Args>(args)...))
-      PRO4D_DEF_ACCESSOR_TEMPLATE(MEM, PRO4D_DEF_MEM_ACCESSOR, operator())
-};
-template <>
-struct operator_dispatch<"[]", false> {
-#if __cpp_multidimensional_subscript >= 202110L
-  template <class T, class... Args>
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Args>(args)...])
-#else
-  template <class T, class Arg>
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Arg>(arg)])
-#endif // __cpp_multidimensional_subscript >= 202110L
-      PRO4D_DEF_ACCESSOR_TEMPLATE(MEM, PRO4D_DEF_MEM_ACCESSOR, operator[])
-};
-
-#undef PROD_ASSIGNMENT_OP_DISPATCH_IMPL
-#undef PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR
-#undef PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR
-#undef PROD_BINARY_OP_DISPATCH_IMPL
-#undef PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL
-#undef PROD_RHS_OP_DISPATCH_IMPL
-#undef PROD_DEF_RHS_OP_ACCESSOR
-#undef PROD_LHS_OP_DISPATCH_IMPL
-#undef PROD_LHS_ALL_OP_DISPATCH_BODY_IMPL
-#undef PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL
-#undef PROD_LHS_UNARY_OP_DISPATCH_BODY_IMPL
-#undef PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL
-#undef PROD_DEF_LHS_ALL_OP_ACCESSOR
-#undef PROD_DEF_LHS_BINARY_OP_ACCESSOR
-#undef PROD_DEF_LHS_UNARY_OP_ACCESSOR
-#undef PROD_DEF_LHS_LEFT_OP_ACCESSOR
-
-struct implicit_conversion_dispatch
-    : details::cast_dispatch_base<false, false> {
-  template <class T>
-  PRO4D_STATIC_CALL(T&&, T&& self) noexcept {
-    return std::forward<T>(self);
-  }
-};
-struct explicit_conversion_dispatch : details::cast_dispatch_base<true, false> {
-  template <class T>
-  PRO4D_STATIC_CALL(auto, T&& self) noexcept {
-    return details::converter{
-        [&self]<class U>(std::in_place_type_t<U>) noexcept(
-            std::is_nothrow_constructible_v<U, T>) -> U
-          requires(details::explicitly_convertible < T &&, U >)
-        { return static_cast<U>(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";
-  }
-};
-
-template <class D>
-struct weak_dispatch : D {
-  using D::operator();
-  template <class... Args>
-  [[noreturn]] PRO4D_STATIC_CALL(details::wildcard, Args&&...)
-    requires(!std::is_invocable_v<D, Args...>)
-  {
-    PRO4D_THROW(not_implemented{});
-  }
-};
-
-// =============================================================================
-// == Skill Extensions (skills::rtti, skills::format, etc.)                   ==
-// =============================================================================
-
-#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";
-  }
-};
-#endif // __cpp_rtti >= 199711L
-
-namespace details {
-
-template <template <class...> class TT, class... Ctx>
-struct enabled_t {};
-template <class T, template <class...> class TT, class... Ctx>
-concept enabled_for = std::is_base_of_v<enabled_t<TT, Ctx...>, T>;
-
-struct view_conversion_dispatch : cast_dispatch_base<false, true> {
-  template <class T>
-  PRO4D_STATIC_CALL(auto, T& 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};
-  }
-};
-template <class F>
-using view_conversion_overload = proxy_view<F>() & noexcept;
-
-struct weak_conversion_dispatch : cast_dispatch_base<false, true> {
-  template <class P>
-  PRO4D_STATIC_CALL(auto, const P& self) noexcept
-    requires(requires(const typename P::weak_type& w) {
-      { w.lock() } noexcept;
-    } && std::is_convertible_v<const P&, typename P::weak_type>)
-  {
-    return converter{
-        [&self]<class F>(std::in_place_type_t<proxy<F>>) noexcept
-          requires(proxiable<typename P::weak_type, F>)
-        { return proxy<F>{std::in_place_type<typename P::weak_type>, self}; }};
-  }
-};
-template <class F>
-using weak_conversion_overload = weak_proxy<F>() const noexcept;
-
-template <template <class...> class Formatter,
-          template <class...> class StringView,
-          template <class...> class ParseContext,
-          template <class...> class FormatContext>
-struct format_traits {
-  template <class CharT>
-  using overload = typename FormatContext<CharT>::iterator(
-      StringView<CharT> spec, FormatContext<CharT>& fc) const;
-
-  struct dispatch {
-    template <class T, class CharT>
-    PRO4D_STATIC_CALL(auto, const T& self, StringView<CharT> spec,
-                      FormatContext<CharT>& fc)
-      requires(std::is_default_constructible_v<Formatter<T, CharT>>)
-    {
-      Formatter<T, CharT> impl;
-      {
-        ParseContext<CharT> pc{spec};
-        impl.parse(pc);
-      }
-      return impl.format(self, fc);
-    }
-
-    template <class P, class D, class... Os>
-    struct PRO4D_ENFORCE_EBO accessor : accessor<P, D, Os>... {};
-    template <class P, class D>
-    struct accessor<P, D, overload<char>> : enabled_t<Formatter, char> {};
-    template <class P, class D>
-    struct accessor<P, D, overload<wchar_t>> : enabled_t<Formatter, wchar_t> {};
-  };
-
-  template <class CharT>
-  struct formatter {
-    constexpr auto parse(ParseContext<CharT>& pc) {
-      for (auto it = pc.begin(); it != pc.end(); ++it) {
-        if (*it == '}') {
-          spec_ = StringView<CharT>{pc.begin(), it + 1};
-          return it;
-        }
-      }
-      return pc.end();
-    }
-
-    template <class P, class CompatibleFormatContext>
-    auto format(const P& p, CompatibleFormatContext& fc) const ->
-        typename CompatibleFormatContext::iterator {
-      return invoke<dispatch, overload<CharT>>(p, spec_, fc);
-    }
-
-  private:
-    StringView<CharT> spec_;
-  };
-};
-
-#ifdef PRO4D_HAS_FORMAT
-template <class CharT>
-struct std_format_context_traits;
-template <>
-struct std_format_context_traits<char>
-    : std::type_identity<std::format_context> {};
-template <>
-struct std_format_context_traits<wchar_t>
-    : std::type_identity<std::wformat_context> {};
-template <class CharT>
-using std_format_context = typename std_format_context_traits<CharT>::type;
-struct std_format_traits
-    : format_traits<std::formatter, std::basic_string_view,
-                    std::basic_format_parse_context, std_format_context> {};
-#endif // PRO4D_HAS_FORMAT
-
-#if __cpp_rtti >= 199711L
-struct proxy_cast_context {
-  const std::type_info* type_ptr;
-  bool is_ref;
-  bool is_const;
-  void* result_ptr;
-};
-
-template <class Self, class D, class O>
-struct proxy_cast_accessor_impl {
-  template <class T>
-  friend T proxy_cast(Self self) {
-    static_assert(!std::is_rvalue_reference_v<T>);
-    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};
-      invoke<D, O>(static_cast<Self>(self), ctx);
-      if (result == nullptr) [[unlikely]] {
-        PRO4D_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};
-      invoke<D, O>(static_cast<Self>(self), ctx);
-      if (!result.has_value()) [[unlikely]] {
-        PRO4D_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<Self>::value)
-  {
-    void* result = nullptr;
-    proxy_cast_context ctx{.type_ptr = &typeid(T),
-                           .is_ref = true,
-                           .is_const = std::is_const_v<T>,
-                           .result_ptr = &result};
-    invoke<D, O>(*self, ctx);
-    return static_cast<T*>(result);
-  }
-};
-
-#define PROD_DEF_PROXY_CAST_ACCESSOR(oq, pq, ne, ...)                          \
-  template <class P, class D>                                                  \
-  struct accessor<P, D, void(proxy_cast_context) oq ne>                        \
-      : proxy_cast_accessor_impl<P pq, D, void(proxy_cast_context) oq ne> {}
-struct proxy_cast_dispatch {
-  template <class T>
-  PRO4D_STATIC_CALL(void, T&& self, proxy_cast_context ctx) {
-    if (typeid(T) == *ctx.type_ptr) [[likely]] {
-      if (ctx.is_ref) {
-        if constexpr (std::is_lvalue_reference_v<T>) {
-          if (ctx.is_const || !std::is_const_v<T>) [[likely]] {
-            *static_cast<void**>(ctx.result_ptr) = (void*)std::addressof(self);
-          }
-        }
-      } else {
-        if constexpr (std::is_constructible_v<std::decay_t<T>, T>) {
-          static_cast<std::optional<std::decay_t<T>>*>(ctx.result_ptr)
-              ->emplace(std::forward<T>(self));
-        }
-      }
-    }
-  }
-  PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PROD_DEF_PROXY_CAST_ACCESSOR)
-};
-#undef PROD_DEF_PROXY_CAST_ACCESSOR
-
-struct proxy_typeid_reflector {
-  proxy_typeid_reflector() = default;
-  template <class T>
-  constexpr explicit proxy_typeid_reflector(std::in_place_type_t<T>)
-      : info(&typeid(T)) {}
-
-  template <class Self, class R>
-  struct accessor {
-    friend const std::type_info& proxy_typeid(const Self& self) noexcept {
-      const proxy_typeid_reflector& refl = reflect<R>(self);
-      return *refl.info;
-    }
-    PRO4D_DEBUG(
-        accessor() noexcept { std::ignore = &pro_symbol_guard; }
-
-        private : static inline const std::type_info& pro_symbol_guard(
-            const Self& self) { return proxy_typeid(self); })
-  };
-
-  const std::type_info* info;
-};
-#endif // __cpp_rtti >= 199711L
-
-} // namespace details
-
-namespace skills {
-
-#ifdef PRO4D_HAS_FORMAT
-template <class FB>
-using format = typename FB::template add_convention<
-    details::std_format_traits::dispatch,
-    details::std_format_traits::overload<char>>;
-
-template <class FB>
-using wformat = typename FB::template add_convention<
-    details::std_format_traits::dispatch,
-    details::std_format_traits::overload<wchar_t>>;
-#endif // PRO4D_HAS_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>;
-
-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>;
-
-template <class FB>
-using rtti = indirect_rtti<FB>;
-#endif // __cpp_rtti >= 199711L
-
-template <class FB>
-using slim =
-    typename FB::template restrict_layout<sizeof(void*), alignof(void*)>;
-
-template <class FB>
-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>>;
-
-} // namespace skills
-
-} // namespace pro::inline v4
-
-// =============================================================================
-// == Adapters (std::formatter)                                               ==
-// =============================================================================
-
-#ifdef PRO4D_HAS_FORMAT
-namespace std {
-
-template <class T, class CharT>
-  requires(pro::v4::details::enabled_for<T, std::formatter, CharT>)
-struct formatter<T, CharT>
-    : pro::v4::details::std_format_traits::formatter<CharT> {};
-
-} // namespace std
-#endif // PRO4D_HAS_FORMAT
-
-#undef PROD_UNREACHABLE
-#undef PROD_NO_UNIQUE_ADDRESS_ATTRIBUTE
+#include "detail/core.h"            // IWYU pragma: export
+#include "detail/dispatch.h"        // IWYU pragma: export
+#include "detail/facade_creation.h" // IWYU pragma: export
+#include "detail/proxy_creation.h"  // IWYU pragma: export
+#include "detail/skills.h"          // IWYU pragma: export
 
 #endif // MSFT_PROXY_V4_PROXY_H_
diff --git a/include/proxy/v4/proxy_fmt.h b/include/proxy/v4/proxy_fmt.h
index a35b490..fa18be3 100644
--- a/include/proxy/v4/proxy_fmt.h
+++ b/include/proxy/v4/proxy_fmt.h
@@ -19,7 +19,7 @@ later) are included before proxy_fmt.h.
 
 namespace pro::inline v4 {
 
-namespace details {
+namespace detail {
 
 template <class CharT>
 #if FMT_VERSION >= 110000
@@ -32,19 +32,19 @@ struct fmt_format_traits
     : format_traits<fmt::formatter, std::basic_string_view,
                     fmt::basic_format_parse_context, fmt_buffered_context> {};
 
-} // namespace details
+} // namespace detail
 
 namespace skills {
 
 template <class FB>
 using fmt_format = typename FB::template add_convention<
-    details::fmt_format_traits::dispatch,
-    details::fmt_format_traits::overload<char>>;
+    detail::fmt_format_traits::dispatch,
+    detail::fmt_format_traits::overload<char>>;
 
 template <class FB>
 using fmt_wformat = typename FB::template add_convention<
-    details::fmt_format_traits::dispatch,
-    details::fmt_format_traits::overload<wchar_t>>;
+    detail::fmt_format_traits::dispatch,
+    detail::fmt_format_traits::overload<wchar_t>>;
 
 } // namespace skills
 
@@ -53,9 +53,9 @@ using fmt_wformat = typename FB::template add_convention<
 namespace fmt {
 
 template <class T, class CharT>
-  requires(pro::v4::details::enabled_for<T, fmt::formatter, CharT>)
+  requires(pro::v4::detail::enabled_for<T, fmt::formatter, CharT>)
 struct formatter<T, CharT>
-    : pro::v4::details::fmt_format_traits::formatter<CharT> {};
+    : pro::v4::detail::fmt_format_traits::formatter<CharT> {};
 
 } // namespace fmt
 
diff --git a/meson.build b/meson.build
index 2eba9f8..26acf94 100644
--- a/meson.build
+++ b/meson.build
@@ -34,34 +34,13 @@ endif
 
 inc = include_directories('include')
 
-hdrs = files(
-  'include/proxy/proxy.h',
-  'include/proxy/proxy_fmt.h',
-  'include/proxy/proxy_macros.h',
-)
-hdrs_v4 = files(
-  'include/proxy/v4/proxy.h',
-  'include/proxy/v4/proxy_fmt.h',
-  'include/proxy/v4/proxy_macros.h',
-)
-hdrs_mod = files('include/proxy/v4/proxy.ixx')
-
 msft_proxy4_dep = declare_dependency(
-  sources: hdrs + hdrs_v4,
   include_directories: inc,
 )
 
-install_headers(
-  hdrs,
-  subdir: 'proxy',
-)
-install_headers(
-  hdrs_v4,
-  subdir: 'proxy/v4',
-)
-install_headers(
-  hdrs_mod,
-  subdir: 'proxy/v4',
+install_subdir(
+  'include/proxy',
+  install_dir: get_option('includedir'),
 )
 pkgconfig = import(
   'pkgconfig',
diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel
index b1f091b..c3c49eb 100644
--- a/tests/BUILD.bazel
+++ b/tests/BUILD.bazel
@@ -15,7 +15,7 @@ cc_test(
     name = "proxy_tests",
     srcs = [
         "proxy_creation_tests.cpp",
-        "proxy_details_tests.cpp",
+        "proxy_detail_tests.cpp",
         "proxy_dispatch_tests.cpp",
         "proxy_fmt_format_no_wchar_tests.cpp",
         "proxy_fmt_format_tests.cpp",
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 8b6f678..75e64e0 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -14,7 +14,7 @@ include(GoogleTest)
 add_executable(
   msft_proxy_tests
   proxy_creation_tests.cpp
-  proxy_details_tests.cpp
+  proxy_detail_tests.cpp
   proxy_dispatch_tests.cpp
   proxy_fmt_format_no_wchar_tests.cpp
   proxy_fmt_format_tests.cpp
diff --git a/tests/meson.build b/tests/meson.build
index 528e8e4..9e6d847 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -1,6 +1,6 @@
 test_srcs = files(
   'proxy_creation_tests.cpp',
-  'proxy_details_tests.cpp',
+  'proxy_detail_tests.cpp',
   'proxy_dispatch_tests.cpp',
   'proxy_format_tests.cpp',
   'proxy_integration_tests.cpp',
diff --git a/tests/proxy_creation_tests.cpp b/tests/proxy_creation_tests.cpp
index 62d99e9..a16292b 100644
--- a/tests/proxy_creation_tests.cpp
+++ b/tests/proxy_creation_tests.cpp
@@ -7,7 +7,7 @@
 #include <memory_resource>
 #include <proxy/proxy.h>
 
-namespace proxy_creation_tests_details {
+namespace proxy_creation_tests_detail {
 
 enum LifetimeModelType {
   kNone,
@@ -21,30 +21,30 @@ enum LifetimeModelType {
 struct LifetimeModelReflector {
   template <class T>
   constexpr explicit LifetimeModelReflector(
-      std::in_place_type_t<pro::details::inplace_ptr<T>>)
+      std::in_place_type_t<pro::detail::inplace_ptr<T>>)
       : Type(LifetimeModelType::kInplace) {}
   template <class T, class Alloc>
   constexpr explicit LifetimeModelReflector(
-      std::in_place_type_t<pro::details::allocated_ptr<T, Alloc>>)
+      std::in_place_type_t<pro::detail::allocated_ptr<T, Alloc>>)
       : Type(LifetimeModelType::kAllocated) {}
   template <class T, class Alloc>
   constexpr explicit LifetimeModelReflector(
-      std::in_place_type_t<pro::details::compact_ptr<T, Alloc>>)
+      std::in_place_type_t<pro::detail::compact_ptr<T, Alloc>>)
       : Type(LifetimeModelType::kCompact) {
-    static_assert(sizeof(pro::details::compact_ptr<T, Alloc>) == sizeof(void*));
+    static_assert(sizeof(pro::detail::compact_ptr<T, Alloc>) == sizeof(void*));
   }
   template <class T, class Alloc>
   constexpr explicit LifetimeModelReflector(
-      std::in_place_type_t<pro::details::shared_compact_ptr<T, Alloc>>)
+      std::in_place_type_t<pro::detail::shared_compact_ptr<T, Alloc>>)
       : Type(LifetimeModelType::kSharedCompact) {
-    static_assert(sizeof(pro::details::shared_compact_ptr<T, Alloc>) ==
+    static_assert(sizeof(pro::detail::shared_compact_ptr<T, Alloc>) ==
                   sizeof(void*));
   }
   template <class T, class Alloc>
   constexpr explicit LifetimeModelReflector(
-      std::in_place_type_t<pro::details::strong_compact_ptr<T, Alloc>>)
+      std::in_place_type_t<pro::detail::strong_compact_ptr<T, Alloc>>)
       : Type(LifetimeModelType::kStrongCompact) {
-    static_assert(sizeof(pro::details::strong_compact_ptr<T, Alloc>) ==
+    static_assert(sizeof(pro::detail::strong_compact_ptr<T, Alloc>) ==
                   sizeof(void*));
   }
   template <class T>
@@ -176,9 +176,9 @@ struct TestWeakSharedStringable
 static_assert(pro::proxiable<int*, TestSharedStringable>);
 static_assert(!pro::proxiable<int*, TestWeakSharedStringable>);
 
-} // namespace proxy_creation_tests_details
+} // namespace proxy_creation_tests_detail
 
-namespace details = proxy_creation_tests_details;
+namespace detail = proxy_creation_tests_detail;
 
 TEST(ProxyCreationTests, TestMakeProxyInplace_FromValue) {
   utils::LifetimeTracker tracker;
@@ -187,10 +187,10 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_FromValue) {
   expected_ops.emplace_back(1,
                             utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::make_proxy_inplace<details::TestLargeStringable>(session);
+    auto p = pro::make_proxy_inplace<detail::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -203,11 +203,11 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy_inplace<details::TestLargeStringable,
+    auto p = pro::make_proxy_inplace<detail::TestLargeStringable,
                                      utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -220,12 +220,12 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_InPlaceInitializerList) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy_inplace<details::TestLargeStringable,
+    auto p = pro::make_proxy_inplace<detail::TestLargeStringable,
                                      utils::LifetimeTracker::Session>({1, 2, 3},
                                                                       &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -239,17 +239,17 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Copy) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     auto p1 =
-        pro::make_proxy_inplace<details::TestLargeStringable,
+        pro::make_proxy_inplace<detail::TestLargeStringable,
                                 utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -264,7 +264,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Move) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     auto p1 =
-        pro::make_proxy_inplace<details::TestLargeStringable,
+        pro::make_proxy_inplace<detail::TestLargeStringable,
                                 utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -272,7 +272,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -289,11 +289,11 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_FromValue) {
   expected_ops.emplace_back(1,
                             utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::allocate_proxy<details::TestSmallStringable>(
+    auto p = pro::allocate_proxy<detail::TestSmallStringable>(
         std::allocator<void>{}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -306,12 +306,12 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::allocate_proxy<details::TestSmallStringable,
+    auto p = pro::allocate_proxy<detail::TestSmallStringable,
                                  utils::LifetimeTracker::Session>(
         std::allocator<void>{}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -325,12 +325,12 @@ TEST(ProxyCreationTests,
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::allocate_proxy<details::TestSmallStringable,
+    auto p = pro::allocate_proxy<detail::TestSmallStringable,
                                  utils::LifetimeTracker::Session>(
         std::allocator<void>{}, {1, 2, 3}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -343,7 +343,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Copy) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::allocate_proxy<details::TestSmallStringable,
+    auto p1 = pro::allocate_proxy<detail::TestSmallStringable,
                                   utils::LifetimeTracker::Session>(
         std::allocator<void>{}, &tracker);
     expected_ops.emplace_back(1,
@@ -351,10 +351,10 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -368,7 +368,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Move) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::allocate_proxy<details::TestSmallStringable,
+    auto p1 = pro::allocate_proxy<detail::TestSmallStringable,
                                   utils::LifetimeTracker::Session>(
         std::allocator<void>{}, &tracker);
     expected_ops.emplace_back(1,
@@ -377,7 +377,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -392,11 +392,11 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_FromValue) {
                             utils::LifetimeOperationType::kValueConstruction);
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy<details::TestSmallStringable>(
+    auto p = pro::allocate_proxy<detail::TestSmallStringable>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kCompact);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -410,12 +410,12 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_InPlace) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy<details::TestSmallStringable,
+    auto p = pro::allocate_proxy<detail::TestSmallStringable,
                                  utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kCompact);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -430,12 +430,12 @@ TEST(ProxyCreationTests,
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy<details::TestSmallStringable,
+    auto p = pro::allocate_proxy<detail::TestSmallStringable,
                                  utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, {1, 2, 3}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kCompact);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -449,7 +449,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Copy) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy<details::TestSmallStringable,
+    auto p1 = pro::allocate_proxy<detail::TestSmallStringable,
                                   utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     expected_ops.emplace_back(1,
@@ -457,10 +457,10 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kCompact);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kCompact);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kCompact);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -475,7 +475,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Move) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy<details::TestSmallStringable,
+    auto p1 = pro::allocate_proxy<detail::TestSmallStringable,
                                   utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     expected_ops.emplace_back(1,
@@ -484,7 +484,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -498,10 +498,10 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_FromValue) {
   expected_ops.emplace_back(1,
                             utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::make_proxy<details::TestLargeStringable>(session);
+    auto p = pro::make_proxy<detail::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -514,11 +514,11 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy<details::TestLargeStringable,
+    auto p = pro::make_proxy<detail::TestLargeStringable,
                              utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -532,11 +532,11 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlaceInitializerList) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     auto p =
-        pro::make_proxy<details::TestLargeStringable,
+        pro::make_proxy<detail::TestLargeStringable,
                         utils::LifetimeTracker::Session>({1, 2, 3}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -549,17 +549,17 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Copy) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy<details::TestLargeStringable,
+    auto p1 = pro::make_proxy<detail::TestLargeStringable,
                               utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -573,7 +573,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Move) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy<details::TestLargeStringable,
+    auto p1 = pro::make_proxy<detail::TestLargeStringable,
                               utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -581,7 +581,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kInplace);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kInplace);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -598,10 +598,10 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_FromValue) {
   expected_ops.emplace_back(1,
                             utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::make_proxy<details::TestSmallStringable>(session);
+    auto p = pro::make_proxy<detail::TestSmallStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -614,11 +614,11 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy<details::TestSmallStringable,
+    auto p = pro::make_proxy<detail::TestSmallStringable,
                              utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -632,11 +632,11 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlaceInitializerList) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     auto p =
-        pro::make_proxy<details::TestSmallStringable,
+        pro::make_proxy<detail::TestSmallStringable,
                         utils::LifetimeTracker::Session>({1, 2, 3}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -649,17 +649,17 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Copy) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy<details::TestSmallStringable,
+    auto p1 = pro::make_proxy<detail::TestSmallStringable,
                               utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -673,7 +673,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Move) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy<details::TestSmallStringable,
+    auto p1 = pro::make_proxy<detail::TestSmallStringable,
                               utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -681,7 +681,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kAllocated);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kAllocated);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -689,8 +689,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Move) {
 }
 
 TEST(ProxyCreationTests, TestMakeProxy_SfinaeUnsafe) {
-  pro::proxy<details::SfinaeUnsafeFacade> p =
-      pro::make_proxy<details::SfinaeUnsafeFacade, int>();
+  pro::proxy<detail::SfinaeUnsafeFacade> p =
+      pro::make_proxy<detail::SfinaeUnsafeFacade, int>();
   Increment(*p);
   ASSERT_EQ(proxy_cast<int>(*p), 1);
 }
@@ -703,11 +703,11 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_SharedCompact_FromValue) {
                             utils::LifetimeOperationType::kValueConstruction);
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy_shared<details::TestSharedStringable>(
+    auto p = pro::allocate_proxy_shared<detail::TestSharedStringable>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -721,12 +721,12 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_SharedCompact_InPlace) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy_shared<details::TestSharedStringable,
+    auto p = pro::allocate_proxy_shared<detail::TestSharedStringable,
                                         utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -741,12 +741,12 @@ TEST(ProxyCreationTests,
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy_shared<details::TestSharedStringable,
+    auto p = pro::allocate_proxy_shared<detail::TestSharedStringable,
                                         utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, {1, 2, 3}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -760,7 +760,7 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_SharedCompact_Lifetime_Copy) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy_shared<details::TestSharedStringable,
+    auto p1 = pro::allocate_proxy_shared<detail::TestSharedStringable,
                                          utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     expected_ops.emplace_back(1,
@@ -768,10 +768,10 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_SharedCompact_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -783,7 +783,7 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_SharedCompact_Lifetime_Move) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy_shared<details::TestSharedStringable,
+    auto p1 = pro::allocate_proxy_shared<detail::TestSharedStringable,
                                          utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     expected_ops.emplace_back(1,
@@ -792,7 +792,7 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_SharedCompact_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -807,11 +807,11 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_StrongCompact_FromValue) {
                             utils::LifetimeOperationType::kValueConstruction);
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy_shared<details::TestWeakSharedStringable>(
+    auto p = pro::allocate_proxy_shared<detail::TestWeakSharedStringable>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -825,12 +825,12 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_StrongCompact_InPlace) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy_shared<details::TestWeakSharedStringable,
+    auto p = pro::allocate_proxy_shared<detail::TestWeakSharedStringable,
                                         utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -845,12 +845,12 @@ TEST(ProxyCreationTests,
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy_shared<details::TestWeakSharedStringable,
+    auto p = pro::allocate_proxy_shared<detail::TestWeakSharedStringable,
                                         utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, {1, 2, 3}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -864,7 +864,7 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_StrongCompact_Lifetime_Copy) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy_shared<details::TestWeakSharedStringable,
+    auto p1 = pro::allocate_proxy_shared<detail::TestWeakSharedStringable,
                                          utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     expected_ops.emplace_back(1,
@@ -872,10 +872,10 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_StrongCompact_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -887,7 +887,7 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_StrongCompact_Lifetime_Move) {
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy_shared<details::TestWeakSharedStringable,
+    auto p1 = pro::allocate_proxy_shared<detail::TestWeakSharedStringable,
                                          utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     expected_ops.emplace_back(1,
@@ -896,7 +896,7 @@ TEST(ProxyCreationTests, TestAllocateProxyShared_StrongCompact_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -909,18 +909,18 @@ TEST(ProxyCreationTests,
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy_shared<details::TestWeakSharedStringable,
+    auto p1 = pro::allocate_proxy_shared<detail::TestWeakSharedStringable,
                                          utils::LifetimeTracker::Session>(
         std::pmr::polymorphic_allocator<>{&memory_pool}, &tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::weak_proxy<details::TestWeakSharedStringable> p2 = p1;
+    pro::weak_proxy<detail::TestWeakSharedStringable> p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     auto p3 = p2.lock();
     ASSERT_TRUE(p3.has_value());
     ASSERT_EQ(ToString(*p3), "Session 1");
-    ASSERT_EQ(p3.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p3.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     p3.reset();
     p1.reset();
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -938,10 +938,10 @@ TEST(ProxyCreationTests, TestMakeProxyShared_SharedCompact_FromValue) {
   expected_ops.emplace_back(1,
                             utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::make_proxy_shared<details::TestSharedStringable>(session);
+    auto p = pro::make_proxy_shared<detail::TestSharedStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -954,11 +954,11 @@ TEST(ProxyCreationTests, TestMakeProxyShared_SharedCompact_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy_shared<details::TestSharedStringable,
+    auto p = pro::make_proxy_shared<detail::TestSharedStringable,
                                     utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -972,12 +972,12 @@ TEST(ProxyCreationTests,
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy_shared<details::TestSharedStringable,
+    auto p = pro::make_proxy_shared<detail::TestSharedStringable,
                                     utils::LifetimeTracker::Session>({1, 2, 3},
                                                                      &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -990,17 +990,17 @@ TEST(ProxyCreationTests, TestMakeProxyShared_SharedCompact_Lifetime_Copy) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy_shared<details::TestSharedStringable,
+    auto p1 = pro::make_proxy_shared<detail::TestSharedStringable,
                                      utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -1011,7 +1011,7 @@ TEST(ProxyCreationTests, TestMakeProxyShared_SharedCompact_Lifetime_Move) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy_shared<details::TestSharedStringable,
+    auto p1 = pro::make_proxy_shared<detail::TestSharedStringable,
                                      utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -1019,7 +1019,7 @@ TEST(ProxyCreationTests, TestMakeProxyShared_SharedCompact_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kSharedCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kSharedCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -1033,10 +1033,10 @@ TEST(ProxyCreationTests, TestMakeProxyShared_StrongCompact_FromValue) {
   expected_ops.emplace_back(1,
                             utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::make_proxy_shared<details::TestWeakSharedStringable>(session);
+    auto p = pro::make_proxy_shared<detail::TestWeakSharedStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -1049,11 +1049,11 @@ TEST(ProxyCreationTests, TestMakeProxyShared_StrongCompact_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy_shared<details::TestWeakSharedStringable,
+    auto p = pro::make_proxy_shared<detail::TestWeakSharedStringable,
                                     utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -1067,12 +1067,12 @@ TEST(ProxyCreationTests,
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy_shared<details::TestWeakSharedStringable,
+    auto p = pro::make_proxy_shared<detail::TestWeakSharedStringable,
                                     utils::LifetimeTracker::Session>({1, 2, 3},
                                                                      &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_EQ(p.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     expected_ops.emplace_back(
         1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -1085,17 +1085,17 @@ TEST(ProxyCreationTests, TestMakeProxyShared_StrongCompact_Lifetime_Copy) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy_shared<details::TestWeakSharedStringable,
+    auto p1 = pro::make_proxy_shared<detail::TestWeakSharedStringable,
                                      utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_EQ(p1.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p1.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -1106,7 +1106,7 @@ TEST(ProxyCreationTests, TestMakeProxyShared_StrongCompact_Lifetime_Move) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy_shared<details::TestWeakSharedStringable,
+    auto p1 = pro::make_proxy_shared<detail::TestWeakSharedStringable,
                                      utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -1114,7 +1114,7 @@ TEST(ProxyCreationTests, TestMakeProxyShared_StrongCompact_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_EQ(p2.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p2.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -1126,17 +1126,17 @@ TEST(ProxyCreationTests,
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy_shared<details::TestWeakSharedStringable,
+    auto p1 = pro::make_proxy_shared<detail::TestWeakSharedStringable,
                                      utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::weak_proxy<details::TestWeakSharedStringable> p2 = p1;
+    pro::weak_proxy<detail::TestWeakSharedStringable> p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     auto p3 = p2.lock();
     ASSERT_TRUE(p3.has_value());
     ASSERT_EQ(ToString(*p3), "Session 1");
-    ASSERT_EQ(p3.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p3.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     p3.reset();
     p1.reset();
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -1152,19 +1152,19 @@ TEST(ProxyCreationTests,
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy_shared<details::TestWeakSharedStringable,
+    auto p1 = pro::make_proxy_shared<detail::TestWeakSharedStringable,
                                      utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::weak_proxy<details::TestWeakSharedStringable> p2 = p1;
-    pro::weak_proxy<details::TestSharedStringable> p3 = std::move(p2);
+    pro::weak_proxy<detail::TestWeakSharedStringable> p2 = p1;
+    pro::weak_proxy<detail::TestSharedStringable> p3 = std::move(p2);
     ASSERT_TRUE(p1.has_value());
     ASSERT_FALSE(p2.has_value());
     ASSERT_TRUE(p3.has_value());
     auto p4 = p3.lock();
     ASSERT_TRUE(p4.has_value());
     ASSERT_EQ(ToString(*p4), "Session 1");
-    ASSERT_EQ(p4.GetLifetimeType(), details::LifetimeModelType::kStrongCompact);
+    ASSERT_EQ(p4.GetLifetimeType(), detail::LifetimeModelType::kStrongCompact);
     p4.reset();
     p1.reset();
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -1179,11 +1179,11 @@ TEST(ProxyCreationTests, TestStdWeakPtrCompatibility) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestWeakSharedStringable> p1 =
+    pro::proxy<detail::TestWeakSharedStringable> p1 =
         std::make_shared<utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::weak_proxy<details::TestWeakSharedStringable> p2 = p1;
+    pro::weak_proxy<detail::TestWeakSharedStringable> p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     auto p3 = p2.lock();
diff --git a/tests/proxy_detail_tests.cpp b/tests/proxy_detail_tests.cpp
new file mode 100644
index 0000000..760f9ce
--- /dev/null
+++ b/tests/proxy_detail_tests.cpp
@@ -0,0 +1,30 @@
+// Copyright (c) 2026-Present Next Gen C++ Foundation.
+// Licensed under the MIT License.
+
+#include <proxy/proxy.h>
+
+namespace proxy_detail_tests_detail {
+
+struct Base {
+  int v;
+};
+struct Derived : Base {};
+
+static_assert(pro::detail::explicitly_convertible<int, int>);
+static_assert(pro::detail::explicitly_convertible<long, int>);
+static_assert(!pro::detail::explicitly_convertible<int, int&&>);
+static_assert(!pro::detail::explicitly_convertible<int, const int&>);
+static_assert(pro::detail::explicitly_convertible<int&&, int&&>);
+static_assert(pro::detail::explicitly_convertible<int&&, const int&>);
+static_assert(!pro::detail::explicitly_convertible<long&&, int&&>);
+static_assert(!pro::detail::explicitly_convertible<long, int&&>);
+static_assert(pro::detail::explicitly_convertible<Derived&, Base&>);
+static_assert(pro::detail::explicitly_convertible<Derived&, const Base&>);
+static_assert(!pro::detail::explicitly_convertible<Derived&, Base&&>);
+static_assert(!pro::detail::explicitly_convertible<const Derived&, Base&>);
+static_assert(pro::detail::explicitly_convertible<const Derived&, const Base&>);
+static_assert(pro::detail::explicitly_convertible<Derived, Base>);
+static_assert(!pro::detail::explicitly_convertible<Derived, Base&&>);
+static_assert(!pro::detail::explicitly_convertible<Base&, Derived&>);
+
+} // namespace proxy_detail_tests_detail
diff --git a/tests/proxy_details_tests.cpp b/tests/proxy_details_tests.cpp
deleted file mode 100644
index a10cd4f..0000000
--- a/tests/proxy_details_tests.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2026-Present Next Gen C++ Foundation.
-// Licensed under the MIT License.
-
-#include <proxy/proxy.h>
-
-namespace proxy_details_tests_details {
-
-struct Base {
-  int v;
-};
-struct Derived : Base {};
-
-static_assert(pro::details::explicitly_convertible<int, int>);
-static_assert(pro::details::explicitly_convertible<long, int>);
-static_assert(!pro::details::explicitly_convertible<int, int&&>);
-static_assert(!pro::details::explicitly_convertible<int, const int&>);
-static_assert(pro::details::explicitly_convertible<int&&, int&&>);
-static_assert(pro::details::explicitly_convertible<int&&, const int&>);
-static_assert(!pro::details::explicitly_convertible<long&&, int&&>);
-static_assert(!pro::details::explicitly_convertible<long, int&&>);
-static_assert(pro::details::explicitly_convertible<Derived&, Base&>);
-static_assert(pro::details::explicitly_convertible<Derived&, const Base&>);
-static_assert(!pro::details::explicitly_convertible<Derived&, Base&&>);
-static_assert(!pro::details::explicitly_convertible<const Derived&, Base&>);
-static_assert(
-    pro::details::explicitly_convertible<const Derived&, const Base&>);
-static_assert(pro::details::explicitly_convertible<Derived, Base>);
-static_assert(!pro::details::explicitly_convertible<Derived, Base&&>);
-static_assert(!pro::details::explicitly_convertible<Base&, Derived&>);
-
-} // namespace proxy_details_tests_details
diff --git a/tests/proxy_dispatch_tests.cpp b/tests/proxy_dispatch_tests.cpp
index 1dde852..d2ac862 100644
--- a/tests/proxy_dispatch_tests.cpp
+++ b/tests/proxy_dispatch_tests.cpp
@@ -20,7 +20,7 @@
 #include <mdspan>
 #endif // __cpp_lib_mdspan >= 202207L
 
-namespace proxy_dispatch_tests_details {
+namespace proxy_dispatch_tests_detail {
 
 struct CommaTester {
 public:
@@ -48,9 +48,9 @@ struct TestFacadeBase : pro::facade_builder //
 
 PRO_DEF_FREE_AS_MEM_DISPATCH(FreeMemToString, std::to_string, ToString);
 
-} // namespace proxy_dispatch_tests_details
+} // namespace proxy_dispatch_tests_detail
 
-namespace details = proxy_dispatch_tests_details;
+namespace detail = proxy_dispatch_tests_detail;
 
 TEST(ProxyDispatchTests, TestOpPlus) {
   struct TestFacade
@@ -391,7 +391,7 @@ TEST(ProxyDispatchTests, TestOpComma) {
   struct TestFacade
       : pro::facade_builder::add_convention<pro::operator_dispatch<",">,
                                             int(int val)>::build {};
-  details::CommaTester v{3};
+  detail::CommaTester v{3};
   pro::proxy<TestFacade> p = &v;
   ASSERT_EQ((*p, 6), 9);
 }
@@ -768,7 +768,7 @@ TEST(ProxyDispatchTests, TestRhsOpComma) {
   struct TestFacade
       : pro::facade_builder::add_convention<pro::operator_dispatch<",", true>,
                                             int(int val)>::build {};
-  details::CommaTester v{3};
+  detail::CommaTester v{3};
   pro::proxy<TestFacade> p = &v;
   ASSERT_EQ((7, *p), 21);
 }
@@ -777,7 +777,7 @@ TEST(ProxyDispatchTests, TestRhsOpPtrToMem) {
   struct TestFacade
       : pro::facade_builder::add_convention<pro::operator_dispatch<"->*", true>,
                                             int(int val)>::build {};
-  details::PtrToMemTester v{3};
+  detail::PtrToMemTester v{3};
   pro::proxy<TestFacade> p = &v;
   ASSERT_EQ(2->**p, 6);
 }
@@ -796,15 +796,15 @@ TEST(ProxyDispatchTests, TestIndirectConversion) {
 TEST(ProxyDispatchTests, TestDirectConversion) {
   struct TestFacade
       : pro::facade_builder                                           //
-        ::add_facade<details::TestFacadeBase>                         //
+        ::add_facade<detail::TestFacadeBase>                          //
         ::add_convention<pro::operator_dispatch<"+=">, void(int val)> //
         ::add_direct_convention<pro::conversion_dispatch,
-                                pro::proxy<details::TestFacadeBase>() &&> //
+                                pro::proxy<detail::TestFacadeBase>() &&> //
         ::build {};
   pro::proxy<TestFacade> p1 = std::make_unique<int>(123);
   *p1 += 3;
-  pro::proxy<details::TestFacadeBase> p2 =
-      static_cast<pro::proxy<details::TestFacadeBase>>(std::move(p1));
+  pro::proxy<detail::TestFacadeBase> p2 =
+      static_cast<pro::proxy<detail::TestFacadeBase>>(std::move(p1));
   ASSERT_FALSE(p1.has_value());
   std::ostringstream stream;
   stream << *p2;
@@ -824,7 +824,7 @@ TEST(ProxyDispatchTests, TestImplciitConversion) {
 
 TEST(ProxyDispatchTests, TestFreeAsMemDispatch) {
   struct TestFacade
-      : pro::facade_builder::add_convention<details::FreeMemToString,
+      : pro::facade_builder::add_convention<detail::FreeMemToString,
                                             std::string() const>::build {};
   int v = 123;
   pro::proxy<TestFacade> p = &v;
diff --git a/tests/proxy_fmt_format_no_wchar_tests.cpp b/tests/proxy_fmt_format_no_wchar_tests.cpp
index 677c57d..eb3bc01 100644
--- a/tests/proxy_fmt_format_no_wchar_tests.cpp
+++ b/tests/proxy_fmt_format_no_wchar_tests.cpp
@@ -8,7 +8,7 @@
 #include <proxy/proxy.h>
 #include <proxy/proxy_fmt.h>
 
-namespace proxy_fmt_format_no_wchar_tests_details {
+namespace proxy_fmt_format_no_wchar_tests_detail {
 
 struct NonFormattable : pro::facade_builder::build {};
 
@@ -23,13 +23,13 @@ struct Formattable : pro::facade_builder                  //
 static_assert(std::is_default_constructible_v<
               fmt::formatter<pro::proxy_indirect_accessor<Formattable>, char>>);
 
-} // namespace proxy_fmt_format_no_wchar_tests_details
+} // namespace proxy_fmt_format_no_wchar_tests_detail
 
-namespace details = proxy_fmt_format_no_wchar_tests_details;
+namespace detail = proxy_fmt_format_no_wchar_tests_detail;
 
 TEST(ProxyFmtFormatNoWcharTests, TestFormat) {
   int v = 123;
-  pro::proxy<details::Formattable> p = &v;
+  pro::proxy<detail::Formattable> p = &v;
   ASSERT_EQ(fmt::format("{}", *p), "123");
   ASSERT_EQ(fmt::format("{:*<6}", *p), "123***");
 }
diff --git a/tests/proxy_fmt_format_tests.cpp b/tests/proxy_fmt_format_tests.cpp
index 2206b63..528aafa 100644
--- a/tests/proxy_fmt_format_tests.cpp
+++ b/tests/proxy_fmt_format_tests.cpp
@@ -11,7 +11,7 @@
 #include <proxy/proxy.h>
 #include <proxy/proxy_fmt.h>
 
-namespace proxy_fmt_format_tests_details {
+namespace proxy_fmt_format_tests_detail {
 
 struct NonFormattable : pro::facade_builder::build {};
 
@@ -33,20 +33,20 @@ static_assert(
     std::is_default_constructible_v<
         fmt::formatter<pro::proxy_indirect_accessor<Formattable>, wchar_t>>);
 
-} // namespace proxy_fmt_format_tests_details
+} // namespace proxy_fmt_format_tests_detail
 
-namespace details = proxy_fmt_format_tests_details;
+namespace detail = proxy_fmt_format_tests_detail;
 
 TEST(ProxyFmtFormatTests, TestFormat) {
   int v = 123;
-  pro::proxy<details::Formattable> p = &v;
+  pro::proxy<detail::Formattable> p = &v;
   ASSERT_EQ(fmt::format("{}", *p), "123");
   ASSERT_EQ(fmt::format("{:*<6}", *p), "123***");
 }
 
 TEST(ProxyFmtFormatTests, TestWformat) {
   int v = 123;
-  pro::proxy<details::Formattable> p = &v;
+  pro::proxy<detail::Formattable> p = &v;
   ASSERT_EQ(fmt::format(L"{}", *p), L"123");
   ASSERT_EQ(fmt::format(L"{:*<6}", *p), L"123***");
 }
diff --git a/tests/proxy_format_tests.cpp b/tests/proxy_format_tests.cpp
index 848cef0..b57e1cd 100644
--- a/tests/proxy_format_tests.cpp
+++ b/tests/proxy_format_tests.cpp
@@ -6,7 +6,7 @@
 #include <proxy/proxy.h>
 
 #ifdef PRO4D_HAS_FORMAT
-namespace proxy_format_tests_details {
+namespace proxy_format_tests_detail {
 
 struct NonFormattable : pro::facade_builder::build {};
 
@@ -28,15 +28,15 @@ static_assert(
     std::is_default_constructible_v<
         std::formatter<pro::proxy_indirect_accessor<Formattable>, wchar_t>>);
 
-} // namespace proxy_format_tests_details
+} // namespace proxy_format_tests_detail
 
-namespace details = proxy_format_tests_details;
+namespace detail = proxy_format_tests_detail;
 #endif // PRO4D_HAS_FORMAT
 
 TEST(ProxyFormatTests, TestFormat) {
 #ifdef PRO4D_HAS_FORMAT
   int v = 123;
-  pro::proxy<details::Formattable> p = &v;
+  pro::proxy<detail::Formattable> p = &v;
   ASSERT_EQ(std::format("{}", *p), "123");
   ASSERT_EQ(std::format("{:*<6}", *p), "123***");
 #else
@@ -47,7 +47,7 @@ TEST(ProxyFormatTests, TestFormat) {
 TEST(ProxyFormatTests, TestWformat) {
 #ifdef PRO4D_HAS_FORMAT
   int v = 123;
-  pro::proxy<details::Formattable> p = &v;
+  pro::proxy<detail::Formattable> p = &v;
   ASSERT_EQ(std::format(L"{}", *p), L"123");
   ASSERT_EQ(std::format(L"{:*<6}", *p), L"123***");
 #else
diff --git a/tests/proxy_integration_tests.cpp b/tests/proxy_integration_tests.cpp
index d54d415..732d3c2 100644
--- a/tests/proxy_integration_tests.cpp
+++ b/tests/proxy_integration_tests.cpp
@@ -12,7 +12,7 @@
 #include <string>
 #include <vector>
 
-namespace proxy_integration_tests_details {
+namespace proxy_integration_tests_detail {
 
 PRO_DEF_MEM_DISPATCH(MemDraw, Draw);
 PRO_DEF_MEM_DISPATCH(MemArea, Area);
@@ -133,28 +133,28 @@ class StreamLogger {
   std::ostream* out_;
 };
 
-} // namespace proxy_integration_tests_details
+} // namespace proxy_integration_tests_detail
 
-namespace details = proxy_integration_tests_details;
+namespace detail = proxy_integration_tests_detail;
 
 TEST(ProxyIntegrationTests, TestDrawable) {
-  pro::proxy<details::Drawable> p =
-      details::MakeDrawableFromCommand("Rectangle 2 3");
-  std::string s = details::PrintDrawableToString(std::move(p));
+  pro::proxy<detail::Drawable> p =
+      detail::MakeDrawableFromCommand("Rectangle 2 3");
+  std::string s = detail::PrintDrawableToString(std::move(p));
   ASSERT_EQ(
       s,
       "shape = {Rectangle: width = 2.00000, height = 3.00000}, area = 6.00000");
 
-  p = details::MakeDrawableFromCommand("Circle 1");
-  s = details::PrintDrawableToString(std::move(p));
+  p = detail::MakeDrawableFromCommand("Circle 1");
+  s = detail::PrintDrawableToString(std::move(p));
   ASSERT_EQ(s, "shape = {Circle: radius = 1.00000}, area = 3.14159");
 
-  p = details::MakeDrawableFromCommand("Point");
-  s = details::PrintDrawableToString(std::move(p));
+  p = detail::MakeDrawableFromCommand("Point");
+  s = detail::PrintDrawableToString(std::move(p));
   ASSERT_EQ(s, "shape = {Point}, area = 0.00000");
 
   try {
-    p = details::MakeDrawableFromCommand("Triangle 2 3");
+    p = detail::MakeDrawableFromCommand("Triangle 2 3");
   } catch (const std::runtime_error& e) {
     ASSERT_STREQ(e.what(), "Invalid command");
   }
@@ -162,7 +162,7 @@ TEST(ProxyIntegrationTests, TestDrawable) {
 
 TEST(ProxyIntegrationTests, TestLogger) {
   std::ostringstream out;
-  auto logger = pro::make_proxy<details::Logger, details::StreamLogger>(out);
+  auto logger = pro::make_proxy<detail::Logger, detail::StreamLogger>(out);
   logger->Log("hello");
   try {
     throw std::runtime_error{"runtime error!"};
diff --git a/tests/proxy_invocation_tests.cpp b/tests/proxy_invocation_tests.cpp
index 064edc6..9b4a758 100644
--- a/tests/proxy_invocation_tests.cpp
+++ b/tests/proxy_invocation_tests.cpp
@@ -25,7 +25,7 @@
 #endif // defined(_MSC_VER) && !defined(__clang__)
 #include "utils.h"
 
-namespace proxy_invocation_tests_details {
+namespace proxy_invocation_tests_detail {
 
 template <class... Os>
 struct MovableCallable
@@ -165,9 +165,9 @@ PRO_DEF_FREE_DISPATCH(FreeDump, Dump);
 PRO_DEF_FREE_DISPATCH(FreeInvoke, std::invoke, Invoke);
 PRO_DEF_FREE_AS_MEM_DISPATCH(MemInvoke, std::invoke, Invoke);
 
-} // namespace proxy_invocation_tests_details
+} // namespace proxy_invocation_tests_detail
 
-namespace details = proxy_invocation_tests_details;
+namespace detail = proxy_invocation_tests_detail;
 
 TEST(ProxyInvocationTests, TestArgumentForwarding) {
   std::string arg1 = "My string";
@@ -181,7 +181,7 @@ TEST(ProxyInvocationTests, TestArgumentForwarding) {
     arg2_received = std::move(v);
     return expected_result;
   };
-  pro::proxy<details::Callable<int(std::string, std::vector<int>)>> p = &f;
+  pro::proxy<detail::Callable<int(std::string, std::vector<int>)>> p = &f;
   int result = (*p)(arg1, std::move(arg2));
   ASSERT_TRUE(p.has_value());
   ASSERT_EQ(arg1_received, arg1);
@@ -194,7 +194,7 @@ TEST(ProxyInvocationTests, TestThrow) {
   const char* expected_error_message = "My exception";
   auto f = [&] { throw std::runtime_error{expected_error_message}; };
   bool exception_thrown = false;
-  pro::proxy<details::Callable<void()>> p = &f;
+  pro::proxy<detail::Callable<void()>> p = &f;
   try {
     (*p)();
   } catch (const std::runtime_error& e) {
@@ -207,7 +207,7 @@ TEST(ProxyInvocationTests, TestThrow) {
 
 TEST(ProxyInvocationTests, TestMultipleDispatches_Unique) {
   std::list<int> l = {1, 2, 3};
-  pro::proxy<details::Iterable<int>> p = &l;
+  pro::proxy<detail::Iterable<int>> p = &l;
   ASSERT_EQ(Size(*p), std::size_t{3});
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
@@ -218,15 +218,15 @@ TEST(ProxyInvocationTests, TestMultipleDispatches_Unique) {
 TEST(ProxyInvocationTests, TestMultipleDispatches_Duplicated) {
   struct DuplicatedIterable
       : pro::facade_builder //
-        ::add_convention<details::FreeForEach,
-                         void(std::function<void(int&)>)>  //
-        ::add_convention<details::FreeSize, std::size_t()> //
-        ::add_convention<details::FreeForEach,
+        ::add_convention<detail::FreeForEach,
+                         void(std::function<void(int&)>)> //
+        ::add_convention<detail::FreeSize, std::size_t()> //
+        ::add_convention<detail::FreeForEach,
                          void(std::function<void(int&)>)> //
         ::build {};
   static_assert(
-      sizeof(pro::details::facade_traits<DuplicatedIterable>::meta) ==
-      sizeof(pro::details::facade_traits<details::Iterable<int>>::meta));
+      sizeof(pro::detail::facade_traits<DuplicatedIterable>::meta) ==
+      sizeof(pro::detail::facade_traits<detail::Iterable<int>>::meta));
   std::list<int> l = {1, 2, 3};
   pro::proxy<DuplicatedIterable> p = &l;
   ASSERT_EQ(Size(*p), std::size_t{3});
@@ -238,7 +238,7 @@ TEST(ProxyInvocationTests, TestMultipleDispatches_Duplicated) {
 
 TEST(ProxyInvocationTests, TestRecursiveDefinition) {
   std::list<int> l = {1, 2, 3};
-  pro::proxy<details::Container<int>> p = &l;
+  pro::proxy<detail::Container<int>> p = &l;
   ASSERT_EQ(Size(*p), std::size_t{3});
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
@@ -260,97 +260,96 @@ TEST(ProxyInvocationTests, TestOverloadResolution_Member) {
         ::build {};
   std::vector<std::type_index> side_effect;
   auto p = pro::make_proxy<OverloadedCallable>([&](auto&&... args) {
-    side_effect = details::GetTypeIndices<std::decay_t<decltype(args)>...>();
+    side_effect = detail::GetTypeIndices<std::decay_t<decltype(args)>...>();
   });
   (*p)(123);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<int>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<int>());
   (*p)(1.23);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<double>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<double>());
   char foo[2];
   (*p)(foo);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<char*>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<char*>());
   (*p)("lalala");
-  ASSERT_EQ(side_effect, details::GetTypeIndices<const char*>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<const char*>());
   (*p)("lalala", 0);
-  ASSERT_EQ(side_effect, (details::GetTypeIndices<std::string, int>()));
+  ASSERT_EQ(side_effect, (detail::GetTypeIndices<std::string, int>()));
   ASSERT_FALSE((std::is_invocable_v<decltype(*p), std::vector<int>>));
 }
 
 TEST(ProxyInvocationTests, TestOverloadResolution_Free) {
   struct OverloadedCallable
       : pro::facade_builder //
-        ::add_convention<details::FreeInvoke, void(int), void(double),
+        ::add_convention<detail::FreeInvoke, void(int), void(double),
                          void(const char*), void(char*),
                          void(std::string, int)> //
         ::build {};
   std::vector<std::type_index> side_effect;
   auto p = pro::make_proxy<OverloadedCallable>([&](auto&&... args) {
-    side_effect = details::GetTypeIndices<std::decay_t<decltype(args)>...>();
+    side_effect = detail::GetTypeIndices<std::decay_t<decltype(args)>...>();
   });
   Invoke(*p, 123);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<int>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<int>());
   Invoke(*p, 1.23);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<double>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<double>());
   char foo[2];
   Invoke(*p, foo);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<char*>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<char*>());
   Invoke(*p, "lalala");
-  ASSERT_EQ(side_effect, details::GetTypeIndices<const char*>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<const char*>());
   Invoke(*p, "lalala", 0);
-  ASSERT_EQ(side_effect, (details::GetTypeIndices<std::string, int>()));
+  ASSERT_EQ(side_effect, (detail::GetTypeIndices<std::string, int>()));
 }
 
 TEST(ProxyInvocationTests, TestOverloadResolution_FreeAsMem) {
   struct OverloadedInvocable
       : pro::facade_builder //
-        ::add_convention<details::MemInvoke, void(int), void(double),
+        ::add_convention<detail::MemInvoke, void(int), void(double),
                          void(const char*), void(char*),
                          void(std::string, int)> //
         ::build {};
   std::vector<std::type_index> side_effect;
   auto p = pro::make_proxy<OverloadedInvocable>([&](auto&&... args) {
-    side_effect = details::GetTypeIndices<std::decay_t<decltype(args)>...>();
+    side_effect = detail::GetTypeIndices<std::decay_t<decltype(args)>...>();
   });
   p->Invoke(123);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<int>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<int>());
   p->Invoke(1.23);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<double>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<double>());
   char foo[2];
   p->Invoke(foo);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<char*>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<char*>());
   p->Invoke("lalala");
-  ASSERT_EQ(side_effect, details::GetTypeIndices<const char*>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<const char*>());
   p->Invoke("lalala", 0);
-  ASSERT_EQ(side_effect, (details::GetTypeIndices<std::string, int>()));
+  ASSERT_EQ(side_effect, (detail::GetTypeIndices<std::string, int>()));
 }
 
 TEST(ProxyInvocationTests, TestNoexcept) {
   std::vector<std::type_index> side_effect;
-  auto p = pro::make_proxy<details::Callable<void(int) noexcept, void(double)>>(
+  auto p = pro::make_proxy<detail::Callable<void(int) noexcept, void(double)>>(
       [&](auto&&... args) noexcept {
-        side_effect =
-            details::GetTypeIndices<std::decay_t<decltype(args)>...>();
+        side_effect = detail::GetTypeIndices<std::decay_t<decltype(args)>...>();
       });
   static_assert(noexcept((*p)(123)));
   (*p)(123);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<int>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<int>());
   static_assert(!noexcept((*p)(1.23)));
   (*p)(1.23);
-  ASSERT_EQ(side_effect, details::GetTypeIndices<double>());
+  ASSERT_EQ(side_effect, detail::GetTypeIndices<double>());
   ASSERT_FALSE((std::is_invocable_v<decltype(*p), char*>));
 }
 
 TEST(ProxyInvocationTests, TestFunctionPointer) {
-  struct TestFacade : details::Callable<std::vector<std::type_index>()> {};
-  pro::proxy<TestFacade> p{&details::GetTypeIndices<int, double>};
+  struct TestFacade : detail::Callable<std::vector<std::type_index>()> {};
+  pro::proxy<TestFacade> p{&detail::GetTypeIndices<int, double>};
   auto ret = (*p)();
-  ASSERT_EQ(ret, (details::GetTypeIndices<int, double>()));
+  ASSERT_EQ(ret, (detail::GetTypeIndices<int, double>()));
 }
 
 TEST(ProxyInvocationTests, TestMemberDispatchDefault) {
   std::vector<std::string> container1{"hello", "world", "!"};
   std::list<std::string> container2{"hello", "world"};
-  pro::proxy<details::ResourceDictionary> p = &container1;
+  pro::proxy<detail::ResourceDictionary> p = &container1;
   ASSERT_EQ(p->at(0), "hello");
   p = &container2;
   {
@@ -367,14 +366,14 @@ TEST(ProxyInvocationTests, TestMemberDispatchDefault) {
 TEST(ProxyInvocationTests, TestFreeDispatchDefault) {
   {
     int side_effect = 0;
-    auto p = pro::make_proxy<details::WeakCallable<void()>>(
-        [&] { side_effect = 1; });
+    auto p =
+        pro::make_proxy<detail::WeakCallable<void()>>([&] { side_effect = 1; });
     (*p)();
     ASSERT_EQ(side_effect, 1);
   }
   {
     bool exception_thrown = false;
-    auto p = pro::make_proxy<details::WeakCallable<void()>>(123);
+    auto p = pro::make_proxy<detail::WeakCallable<void()>>(123);
     try {
       (*p)();
     } catch (const pro::not_implemented&) {
@@ -386,7 +385,7 @@ TEST(ProxyInvocationTests, TestFreeDispatchDefault) {
 
 TEST(ProxyInvocationTests, TestObserverDispatch) {
   int test_val = 123;
-  pro::proxy<details::SharedStringable> p{std::make_shared<int>(test_val)};
+  pro::proxy<detail::SharedStringable> p{std::make_shared<int>(test_val)};
   auto weak = GetWeak(p);
   ASSERT_TRUE(weak.has_value());
   {
@@ -428,7 +427,7 @@ TEST(ProxyInvocationTests, TestQualifiedConvention_Member) {
 TEST(ProxyInvocationTests, TestQualifiedConvention_Free) {
   struct TestFacade
       : pro::facade_builder //
-        ::add_convention<details::FreeDump, std::string() &,
+        ::add_convention<detail::FreeDump, std::string() &,
                          std::string() const&, std::string() && noexcept,
                          std::string() const&&> //
         ::build {};
diff --git a/tests/proxy_lifetime_tests.cpp b/tests/proxy_lifetime_tests.cpp
index 7818f47..701e2ce 100644
--- a/tests/proxy_lifetime_tests.cpp
+++ b/tests/proxy_lifetime_tests.cpp
@@ -6,7 +6,7 @@
 #include <gtest/gtest.h>
 #include <proxy/proxy.h>
 
-namespace proxy_lifetime_tests_details {
+namespace proxy_lifetime_tests_detail {
 
 struct TestFacade
     : pro::facade_builder                                        //
@@ -37,17 +37,17 @@ static_assert(!std::is_convertible_v<pro::proxy<TestTrivialFacade>,
 static_assert(
     std::is_convertible_v<pro::proxy<TestRttiFacade>, pro::proxy<TestFacade>>);
 
-} // namespace proxy_lifetime_tests_details
+} // namespace proxy_lifetime_tests_detail
 
-namespace details = proxy_lifetime_tests_details;
+namespace detail = proxy_lifetime_tests_detail;
 
 TEST(ProxyLifetimeTests, TestDefaultConstrction) {
-  pro::proxy<details::TestFacade> p;
+  pro::proxy<detail::TestFacade> p;
   ASSERT_FALSE(p.has_value());
 }
 
 TEST(ProxyLifetimeTests, TestNullConstrction_Nullptr) {
-  pro::proxy<details::TestFacade> p = nullptr;
+  pro::proxy<detail::TestFacade> p = nullptr;
   ASSERT_FALSE(p.has_value());
 }
 
@@ -61,7 +61,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_FromValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p =
+    pro::proxy<detail::TestFacade> p =
         utils::LifetimeTracker::Session(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
@@ -86,7 +86,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_FromValue_Exception) {
     tracker.ThrowOnNextConstruction();
     bool exception_thrown = false;
     try {
-      pro::proxy<details::TestFacade> p = another_session;
+      pro::proxy<detail::TestFacade> p = another_session;
     } catch (const utils::ConstructionFailure& e) {
       exception_thrown = true;
       ASSERT_EQ(e.type_, utils::LifetimeOperationType::kCopyConstruction);
@@ -102,7 +102,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
@@ -121,7 +121,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_InPlace_Exception) {
     tracker.ThrowOnNextConstruction();
     bool exception_thrown = false;
     try {
-      pro::proxy<details::TestFacade> p{
+      pro::proxy<detail::TestFacade> p{
           std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     } catch (const utils::ConstructionFailure& e) {
       exception_thrown = true;
@@ -137,7 +137,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_InPlaceInitializerList) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>,
         {1, 2, 3},
         &tracker};
@@ -158,7 +158,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_InPlaceInitializerList_Exception) {
     tracker.ThrowOnNextConstruction();
     bool exception_thrown = false;
     try {
-      pro::proxy<details::TestFacade> p{
+      pro::proxy<detail::TestFacade> p{
           std::in_place_type<utils::LifetimeTracker::Session>,
           {1, 2, 3},
           &tracker};
@@ -177,7 +177,7 @@ TEST(ProxyLifetimeTests, TestCopyConstrction_FromValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -199,7 +199,7 @@ TEST(ProxyLifetimeTests, TestCopyConstrction_FromValue_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -221,7 +221,7 @@ TEST(ProxyLifetimeTests, TestCopyConstrction_FromValue_Exception) {
 }
 
 TEST(ProxyLifetimeTests, TestCopyConstrction_FromNull) {
-  pro::proxy<details::TestFacade> p1;
+  pro::proxy<detail::TestFacade> p1;
   auto p2 = p1;
   ASSERT_FALSE(p1.has_value());
   ASSERT_FALSE(p2.has_value());
@@ -231,7 +231,7 @@ TEST(ProxyLifetimeTests, TestMoveConstrction_FromValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -255,7 +255,7 @@ TEST(ProxyLifetimeTests, TestMoveConstrction_FromValue_Trivial) {
     utils::LifetimeTracker::Session session{&tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestTrivialFacade> p1 = &session;
+    pro::proxy<detail::TestTrivialFacade> p1 = &session;
     ASSERT_TRUE(p1.has_value());
     auto p2 = std::move(p1);
     ASSERT_TRUE(p1.has_value());
@@ -268,7 +268,7 @@ TEST(ProxyLifetimeTests, TestMoveConstrction_FromValue_Trivial) {
 }
 
 TEST(ProxyLifetimeTests, TestMoveConstrction_FromNull) {
-  pro::proxy<details::TestFacade> p1;
+  pro::proxy<detail::TestFacade> p1;
   auto p2 = std::move(p1);
   ASSERT_FALSE(p1.has_value());
   ASSERT_FALSE(p2.has_value());
@@ -278,7 +278,7 @@ TEST(ProxyLifetimeTests, TestNullAssignment_FromNullptr_ToValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -298,7 +298,7 @@ TEST(ProxyLifetimeTests, TestNullAssignment_FromTypedNullPointer_ToValue) {
 }
 
 TEST(ProxyLifetimeTests, TestNullAssignment_ToNull) {
-  pro::proxy<details::TestFacade> p;
+  pro::proxy<detail::TestFacade> p;
   p = nullptr;
   ASSERT_FALSE(p.has_value());
 }
@@ -307,7 +307,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_ToValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -333,7 +333,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_ToValue_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -362,7 +362,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_FromValue_ToNull) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     p = utils::LifetimeTracker::Session{&tracker};
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 3");
@@ -387,7 +387,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_FromValue_ToNull_Exception) {
     utils::LifetimeTracker::Session session{&tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     tracker.ThrowOnNextConstruction();
     bool exception_thrown = false;
     try {
@@ -408,7 +408,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlace_ToValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -428,7 +428,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlace_ToValue_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -452,7 +452,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlace_ToNull) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     p.emplace<utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
@@ -468,7 +468,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlace_ToNull_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     tracker.ThrowOnNextConstruction();
     bool exception_thrown = false;
     try {
@@ -488,7 +488,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlaceInitializerList_ToValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -509,7 +509,7 @@ TEST(ProxyLifetimeTests,
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -534,7 +534,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlaceInitializerList_ToNull) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     p.emplace<utils::LifetimeTracker::Session>({1, 2, 3}, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
@@ -551,7 +551,7 @@ TEST(ProxyLifetimeTests,
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     tracker.ThrowOnNextConstruction();
     bool exception_thrown = false;
     try {
@@ -572,11 +572,11 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -602,11 +602,11 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToValue_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -634,7 +634,7 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToSelf) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -658,8 +658,8 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToNull) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1;
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p1;
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -684,8 +684,8 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToNull_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1;
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p1;
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -711,11 +711,11 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromNull_ToValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2;
+    pro::proxy<detail::TestFacade> p2;
     p1 = p2;
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -724,7 +724,7 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromNull_ToValue) {
 }
 
 TEST(ProxyLifetimeTests, TestCopyAssignment_FromNull_ToSelf) {
-  pro::proxy<details::TestFacade> p;
+  pro::proxy<detail::TestFacade> p;
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wself-assign-overloaded"
@@ -737,8 +737,8 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromNull_ToSelf) {
 }
 
 TEST(ProxyLifetimeTests, TestCopyAssignment_FromNull_ToNull) {
-  pro::proxy<details::TestFacade> p1;
-  pro::proxy<details::TestFacade> p2;
+  pro::proxy<detail::TestFacade> p1;
+  pro::proxy<detail::TestFacade> p2;
   p1 = p2;
   ASSERT_FALSE(p1.has_value());
   ASSERT_FALSE(p2.has_value());
@@ -748,11 +748,11 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromValue_ToValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -774,11 +774,11 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromValue_ToValue_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -804,7 +804,7 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromValue_ToSelf) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -832,8 +832,8 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromValue_ToNull) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1;
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p1;
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -854,8 +854,8 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromValue_ToNull_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1;
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p1;
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -880,11 +880,11 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromNull_ToValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2;
+    pro::proxy<detail::TestFacade> p2;
     p1 = std::move(p2);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -893,7 +893,7 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromNull_ToValue) {
 }
 
 TEST(ProxyLifetimeTests, TestMoveAssignment_FromNull_ToSelf) {
-  pro::proxy<details::TestFacade> p;
+  pro::proxy<detail::TestFacade> p;
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wself-move"
@@ -911,8 +911,8 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromNull_ToSelf) {
 }
 
 TEST(ProxyLifetimeTests, TestMoveAssignment_FromNull_ToNull) {
-  pro::proxy<details::TestFacade> p1;
-  pro::proxy<details::TestFacade> p2;
+  pro::proxy<detail::TestFacade> p1;
+  pro::proxy<detail::TestFacade> p2;
   p1 = std::move(p2);
   ASSERT_FALSE(p1.has_value());
   ASSERT_FALSE(p2.has_value());
@@ -922,7 +922,7 @@ TEST(ProxyLifetimeTests, TestHasValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     ASSERT_FALSE(p.has_value());
     p.emplace<utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
@@ -938,12 +938,12 @@ TEST(ProxyLifetimeTests, TestHasValue) {
 TEST(ProxyLifetimeTests, TestOperatorBool) {
   // Implicit conversion to bool shall be prohibited.
   static_assert(
-      !std::is_nothrow_convertible_v<pro::proxy<details::TestFacade>, bool>);
+      !std::is_nothrow_convertible_v<pro::proxy<detail::TestFacade>, bool>);
 
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     ASSERT_FALSE(static_cast<bool>(p));
     p.emplace<utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(static_cast<bool>(p));
@@ -960,7 +960,7 @@ TEST(ProxyLifetimeTests, TestEqualsToNullptr) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p;
+    pro::proxy<detail::TestFacade> p;
     ASSERT_TRUE(p == nullptr);
     ASSERT_TRUE(nullptr == p);
     p.emplace<utils::LifetimeTracker::Session>(&tracker);
@@ -979,7 +979,7 @@ TEST(ProxyLifetimeTests, TestReset_FromValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -992,7 +992,7 @@ TEST(ProxyLifetimeTests, TestReset_FromValue) {
 }
 
 TEST(ProxyLifetimeTests, TestReset_FromNull) {
-  pro::proxy<details::TestFacade> p;
+  pro::proxy<detail::TestFacade> p;
   p.reset();
   ASSERT_FALSE(p.has_value());
 }
@@ -1001,11 +1001,11 @@ TEST(ProxyLifetimeTests, TestSwap_Value_Value) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(2,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -1034,7 +1034,7 @@ TEST(ProxyLifetimeTests, TestSwap_Value_Self) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -1057,11 +1057,11 @@ TEST(ProxyLifetimeTests, TestSwap_Value_Null) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1{
+    pro::proxy<detail::TestFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2;
+    pro::proxy<detail::TestFacade> p2;
     swap(p1, p2);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
@@ -1078,8 +1078,8 @@ TEST(ProxyLifetimeTests, TestSwap_Null_Value) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p1;
-    pro::proxy<details::TestFacade> p2{
+    pro::proxy<detail::TestFacade> p1;
+    pro::proxy<detail::TestFacade> p2{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -1096,24 +1096,24 @@ TEST(ProxyLifetimeTests, TestSwap_Null_Value) {
 }
 
 TEST(ProxyLifetimeTests, TestSwap_Null_Self) {
-  pro::proxy<details::TestFacade> p;
+  pro::proxy<detail::TestFacade> p;
   swap(p, p);
   ASSERT_FALSE(p.has_value());
 }
 
 TEST(ProxyLifetimeTests, TestSwap_Null_Null) {
-  pro::proxy<details::TestFacade> p1;
-  pro::proxy<details::TestFacade> p2;
+  pro::proxy<detail::TestFacade> p1;
+  pro::proxy<detail::TestFacade> p2;
   swap(p1, p2);
   ASSERT_FALSE(p1.has_value());
   ASSERT_FALSE(p2.has_value());
 }
 
 TEST(ProxyLifetimeTests, TestSwap_Trivial) {
-  pro::proxy<details::TestTrivialFacade> p1 =
-      pro::make_proxy<details::TestTrivialFacade>(123);
-  pro::proxy<details::TestTrivialFacade> p2 =
-      pro::make_proxy<details::TestTrivialFacade>(456);
+  pro::proxy<detail::TestTrivialFacade> p1 =
+      pro::make_proxy<detail::TestTrivialFacade>(123);
+  pro::proxy<detail::TestTrivialFacade> p2 =
+      pro::make_proxy<detail::TestTrivialFacade>(456);
   swap(p1, p2);
   ASSERT_TRUE(p1.has_value());
   ASSERT_EQ(ToString(*p1), "456");
@@ -1125,7 +1125,7 @@ TEST(ProxyLifetimeTests, Test_DirectConvension_Lvalue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -1146,7 +1146,7 @@ TEST(ProxyLifetimeTests, Test_DirectConvension_Rvalue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -1166,7 +1166,7 @@ TEST(ProxyLifetimeTests, Test_DirectConvension_Rvalue_Exception) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestFacade> p{
+    pro::proxy<detail::TestFacade> p{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
@@ -1190,11 +1190,11 @@ TEST(ProxyLifetimeTests, Test_CopySubstitution_FromValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestRttiFacade> p1{
+    pro::proxy<detail::TestRttiFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2 = p1;
+    pro::proxy<detail::TestFacade> p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
     ASSERT_STREQ(p1.GetTypeName(),
@@ -1211,8 +1211,8 @@ TEST(ProxyLifetimeTests, Test_CopySubstitution_FromValue) {
 }
 
 TEST(ProxyLifetimeTests, Test_CopySubstitution_FromNull) {
-  pro::proxy<details::TestRttiFacade> p1;
-  pro::proxy<details::TestFacade> p2 = p1;
+  pro::proxy<detail::TestRttiFacade> p1;
+  pro::proxy<detail::TestFacade> p2 = p1;
   ASSERT_FALSE(p1.has_value());
   ASSERT_FALSE(p2.has_value());
 }
@@ -1221,11 +1221,11 @@ TEST(ProxyLifetimeTests, Test_MoveSubstitution_FromValue) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    pro::proxy<details::TestRttiFacade> p1{
+    pro::proxy<detail::TestRttiFacade> p1{
         std::in_place_type<utils::LifetimeTracker::Session>, &tracker};
     expected_ops.emplace_back(1,
                               utils::LifetimeOperationType::kValueConstruction);
-    pro::proxy<details::TestFacade> p2 = std::move(p1);
+    pro::proxy<detail::TestFacade> p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
@@ -1239,8 +1239,8 @@ TEST(ProxyLifetimeTests, Test_MoveSubstitution_FromValue) {
 }
 
 TEST(ProxyLifetimeTests, Test_MoveSubstitution_FromNull) {
-  pro::proxy<details::TestRttiFacade> p1;
-  pro::proxy<details::TestFacade> p2 = std::move(p1);
+  pro::proxy<detail::TestRttiFacade> p1;
+  pro::proxy<detail::TestFacade> p2 = std::move(p1);
   ASSERT_FALSE(p1.has_value());
   ASSERT_FALSE(p2.has_value());
 }
diff --git a/tests/proxy_reflection_tests.cpp b/tests/proxy_reflection_tests.cpp
index 717205a..c304738 100644
--- a/tests/proxy_reflection_tests.cpp
+++ b/tests/proxy_reflection_tests.cpp
@@ -8,7 +8,7 @@
 #include <proxy/proxy.h>
 #include <typeinfo>
 
-namespace proxy_reflection_tests_details {
+namespace proxy_reflection_tests_detail {
 
 struct TraitsReflector {
 public:
@@ -44,26 +44,26 @@ struct TestTraitsFacade : pro::facade_builder                      //
                           ::add_direct_reflection<TraitsReflector> //
                           ::build {};
 
-} // namespace proxy_reflection_tests_details
+} // namespace proxy_reflection_tests_detail
 
-namespace details = proxy_reflection_tests_details;
+namespace detail = proxy_reflection_tests_detail;
 
 TEST(ProxyReflectionTests, TestRtti_RawPtr) {
   int foo = 123;
-  pro::proxy<details::TestRttiFacade> p = &foo;
+  pro::proxy<detail::TestRttiFacade> p = &foo;
   ASSERT_STREQ(p.GetTypeName(), typeid(int*).name());
   ASSERT_STREQ(p->GetTypeName(), typeid(int).name());
 }
 
 TEST(ProxyReflectionTests, TestRtti_FancyPtr) {
-  pro::proxy<details::TestRttiFacade> p = std::make_unique<double>(1.23);
+  pro::proxy<detail::TestRttiFacade> p = std::make_unique<double>(1.23);
   ASSERT_STREQ(p.GetTypeName(), typeid(std::unique_ptr<double>).name());
   ASSERT_STREQ(p->GetTypeName(), typeid(double).name());
 }
 
 TEST(ProxyReflectionTests, TestTraits_RawPtr) {
   int foo = 123;
-  pro::proxy<details::TestTraitsFacade> p = &foo;
+  pro::proxy<detail::TestTraitsFacade> p = &foo;
   ASSERT_EQ(p.ReflectTraits().is_default_constructible_, true);
   ASSERT_EQ(p.ReflectTraits().is_copy_constructible_, true);
   ASSERT_EQ(p.ReflectTraits().is_nothrow_move_constructible_, true);
@@ -72,7 +72,7 @@ TEST(ProxyReflectionTests, TestTraits_RawPtr) {
 }
 
 TEST(ProxyReflectionTests, TestTraits_FancyPtr) {
-  pro::proxy<details::TestTraitsFacade> p = std::make_unique<double>(1.23);
+  pro::proxy<detail::TestTraitsFacade> p = std::make_unique<double>(1.23);
   ASSERT_EQ(p.ReflectTraits().is_default_constructible_, true);
   ASSERT_EQ(p.ReflectTraits().is_copy_constructible_, false);
   ASSERT_EQ(p.ReflectTraits().is_nothrow_move_constructible_, true);
diff --git a/tests/proxy_regression_tests.cpp b/tests/proxy_regression_tests.cpp
index d338908..70f4a50 100644
--- a/tests/proxy_regression_tests.cpp
+++ b/tests/proxy_regression_tests.cpp
@@ -14,7 +14,7 @@
 #endif // defined(_MSC_VER) && !defined(__clang__)
 #include <vector>
 
-namespace proxy_regression_tests_details {
+namespace proxy_regression_tests_detail {
 
 template <class It, class F>
 bool operator==(const It& it, const pro::proxy<F>& rhs) noexcept
@@ -50,9 +50,9 @@ struct Range : pro::facade_builder                                          //
 
 PRO_DEF_MEM_DISPATCH(MemFun, Fun);
 
-} // namespace proxy_regression_tests_details
+} // namespace proxy_regression_tests_detail
 
-namespace details = proxy_regression_tests_details;
+namespace detail = proxy_regression_tests_detail;
 
 // https://github.com/microsoft/proxy/issues/213
 TEST(ProxyRegressionTests, TestUnexpectedCompilerWarning) {
@@ -74,7 +74,7 @@ TEST(ProxyRegressionTests, TestUnexpectedCompilerWarning) {
 TEST(ProxyRegressionTests, TestProxiableSelfDependency) {
   std::vector<int> original{1, 2, 123};
   std::vector<int> expected;
-  pro::proxy<details::Range<int>> p = &original;
+  pro::proxy<detail::Range<int>> p = &original;
   for (int i : *p) {
     expected.push_back(i);
   }
@@ -84,8 +84,8 @@ TEST(ProxyRegressionTests, TestProxiableSelfDependency) {
 // https://github.com/ngcpp/proxy/issues/10
 TEST(ProxyRegressionTests, TestWeakDispatchReferenceReturningOverload) {
   struct MyFacade
-      : pro::facade_builder                                           //
-        ::add_convention<pro::weak_dispatch<details::MemFun>, int&()> //
+      : pro::facade_builder                                          //
+        ::add_convention<pro::weak_dispatch<detail::MemFun>, int&()> //
         ::build {};
   static_assert(pro::proxiable<int*, MyFacade>);
 
diff --git a/tests/proxy_rtti_tests.cpp b/tests/proxy_rtti_tests.cpp
index 1545939..fbfbb95 100644
--- a/tests/proxy_rtti_tests.cpp
+++ b/tests/proxy_rtti_tests.cpp
@@ -6,27 +6,27 @@
 #include <proxy/proxy.h>
 #include <vector>
 
-namespace proxy_rtti_tests_details {
+namespace proxy_rtti_tests_detail {
 
 struct TestFacade : pro::facade_builder                   //
                     ::add_skill<pro::skills::rtti>        //
                     ::add_skill<pro::skills::direct_rtti> //
                     ::build {};
 
-} // namespace proxy_rtti_tests_details
+} // namespace proxy_rtti_tests_detail
 
-namespace details = proxy_rtti_tests_details;
+namespace detail = proxy_rtti_tests_detail;
 
 TEST(ProxyRttiTests, TestIndirectCast_Ref_Succeed) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   proxy_cast<int&>(*p) = 456;
   ASSERT_EQ(v, 456);
 }
 
 TEST(ProxyRttiTests, TestIndirectCast_Ref_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   bool exception_thrown = false;
   try {
     proxy_cast<double&>(*p);
@@ -38,7 +38,7 @@ TEST(ProxyRttiTests, TestIndirectCast_Ref_Fail) {
 
 TEST(ProxyRttiTests, TestIndirectCast_ConstRef_Succeed) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   const int& r = proxy_cast<const int&>(*p);
   ASSERT_EQ(&v, &r);
   ASSERT_EQ(v, 123);
@@ -46,7 +46,7 @@ TEST(ProxyRttiTests, TestIndirectCast_ConstRef_Succeed) {
 
 TEST(ProxyRttiTests, TestIndirectCast_ConstRef_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   bool exception_thrown = false;
   try {
     proxy_cast<const double&>(*p);
@@ -58,7 +58,7 @@ TEST(ProxyRttiTests, TestIndirectCast_ConstRef_Fail) {
 
 TEST(ProxyRttiTests, TestIndirectCast_Copy_Succeed) {
   int v1 = 123;
-  pro::proxy<details::TestFacade> p = &v1;
+  pro::proxy<detail::TestFacade> p = &v1;
   int v2 = proxy_cast<int>(*p);
   ASSERT_EQ(v1, 123);
   ASSERT_EQ(v2, 123);
@@ -66,7 +66,7 @@ TEST(ProxyRttiTests, TestIndirectCast_Copy_Succeed) {
 
 TEST(ProxyRttiTests, TestIndirectCast_Copy_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   bool exception_thrown = false;
   try {
     proxy_cast<double>(*p);
@@ -78,14 +78,14 @@ TEST(ProxyRttiTests, TestIndirectCast_Copy_Fail) {
 
 TEST(ProxyRttiTests, TestIndirectCast_Move_Succeed) {
   const std::vector<int> v1{1, 2, 3};
-  auto p = pro::make_proxy<details::TestFacade>(v1);
+  auto p = pro::make_proxy<detail::TestFacade>(v1);
   auto v2 = proxy_cast<std::vector<int>>(std::move(*p));
   ASSERT_EQ(v2, v1);
   ASSERT_FALSE(p.has_value());
 }
 
 TEST(ProxyRttiTests, TestIndirectCast_Move_Fail) {
-  auto p = pro::make_proxy<details::TestFacade>(std::vector<int>{1, 2, 3});
+  auto p = pro::make_proxy<detail::TestFacade>(std::vector<int>{1, 2, 3});
   bool exception_thrown = false;
   try {
     proxy_cast<std::vector<double>>(std::move(*p));
@@ -97,7 +97,7 @@ TEST(ProxyRttiTests, TestIndirectCast_Move_Fail) {
 
 TEST(ProxyRttiTests, TestIndirectCast_Ptr_Succeed) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   auto ptr = proxy_cast<int>(&*p);
   static_assert(std::is_same_v<decltype(ptr), int*>);
   ASSERT_EQ(ptr, &v);
@@ -106,7 +106,7 @@ TEST(ProxyRttiTests, TestIndirectCast_Ptr_Succeed) {
 
 TEST(ProxyRttiTests, TestIndirectCast_Ptr_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   auto ptr = proxy_cast<double>(&*p);
   static_assert(std::is_same_v<decltype(ptr), double*>);
   ASSERT_EQ(ptr, nullptr);
@@ -115,7 +115,7 @@ TEST(ProxyRttiTests, TestIndirectCast_Ptr_Fail) {
 
 TEST(ProxyRttiTests, TestIndirectCast_ConstPtr_Succeed) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   auto ptr = proxy_cast<const int>(&*p);
   static_assert(std::is_same_v<decltype(ptr), const int*>);
   ASSERT_EQ(ptr, &v);
@@ -124,7 +124,7 @@ TEST(ProxyRttiTests, TestIndirectCast_ConstPtr_Succeed) {
 
 TEST(ProxyRttiTests, TestIndirectCast_ConstPtr_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   auto ptr = proxy_cast<const double>(&*p);
   static_assert(std::is_same_v<decltype(ptr), const double*>);
   ASSERT_EQ(ptr, nullptr);
@@ -133,20 +133,20 @@ TEST(ProxyRttiTests, TestIndirectCast_ConstPtr_Fail) {
 
 TEST(ProxyRttiTests, TestIndirectTypeid) {
   int a = 123;
-  pro::proxy<details::TestFacade> p = &a;
+  pro::proxy<detail::TestFacade> p = &a;
   ASSERT_EQ(proxy_typeid(*p), typeid(int));
 }
 
 TEST(ProxyRttiTests, TestDirectCast_Ref_Succeed) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   *proxy_cast<int*&>(p) = 456;
   ASSERT_EQ(v, 456);
 }
 
 TEST(ProxyRttiTests, TestDirectCast_Ref_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   bool exception_thrown = false;
   try {
     proxy_cast<double*&>(p);
@@ -158,7 +158,7 @@ TEST(ProxyRttiTests, TestDirectCast_Ref_Fail) {
 
 TEST(ProxyRttiTests, TestDirectCast_ConstRef_Succeed) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   int* const& r = proxy_cast<int* const&>(p);
   ASSERT_EQ(&v, r);
   ASSERT_EQ(v, 123);
@@ -166,7 +166,7 @@ TEST(ProxyRttiTests, TestDirectCast_ConstRef_Succeed) {
 
 TEST(ProxyRttiTests, TestDirectCast_ConstRef_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   bool exception_thrown = false;
   try {
     proxy_cast<double* const&>(p);
@@ -178,7 +178,7 @@ TEST(ProxyRttiTests, TestDirectCast_ConstRef_Fail) {
 
 TEST(ProxyRttiTests, TestDirectCast_Copy_Succeed) {
   int v1 = 123;
-  pro::proxy<details::TestFacade> p = &v1;
+  pro::proxy<detail::TestFacade> p = &v1;
   int* v2 = proxy_cast<int*>(p);
   ASSERT_EQ(v2, &v1);
   ASSERT_EQ(v1, 123);
@@ -186,7 +186,7 @@ TEST(ProxyRttiTests, TestDirectCast_Copy_Succeed) {
 
 TEST(ProxyRttiTests, TestDirectCast_Copy_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   bool exception_thrown = false;
   try {
     proxy_cast<double*>(p);
@@ -198,7 +198,7 @@ TEST(ProxyRttiTests, TestDirectCast_Copy_Fail) {
 
 TEST(ProxyRttiTests, TestDirectCast_Move_Succeed) {
   int v1 = 123;
-  pro::proxy<details::TestFacade> p = &v1;
+  pro::proxy<detail::TestFacade> p = &v1;
   auto v2 = proxy_cast<int*>(std::move(p));
   ASSERT_EQ(v2, &v1);
   ASSERT_EQ(v1, 123);
@@ -207,7 +207,7 @@ TEST(ProxyRttiTests, TestDirectCast_Move_Succeed) {
 
 TEST(ProxyRttiTests, TestDirectCast_Move_Fail) {
   int v1 = 123;
-  pro::proxy<details::TestFacade> p = &v1;
+  pro::proxy<detail::TestFacade> p = &v1;
   bool exception_thrown = false;
   try {
     proxy_cast<double*>(std::move(p));
@@ -220,7 +220,7 @@ TEST(ProxyRttiTests, TestDirectCast_Move_Fail) {
 
 TEST(ProxyRttiTests, TestDirectCast_Ptr_Succeed) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   auto ptr = proxy_cast<int*>(&p);
   static_assert(std::is_same_v<decltype(ptr), int**>);
   ASSERT_EQ(*ptr, &v);
@@ -229,7 +229,7 @@ TEST(ProxyRttiTests, TestDirectCast_Ptr_Succeed) {
 
 TEST(ProxyRttiTests, TestDirectCast_Ptr_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   auto ptr = proxy_cast<double*>(&p);
   static_assert(std::is_same_v<decltype(ptr), double**>);
   ASSERT_EQ(ptr, nullptr);
@@ -238,7 +238,7 @@ TEST(ProxyRttiTests, TestDirectCast_Ptr_Fail) {
 
 TEST(ProxyRttiTests, TestDirectCast_ConstPtr_Succeed) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   auto ptr = proxy_cast<int* const>(&p);
   static_assert(std::is_same_v<decltype(ptr), int* const*>);
   ASSERT_EQ(*ptr, &v);
@@ -247,7 +247,7 @@ TEST(ProxyRttiTests, TestDirectCast_ConstPtr_Succeed) {
 
 TEST(ProxyRttiTests, TestDirectCast_ConstPtr_Fail) {
   int v = 123;
-  pro::proxy<details::TestFacade> p = &v;
+  pro::proxy<detail::TestFacade> p = &v;
   auto ptr = proxy_cast<double* const>(&*p);
   static_assert(std::is_same_v<decltype(ptr), double* const*>);
   ASSERT_EQ(ptr, nullptr);
@@ -256,6 +256,6 @@ TEST(ProxyRttiTests, TestDirectCast_ConstPtr_Fail) {
 
 TEST(ProxyRttiTests, TestDirectTypeid) {
   int a = 123;
-  pro::proxy<details::TestFacade> p = &a;
+  pro::proxy<detail::TestFacade> p = &a;
   ASSERT_EQ(proxy_typeid(p), typeid(int*));
 }
diff --git a/tests/proxy_traits_tests.cpp b/tests/proxy_traits_tests.cpp
index ab593bd..ebadf84 100644
--- a/tests/proxy_traits_tests.cpp
+++ b/tests/proxy_traits_tests.cpp
@@ -8,7 +8,7 @@
 #include <stdexcept>
 #include <type_traits>
 
-namespace proxy_traits_tests_details {
+namespace proxy_traits_tests_detail {
 
 template <bool kNothrowRelocatable, bool kCopyable, bool kTrivial,
           std::size_t kSize, std::size_t kAlignment>
@@ -42,19 +42,19 @@ using MockCopyableSmallPtr =
 using MockTrivialPtr = MockPtr<true, true, true, sizeof(void*), alignof(void*)>;
 using MockFunctionPtr = void (*)();
 
-} // namespace proxy_traits_tests_details
+} // namespace proxy_traits_tests_detail
 
 namespace pro {
 
 template <bool kNothrowRelocatable, bool kCopyable, bool kTrivial,
           std::size_t kSize, std::size_t kAlignment>
-struct is_bitwise_trivially_relocatable<proxy_traits_tests_details::MockPtr<
+struct is_bitwise_trivially_relocatable<proxy_traits_tests_detail::MockPtr<
     kNothrowRelocatable, kCopyable, kTrivial, kSize, kAlignment>>
     : std::true_type {};
 
 } // namespace pro
 
-namespace proxy_traits_tests_details {
+namespace proxy_traits_tests_detail {
 
 struct DefaultFacade : pro::facade_builder::build {};
 static_assert(
@@ -328,57 +328,57 @@ static_assert(!pro::facade<BadFacade_BadConstraints_UnexpectedType>);
 
 // Well-formed facade_impl specialization
 static_assert(
-    pro::facade<pro::details::facade_impl<
+    pro::facade<pro::detail::facade_impl<
         std::tuple<>, std::tuple<>, 8, 4, pro::constraint_level::none,
         pro::constraint_level::trivial, pro::constraint_level::nothrow>>);
 
 // Bad size (max_size should be positive)
 static_assert(
-    !pro::facade<pro::details::facade_impl<
+    !pro::facade<pro::detail::facade_impl<
         std::tuple<>, std::tuple<>, 0, 4, pro::constraint_level::none,
         pro::constraint_level::trivial, pro::constraint_level::nothrow>>);
 
 // Bad size (max_size should be a multiple of max_align)
 static_assert(
-    !pro::facade<pro::details::facade_impl<
+    !pro::facade<pro::detail::facade_impl<
         std::tuple<>, std::tuple<>, 10, 4, pro::constraint_level::none,
         pro::constraint_level::trivial, pro::constraint_level::nothrow>>);
 
 // Bad alignment (max_align should be a power of 2)
 static_assert(
-    !pro::facade<pro::details::facade_impl<
+    !pro::facade<pro::detail::facade_impl<
         std::tuple<>, std::tuple<>, 6, 6, pro::constraint_level::none,
         pro::constraint_level::trivial, pro::constraint_level::nothrow>>);
 
 // Bad copyability (less than constraint_level::none)
 static_assert(
-    !pro::facade<pro::details::facade_impl<
+    !pro::facade<pro::detail::facade_impl<
         std::tuple<>, std::tuple<>, 8, 4, (pro::constraint_level)-1,
         pro::constraint_level::trivial, pro::constraint_level::nothrow>>);
 
 // Bad copyability (greater than constraint_level::trivial)
 static_assert(
-    !pro::facade<pro::details::facade_impl<
+    !pro::facade<pro::detail::facade_impl<
         std::tuple<>, std::tuple<>, 8, 4, (pro::constraint_level)100,
         pro::constraint_level::trivial, pro::constraint_level::nothrow>>);
 
 // Bad relocatability (less than constraint_level::none)
-static_assert(!pro::facade<pro::details::facade_impl<
+static_assert(!pro::facade<pro::detail::facade_impl<
                   std::tuple<>, std::tuple<>, 8, 4, pro::constraint_level::none,
                   (pro::constraint_level)-1, pro::constraint_level::nothrow>>);
 
 // Bad relocatability (greater than constraint_level::trivial)
-static_assert(!pro::facade<pro::details::facade_impl<
+static_assert(!pro::facade<pro::detail::facade_impl<
                   std::tuple<>, std::tuple<>, 8, 4, pro::constraint_level::none,
                   (pro::constraint_level)100, pro::constraint_level::nothrow>>);
 
 // Bad destructibility (less than constraint_level::none)
-static_assert(!pro::facade<pro::details::facade_impl<
+static_assert(!pro::facade<pro::detail::facade_impl<
                   std::tuple<>, std::tuple<>, 8, 4, pro::constraint_level::none,
                   pro::constraint_level::trivial, (pro::constraint_level)-1>>);
 
 // Bad destructibility (greater than constraint_level::trivial)
-static_assert(!pro::facade<pro::details::facade_impl<
+static_assert(!pro::facade<pro::detail::facade_impl<
                   std::tuple<>, std::tuple<>, 8, 4, pro::constraint_level::none,
                   pro::constraint_level::trivial, (pro::constraint_level)100>>);
 
@@ -501,4 +501,4 @@ static_assert(std::is_move_constructible_v<ProxyWrapperTemplate<void>>);
 // proxiable shall not reject a specialization of proxy.
 static_assert(pro::proxiable<pro::proxy_view<DefaultFacade>, DefaultFacade>);
 
-} // namespace proxy_traits_tests_details
+} // namespace proxy_traits_tests_detail
diff --git a/tests/proxy_view_tests.cpp b/tests/proxy_view_tests.cpp
index df18332..6987599 100644
--- a/tests/proxy_view_tests.cpp
+++ b/tests/proxy_view_tests.cpp
@@ -6,7 +6,7 @@
 #include <gtest/gtest.h>
 #include <proxy/proxy.h>
 
-namespace proxy_view_tests_details {
+namespace proxy_view_tests_detail {
 
 struct TestFacade
     : pro::facade_builder                                              //
@@ -76,28 +76,27 @@ class Point_2 {
   double x_, y_;
 };
 
-} // namespace proxy_view_tests_details
+} // namespace proxy_view_tests_detail
 
-namespace details = proxy_view_tests_details;
+namespace detail = proxy_view_tests_detail;
 
 TEST(ProxyViewTests, TestViewOfNull) {
-  pro::proxy<details::TestFacade> p1;
-  pro::proxy_view<details::TestFacade> p2 = p1;
+  pro::proxy<detail::TestFacade> p1;
+  pro::proxy_view<detail::TestFacade> p2 = p1;
   ASSERT_FALSE(p2.has_value());
 }
 
 TEST(ProxyViewTests, TestViewIndependentUse) {
   int a = 123;
-  pro::proxy_view<details::TestFacade> p = &a;
+  pro::proxy_view<detail::TestFacade> p = &a;
   *p += 3;
   ASSERT_EQ(ToString(*p), "126");
   ASSERT_EQ(a, 126);
 }
 
 TEST(ProxyViewTests, TestViewOfOwning) {
-  pro::proxy<details::TestFacade> p1 =
-      pro::make_proxy<details::TestFacade>(123);
-  pro::proxy_view<details::TestFacade> p2 = p1;
+  pro::proxy<detail::TestFacade> p1 = pro::make_proxy<detail::TestFacade>(123);
+  pro::proxy_view<detail::TestFacade> p2 = p1;
   ASSERT_TRUE(p1.has_value());
   ASSERT_TRUE(p2.has_value());
   *p2 += 3;
@@ -108,8 +107,8 @@ TEST(ProxyViewTests, TestViewOfOwning) {
 
 TEST(ProxyViewTests, TestViewOfNonOwning) {
   int a = 123;
-  pro::proxy<details::TestFacade> p1 = &a;
-  pro::proxy_view<details::TestFacade> p2 = p1;
+  pro::proxy<detail::TestFacade> p1 = &a;
+  pro::proxy_view<detail::TestFacade> p2 = p1;
   ASSERT_TRUE(p1.has_value());
   ASSERT_TRUE(p2.has_value());
   *p2 += 3;
@@ -170,15 +169,15 @@ TEST(ProxyViewTests, TestSubstitution_FromValue) {
 }
 
 TEST(ProxyViewTests, TestFacadeAware) {
-  details::Point_2 v1{1, 1};
-  details::Point_2 v2{1, 0};
-  details::Point_2 v3{1.0000001, 1.0000001};
-  pro::proxy_view<details::EqualableQuantity> p1 =
-      pro::make_proxy_view<details::EqualableQuantity>(v1);
-  pro::proxy_view<details::EqualableQuantity> p2 =
-      pro::make_proxy_view<details::EqualableQuantity>(v2);
-  pro::proxy_view<details::EqualableQuantity> p3 =
-      pro::make_proxy_view<details::EqualableQuantity>(v3);
+  detail::Point_2 v1{1, 1};
+  detail::Point_2 v2{1, 0};
+  detail::Point_2 v3{1.0000001, 1.0000001};
+  pro::proxy_view<detail::EqualableQuantity> p1 =
+      pro::make_proxy_view<detail::EqualableQuantity>(v1);
+  pro::proxy_view<detail::EqualableQuantity> p2 =
+      pro::make_proxy_view<detail::EqualableQuantity>(v2);
+  pro::proxy_view<detail::EqualableQuantity> p3 =
+      pro::make_proxy_view<detail::EqualableQuantity>(v3);
   ASSERT_TRUE(p1->AreEqual(*p1, 1e-6));
   ASSERT_FALSE(p1->AreEqual(*p2, 1e-6));
   ASSERT_TRUE(p1->AreEqual(*p3, 1e-6));

From 603eb261fa0a93643d1ebf88365f227582d22214 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@outlook.com>
Date: Thu, 11 Jun 2026 19:15:01 +0800
Subject: [PATCH 2/2] Move <version> header

---
 include/proxy/v4/detail/core.h   | 1 -
 include/proxy/v4/detail/skills.h | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/proxy/v4/detail/core.h b/include/proxy/v4/detail/core.h
index a1a0f00..7ed3a24 100644
--- a/include/proxy/v4/detail/core.h
+++ b/include/proxy/v4/detail/core.h
@@ -15,7 +15,6 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
-#include <version>
 
 #include "../proxy_macros.h"
 
diff --git a/include/proxy/v4/detail/skills.h b/include/proxy/v4/detail/skills.h
index 8f0f357..67d9a4c 100644
--- a/include/proxy/v4/detail/skills.h
+++ b/include/proxy/v4/detail/skills.h
@@ -6,6 +6,7 @@
 #define MSFT_PROXY_V4_DETAIL_SKILLS_H_
 
 #include <memory>
+#include <version>
 
 #if __STDC_HOSTED__
 // LLVM libc++ 17 has usable <format> despite lacking __cpp_lib_format until 19.