diff --git a/proxy.h b/proxy.h
index 87f00b96..7eac149f 100644
--- a/proxy.h
+++ b/proxy.h
@@ -29,8 +29,10 @@ template <class F> class proxy;
 
 namespace details {
 
-struct applicable_traits { static constexpr bool applicable = true; };
-struct inapplicable_traits { static constexpr bool applicable = false; };
+template <bool A>
+struct conditional_traits { static constexpr bool applicable = A; };
+using applicable_traits = conditional_traits<true>;
+using inapplicable_traits = conditional_traits<false>;
 
 template <template <class, class> class R, class O, class... Is>
 struct recursive_reduction : std::type_identity<O> {};
@@ -38,10 +40,9 @@ 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> class R, class O, class I, class... Is>
 struct recursive_reduction<R, O, I, Is...>
-    { using type = recursive_reduction_t<R, typename R<O, I>::type, Is...>; };
+    { using type = recursive_reduction_t<R, R<O, I>, Is...>; };
 
-template <template <class> class T, class... Is>
-struct first_applicable {};
+template <template <class> class T, class... Is> struct first_applicable {};
 template <template <class> class T, class I, class... Is>
     requires(T<I>::applicable)
 struct first_applicable<T, I, Is...> : std::type_identity<I> {};
@@ -133,64 +134,45 @@ struct ptr_traits<T*> : applicable_traits {
   using target_type = T;
 };
 
-template <class F, class T, bool NE, class R, class... Args>
-consteval bool is_invoker_well_formed() {
-  if constexpr (std::is_trivially_default_constructible_v<F>) {
-    if constexpr (std::is_void_v<T>) {
-      if constexpr (NE) {
-        return std::is_nothrow_invocable_r_v<R, F, Args...>;
-      } else {
-        return std::is_invocable_r_v<R, F, Args...>;
-      }
-    } else {
-      if constexpr (NE) {
-        return std::is_nothrow_invocable_r_v<R, F, T&, Args...>;
-      } else {
-        return std::is_invocable_r_v<R, F, T&, Args...>;
-      }
-    }
-  }
-  return false;
-}
-template <class D, class T, bool NE, class R, class... Args>
-concept invocable_dispatch = requires { typename D::template invoker<T>; } &&
-    is_invoker_well_formed<
-        typename D::template invoker<T>, T, NE, R, Args...>();
+template <class D, bool NE, class R, class... Args>
+constexpr bool invocable_dispatch = std::conditional_t<
+    NE, std::is_nothrow_invocable_r<R, D, Args...>,
+    std::is_invocable_r<R, D, Args...>>::value;
 template <class D, class P, bool NE, class R, class... Args>
 concept invocable_dispatch_ptr = invocable_dispatch<
-    D, typename ptr_traits<P>::target_type, NE, R, Args...> ||
-    invocable_dispatch<D, const P, NE, R, Args...> ||
-    invocable_dispatch<D, void, NE, R, Args...>;
+    D, NE, R, typename ptr_traits<P>::target_type&, Args...> ||
+    invocable_dispatch<D, NE, R, const P&, Args...> ||
+    invocable_dispatch<D, NE, R, std::nullptr_t, Args...>;
 
 template <bool NE, class R, class... Args>
 using func_ptr_t = std::conditional_t<
     NE, R (*)(Args...) noexcept, R (*)(Args...)>;
 
-template <class F, class R, class... Args>
+template <class D, class R, class... Args>
 R invoke_dispatch(Args&&... args) {
   if constexpr (std::is_void_v<R>) {
-    F{}(std::forward<Args>(args)...);
+    D{}(std::forward<Args>(args)...);
   } else {
-    return F{}(std::forward<Args>(args)...);
+    return D{}(std::forward<Args>(args)...);
   }
 }
-template <class P, class F, class R, class... Args>
+template <class P, class D, class R, class... Args>
 R invocation_dispatcher_ref(const std::byte* self, Args... args)
-    noexcept(is_invoker_well_formed<
-        F, typename ptr_traits<P>::target_type, true, R, Args...>()) {
-  return invoke_dispatch<F, R>(ptr_traits<P>::dereference(*std::launder(
+    noexcept(invocable_dispatch<
+        D, true, R, typename ptr_traits<P>::target_type&, Args...>) {
+  return invoke_dispatch<D, R>(ptr_traits<P>::dereference(*std::launder(
       reinterpret_cast<const P*>(self))), std::forward<Args>(args)...);
 }
-template <class P, class F, class R, class... Args>
+template <class P, class D, class R, class... Args>
 R invocation_dispatcher_ptr(const std::byte* self, Args... args)
-    noexcept(is_invoker_well_formed<F, const P, true, R, Args...>()) {
-  return invoke_dispatch<F, R>(*std::launder(reinterpret_cast<const P*>(self)),
+    noexcept(invocable_dispatch<D, true, R, const P&, Args...>) {
+  return invoke_dispatch<D, R>(*std::launder(reinterpret_cast<const P*>(self)),
       std::forward<Args>(args)...);
 }
-template <class F, class R, class... Args>
-R invocation_dispatcher_void(const std::byte*, Args... args)
-    noexcept(is_invoker_well_formed<F, void, true, R, Args...>())
-    { return invoke_dispatch<F, R>(std::forward<Args>(args)...); }
+template <class D, class R, class... Args>
+R invocation_dispatcher_default(const std::byte*, Args... args)
+    noexcept(invocable_dispatch<D, true, R, std::nullptr_t, Args...>)
+    { return invoke_dispatch<D, R>(nullptr, std::forward<Args>(args)...); }
 template <class P>
 void copying_dispatcher(std::byte* self, const std::byte* rhs)
     noexcept(has_copyability<P>(constraint_level::nothrow)) {
@@ -223,15 +205,12 @@ struct overload_traits_impl : applicable_traits {
     template <class P>
     static constexpr func_ptr_t<NE, R, const std::byte*, Args...> get() {
       if constexpr (invocable_dispatch<
-          D, typename ptr_traits<P>::target_type, NE, R, Args...>) {
-        return &invocation_dispatcher_ref<P, typename D::template invoker<
-            typename ptr_traits<P>::target_type>, R, Args...>;
-      } else if constexpr (invocable_dispatch<D, const P, NE, R, Args...>) {
-        return &invocation_dispatcher_ptr<
-            P, typename D::template invoker<const P>, R, Args...>;
+          D, NE, R, typename ptr_traits<P>::target_type&, Args...>) {
+        return &invocation_dispatcher_ref<P, D, R, Args...>;
+      } else if constexpr (invocable_dispatch<D, NE, R, const P&, Args...>) {
+        return &invocation_dispatcher_ptr<P, D, R, Args...>;
       } else {
-        return &invocation_dispatcher_void<
-            typename D::template invoker<void>, R, Args...>;
+        return &invocation_dispatcher_default<D, R, Args...>;
       }
     }
   };
@@ -248,15 +227,12 @@ template <class R, class... Args>
 struct overload_traits<R(Args...) noexcept>
     : overload_traits_impl<true, R, Args...> {};
 
-template <class T> struct nullable_traits : inapplicable_traits {};
 template <class T>
-    requires(
-        requires(const T& cv, T& v) {
-          { T{} } noexcept;
-          { cv.has_value() } noexcept -> std::same_as<bool>;
-          { v.reset() } noexcept;
-        })
-struct nullable_traits<T> : applicable_traits {};
+struct nullable_traits : conditional_traits<requires(const T& cv, T& v) {
+      { T{} } noexcept;
+      { cv.has_value() } noexcept -> std::same_as<bool>;
+      { v.reset() } noexcept;
+    }> {};
 
 template <class MP>
 struct dispatcher_meta {
@@ -271,13 +247,13 @@ struct dispatcher_meta {
 };
 
 template <class... Ms>
-struct composite_meta : Ms... {
+struct composite_meta_impl : Ms... {
   static constexpr bool is_nullable =
       requires { typename first_applicable_t<nullable_traits, Ms...>; };
 
-  constexpr composite_meta() noexcept requires(is_nullable) = default;
+  constexpr composite_meta_impl() noexcept requires(is_nullable) = default;
   template <class P>
-  constexpr explicit composite_meta(std::in_place_type_t<P>) noexcept
+  constexpr explicit composite_meta_impl(std::in_place_type_t<P>) noexcept
       : Ms(std::in_place_type<P>)... {}
 
   bool has_value() const noexcept requires(is_nullable)
@@ -285,33 +261,51 @@ struct composite_meta : Ms... {
   void reset() noexcept requires(is_nullable)
       { first_applicable_t<nullable_traits, Ms...>::reset(); }
 };
+template <class O, class I> struct meta_reduction : std::type_identity<O> {};
+template <class... Ms, class I> requires(!std::is_void_v<I>)
+struct meta_reduction<composite_meta_impl<Ms...>, I>
+    : std::type_identity<composite_meta_impl<Ms..., I>> {};
+template <class... Ms0, class... Ms1>
+struct meta_reduction<composite_meta_impl<Ms0...>, composite_meta_impl<Ms1...>>
+    : std::type_identity<composite_meta_impl<Ms0..., Ms1...>> {};
+template <class O, class I>
+using meta_reduction_t = typename meta_reduction<O, I>::type;
+template <class... Ms>
+using composite_meta =
+    recursive_reduction_t<meta_reduction_t, composite_meta_impl<>, Ms...>;
 
-template <class D, class... Os>
-struct dispatch_traits_impl : inapplicable_traits {};
-template <class D, class... Os>
+template <class C, class... Os>
+struct conv_traits_impl : inapplicable_traits {};
+template <class C, class... Os>
     requires(sizeof...(Os) > 0u && (overload_traits<Os>::applicable && ...))
-struct dispatch_traits_impl<D, Os...> : applicable_traits {
+struct conv_traits_impl<C, Os...> : applicable_traits {
  private:
   struct overload_resolver : overload_traits<Os>::resolver...
       { using overload_traits<Os>::resolver::operator()...; };
 
  public:
+  using dispatch_type = typename C::dispatch_type;
   using meta = composite_meta<dispatcher_meta<
-      typename overload_traits<Os>::template meta_provider<D>>...>;
+      typename overload_traits<Os>::template meta_provider<dispatch_type>>...>;
   template <class... Args>
   using matched_overload =
       std::remove_pointer_t<std::invoke_result_t<overload_resolver, Args...>>;
 
   template <class P>
   static constexpr bool applicable_ptr =
-      (overload_traits<Os>::template applicable_ptr<D, P> && ...);
+      (overload_traits<Os>::template applicable_ptr<dispatch_type, P> && ...);
 };
-template <class D> struct dispatch_traits : inapplicable_traits {};
-template <class D>
-    requires(requires { typename D::overload_types; } &&
-        is_tuple_like_well_formed<typename D::overload_types>())
-struct dispatch_traits<D> : instantiated_t<
-    dispatch_traits_impl, typename D::overload_types, D> {};
+template <class C> struct conv_traits : inapplicable_traits {};
+template <class C>
+    requires(
+        requires {
+          typename C::dispatch_type;
+          typename C::overload_types;
+        } &&
+        std::is_nothrow_default_constructible_v<typename C::dispatch_type> &&
+        is_tuple_like_well_formed<typename C::overload_types>())
+struct conv_traits<C> : instantiated_t<
+    conv_traits_impl, typename C::overload_types, C> {};
 
 template <bool NE>
 struct copyability_meta_provider {
@@ -357,23 +351,28 @@ struct lifetime_meta_traits<MP, constraint_level::nontrivial>
 template <template <bool> class MP, constraint_level C>
 using lifetime_meta_t = typename lifetime_meta_traits<MP, C>::type;
 
-template <class O, class I>
-struct facade_meta_reduction : std::type_identity<O> {};
-template <class... Ms, class I> requires(!std::is_void_v<I>)
-struct facade_meta_reduction<composite_meta<Ms...>, I>
-    : std::type_identity<composite_meta<Ms..., I>> {};
-
-template <class... As> struct composite_accessor : As... {};
+template <class... As> struct composite_accessor_impl : As... {};
+template <class T, class O, class I>
+struct accessor_reduction : std::type_identity<O> {};
+template <class T, class... As, class I>
+    requires(requires { typename I::template accessor<T>; } &&
+        std::is_nothrow_default_constructible_v<
+            typename I::template accessor<T>>)
+struct accessor_reduction<T, composite_accessor_impl<As...>, I>
+    : std::type_identity<composite_accessor_impl<
+          As..., typename I::template accessor<T>>> {};
+template <class T, class... As0, class... As1>
+struct accessor_reduction<
+    T, composite_accessor_impl<As0...>, composite_accessor_impl<As1...>>
+    : std::type_identity<composite_accessor_impl<As0..., As1...>> {};
 template <class T>
 struct accessor_helper {
-  template <class D> using accessor = typename D::template accessor<T>;
-  template <class O, class I> struct reduction : std::type_identity<O> {};
-  template <class... As, class I>
-      requires(requires { typename accessor<I>; } &&
-          std::is_nothrow_default_constructible_v<accessor<I>>)
-  struct reduction<composite_accessor<As...>, I>
-      : std::type_identity<composite_accessor<As..., accessor<I>>> {};
+  template <class O, class I>
+  using reduction_t = typename accessor_reduction<T, O, I>::type;
 };
+template <class F, class... As>
+using composite_accessor = recursive_reduction_t<accessor_helper<proxy<F>>
+    ::template reduction_t, composite_accessor_impl<>, As...>;
 
 template <class F>
 consteval bool is_facade_constraints_well_formed() {
@@ -392,30 +391,66 @@ consteval bool is_reflection_type_well_formed() {
   }
   return false;
 }
-template <class... Ds>
-struct default_dispatch_traits { using default_dispatch = void; };
 template <class D>
-struct default_dispatch_traits<D> { using default_dispatch = D; };
-template <class F, class... Ds>
-struct facade_traits_impl : inapplicable_traits {};
-template <class F, class... Ds> requires(dispatch_traits<Ds>::applicable && ...)
-struct facade_traits_impl<F, Ds...>
-    : applicable_traits, default_dispatch_traits<Ds...> {
+struct dispatch_match_helper {
+  template <class C>
+  using traits =
+      conditional_traits<std::is_same_v<typename C::dispatch_type, D>>;
+};
+template <class F, class... Cs>
+struct facade_conv_traits_impl : inapplicable_traits {};
+template <class F, class... Cs> requires(conv_traits<Cs>::applicable && ...)
+struct facade_conv_traits_impl<F, Cs...> : applicable_traits {
+  using conv_meta = composite_meta<typename conv_traits<Cs>::meta...>;
+  using conv_accessor = composite_accessor<
+      F, typename conv_traits<Cs>::dispatch_type...>;
+  template <class D, class... Args>
+  using matched_overload = typename conv_traits<
+      first_applicable_t<dispatch_match_helper<D>::template traits, Cs...>>
+      ::template matched_overload<Args...>;
+
+  template <class P>
+  static constexpr bool conv_applicable_ptr =
+      (conv_traits<Cs>::template applicable_ptr<P> && ...);
+};
+template <class F, class... Rs>
+struct facade_refl_traits_impl {
+  using refl_meta = composite_meta<Rs...>;
+  using refl_accessor = composite_accessor<F, Rs...>;
+
+  template <class R>
+  static constexpr bool has_refl = (std::is_same_v<R, Rs> || ...);
+  template <class P>
+  static constexpr bool refl_applicable_ptr =
+      (is_reflection_type_well_formed<Rs, P>() && ...);
+};
+template <class F> struct facade_traits : inapplicable_traits {};
+template <class F>
+    requires(
+        requires {
+          typename F::convention_types;
+          typename F::reflection_types;
+          { F::constraints } -> std::same_as<const proxiable_ptr_constraints&>;
+        } && is_tuple_like_well_formed<typename F::convention_types>() &&
+        is_tuple_like_well_formed<typename F::reflection_types>() &&
+        is_facade_constraints_well_formed<F>() &&
+        instantiated_t<facade_conv_traits_impl,
+            typename F::convention_types, F>::applicable)
+struct facade_traits<F>
+    : instantiated_t<facade_conv_traits_impl, typename F::convention_types, F>,
+      instantiated_t<facade_refl_traits_impl, typename F::reflection_types, F> {
   using copyability_meta = lifetime_meta_t<
       copyability_meta_provider, F::constraints.copyability>;
   using relocatability_meta = lifetime_meta_t<
       relocatability_meta_provider, F::constraints.relocatability>;
   using destructibility_meta = lifetime_meta_t<
       destructibility_meta_provider, F::constraints.destructibility>;
-  using meta = recursive_reduction_t<facade_meta_reduction,
-      composite_meta<>, copyability_meta, relocatability_meta,
-      destructibility_meta, typename dispatch_traits<Ds>::meta...,
-      typename F::reflection_type>;
-  using base = recursive_reduction_t<accessor_helper<proxy<F>>
-      ::template reduction, composite_accessor<>, Ds...>;
+  using meta = composite_meta<copyability_meta, relocatability_meta,
+      destructibility_meta, typename facade_traits::conv_meta,
+      typename facade_traits::refl_meta>;
+  using base = composite_accessor<F, typename facade_traits::conv_accessor,
+      typename facade_traits::refl_accessor>;
 
-  template <class D>
-  static constexpr bool has_dispatch = (std::is_same_v<D, Ds> || ...);
   template <class P>
   static constexpr bool applicable_ptr =
       sizeof(P) <= F::constraints.max_size &&
@@ -423,20 +458,9 @@ struct facade_traits_impl<F, Ds...>
       has_copyability<P>(F::constraints.copyability) &&
       has_relocatability<P>(F::constraints.relocatability) &&
       has_destructibility<P>(F::constraints.destructibility) &&
-      (dispatch_traits<Ds>::template applicable_ptr<P> && ...) &&
-      is_reflection_type_well_formed<typename F::reflection_type, P>();
+      facade_traits::template conv_applicable_ptr<P> &&
+      facade_traits::template refl_applicable_ptr<P>;
 };
-template <class F> struct facade_traits : inapplicable_traits {};
-template <class F>
-    requires(
-        requires {
-          typename F::dispatch_types;
-          { F::constraints } -> std::same_as<const proxiable_ptr_constraints&>;
-          typename F::reflection_type;
-        } && is_tuple_like_well_formed<typename F::dispatch_types>() &&
-        is_facade_constraints_well_formed<F>())
-struct facade_traits<F> : instantiated_t<
-    facade_traits_impl, typename F::dispatch_types, F> {};
 
 using ptr_prototype = void*[2];
 
@@ -475,10 +499,9 @@ template <class F>
 class proxy : public details::facade_traits<F>::base {
   using Traits = details::facade_traits<F>;
   static_assert(Traits::applicable);
-  using DefaultDispatch = typename Traits::default_dispatch;
   template <class D, class... Args>
   using MatchedOverload =
-      typename details::dispatch_traits<D>::template matched_overload<Args...>;
+      typename Traits::template matched_overload<D, Args...>;
 
   template <class P, class... Args>
   static constexpr bool HasNothrowPolyConstructor = std::conditional_t<
@@ -623,10 +646,6 @@ class proxy : public details::facade_traits<F>::base {
   ~proxy() requires(!HasDestructor) = delete;
 
   bool has_value() const noexcept { return meta_.has_value(); }
-  decltype(auto) reflect() const noexcept
-      requires(!std::is_void_v<typename F::reflection_type>) {
-    return *static_cast<const typename F::reflection_type*>(meta_.operator->());
-  }
   void reset() noexcept(HasNothrowDestructor) requires(HasDestructor)
       { std::destroy_at(this); meta_.reset(); }
   void swap(proxy& rhs) noexcept(HasNothrowMoveConstructor)
@@ -663,20 +682,17 @@ class proxy : public details::facade_traits<F>::base {
     reset();
     return initialize<P>(il, std::forward<Args>(args)...);
   }
-  template <class D = DefaultDispatch, class... Args>
+  template <class D, class... Args>
   decltype(auto) invoke(Args&&... args) const
       noexcept(HasNothrowInvocation<D, Args...>)
-      requires(Traits::template has_dispatch<D> &&
-          requires { typename MatchedOverload<D, Args...>; }) {
+      requires(requires { typename MatchedOverload<D, Args...>; }) {
     return meta_->template dispatcher_meta<typename details::overload_traits<
         MatchedOverload<D, Args...>>::template meta_provider<D>>
         ::dispatcher(ptr_, std::forward<Args>(args)...);
   }
-  template <class... Args>
-  decltype(auto) operator()(Args&&... args) const
-      noexcept(HasNothrowInvocation<DefaultDispatch, Args...>)
-      requires(requires { typename MatchedOverload<DefaultDispatch, Args...>; })
-      { return invoke(std::forward<Args>(args)...); }
+  template <class R>
+  const R& reflect() const noexcept requires(Traits::template has_refl<R>)
+      { return *static_cast<const R*>(meta_.operator->()); }
 
  private:
   template <class P, class... Args>
@@ -690,28 +706,6 @@ class proxy : public details::facade_traits<F>::base {
   alignas(F::constraints.max_align) std::byte ptr_[F::constraints.max_size];
 };
 
-constexpr proxiable_ptr_constraints relocatable_ptr_constraints{
-  .max_size = sizeof(details::ptr_prototype),
-  .max_align = alignof(details::ptr_prototype),
-  .copyability = constraint_level::none,
-  .relocatability = constraint_level::nothrow,
-  .destructibility = constraint_level::nothrow,
-};
-constexpr proxiable_ptr_constraints copyable_ptr_constraints{
-  .max_size = sizeof(details::ptr_prototype),
-  .max_align = alignof(details::ptr_prototype),
-  .copyability = constraint_level::nontrivial,
-  .relocatability = constraint_level::nothrow,
-  .destructibility = constraint_level::nothrow,
-};
-constexpr proxiable_ptr_constraints trivial_ptr_constraints{
-  .max_size = sizeof(void*),
-  .max_align = alignof(void*),
-  .copyability = constraint_level::trivial,
-  .relocatability = constraint_level::trivial,
-  .destructibility = constraint_level::trivial,
-};
-
 namespace details {
 
 template <class T>
@@ -861,7 +855,8 @@ template <facade F, class T, class Alloc, class... Args>
 proxy<F> allocate_proxy(const Alloc& alloc, Args&&... args) {
   return details::allocate_proxy_impl<F, T>(alloc, std::forward<Args>(args)...);
 }
-template <facade F, class T, class Alloc, class U, class... Args>
+template <facade F, class T, class Alloc, class U,
+    class... Args>
 proxy<F> allocate_proxy(const Alloc& alloc, std::initializer_list<U> il,
     Args&&... args) {
   return details::allocate_proxy_impl<F, T>(
@@ -884,83 +879,216 @@ proxy<F> make_proxy(T&& value) {
 }
 #endif  // __STDC_HOSTED__
 
-// The following types and macros aim to simplify definition of dispatch and
-// facade types prior to C++26
+// The following types and macros aim to simplify definition of dispatch,
+// convention, and facade types prior to C++26
 namespace details {
 
 template <class... Args> void invalid_call(Args&&...) = delete;
-template <class T, class...> struct dependent : std::type_identity<T> {};
-template <class T, class... U>
-using dependent_t = typename dependent<T, U...>::type;
+template <class T, class...> struct lazy_eval_traits : std::type_identity<T> {};
 
-template <class O, class I> struct flat_reduction : std::type_identity<O> {};
-template <class O, class... Is>
-struct flat_reduction_impl : recursive_reduction<flat_reduction, O, Is...> {};
-template <class... Os, class I>
-    requires(!is_tuple_like_well_formed<I>() && (!std::is_same_v<I, Os> && ...))
-struct flat_reduction<std::tuple<Os...>, I>
-    : std::type_identity<std::tuple<Os..., I>> {};
-template <class O, class I> requires(is_tuple_like_well_formed<I>())
-struct flat_reduction<O, I> : instantiated_t<flat_reduction_impl, I, O> {};
+constexpr std::size_t invalid_size = static_cast<std::size_t>(-1);
+constexpr constraint_level invalid_cl = static_cast<constraint_level>(-1);
+consteval auto normalize(proxiable_ptr_constraints value) {
+  if (value.max_size == invalid_size) {
+    value.max_size = sizeof(ptr_prototype);
+  }
+  if (value.max_align == invalid_size) {
+    value.max_align = alignof(ptr_prototype);
+  }
+  if (value.copyability == invalid_cl) {
+    value.copyability = constraint_level::none;
+  }
+  if (value.relocatability == invalid_cl) {
+    value.relocatability = constraint_level::nothrow;
+  }
+  if (value.destructibility == invalid_cl) {
+    value.destructibility = constraint_level::nothrow;
+  }
+  return value;
+}
+consteval auto make_restricted_layout(proxiable_ptr_constraints value,
+    std::size_t max_size, std::size_t max_align) {
+  if (value.max_size == invalid_size || value.max_size > max_size) {
+    value.max_size = max_size;
+  }
+  if (value.max_align == invalid_size || value.max_align > max_align) {
+    value.max_align = max_align;
+  }
+  return value;
+}
+consteval auto make_copyable(proxiable_ptr_constraints value,
+    constraint_level cl) {
+  if (value.copyability == invalid_cl || value.copyability < cl) {
+    value.copyability = cl;
+  }
+  return value;
+}
+consteval auto make_relocatable(proxiable_ptr_constraints value,
+    constraint_level cl) {
+  if (value.relocatability == invalid_cl || value.relocatability < cl) {
+    value.relocatability = cl;
+  }
+  return value;
+}
+consteval auto make_destructible(proxiable_ptr_constraints value,
+    constraint_level cl) {
+  if (value.destructibility == invalid_cl || value.destructibility < cl) {
+    value.destructibility = cl;
+  }
+  return value;
+}
+consteval auto merge_constraints(proxiable_ptr_constraints a,
+    proxiable_ptr_constraints b) {
+  a = make_restricted_layout(a, b.max_size, b.max_align);
+  a = make_copyable(a, b.copyability);
+  a = make_relocatable(a, b.relocatability);
+  a = make_destructible(a, b.destructibility);
+  return a;
+}
 
-template <class Ds = std::tuple<>, proxiable_ptr_constraints C =
-    relocatable_ptr_constraints, class R = void>
-struct facade_prototype {
-  using dispatch_types = typename flat_reduction<std::tuple<>, Ds>::type;
+template <class D, class Os>
+struct conv_impl {
+  using dispatch_type = D;
+  using overload_types = Os;
+};
+template <class Cs, class Rs, proxiable_ptr_constraints C>
+struct facade_impl {
+  using convention_types = Cs;
+  using reflection_types = Rs;
   static constexpr proxiable_ptr_constraints constraints = C;
-  using reflection_type = R;
+};
+
+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 T, class U>
+using add_tuple_t = typename add_tuple_reduction<T, U>::type;
+template <class O, class... Is>
+using merge_tuple_impl_t = recursive_reduction_t<add_tuple_t, O, Is...>;
+template <class T, class U>
+using merge_tuple_t = instantiated_t<merge_tuple_impl_t, U, T>;
+
+template <class C0, class C1>
+using merge_conv_t = conv_impl<typename C0::dispatch_type, merge_tuple_t<
+    typename C0::overload_types, typename C1::overload_types>>;
+
+template <class Cs0, class C1, class C> struct add_conv_reduction;
+template <class... Cs0, class C1, class... Cs2, class C>
+struct add_conv_reduction<std::tuple<Cs0...>, std::tuple<C1, Cs2...>, C>
+    : add_conv_reduction<std::tuple<Cs0..., C1>, std::tuple<Cs2...>, C> {};
+template <class... Cs0, class C1, class... Cs2, class C>
+    requires(std::is_same_v<
+        typename C::dispatch_type, typename C1::dispatch_type>)
+struct add_conv_reduction<std::tuple<Cs0...>, std::tuple<C1, Cs2...>, C>
+    : std::type_identity<std::tuple<Cs0..., merge_conv_t<C1, C>, Cs2...>> {};
+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<typename C::dispatch_type, std::tuple<>>, C>>> {};
+template <class Cs, class C>
+using add_conv_t = typename add_conv_reduction<std::tuple<>, Cs, C>::type;
+
+template <class Cs0, class... Cs1>
+using merge_conv_tuple_impl_t = recursive_reduction_t<add_conv_t, Cs0, Cs1...>;
+template <class Cs0, class Cs1>
+using merge_conv_tuple_t = instantiated_t<merge_conv_tuple_impl_t, Cs1, Cs0>;
+
+template <class Cs, class Rs, proxiable_ptr_constraints C>
+struct facade_builder_impl {
+  template <class D, class... Os>
+      requires(std::is_nothrow_default_constructible_v<D> &&
+          (overload_traits<Os>::applicable && ...))
+  using add_convention = facade_builder_impl<add_conv_t<
+      Cs, conv_impl<D, std::tuple<Os...>>>, Rs, C>;
+  template <class R>
+  using add_reflection = facade_builder_impl<Cs, add_tuple_t<Rs, R>, C>;
+  template <facade F>
+  using add_facade = facade_builder_impl<
+      merge_conv_tuple_t<Cs, typename F::convention_types>,
+      merge_tuple_t<Rs, typename F::reflection_types>,
+      merge_constraints(C, F::constraints)>;
+  template <std::size_t PtrSize, std::size_t PtrAlign =
+      std::min(PtrSize, alignof(std::max_align_t))>
+      requires(std::has_single_bit(PtrAlign) && PtrSize % PtrAlign == 0u)
+  using restrict_layout = facade_builder_impl<
+      Cs, Rs, make_restricted_layout(C, PtrSize, PtrAlign)>;
+  template <constraint_level CL>
+  using support_copy = facade_builder_impl<Cs, Rs, make_copyable(C, CL)>;
+  template <constraint_level CL>
+  using support_relocation = facade_builder_impl<
+      Cs, Rs, make_relocatable(C, CL)>;
+  template <constraint_level CL>
+  using support_destruction = facade_builder_impl<
+      Cs, Rs, make_destructible(C, CL)>;
+  using build = facade_impl<Cs, Rs, normalize(C)>;
 };
 
 }  // namespace details
 
+template <class U, class... T>
+using lazy_eval_t = typename details::lazy_eval_traits<U, T...>::type;
+template <class... T>
+auto lazy_eval(auto& value) noexcept -> lazy_eval_t<decltype(value), T...>
+    { return value; }
+
+using facade_builder = details::facade_builder_impl<std::tuple<>, std::tuple<>,
+    proxiable_ptr_constraints{
+        .max_size = details::invalid_size,
+        .max_align = details::invalid_size,
+        .copyability = details::invalid_cl,
+        .relocatability = details::invalid_cl,
+        .destructibility = details::invalid_cl}>;
+
 }  // namespace pro
 
 #define ___PRO_DIRECT_FUNC_IMPL(__EXPR) \
     noexcept(noexcept(__EXPR)) requires(requires { __EXPR; }) { return __EXPR; }
-#define ___PRO_DEF_DISPATCH_IMPL(__NAME, __EXPR, __DEFEXPR, ...) \
+#define PRO_DEF_MEM_DISPATCH_WITH_DEFAULT(__NAME, __FUNC, __DEFFUNC) \
     struct __NAME { \
-     private: \
-      using __Name = __NAME; \
-      struct __FT { \
-        template <class __T, class... __Args> \
-        decltype(auto) operator()(__T& __self, __Args&&... __args) \
-            ___PRO_DIRECT_FUNC_IMPL(__EXPR) \
-      }; \
-      struct __FV { \
+      using __name = __NAME; \
+      template <class __T, class... __Args> \
+      decltype(auto) operator()(__T& __self, __Args&&... __args) \
+          ___PRO_DIRECT_FUNC_IMPL( \
+              __self.__FUNC(::std::forward<__Args>(__args)...)) \
+      template <class... __Args> \
+      decltype(auto) operator()(std::nullptr_t, __Args&&... __args) \
+          ___PRO_DIRECT_FUNC_IMPL( \
+              __DEFFUNC(::std::forward<__Args>(__args)...)) \
+      template <class __P> \
+      struct accessor { \
         template <class... __Args> \
-        decltype(auto) operator()(__Args&&... __args) \
-            ___PRO_DIRECT_FUNC_IMPL(__DEFEXPR) \
+        decltype(auto) __FUNC(__Args&&... __args) const \
+            ___PRO_DIRECT_FUNC_IMPL((static_cast< \
+                ::pro::lazy_eval_t<const __P&, __Args...>>(*this) \
+                .template invoke<__name>(::std::forward<__Args>(__args)...))) \
       }; \
-    \
-     public: \
-      using overload_types = ::std::tuple<__VA_ARGS__>; \
-      template <class __T> \
-      using invoker = ::std::conditional_t<::std::is_void_v<__T>, __FV, __FT>; \
+    }
+#define PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(__NAME, __FNAME, __FUNC, __DEFFUNC) \
+    struct __NAME { \
+      using __name = __NAME; \
+      template <class __T, class... __Args> \
+      decltype(auto) operator()(__T& __self, __Args&&... __args) \
+          ___PRO_DIRECT_FUNC_IMPL( \
+              __FUNC(__self, ::std::forward<__Args>(__args)...)) \
+      template <class... __Args> \
+      decltype(auto) operator()(std::nullptr_t, __Args&&... __args) \
+          ___PRO_DIRECT_FUNC_IMPL( \
+              __DEFFUNC(::std::forward<__Args>(__args)...)) \
       template <class __P> \
       struct accessor { \
         template <class... __Args> \
-        decltype(auto) __NAME(__Args&&... __args) const \
-            ___PRO_DIRECT_FUNC_IMPL((static_cast<::pro::details::dependent_t< \
-                const __P*, __Args...>>(this)->template invoke<__Name>( \
-                ::std::forward<__Args>(__args)...))) \
+        friend decltype(auto) __FNAME(const __P& __self, __Args&&... __args) \
+            ___PRO_DIRECT_FUNC_IMPL((::pro::lazy_eval<__Args...>(__self) \
+                .template invoke<__name>(::std::forward<__Args>(__args)...))) \
       }; \
     }
-#define PRO_DEF_MEMBER_DISPATCH_WITH_DEFAULT(__NAME, __FUNC, __DEFFUNC, ...) \
-    ___PRO_DEF_DISPATCH_IMPL(__NAME, \
-        __self.__FUNC(::std::forward<__Args>(__args)...), \
-        __DEFFUNC(::std::forward<__Args>(__args)...), __VA_ARGS__)
-#define PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(__NAME, __FUNC, __DEFFUNC, ...) \
-    ___PRO_DEF_DISPATCH_IMPL(__NAME, \
-        __FUNC(__self, ::std::forward<__Args>(__args)...), \
-        __DEFFUNC(::std::forward<__Args>(__args)...), __VA_ARGS__)
-#define PRO_DEF_MEMBER_DISPATCH(__NAME, ...) \
-    PRO_DEF_MEMBER_DISPATCH_WITH_DEFAULT( \
-        __NAME, __NAME, ::pro::details::invalid_call, __VA_ARGS__)
-#define PRO_DEF_FREE_DISPATCH(__NAME, __FUNC, ...) \
+#define PRO_DEF_MEM_DISPATCH(__NAME, __FUNC) \
+    PRO_DEF_MEM_DISPATCH_WITH_DEFAULT( \
+        __NAME, __FUNC, ::pro::details::invalid_call)
+#define PRO_DEF_FREE_DISPATCH(__NAME, __FNAME, __FUNC) \
     PRO_DEF_FREE_DISPATCH_WITH_DEFAULT( \
-        __NAME, __FUNC, ::pro::details::invalid_call, __VA_ARGS__)
-#define PRO_MAKE_DISPATCH_PACK(...) ::std::tuple<__VA_ARGS__>
-#define PRO_DEF_FACADE(__NAME, ...) \
-    struct __NAME : ::pro::details::facade_prototype<__VA_ARGS__> {}
+        __NAME, __FNAME, __FUNC, ::pro::details::invalid_call)
 
 #endif  // _MSFT_PROXY_
diff --git a/samples/resource_dictionary/main.cpp b/samples/resource_dictionary/main.cpp
index 8f94e383..c77a4be0 100644
--- a/samples/resource_dictionary/main.cpp
+++ b/samples/resource_dictionary/main.cpp
@@ -7,8 +7,10 @@
 
 namespace spec {
 
-PRO_DEF_MEMBER_DISPATCH(at, std::string(int));
-PRO_DEF_FACADE(Dictionary, at);
+PRO_DEF_MEM_DISPATCH(MemAt, at);
+struct Dictionary : pro::facade_builder
+    ::add_convention<MemAt, std::string(int)>
+    ::build {};
 
 }  // namespace spec
 
diff --git a/tests/freestanding/proxy_freestanding_tests.cpp b/tests/freestanding/proxy_freestanding_tests.cpp
index 59d61460..c315979f 100644
--- a/tests/freestanding/proxy_freestanding_tests.cpp
+++ b/tests/freestanding/proxy_freestanding_tests.cpp
@@ -17,8 +17,10 @@ unsigned GetDefaultHash() { return -1; }
 
 namespace spec {
 
-PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(GetHash, ::GetHash, ::GetDefaultHash, unsigned());
-PRO_DEF_FACADE(Hashable, GetHash);
+PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(FreeGetHash, GetHash, ::GetHash, ::GetDefaultHash);
+struct Hashable : pro::facade_builder
+    ::add_convention<FreeGetHash, unsigned()>
+    ::build {};
 
 }  // namespace spec
 
@@ -29,19 +31,19 @@ extern "C" int main() {
   std::tuple<int, double> t{11, 22};
   pro::proxy<spec::Hashable> p;
   p = &i;
-  if (p.GetHash() != GetHash(i)) {
+  if (GetHash(p) != GetHash(i)) {
     return 1;
   }
   p = &d;
-  if (p.GetHash() != GetHash(d)) {
+  if (GetHash(p) != GetHash(d)) {
     return 1;
   }
   p = pro::make_proxy_inplace<spec::Hashable>(s);
-  if (p.GetHash() != GetHash(s)) {
+  if (GetHash(p) != GetHash(s)) {
     return 1;
   }
   p = &t;
-  if (p.GetHash() != GetDefaultHash()) {
+  if (GetHash(p) != GetDefaultHash()) {
     return 1;
   }
   return 0;
diff --git a/tests/proxy_creation_tests.cpp b/tests/proxy_creation_tests.cpp
index d1cf08c1..b11e7694 100644
--- a/tests/proxy_creation_tests.cpp
+++ b/tests/proxy_creation_tests.cpp
@@ -26,19 +26,23 @@ struct SboObserver {
 
 namespace spec {
 
-PRO_DEF_FACADE(TestSmallStringable, utils::spec::ToString, pro::proxiable_ptr_constraints{
-    .max_size = sizeof(void*),
-    .max_align = alignof(void*),
-    .copyability = pro::constraint_level::nontrivial,
-    .relocatability = pro::constraint_level::nothrow,
-    .destructibility = pro::constraint_level::nothrow,
-  }, SboObserver);
-PRO_DEF_FACADE(TestLargeStringable, utils::spec::ToString, pro::copyable_ptr_constraints, SboObserver);
+struct TestLargeStringable : pro::facade_builder
+    ::add_facade<utils::spec::Stringable>
+    ::support_copy<pro::constraint_level::nontrivial>
+    ::add_reflection<SboObserver>
+    ::build {};
+
+struct TestSmallStringable : pro::facade_builder
+    ::add_facade<TestLargeStringable>
+    ::restrict_layout<sizeof(void*)>
+    ::build {};
 
 }  // namespace spec
 
-PRO_DEF_MEMBER_DISPATCH(MemFn0, void(int) noexcept);
-PRO_DEF_FACADE(TestMemFn0, MemFn0);
+PRO_DEF_MEM_DISPATCH(MemFn0, MemFn0);
+struct TestMemFn0 : pro::facade_builder
+    ::add_convention<MemFn0, void(int) noexcept>
+    ::build {};
 struct TestMemFn0_Normal { void MemFn0(int) noexcept {} };
 static_assert(pro::proxiable<TestMemFn0_Normal*, TestMemFn0>);
 struct TestMemFn0_Unsupproted { void MemFn1(int) noexcept {} };
@@ -52,8 +56,10 @@ static_assert(!pro::proxiable<TestMemFn0_ArgumentNotMatch*, TestMemFn0>);
 struct TestMemFn0_ReturnTypeNotMatch { std::string MemFn0(int) noexcept { return {}; } };
 static_assert(pro::proxiable<TestMemFn0_ReturnTypeNotMatch*, TestMemFn0>);
 
-PRO_DEF_MEMBER_DISPATCH(MemFn1, int(double));
-PRO_DEF_FACADE(TestMemFn1, MemFn1);
+PRO_DEF_MEM_DISPATCH(MemFn1, MemFn1);
+struct TestMemFn1 : pro::facade_builder
+    ::add_convention<MemFn1, int(double)>
+    ::build {};
 struct TestMemFn1_Normal { int MemFn1(double) { return 0; } };
 static_assert(pro::proxiable<TestMemFn1_Normal*, TestMemFn1>);
 struct TestMemFn1_HasNoexcept { int MemFn1(double) noexcept { return 0; } };
@@ -80,8 +86,8 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_FromValue) {
   {
     auto p = pro::make_proxy_inplace<spec::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
-    ASSERT_TRUE(p.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p), "Session 2");
+    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -95,8 +101,8 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_InPlace) {
   {
     auto p = pro::make_proxy_inplace<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_TRUE(p.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -110,8 +116,8 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_InPlaceInitializerList) {
   {
     auto p = pro::make_proxy_inplace<spec::TestLargeStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_TRUE(p.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -127,11 +133,11 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Copy) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 1");
-    ASSERT_TRUE(p1.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p1), "Session 1");
+    ASSERT_TRUE(p1.reflect<SboObserver>().SboEnabled);
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
-    ASSERT_TRUE(p2.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p2), "Session 2");
+    ASSERT_TRUE(p2.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -149,8 +155,8 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Move) {
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
-    ASSERT_TRUE(p2.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p2), "Session 2");
+    ASSERT_TRUE(p2.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -167,9 +173,9 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_FromValue) {
   {
     auto p = pro::allocate_proxy<spec::TestSmallStringable>(std::allocator<void>{}, session);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_FALSE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 2");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -183,9 +189,9 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_InPlace) {
   {
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_FALSE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -199,9 +205,9 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_InPlaceInitializerLis
   {
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, { 1, 2, 3 }, & tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_FALSE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -217,13 +223,13 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Copy) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 1");
-    ASSERT_FALSE(p1.reflect().SboEnabled);
-    ASSERT_FALSE(p1.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p1), "Session 1");
+    ASSERT_FALSE(p1.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p1.reflect<SboObserver>().AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
-    ASSERT_FALSE(p2.reflect().SboEnabled);
-    ASSERT_FALSE(p2.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p2), "Session 2");
+    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -241,9 +247,9 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Move) {
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 1");
-    ASSERT_FALSE(p2.reflect().SboEnabled);
-    ASSERT_FALSE(p2.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p2), "Session 1");
+    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -259,9 +265,9 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_FromValue) {
     std::pmr::unsynchronized_pool_resource memory_pool;
     auto p = pro::allocate_proxy<spec::TestSmallStringable>(std::pmr::polymorphic_allocator<>{&memory_pool}, session);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_TRUE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 2");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -276,9 +282,9 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_InPlace) {
     std::pmr::unsynchronized_pool_resource memory_pool;
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_TRUE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -293,9 +299,9 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_InPlaceInitializerL
     std::pmr::unsynchronized_pool_resource memory_pool;
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, { 1, 2, 3 }, & tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_TRUE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -312,13 +318,13 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Copy) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 1");
-    ASSERT_FALSE(p1.reflect().SboEnabled);
-    ASSERT_TRUE(p1.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p1), "Session 1");
+    ASSERT_FALSE(p1.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(p1.reflect<SboObserver>().AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
-    ASSERT_FALSE(p2.reflect().SboEnabled);
-    ASSERT_TRUE(p2.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p2), "Session 2");
+    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -337,9 +343,9 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Move) {
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 1");
-    ASSERT_FALSE(p2.reflect().SboEnabled);
-    ASSERT_TRUE(p2.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p2), "Session 1");
+    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -354,8 +360,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_FromValue) {
   {
     auto p = pro::make_proxy<spec::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
-    ASSERT_TRUE(p.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p), "Session 2");
+    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -369,8 +375,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlace) {
   {
     auto p = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_TRUE(p.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -384,8 +390,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlaceInitializerList) {
   {
     auto p = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_TRUE(p.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -401,11 +407,11 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Copy) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 1");
-    ASSERT_TRUE(p1.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p1), "Session 1");
+    ASSERT_TRUE(p1.reflect<SboObserver>().SboEnabled);
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
-    ASSERT_TRUE(p2.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p2), "Session 2");
+    ASSERT_TRUE(p2.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -423,8 +429,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Move) {
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
-    ASSERT_TRUE(p2.reflect().SboEnabled);
+    ASSERT_EQ(ToString(p2), "Session 2");
+    ASSERT_TRUE(p2.reflect<SboObserver>().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -441,9 +447,9 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_FromValue) {
   {
     auto p = pro::make_proxy<spec::TestSmallStringable>(session);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_FALSE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 2");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -457,9 +463,9 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlace) {
   {
     auto p = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_FALSE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -473,9 +479,9 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlaceInitializerList) {
   {
     auto p = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
-    ASSERT_FALSE(p.reflect().SboEnabled);
-    ASSERT_FALSE(p.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p), "Session 1");
+    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -491,13 +497,13 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Copy) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 1");
-    ASSERT_FALSE(p1.reflect().SboEnabled);
-    ASSERT_FALSE(p1.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p1), "Session 1");
+    ASSERT_FALSE(p1.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p1.reflect<SboObserver>().AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
-    ASSERT_FALSE(p2.reflect().SboEnabled);
-    ASSERT_FALSE(p2.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p2), "Session 2");
+    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -515,9 +521,9 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Move) {
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 1");
-    ASSERT_FALSE(p2.reflect().SboEnabled);
-    ASSERT_FALSE(p2.reflect().AllocatorAllocatesForItself);
+    ASSERT_EQ(ToString(p2), "Session 1");
+    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_FALSE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
diff --git a/tests/proxy_integration_tests.cpp b/tests/proxy_integration_tests.cpp
index 812d8eef..a9beb499 100644
--- a/tests/proxy_integration_tests.cpp
+++ b/tests/proxy_integration_tests.cpp
@@ -15,12 +15,19 @@ namespace {
 
 namespace spec {
 
-PRO_DEF_MEMBER_DISPATCH(Draw, void(std::ostream&));
-PRO_DEF_MEMBER_DISPATCH(Area, double() noexcept);
-PRO_DEF_FACADE(Drawable, PRO_MAKE_DISPATCH_PACK(Draw, Area));
+PRO_DEF_MEM_DISPATCH(MemDraw, Draw);
+PRO_DEF_MEM_DISPATCH(MemArea, Area);
 
-PRO_DEF_MEMBER_DISPATCH(Log, void(const char*), void(const char*, const std::exception&));
-PRO_DEF_FACADE(Logger, Log);
+struct Drawable : pro::facade_builder
+    ::add_convention<MemDraw, void(std::ostream&)>
+    ::add_convention<MemArea, double() noexcept>
+    ::build {};
+
+PRO_DEF_MEM_DISPATCH(MemLog, Log);
+
+struct Logger : pro::facade_builder
+    ::add_convention<MemLog, void(const char*), void(const char*, const std::exception&)>
+    ::build {};
 
 }  // namespace spec
 
diff --git a/tests/proxy_invocation_tests.cpp b/tests/proxy_invocation_tests.cpp
index dbdca74e..33cca9cb 100644
--- a/tests/proxy_invocation_tests.cpp
+++ b/tests/proxy_invocation_tests.cpp
@@ -17,39 +17,93 @@ namespace {
 
 namespace spec {
 
-template <class... Os>
-PRO_DEF_FREE_DISPATCH(Call, std::invoke, Os...);
-template <class... Os>
-PRO_DEF_FACADE(Callable, Call<Os...>, pro::copyable_ptr_constraints);
+struct Call {
+  template <class T, class... Args>
+  decltype(auto) operator()(T& v, Args&&... args)
+      noexcept(std::is_nothrow_invocable_v<T&, Args...>)
+      requires(std::is_invocable_v<T&, Args...>)
+      { return std::invoke(v, std::forward<Args>(args)...); }
+
+  template <class P>
+  struct accessor {
+    template <class... Args>
+    decltype(auto) operator()(Args&&... args) const
+        noexcept(noexcept(static_cast<const P&>(*this).template invoke<Call>(std::forward<Args>(args)...)))
+        requires(requires { static_cast<pro::lazy_eval_t<const P&, Args...>>(*this).template invoke<Call>(std::forward<Args>(args)...); })
+        { return static_cast<const P&>(*this).template invoke<Call>(std::forward<Args>(args)...); }
+  };
+};
 
-template <class R>
-R NotImplemented(auto&&...) { throw std::runtime_error{ "Not implemented!" }; }
 template <class... Os>
-PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(WeakCall, std::invoke, NotImplemented<void>, Os...);
+struct Callable : pro::facade_builder
+    ::support_copy<pro::constraint_level::nontrivial>
+    ::add_convention<Call, Os...>
+    ::build {};
+
+struct Wildcard {
+  template <class T>
+  operator T() const noexcept { std::terminate(); }
+};
+
+Wildcard NotImplemented(auto&&...) { throw std::runtime_error{ "Not implemented!" }; }
+
+struct WeakCall {
+  template <class T, class... Args>
+  decltype(auto) operator()(T& v, Args&&... args)
+      noexcept(std::is_nothrow_invocable_v<T&, Args...>)
+      requires(std::is_invocable_v<T&, Args...>)
+      { return std::invoke(v, std::forward<Args>(args)...); }
+
+  template <class... Args>
+  Wildcard operator()(std::nullptr_t, Args&&...) { NotImplemented(); return {}; }
+
+  template <class P>
+  struct accessor {
+    template <class... Args>
+    decltype(auto) operator()(Args&&... args) const
+        noexcept(noexcept(static_cast<const P&>(*this).template invoke<WeakCall>(std::forward<Args>(args)...)))
+        requires(requires { static_cast<pro::lazy_eval_t<const P&, Args...>>(*this).template invoke<WeakCall>(std::forward<Args>(args)...); })
+        { return static_cast<const P&>(*this).template invoke<WeakCall>(std::forward<Args>(args)...); }
+  };
+};
+
 template <class... Os>
-PRO_DEF_FACADE(WeakCallable, WeakCall<Os...>, pro::copyable_ptr_constraints);
+struct WeakCallable : pro::facade_builder
+    ::support_copy<pro::constraint_level::nontrivial>
+    ::add_convention<WeakCall, Os...>
+    ::build {};
 
-PRO_DEF_FREE_DISPATCH(GetSize, std::ranges::size, std::size_t() noexcept);
+PRO_DEF_FREE_DISPATCH(FreeSize, Size, std::ranges::size);
+PRO_DEF_FREE_DISPATCH(FreeForEach, ForEach, std::ranges::for_each);
 
 template <class T>
-PRO_DEF_FREE_DISPATCH(ForEach, std::ranges::for_each, void(pro::proxy<Callable<void(T&)>>));
-template <class T>
-PRO_DEF_FACADE(Iterable, PRO_MAKE_DISPATCH_PACK(ForEach<T>, GetSize));
+struct Iterable : pro::facade_builder
+    ::add_convention<FreeForEach, void(pro::proxy<Callable<void(T&)>>)>
+    ::template add_convention<FreeSize, std::size_t() noexcept>
+    ::build {};
 
-template <class T> struct Append;
 template <class T>
-PRO_DEF_FACADE(Container, PRO_MAKE_DISPATCH_PACK(ForEach<T>, GetSize, Append<T>));
+struct Container;
 
 template <class C, class T>
 pro::proxy<Container<T>> AppendImpl(C& container, T&& v) {
   container.push_back(std::move(v));
   return &container;
 }
+
+PRO_DEF_FREE_DISPATCH(FreeAppend, Append, AppendImpl);
+
 template <class T>
-PRO_DEF_FREE_DISPATCH(Append, AppendImpl, pro::proxy<Container<T>>(T));
+struct Container : pro::facade_builder
+    ::add_facade<Iterable<T>>
+    ::template add_convention<FreeAppend, pro::proxy<Container<T>>(T)>
+    ::build {};
+
+PRO_DEF_MEM_DISPATCH_WITH_DEFAULT(MemAtWeak, at, NotImplemented);
 
-PRO_DEF_MEMBER_DISPATCH_WITH_DEFAULT(WeakAt, at, NotImplemented<std::string>, std::string(int));
-PRO_DEF_FACADE(ResourceDictionary, WeakAt);
+struct ResourceDictionary : pro::facade_builder
+    ::add_convention<MemAtWeak, std::string(int)>
+    ::build {};
 
 template <class F, class T>
 pro::proxy<F> LockImpl(const std::weak_ptr<T>& p) {
@@ -60,15 +114,24 @@ pro::proxy<F> LockImpl(const std::weak_ptr<T>& p) {
   return nullptr;
 }
 template <class F>
-PRO_DEF_FREE_DISPATCH(Lock, LockImpl<F>, pro::proxy<F>());
+PRO_DEF_FREE_DISPATCH(FreeLock, Lock, LockImpl<F>);
+
 template <class F>
-PRO_DEF_FACADE(Weak, Lock<F>, pro::copyable_ptr_constraints);
+struct Weak : pro::facade_builder
+    ::support_copy<pro::constraint_level::nontrivial>
+    ::add_convention<FreeLock<F>, pro::proxy<F>()>
+    ::build {};
+
 template <class F, class T>
 auto GetWeakImpl(const std::shared_ptr<T>& p) { return pro::make_proxy<Weak<F>, std::weak_ptr<T>>(p); }
+
 template <class F>
-PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(GetWeak, GetWeakImpl<F>, std::nullptr_t, pro::proxy<Weak<F>>());
+PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(FreeGetWeak, GetWeak, GetWeakImpl<F>, std::nullptr_t);
 
-PRO_DEF_FACADE(SharedStringable, PRO_MAKE_DISPATCH_PACK(utils::spec::ToString, GetWeak<SharedStringable>), pro::copyable_ptr_constraints);
+struct SharedStringable : pro::facade_builder
+    ::add_facade<utils::spec::Stringable>
+    ::add_convention<FreeGetWeak<SharedStringable>, pro::proxy<Weak<SharedStringable>>()>
+    ::build {};
 
 }  // namespace spec
 
@@ -86,8 +149,8 @@ concept InvocableWithoutDispatch =
 };
 
 // Static assertions for a facade of a single dispatch
-static_assert(InvocableWithDispatch<spec::Callable<int(double)>, spec::Call<int(double)>, false, double>);
-static_assert(!InvocableWithDispatch<spec::Callable<int(double)>, spec::Call<int(double)>, false, std::nullptr_t>);  // Wrong arguments
+static_assert(InvocableWithDispatch<spec::Callable<int(double)>, spec::Call, false, double>);
+static_assert(!InvocableWithDispatch<spec::Callable<int(double)>, spec::Call, false, std::nullptr_t>);  // Wrong arguments
 static_assert(!InvocableWithoutDispatch<spec::Callable<int(double)>, false, std::nullptr_t>);  // Wrong arguments
 static_assert(!InvocableWithDispatch<spec::Callable<int(double)>, int(double), false, double>);  // Wrong dispatch
 static_assert(InvocableWithoutDispatch<spec::Callable<int(double)>, false, float>);  // Invoking without specifying a dispatch
@@ -95,9 +158,9 @@ static_assert(InvocableWithoutDispatch<spec::Callable<int(double), void(int) noe
 static_assert(InvocableWithoutDispatch<spec::Callable<int(double), void(int) noexcept>, false, double>);  // Invoking overloads that may throw
 
 // Static assertions for a facade of multiple dispatches
-static_assert(InvocableWithDispatch<spec::Iterable<int>, spec::GetSize, true>);
-static_assert(!InvocableWithDispatch<spec::Iterable<int>, spec::ForEach<int>, false, pro::proxy<spec::Callable<void(double&)>>>);  // Wrong arguments
-static_assert(!InvocableWithDispatch<spec::Iterable<int>, spec::Append<int>, false>);  // Wrong dispatch
+static_assert(InvocableWithDispatch<spec::Iterable<int>, spec::FreeSize, true>);
+static_assert(!InvocableWithDispatch<spec::Iterable<int>, spec::FreeForEach, false, pro::proxy<spec::Callable<void(double&)>>>);  // Wrong arguments
+static_assert(!InvocableWithDispatch<spec::Iterable<int>, spec::FreeAppend, false>);  // Wrong dispatch
 static_assert(!InvocableWithoutDispatch<spec::Iterable<int>, false>);  // Invoking without specifying a dispatch
 
 template <class... Args>
@@ -119,7 +182,7 @@ TEST(ProxyInvocationTests, TestArgumentForwarding) {
     return expected_result;
   };
   pro::proxy<spec::Callable<int(std::string, std::vector<int>)>> p = &f;
-  int result = p.invoke(arg1, std::move(arg2));
+  int result = p(arg1, std::move(arg2));
   ASSERT_TRUE(p.has_value());
   ASSERT_EQ(arg1_received, arg1);
   ASSERT_TRUE(arg2.empty());
@@ -133,7 +196,7 @@ TEST(ProxyInvocationTests, TestThrow) {
   bool exception_thrown = false;
   pro::proxy<spec::Callable<void()>> p = &f;
   try {
-    p.invoke();
+    p();
   } catch (const std::runtime_error& e) {
     exception_thrown = true;
     ASSERT_STREQ(e.what(), expected_error_message);
@@ -145,59 +208,49 @@ TEST(ProxyInvocationTests, TestThrow) {
 TEST(ProxyInvocationTests, TestMultipleDispatches_Unique) {
   std::list<int> l = { 1, 2, 3 };
   pro::proxy<spec::Iterable<int>> p = &l;
-  ASSERT_EQ(p.invoke<spec::GetSize>(), 3);
+  ASSERT_EQ(Size(p), 3);
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
-  p.invoke<spec::ForEach<int>>(&accumulate_sum);
+  ForEach(p, &accumulate_sum);
   ASSERT_EQ(sum, 6);
 }
 
 TEST(ProxyInvocationTests, TestMultipleDispatches_Duplicated) {
-  using SomeCombination = std::tuple<spec::ForEach<int>, std::tuple<spec::GetSize, spec::ForEach<int>>>;
-  PRO_DEF_FACADE(DuplicatedIterable, PRO_MAKE_DISPATCH_PACK(spec::ForEach<int>, SomeCombination, spec::ForEach<int>, spec::GetSize, spec::GetSize));
+  struct DuplicatedIterable : pro::facade_builder
+      ::add_convention<spec::FreeForEach, void(pro::proxy<spec::Callable<void(int&)>>)>
+      ::add_convention<spec::FreeSize, std::size_t()>
+      ::add_convention<spec::FreeForEach, void(pro::proxy<spec::Callable<void(int&)>>)>
+      ::build {};
   static_assert(sizeof(pro::details::facade_traits<DuplicatedIterable>::meta) ==
       sizeof(pro::details::facade_traits<spec::Iterable<int>>::meta));
   std::list<int> l = { 1, 2, 3 };
   pro::proxy<DuplicatedIterable> p = &l;
-  ASSERT_EQ(p.invoke<spec::GetSize>(), 3);
+  ASSERT_EQ(Size(p), 3);
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
-  p.invoke<spec::ForEach<int>>(&accumulate_sum);
+  ForEach(p, &accumulate_sum);
   ASSERT_EQ(sum, 6);
 }
 
 TEST(ProxyInvocationTests, TestRecursiveDefinition) {
   std::list<int> l = { 1, 2, 3 };
   pro::proxy<spec::Container<int>> p = &l;
-  ASSERT_EQ(p.invoke<spec::GetSize>(), 3);
-  int sum = 0;
-  auto accumulate_sum = [&](int x) { sum += x; };
-  p.invoke<spec::ForEach<int>>(&accumulate_sum);
-  ASSERT_EQ(sum, 6);
-  p.invoke<spec::Append<int>>(4).invoke<spec::Append<int>>(5).invoke<spec::Append<int>>(6);
-  ASSERT_EQ(p.invoke<spec::GetSize>(), 6);
-  sum = 0;
-  p.invoke<spec::ForEach<int>>(&accumulate_sum);
-  ASSERT_EQ(sum, 21);
-}
-
-TEST(ProxyInvocationTests, TestAccessor) {
-  std::list<int> l = { 1, 2, 3 };
-  pro::proxy<spec::Container<int>> p = &l;
-  ASSERT_EQ(p.GetSize(), 3);
+  ASSERT_EQ(Size(p), 3);
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
-  p.ForEach(&accumulate_sum);
+  ForEach(p, &accumulate_sum);
   ASSERT_EQ(sum, 6);
-  p.Append(4).Append(5).Append(6);
-  ASSERT_EQ(p.GetSize(), 6);
+  Append(Append(Append(p, 4), 5), 6);
+  ASSERT_EQ(Size(p), 6);
   sum = 0;
-  p.ForEach(&accumulate_sum);
+  ForEach(p, &accumulate_sum);
   ASSERT_EQ(sum, 21);
 }
 
 TEST(ProxyInvocationTests, TestOverloadResolution) {
-  PRO_DEF_FACADE(OverloadedCallable, spec::Call<void(int), void(double), void(const char*), void(char*), void(std::string, int)>);
+  struct OverloadedCallable : pro::facade_builder
+      ::add_convention<spec::Call, 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 = GetTypeIndices<std::decay_t<decltype(args)>...>(); });
@@ -239,12 +292,12 @@ TEST(ProxyInvocationTests, TestMemberDispatchDefault) {
   std::vector<std::string> container1{ "hello", "world", "!"};
   std::list<std::string> container2{ "hello", "world" };
   pro::proxy<spec::ResourceDictionary> p = &container1;
-  ASSERT_EQ(p(0), "hello");
+  ASSERT_EQ(p.at(0), "hello");
   p = &container2;
   {
     bool exception_thrown = false;
     try {
-      p(0);
+      p.at(0);
     } catch (const std::runtime_error& e) {
       exception_thrown = true;
       ASSERT_EQ(static_cast<std::string>(e.what()), "Not implemented!");
@@ -276,16 +329,17 @@ TEST(ProxyInvocationTests, TestFreeDispatchDefault) {
 TEST(ProxyInvocationTests, TestObserverDispatch) {
   int test_val = 123;
   pro::proxy<spec::SharedStringable> p{std::make_shared<int>(test_val)};
-  auto weak = p.invoke<spec::GetWeak<spec::SharedStringable>>();
+  auto weak = GetWeak(p);
   ASSERT_TRUE(weak.has_value());
   {
-    auto locked = weak();
+    auto locked = Lock(weak);
     ASSERT_TRUE(locked.has_value());
-    ASSERT_EQ(locked.invoke<utils::spec::ToString>(), "123");
+    ASSERT_EQ(ToString(locked), "123");
   }
   p = &test_val;  // The underlying std::shared_ptr will be destroyed
   ASSERT_TRUE(weak.has_value());
-  ASSERT_FALSE(weak().has_value());
-  ASSERT_FALSE(p.invoke<spec::GetWeak<spec::SharedStringable>>().has_value());
-  ASSERT_EQ(p.invoke<utils::spec::ToString>(), "123");
+  ASSERT_FALSE(Lock(weak).has_value());
+  ASSERT_FALSE(GetWeak(p).has_value());
+  ASSERT_EQ(ToString(p), "123");
 }
+
diff --git a/tests/proxy_lifetime_tests.cpp b/tests/proxy_lifetime_tests.cpp
index 37ffd52d..4aae22d0 100644
--- a/tests/proxy_lifetime_tests.cpp
+++ b/tests/proxy_lifetime_tests.cpp
@@ -7,8 +7,17 @@
 
 namespace {
 
-PRO_DEF_FACADE(TestFacade, utils::spec::ToString, pro::copyable_ptr_constraints);
-PRO_DEF_FACADE(TestTrivialFacade, utils::spec::ToString, pro::trivial_ptr_constraints);
+struct TestFacade : pro::facade_builder
+    ::add_facade<utils::spec::Stringable>
+    ::support_copy<pro::constraint_level::nontrivial>
+    ::build {};
+
+struct TestTrivialFacade : pro::facade_builder
+    ::add_facade<utils::spec::Stringable>
+    ::support_copy<pro::constraint_level::trivial>
+    ::support_relocation<pro::constraint_level::trivial>
+    ::support_destruction<pro::constraint_level::trivial>
+    ::build {};
 
 }  // namespace
 
@@ -28,7 +37,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_FromValue) {
   {
     pro::proxy<TestFacade> p = utils::LifetimeTracker::Session(&tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p), "Session 2");
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -65,7 +74,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_InPlace) {
   {
     pro::proxy<TestFacade> p{ std::in_place_type<utils::LifetimeTracker::Session>, &tracker };
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p), "Session 1");
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -97,7 +106,7 @@ TEST(ProxyLifetimeTests, TestPolyConstrction_InPlaceInitializerList) {
   {
     pro::proxy<TestFacade> p{ std::in_place_type<utils::LifetimeTracker::Session>, { 1, 2, 3 }, &tracker };
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p), "Session 1");
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -131,9 +140,9 @@ TEST(ProxyLifetimeTests, TestCopyConstrction_FromValue) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p1), "Session 1");
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p2), "Session 2");
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -158,7 +167,7 @@ TEST(ProxyLifetimeTests, TestCopyConstrction_FromValue_Exception) {
     }
     ASSERT_TRUE(exception_thrown);
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p1), "Session 1");
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -181,7 +190,7 @@ TEST(ProxyLifetimeTests, TestMoveConstrction_FromValue) {
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p2), "Session 2");
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -201,7 +210,7 @@ TEST(ProxyLifetimeTests, TestMoveConstrction_FromValue_Trivial) {
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.invoke(), "Session 1");
+    ASSERT_EQ(ToString(p2), "Session 1");
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -243,7 +252,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_ToValue) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     p = utils::LifetimeTracker::Session{ &tracker };
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 3");
+    ASSERT_EQ(ToString(p), "Session 3");
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kValueConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     expected_ops.emplace_back(3, utils::LifetimeOperationType::kMoveConstruction);
@@ -272,7 +281,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_ToValue_Exception) {
     }
     ASSERT_TRUE(exception_thrown);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p), "Session 1");
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(2, utils::LifetimeOperationType::kDestruction);
@@ -287,7 +296,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_FromValue_ToNull) {
     pro::proxy<TestFacade> p;
     p = utils::LifetimeTracker::Session{ &tracker };
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p), "Session 2");
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -328,7 +337,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlace_ToValue) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     p.emplace<utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p), "Session 2");
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -366,7 +375,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlace_ToNull) {
     pro::proxy<TestFacade> p;
     p.emplace<utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p), "Session 1");
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -402,7 +411,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlaceInitializerList_ToValue) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     p.emplace<utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p), "Session 2");
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -440,7 +449,7 @@ TEST(ProxyLifetimeTests, TestPolyAssignment_InPlaceInitializerList_ToNull) {
     pro::proxy<TestFacade> p;
     p.emplace<utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p), "Session 1");
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -478,9 +487,9 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToValue) {
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kValueConstruction);
     p1 = p2;
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 4");
+    ASSERT_EQ(ToString(p1), "Session 4");
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p2), "Session 2");
     expected_ops.emplace_back(3, utils::LifetimeOperationType::kCopyConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     expected_ops.emplace_back(4, utils::LifetimeOperationType::kMoveConstruction);
@@ -510,9 +519,9 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToValue_Exception) {
     }
     ASSERT_TRUE(exception_thrown);
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p1), "Session 1");
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p2), "Session 2");
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(2, utils::LifetimeOperationType::kDestruction);
@@ -535,7 +544,7 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToSelf) {
 #pragma clang diagnostic pop
 #endif  // __clang__
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 3");
+    ASSERT_EQ(ToString(p), "Session 3");
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     expected_ops.emplace_back(3, utils::LifetimeOperationType::kMoveConstruction);
@@ -555,9 +564,9 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToNull) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     p1 = p2;
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 3");
+    ASSERT_EQ(ToString(p1), "Session 3");
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p2), "Session 1");
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     expected_ops.emplace_back(3, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kDestruction);
@@ -586,7 +595,7 @@ TEST(ProxyLifetimeTests, TestCopyAssignment_FromValue_ToNull_Exception) {
     ASSERT_TRUE(exception_thrown);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 1");
+    ASSERT_EQ(ToString(p2), "Session 1");
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -638,7 +647,7 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromValue_ToValue) {
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kValueConstruction);
     p1 = std::move(p2);
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 3");
+    ASSERT_EQ(ToString(p1), "Session 3");
     ASSERT_FALSE(p2.has_value());
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     expected_ops.emplace_back(3, utils::LifetimeOperationType::kMoveConstruction);
@@ -684,7 +693,7 @@ TEST(ProxyLifetimeTests, TestMoveAssignment_FromValue_ToNull) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     p1 = std::move(p2);
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p1), "Session 2");
     ASSERT_FALSE(p2.has_value());
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -740,7 +749,7 @@ TEST(ProxyLifetimeTests, TestHasValue) {
   ASSERT_FALSE(p1.has_value());
   p1 = &foo;
   ASSERT_TRUE(p1.has_value());
-  ASSERT_EQ(p1.ToString(), "123");
+  ASSERT_EQ(ToString(p1), "123");
 }
 
 TEST(ProxyLifetimeTests, TestReset_FromValue) {
@@ -773,9 +782,9 @@ TEST(ProxyLifetimeTests, TestSwap_Value_Value) {
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kValueConstruction);
     swap(p1, p2);
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 4");
+    ASSERT_EQ(ToString(p1), "Session 4");
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 5");
+    ASSERT_EQ(ToString(p2), "Session 5");
     expected_ops.emplace_back(3, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     expected_ops.emplace_back(4, utils::LifetimeOperationType::kMoveConstruction);
@@ -797,7 +806,7 @@ TEST(ProxyLifetimeTests, TestSwap_Value_Self) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     swap(p, p);
     ASSERT_TRUE(p.has_value());
-    ASSERT_EQ(p.ToString(), "Session 3");
+    ASSERT_EQ(ToString(p), "Session 3");
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     expected_ops.emplace_back(3, utils::LifetimeOperationType::kMoveConstruction);
@@ -818,7 +827,7 @@ TEST(ProxyLifetimeTests, TestSwap_Value_Null) {
     swap(p1, p2);
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
-    ASSERT_EQ(p2.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p2), "Session 2");
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
   }
@@ -835,7 +844,7 @@ TEST(ProxyLifetimeTests, TestSwap_Null_Value) {
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     swap(p1, p2);
     ASSERT_TRUE(p1.has_value());
-    ASSERT_EQ(p1.ToString(), "Session 2");
+    ASSERT_EQ(ToString(p1), "Session 2");
     ASSERT_FALSE(p2.has_value());
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
diff --git a/tests/proxy_reflection_tests.cpp b/tests/proxy_reflection_tests.cpp
index 3593636c..a9b33140 100644
--- a/tests/proxy_reflection_tests.cpp
+++ b/tests/proxy_reflection_tests.cpp
@@ -8,9 +8,9 @@
 
 namespace {
 
-template <class F>
+template <class F, class R>
 concept ReflectionApplicable = requires(pro::proxy<F> p) {
-  { p.reflect() };
+  { p.template reflect<R>() };
 };
 
 class RttiReflection {
@@ -42,43 +42,47 @@ struct TraitsReflection {
   bool is_trivial_;
 };
 
-PRO_DEF_FACADE(DefaultFacade);
-static_assert(!ReflectionApplicable<DefaultFacade>);
+struct DefaultFacade : pro::facade_builder::build {};
+static_assert(!ReflectionApplicable<DefaultFacade, RttiReflection>);
 
-PRO_DEF_FACADE(TestRttiFacade, PRO_MAKE_DISPATCH_PACK(), pro::relocatable_ptr_constraints, RttiReflection);
-static_assert(ReflectionApplicable<TestRttiFacade>);
+struct TestRttiFacade : pro::facade_builder
+    ::add_reflection<RttiReflection>
+    ::build {};
+static_assert(ReflectionApplicable<TestRttiFacade, RttiReflection>);
 
-PRO_DEF_FACADE(TestTraitsFacade, PRO_MAKE_DISPATCH_PACK(), pro::relocatable_ptr_constraints, TraitsReflection);
-static_assert(ReflectionApplicable<TestTraitsFacade>);
+struct TestTraitsFacade : pro::facade_builder
+    ::add_reflection<TraitsReflection>
+    ::build {};
+static_assert(ReflectionApplicable<TestTraitsFacade, TraitsReflection>);
 
 }  // namespace
 
 TEST(ProxyReflectionTests, TestRtti_RawPtr) {
   int foo = 123;
   pro::proxy<TestRttiFacade> p = &foo;
-  ASSERT_EQ(p.reflect().GetName(), typeid(int*).name());
+  ASSERT_EQ(p.reflect<RttiReflection>().GetName(), typeid(int*).name());
 }
 
 TEST(ProxyReflectionTests, TestRtti_FancyPtr) {
   pro::proxy<TestRttiFacade> p = std::make_unique<double>(1.23);
-  ASSERT_EQ(p.reflect().GetName(), typeid(std::unique_ptr<double>).name());
+  ASSERT_EQ(p.reflect<RttiReflection>().GetName(), typeid(std::unique_ptr<double>).name());
 }
 
 TEST(ProxyReflectionTests, TestTraits_RawPtr) {
   int foo = 123;
   pro::proxy<TestTraitsFacade> p = &foo;
-  ASSERT_EQ(p.reflect().is_default_constructible_, true);
-  ASSERT_EQ(p.reflect().is_copy_constructible_, true);
-  ASSERT_EQ(p.reflect().is_nothrow_move_constructible_, true);
-  ASSERT_EQ(p.reflect().is_nothrow_destructible_, true);
-  ASSERT_EQ(p.reflect().is_trivial_, true);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_default_constructible_, true);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_copy_constructible_, true);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_nothrow_move_constructible_, true);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_nothrow_destructible_, true);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_trivial_, true);
 }
 
 TEST(ProxyReflectionTests, TestTraits_FancyPtr) {
   pro::proxy<TestTraitsFacade> p = std::make_unique<double>(1.23);
-  ASSERT_EQ(p.reflect().is_default_constructible_, true);
-  ASSERT_EQ(p.reflect().is_copy_constructible_, false);
-  ASSERT_EQ(p.reflect().is_nothrow_move_constructible_, true);
-  ASSERT_EQ(p.reflect().is_nothrow_destructible_, true);
-  ASSERT_EQ(p.reflect().is_trivial_, false);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_default_constructible_, true);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_copy_constructible_, false);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_nothrow_move_constructible_, true);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_nothrow_destructible_, true);
+  ASSERT_EQ(p.reflect<TraitsReflection>().is_trivial_, false);
 }
diff --git a/tests/proxy_traits_tests.cpp b/tests/proxy_traits_tests.cpp
index 2530c9cf..a9f21983 100644
--- a/tests/proxy_traits_tests.cpp
+++ b/tests/proxy_traits_tests.cpp
@@ -27,14 +27,14 @@ using MockCopyableSmallPtr = MockPtr<true, true, false, sizeof(void*), alignof(v
 using MockTrivialPtr = MockPtr<true, true, true, sizeof(void*), alignof(void*)>;
 using MockFunctionPtr = void(*)();
 
-PRO_DEF_FACADE(DefaultFacade);
+struct DefaultFacade : pro::facade_builder::build {};
 static_assert(DefaultFacade::constraints.copyability == pro::constraint_level::none);
 static_assert(DefaultFacade::constraints.relocatability == pro::constraint_level::nothrow);
 static_assert(DefaultFacade::constraints.destructibility == pro::constraint_level::nothrow);
 static_assert(DefaultFacade::constraints.max_size >= 2 * sizeof(void*));
 static_assert(DefaultFacade::constraints.max_align >= sizeof(void*));
-static_assert(std::is_same_v<DefaultFacade::dispatch_types, std::tuple<>>);
-static_assert(std::is_same_v<DefaultFacade::reflection_type, void>);
+static_assert(std::is_same_v<DefaultFacade::convention_types, std::tuple<>>);
+static_assert(std::is_same_v<DefaultFacade::reflection_types, std::tuple<>>);
 static_assert(std::is_nothrow_default_constructible_v<pro::proxy<DefaultFacade>>);
 static_assert(!std::is_trivially_default_constructible_v<pro::proxy<DefaultFacade>>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, std::nullptr_t>);
@@ -46,35 +46,36 @@ static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, std::in
 static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, std::in_place_type_t<MockFunctionPtr>, MockFunctionPtr>);
 static_assert(sizeof(pro::proxy<DefaultFacade>) == 4 * sizeof(void*));  // VTABLE should be embeded
 
-PRO_DEF_FACADE(RelocatableFacade);
-static_assert(!std::is_copy_constructible_v<pro::proxy<RelocatableFacade>>);
-static_assert(!std::is_copy_assignable_v<pro::proxy<RelocatableFacade>>);
-static_assert(std::is_nothrow_move_constructible_v<pro::proxy<RelocatableFacade>>);
-static_assert(!std::is_trivially_move_constructible_v<pro::proxy<RelocatableFacade>>);
-static_assert(std::is_nothrow_move_assignable_v<pro::proxy<RelocatableFacade>>);
-static_assert(!std::is_trivially_move_assignable_v<pro::proxy<RelocatableFacade>>);
-static_assert(std::is_nothrow_destructible_v<pro::proxy<RelocatableFacade>>);
-static_assert(!std::is_trivially_destructible_v<pro::proxy<RelocatableFacade>>);
-static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockMovablePtr>);
-static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockMovablePtr>);
-static_assert(pro::proxiable<MockMovablePtr, RelocatableFacade>);
-static_assert(pro::proxiable<MockCopyablePtr, RelocatableFacade>);
-static_assert(pro::proxiable<MockCopyableSmallPtr, RelocatableFacade>);
-static_assert(pro::proxiable<MockTrivialPtr, RelocatableFacade>);
-static_assert(pro::proxiable<MockFunctionPtr, RelocatableFacade>);
-static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockMovablePtr>);
-static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockMovablePtr>);
-static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockCopyablePtr>);
-static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockCopyablePtr>);
-static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockCopyableSmallPtr>);
-static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockCopyableSmallPtr>);
-static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockTrivialPtr>);
-static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockTrivialPtr>);
-static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockFunctionPtr>);
-static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockFunctionPtr>);
-static_assert(sizeof(pro::proxy<RelocatableFacade>) == 4 * sizeof(void*));  // VTABLE should be embeded
+static_assert(!std::is_copy_constructible_v<pro::proxy<DefaultFacade>>);
+static_assert(!std::is_copy_assignable_v<pro::proxy<DefaultFacade>>);
+static_assert(std::is_nothrow_move_constructible_v<pro::proxy<DefaultFacade>>);
+static_assert(!std::is_trivially_move_constructible_v<pro::proxy<DefaultFacade>>);
+static_assert(std::is_nothrow_move_assignable_v<pro::proxy<DefaultFacade>>);
+static_assert(!std::is_trivially_move_assignable_v<pro::proxy<DefaultFacade>>);
+static_assert(std::is_nothrow_destructible_v<pro::proxy<DefaultFacade>>);
+static_assert(!std::is_trivially_destructible_v<pro::proxy<DefaultFacade>>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, MockMovablePtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<DefaultFacade>, MockMovablePtr>);
+static_assert(pro::proxiable<MockMovablePtr, DefaultFacade>);
+static_assert(pro::proxiable<MockCopyablePtr, DefaultFacade>);
+static_assert(pro::proxiable<MockCopyableSmallPtr, DefaultFacade>);
+static_assert(pro::proxiable<MockTrivialPtr, DefaultFacade>);
+static_assert(pro::proxiable<MockFunctionPtr, DefaultFacade>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, MockMovablePtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<DefaultFacade>, MockMovablePtr>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, MockCopyablePtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<DefaultFacade>, MockCopyablePtr>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, MockCopyableSmallPtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<DefaultFacade>, MockCopyableSmallPtr>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, MockTrivialPtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<DefaultFacade>, MockTrivialPtr>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, MockFunctionPtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<DefaultFacade>, MockFunctionPtr>);
+static_assert(sizeof(pro::proxy<DefaultFacade>) == 4 * sizeof(void*));  // VTABLE should be embeded
 
-PRO_DEF_FACADE(CopyableFacade, PRO_MAKE_DISPATCH_PACK(), pro::copyable_ptr_constraints);
+struct CopyableFacade : pro::facade_builder
+    ::support_copy<pro::constraint_level::nontrivial>
+    ::build {};
 static_assert(std::is_copy_constructible_v<pro::proxy<CopyableFacade>>);
 static_assert(!std::is_nothrow_copy_constructible_v<pro::proxy<CopyableFacade>>);
 static_assert(std::is_copy_assignable_v<pro::proxy<CopyableFacade>>);
@@ -102,13 +103,10 @@ static_assert(std::is_nothrow_constructible_v<pro::proxy<CopyableFacade>, MockFu
 static_assert(std::is_nothrow_assignable_v<pro::proxy<CopyableFacade>, MockFunctionPtr>);
 static_assert(sizeof(pro::proxy<CopyableFacade>) == 3 * sizeof(void*));  // VTABLE should not be embeded
 
-PRO_DEF_FACADE(CopyableSmallFacade, PRO_MAKE_DISPATCH_PACK(), pro::proxiable_ptr_constraints{
-    .max_size = sizeof(void*),
-    .max_align = alignof(void*),
-    .copyability = pro::constraint_level::nontrivial,
-    .relocatability = pro::constraint_level::nothrow,
-    .destructibility = pro::constraint_level::nothrow,
-  });
+struct CopyableSmallFacade : pro::facade_builder
+    ::restrict_layout<sizeof(void*), alignof(void*)>
+    ::support_copy<pro::constraint_level::nontrivial>
+    ::build {};
 static_assert(!pro::proxiable<MockMovablePtr, CopyableSmallFacade>);
 static_assert(!pro::proxiable<MockCopyablePtr, CopyableSmallFacade>);
 static_assert(pro::proxiable<MockCopyableSmallPtr, CopyableSmallFacade>);
@@ -126,7 +124,12 @@ static_assert(std::is_constructible_v<pro::proxy<CopyableSmallFacade>, MockFunct
 static_assert(std::is_assignable_v<pro::proxy<CopyableSmallFacade>, MockFunctionPtr>);
 static_assert(sizeof(pro::proxy<CopyableSmallFacade>) == 2 * sizeof(void*));  // VTABLE should not be embeded
 
-PRO_DEF_FACADE(TrivialFacade, PRO_MAKE_DISPATCH_PACK(), pro::trivial_ptr_constraints);
+struct TrivialFacade : pro::facade_builder
+    ::restrict_layout<sizeof(void*), alignof(void*)>
+    ::support_copy<pro::constraint_level::trivial>
+    ::support_relocation<pro::constraint_level::trivial>
+    ::support_destruction<pro::constraint_level::trivial>
+    ::build {};
 static_assert(std::is_trivially_copy_constructible_v<pro::proxy<TrivialFacade>>);
 static_assert(std::is_trivially_copy_assignable_v<pro::proxy<TrivialFacade>>);
 static_assert(std::is_nothrow_move_constructible_v<pro::proxy<TrivialFacade>>);
@@ -155,7 +158,9 @@ struct ReflectionOfSmallPtr {
   template <class P> requires(sizeof(P) <= sizeof(void*))
   constexpr ReflectionOfSmallPtr(std::in_place_type_t<P>) {}
 };
-PRO_DEF_FACADE(RelocatableFacadeWithReflection, PRO_MAKE_DISPATCH_PACK(), pro::relocatable_ptr_constraints, ReflectionOfSmallPtr);
+struct RelocatableFacadeWithReflection : pro::facade_builder
+    ::add_reflection<ReflectionOfSmallPtr>
+    ::build {};
 static_assert(!pro::proxiable<MockMovablePtr, RelocatableFacadeWithReflection>);
 static_assert(!pro::proxiable<MockCopyablePtr, RelocatableFacadeWithReflection>);
 static_assert(pro::proxiable<MockCopyableSmallPtr, RelocatableFacadeWithReflection>);
@@ -166,58 +171,83 @@ struct RuntimeReflection {
   template <class P>
   explicit RuntimeReflection(std::in_place_type_t<P>) { throw std::runtime_error{"Not supported"}; }
 };
-PRO_DEF_FACADE(FacadeWithRuntimeReflection, PRO_MAKE_DISPATCH_PACK(), pro::relocatable_ptr_constraints, RuntimeReflection);
+struct FacadeWithRuntimeReflection : pro::facade_builder
+    ::add_reflection<RuntimeReflection>
+    ::build {};
 static_assert(!pro::proxiable<MockTrivialPtr, FacadeWithRuntimeReflection>);
 
-struct FacadeWithTupleLikeDispatches {
-  using dispatch_types = std::array<utils::spec::ToString, 1>;
-  static constexpr auto constraints = pro::relocatable_ptr_constraints;
-  using reflection_type = void;
+struct FacadeWithTupleLikeConventions {
+  struct ToStringConvention {
+    using dispatch_type = utils::spec::FreeToString;
+    using overload_types = std::tuple<std::string()>;
+  };
+  using convention_types = std::array<ToStringConvention, 1>;
+  using reflection_types = std::tuple<>;
+  static constexpr auto constraints = pro::proxiable_ptr_constraints{
+      .max_size = 2 * sizeof(void*),
+      .max_align = alignof(void*),
+      .copyability = pro::constraint_level::none,
+      .relocatability = pro::constraint_level::nothrow,
+      .destructibility = pro::constraint_level::nothrow,
+  };
 };
-static_assert(pro::facade<FacadeWithTupleLikeDispatches>);
+static_assert(pro::facade<FacadeWithTupleLikeConventions>);
 
-struct BadFacade_MissingDispatchTypes {
+struct BadFacade_MissingConventionTypes {
+  using reflection_types = std::tuple<>;
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-const-variable"
 #endif  // __clang__
-  static constexpr auto constraints = pro::relocatable_ptr_constraints;
+  static constexpr auto constraints = pro::proxiable_ptr_constraints{
+      .max_size = 2 * sizeof(void*),
+      .max_align = alignof(void*),
+      .copyability = pro::constraint_level::none,
+      .relocatability = pro::constraint_level::nothrow,
+      .destructibility = pro::constraint_level::nothrow,
+  };
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif  // __clang__
-  using reflection_type = void;
 };
-static_assert(!pro::facade<BadFacade_MissingDispatchTypes>);
+static_assert(!pro::facade<BadFacade_MissingConventionTypes>);
 
-struct BadFacade_BadDispatchTypes {
-  using dispatch_types = int;
+struct BadFacade_BadConventionTypes {
+  using convention_types = int;
+  using reflection_types = std::tuple<>;
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-const-variable"
 #endif  // __clang__
-  static constexpr auto constraints = pro::relocatable_ptr_constraints;
+  static constexpr auto constraints = pro::proxiable_ptr_constraints{
+      .max_size = 2 * sizeof(void*),
+      .max_align = alignof(void*),
+      .copyability = pro::constraint_level::none,
+      .relocatability = pro::constraint_level::nothrow,
+      .destructibility = pro::constraint_level::nothrow,
+  };
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif  // __clang__
-  using reflection_type = void;
 };
-static_assert(!pro::facade<BadFacade_BadDispatchTypes>);
+static_assert(!pro::facade<BadFacade_BadConventionTypes>);
 
 struct BadFacade_MissingConstraints {
-  using dispatch_types = std::tuple<>;
-  using reflection_type = void;
+  using convention_types = std::tuple<>;
+  using reflection_types = std::tuple<>;
 };
 static_assert(!pro::facade<BadFacade_MissingConstraints>);
 
 struct BadFacade_BadConstraints_UnexpectedType {
-  using dispatch_types = std::tuple<>;
+  using convention_types = std::tuple<>;
+  using reflection_types = std::tuple<>;
   static constexpr auto constraints = 0;
-  using reflection_type = void;
 };
 static_assert(!pro::facade<BadFacade_BadConstraints_UnexpectedType>);
 
 struct BadFacade_BadConstraints_BadAlignment {
-  using dispatch_types = std::tuple<>;
+  using convention_types = std::tuple<>;
+  using reflection_types = std::tuple<>;
   static constexpr pro::proxiable_ptr_constraints constraints{
       .max_size = 6u,
       .max_align = 6u, // Should be a power of 2
@@ -225,12 +255,12 @@ struct BadFacade_BadConstraints_BadAlignment {
       .relocatability = pro::constraint_level::nothrow,
       .destructibility = pro::constraint_level::nothrow,
   };
-  using reflection_type = void;
 };
 static_assert(!pro::facade<BadFacade_BadConstraints_BadAlignment>);
 
 struct BadFacade_BadConstraints_BadSize {
-  using dispatch_types = std::tuple<>;
+  using convention_types = std::tuple<>;
+  using reflection_types = std::tuple<>;
   static constexpr pro::proxiable_ptr_constraints constraints{
       .max_size = 6u, // Should be a multiple of max_alignment
       .max_align = 4u,
@@ -238,27 +268,51 @@ struct BadFacade_BadConstraints_BadSize {
       .relocatability = pro::constraint_level::nothrow,
       .destructibility = pro::constraint_level::nothrow,
   };
-  using reflection_type = void;
 };
 static_assert(!pro::facade<BadFacade_BadConstraints_BadSize>);
 
 struct BadFacade_BadConstraints_NotConstant {
-  using dispatch_types = std::tuple<>;
-  static inline const auto constraints = pro::relocatable_ptr_constraints;
-  using reflection_type = void;
+  using convention_types = std::tuple<>;
+  using reflection_types = std::tuple<>;
+  static inline const auto constraints = pro::proxiable_ptr_constraints{
+      .max_size = 2 * sizeof(void*),
+      .max_align = alignof(void*),
+      .copyability = pro::constraint_level::none,
+      .relocatability = pro::constraint_level::nothrow,
+      .destructibility = pro::constraint_level::nothrow,
+  };
 };
 static_assert(!pro::facade<BadFacade_BadConstraints_NotConstant>);
 
-struct BadFacade_MissingReflectionType {
-  using dispatch_types = std::tuple<>;
-  static constexpr auto constraints = pro::relocatable_ptr_constraints;
+struct BadFacade_MissingReflectionTypes {
+  using convention_types = std::tuple<>;
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-const-variable"
+#endif  // __clang__
+  static constexpr auto constraints = pro::proxiable_ptr_constraints{
+      .max_size = 2 * sizeof(void*),
+      .max_align = alignof(void*),
+      .copyability = pro::constraint_level::none,
+      .relocatability = pro::constraint_level::nothrow,
+      .destructibility = pro::constraint_level::nothrow,
+  };
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif  // __clang__
 };
-static_assert(!pro::facade<BadFacade_MissingReflectionType>);
+static_assert(!pro::facade<BadFacade_MissingReflectionTypes>);
 
 struct BadFacade_BadReflectionType {
-  using dispatch_types = std::tuple<>;
-  static constexpr auto constraints = pro::relocatable_ptr_constraints;
-  using reflection_type = std::unique_ptr<int>;  // Probably constexpr, unknown until the evaluation of proxiablility
+  using convention_types = std::tuple<>;
+  using reflection_types = std::tuple<std::unique_ptr<int>>;  // Probably constexpr, unknown until the evaluation of proxiablility
+  static constexpr auto constraints = pro::proxiable_ptr_constraints{
+      .max_size = 2 * sizeof(void*),
+      .max_align = alignof(void*),
+      .copyability = pro::constraint_level::none,
+      .relocatability = pro::constraint_level::nothrow,
+      .destructibility = pro::constraint_level::nothrow,
+  };
 };
 static_assert(pro::facade<BadFacade_BadReflectionType>);
 
diff --git a/tests/utils.h b/tests/utils.h
index e1dcab78..908745ce 100644
--- a/tests/utils.h
+++ b/tests/utils.h
@@ -83,7 +83,11 @@ class LifetimeTracker {
 namespace spec {
 
 using std::to_string;
-PRO_DEF_FREE_DISPATCH(ToString, to_string, std::string());
+PRO_DEF_FREE_DISPATCH(FreeToString, ToString, to_string);
+
+struct Stringable : pro::facade_builder
+    ::add_convention<FreeToString, std::string()>
+    ::build {};
 
 }  // namespace spec