diff --git a/docs/PRO_DEF_FREE_AS_MEM_DISPATCH.md b/docs/PRO_DEF_FREE_AS_MEM_DISPATCH.md
new file mode 100644
index 0000000..a917e92
--- /dev/null
+++ b/docs/PRO_DEF_FREE_AS_MEM_DISPATCH.md
@@ -0,0 +1,71 @@
+# Macro `PRO_DEF_FREE_AS_MEM_DISPATCH`
+
+```cpp
+#define PRO_DEF_FREE_AS_MEM_DISPATCH // see below
+```
+
+Macro `PRO_DEF_FREE_AS_MEM_DISPATCH` defines dispatch types for free function expressions with accessibility via a member function. It supports two syntaxes:
+
+```cpp
+// (1)
+PRO_DEF_FREE_AS_MEM_DISPATCH(dispatch_name, func_name);
+
+// (2)
+PRO_DEF_FREE_AS_MEM_DISPATCH(dispatch_name, func_name, accessibility_func_name);
+```
+
+`(1)` Equivalent to `PRO_DEF_FREE_AS_MEM_DISPATCH(dispatch_name, func_name, func_name);`
+
+`(2)` Defines a class named `dispatch_name` of free function call expressions of `func_name` with accessibility via a member function. `dispatch_name` meets the [*ProAccessible*](ProAccessible.md) requirements of types `F`, `C`, and `Os...`, where `F` models concept [`facade`](facade.md), `C` is a tuple element type defined in `typename F::convention_types`, and each type `O` (possibly qualified with *cv ref noex*) in `Os...` is a tuple element type defined in `typename C::overload_types`. The member functions provided by `typename dispatch_name::template accessor<F, C, Os...>` are named `accessibility_func_name`. Let `SELF` be `std::forward<accessor cv ref>(*this)`, effectively equivalent to:
+
+```cpp
+struct dispatch_name {
+  template <class T, class... Args>
+  decltype(auto) operator()(T&& self, Args&&... args)
+      noexcept(noexcept(func_name(std::forward<T>(self), std::forward<Args>(args)...)))
+      requires(requires { func_name(std::forward<T>(self), std::forward<Args>(args)...); }) {
+    return func_name(std::forward<T>(self), std::forward<Args>(args)...);
+  }
+
+  template <class F, class C, class... Os>
+  struct accessor {
+    accessor() = delete;
+  };
+  template <class F, class C, class... Os>
+      requires(sizeof...(Os) > 1u && (std::is_trivial_v<accessor<F, C, Os>> && ...))
+  struct accessor<F, C, Os...> : accessor<F, C, Os>... {
+    using accessor<F, C, Os>::accessibility_func_name ...;
+  };
+  template <class F, class C, class R, class... Args>
+  struct accessor<F, C, R(Args...) cv ref noex> {
+    R accessibility_func_name(Args... args) cv ref noex {
+      return pro::proxy_invoke<C, R(Args...) cv ref noex>(pro::access_proxy<F>(SELF), std::forward<Args>(args)...);
+    }
+  };
+}
+```
+
+## Example
+
+```cpp
+#include <iostream>
+#include <string>
+
+#include "proxy.h"
+
+PRO_DEF_FREE_AS_MEM_DISPATCH(FreeToString, std::to_string, ToString);
+
+struct Stringable : pro::facade_builder
+    ::add_convention<FreeToString, std::string()>
+    ::build {};
+
+int main() {
+  pro::proxy<Stringable> p = pro::make_proxy<Stringable>(123);
+  std::cout << p->ToString() << "\n";  // Prints: "123"
+}
+```
+
+## See Also
+
+- [macro `PRO_DEF_FREE_DISPATCH`](PRO_DEF_FREE_DISPATCH.md)
+- [alias template `basic_facade_builder::add_convention`](basic_facade_builder/add_convention.md)
diff --git a/docs/PRO_DEF_FREE_DISPATCH.md b/docs/PRO_DEF_FREE_DISPATCH.md
index 60d9617..710555e 100644
--- a/docs/PRO_DEF_FREE_DISPATCH.md
+++ b/docs/PRO_DEF_FREE_DISPATCH.md
@@ -39,7 +39,7 @@ struct dispatch_name {
       return pro::proxy_invoke<C, R(Args...) cv ref noex>(pro::access_proxy<F>(SELF), std::forward<Args>(args)...);
     }
   };
-};
+}
 ```
 
 ## Example
@@ -65,4 +65,5 @@ int main() {
 ## See Also
 
 - [macro `PRO_DEF_MEM_DISPATCH`](PRO_DEF_MEM_DISPATCH.md)
+- [macro `PRO_DEF_FREE_AS_MEM_DISPATCH`](PRO_DEF_FREE_AS_MEM_DISPATCH.md)
 - [alias template `basic_facade_builder::add_convention`](basic_facade_builder/add_convention.md)
diff --git a/docs/PRO_DEF_MEM_DISPATCH.md b/docs/PRO_DEF_MEM_DISPATCH.md
index 1857974..8239a84 100644
--- a/docs/PRO_DEF_MEM_DISPATCH.md
+++ b/docs/PRO_DEF_MEM_DISPATCH.md
@@ -42,7 +42,7 @@ struct dispatch_name {
       return pro::proxy_invoke<C, R(Args...) cv ref noex>(pro::access_proxy<F>(SELF), std::forward<Args>(args)...);
     }
   };
-};
+}
 ```
 
 ## Example
diff --git a/docs/PRO_DEF_WEAK_DISPATCH.md b/docs/PRO_DEF_WEAK_DISPATCH.md
index cc16606..72b03e4 100644
--- a/docs/PRO_DEF_WEAK_DISPATCH.md
+++ b/docs/PRO_DEF_WEAK_DISPATCH.md
@@ -21,7 +21,7 @@ struct dispatch_name : existing_dispatch {
       requires(requires { default_func_name(std::forward<Args>(args)...); }) {
     return default_func_name(std::forward<Args>(args)...);
   }
-};
+}
 ```
 
 ## Notes
diff --git a/docs/ProBasicReflection.md b/docs/ProBasicReflection.md
new file mode 100644
index 0000000..17e785e
--- /dev/null
+++ b/docs/ProBasicReflection.md
@@ -0,0 +1,13 @@
+# Named requirements: *ProBasicReflection*
+
+A type `R` meets the *ProBasicReflection* requirements if the following expressions are well-formed and have the specified semantics.
+
+| Expressions                  | Semantics                                                    |
+| ---------------------------- | ------------------------------------------------------------ |
+| `R::is_direct`               | A [core constant expression](https://en.cppreference.com/w/cpp/language/constant_expression) of type `bool`, specifying whether the reflection applies to a pointer type itself (`true`), or the element type of a pointer type (`false`). |
+| `typename R::reflector_type` | A [trivial type](https://en.cppreference.com/w/cpp/named_req/TrivialType) that defines the data structure reflected from the type. |
+
+## See Also
+
+- [*ProBasicFacade* requirements](ProBasicFacade.md)
+- [*ProReflection* requirements](ProReflection.md)
diff --git a/docs/ProReflection.md b/docs/ProReflection.md
index b8f0af6..dc75fb5 100644
--- a/docs/ProReflection.md
+++ b/docs/ProReflection.md
@@ -1,10 +1,10 @@
 # Named requirements: *ProReflection*
 
-A type `R` meets the *ProReflection* requirements of a type `P` if the following expressions are well-formed and have the specified semantics.
+A type `R` meets the *ProReflection* requirements of a type `P` if `R` meets the [*ProBasicReflection* requirements](ProBasicReflection.md), and the following expressions are well-formed and have the specified semantics (let `T` be `P` when `R::is_direct` is `true`, or otherwise `typename std::pointer_traits<P>::element_type`).
 
-| Expressions                | Semantics                                                    |
-| -------------------------- | ------------------------------------------------------------ |
-| `R{std::in_place_type<P>}` | A [core constant expression](https://en.cppreference.com/w/cpp/language/constant_expression) that constructs a value of type `R`, reflecting implementation-defined metadata of type `P`. |
+| Expressions                                         | Semantics                                                    |
+| --------------------------------------------------- | ------------------------------------------------------------ |
+| `typename R::reflector_type{std::in_place_type<T>}` | A [core constant expression](https://en.cppreference.com/w/cpp/language/constant_expression) that constructs a value of type `typename R::reflector_type`, reflecting implementation-defined metadata of type `T`. |
 
 ## See Also
 
diff --git a/docs/basic_facade_builder.md b/docs/basic_facade_builder.md
index 5bbd1fd..d080ec9 100644
--- a/docs/basic_facade_builder.md
+++ b/docs/basic_facade_builder.md
@@ -36,7 +36,7 @@ using facade_builder = basic_facade_builder<std::tuple<>, std::tuple<>,
 | Name                                                         | Description                                                  |
 | ------------------------------------------------------------ | ------------------------------------------------------------ |
 | [`add_convention`<br />`add_indirect_convention`<br />`add_direct_convention`](basic_facade_builder/add_convention.md) | Adds a convention to the template parameters                 |
-| [`add_reflection`](basic_facade_builder/add_reflection.md)   | Adds a reflection to the template parameters                 |
+| [`add_reflection`<br />`add_indirect_reflection`<br />`add_direct_reflection`](basic_facade_builder/add_reflection.md) | Adds a reflection to the template parameters                 |
 | [`add_facade`](basic_facade_builder/add_facade.md)           | Adds a facade to the template parameters                     |
 | [`restrict_layout`](basic_facade_builder/restrict_layout.md) | Specifies maximum `max_size` and `max_align` of `C` in the template parameters |
 | [`support_copy`](basic_facade_builder/support_copy.md)       | Specifies minimum `copyability` of `C` in the template parameters |
diff --git a/docs/basic_facade_builder/add_convention.md b/docs/basic_facade_builder/add_convention.md
index 7e66f8c..afecaa6 100644
--- a/docs/basic_facade_builder/add_convention.md
+++ b/docs/basic_facade_builder/add_convention.md
@@ -18,12 +18,12 @@ The alias templates `add_convention`, `add_indirect_convention`, and `add_direct
   - `IC::is_direct` is `false`.
   - `typename IC::dispatch_type` is `D`.
   - `typename IC::overload_types` is a [tuple-like](https://en.cppreference.com/w/cpp/utility/tuple/tuple-like) type of distinct types in `Os`.
-  - `typename IC::template accessor<F>` is `typename D::template accessor<F, IC, Os...>`.
+  - `typename IC::template accessor<F>` is `typename D::template accessor<F, IC, Os...>` if applicable.
 - `add_direct_convention` merges an implementation-defined convention type `IC` into `Cs`, where:
   - `IC::is_direct` is `true`.
   - `typename IC::dispatch_type` is `D`.
   - `typename IC::overload_types` is a [tuple-like](https://en.cppreference.com/w/cpp/utility/tuple/tuple-like) type of distinct types in `Os`.
-  - `typename IC::template accessor<F>` is `typename D::template accessor<F, IC, Os...>`.
+  - `typename IC::template accessor<F>` is `typename D::template accessor<F, IC, Os...>` if applicable.
 
 When `Cs` already contains a convention type `IC2` where `IC2::is_direct == IC::is_direct && std::is_same_v<typename IC2::dispatch_type, typename IC::dispatch_type>` is `true`, `Os` merges with `typename IC2::overload_types` and removes duplicates, and `std::tuple_size_v<Cs>` shall not change.
 
diff --git a/docs/basic_facade_builder/add_reflection.md b/docs/basic_facade_builder/add_reflection.md
index 9ac03a5..df2ae0e 100644
--- a/docs/basic_facade_builder/add_reflection.md
+++ b/docs/basic_facade_builder/add_reflection.md
@@ -2,14 +2,32 @@
 
 ```cpp
 template <class R>
-using add_reflection = basic_facade_builder</* see below */>;
+using add_reflection = add_indirect_reflection<R>;
+
+template <class R>
+using add_indirect_reflection = basic_facade_builder</* see below */>;
+
+template <class R>
+using add_direct_reflection = basic_facade_builder</* see below */>;
 ```
 
-The alias template `add_reflection` of `basic_facade_builder<Cs, Rs, C>` incorporates reflection types (see [named requirements: *ProReflection*](../ProReflection.md)) into the template parameters. It merges `R` into `Rs` if `Rs` does not already contain `R`.
+The alias templates `add_reflection`, `add_indirect_reflection` and `add_direct_reflection` of `basic_facade_builder<Cs, Rs, C>` add reflection types to the template parameters. Specifically,
+
+- `add_reflection` is equivalent to `add_indirect_reflection`.
+- `add_indirect_reflection` merges an implementation-defined reflection type `R2` into `Rs`, where:
+  - `R2::is_direct` is `false`.
+  - `typename R2::reflector_type` is `R`.
+  - `typename R2::template accessor<F>` is `typename R2::template accessor<F, R2>` if applicable.
+- `add_direct_reflection` merges an implementation-defined reflection type `R2` into `Rs`, where:
+  - `R2::is_direct` is `true`.
+  - `typename R2::reflector_type` is `R`.
+  - `typename R2::template accessor<F>` is `typename R2::template accessor<F, R2>` if applicable.
+
+When `Rs` already contains `R2`, the template parameters shall not change.
 
 ## Notes
 
-Adding duplicate reflection types is well-defined, whether done directly via `add_reflection` or indirectly via [`add_facade`](add_facade.md). This process does not affect the behavior of [`build`](build.md) at either compile-time or runtime.
+Adding duplicate reflection types is well-defined, whether done directly via `add_reflection`, `add_indirect_reflection`, `add_direct_reflection`, or indirectly via [`add_facade`](add_facade.md). This process does not affect the behavior of [`build`](build.md) at either compile-time or runtime.
 
 ## Example
 
@@ -19,36 +37,33 @@ Adding duplicate reflection types is well-defined, whether done directly via `ad
 
 #include "proxy.h"
 
-class DebugReflection {
+class RttiReflector {
  public:
-  template <class P>
-  constexpr explicit DebugReflection(std::in_place_type_t<P>)
-      : pointer_type_(typeid(P)),
-        element_type_(typeid(typename std::pointer_traits<P>::element_type)) {}
+  template <class T>
+  constexpr explicit RttiReflector(std::in_place_type_t<T>) : type_(typeid(T)) {}
 
-  void PrintDebugInfo() const {
-    std::cout << "Pointer type: " << pointer_type_.name() << "\n";
-    std::cout << "Element type: " << element_type_.name() << "\n";
-  }
+  template <class F, class R>
+  struct accessor {
+    const char* GetTypeName() const noexcept {
+      const RttiReflector& self = pro::proxy_reflect<R>(pro::access_proxy<F>(*this));
+      return self.type_.name();
+    }
+  };
 
  private:
-  const std::type_info& pointer_type_;
-  const std::type_info& element_type_;
+  const std::type_info& type_;
 };
 
-struct TestFacade : pro::facade_builder
-    ::add_reflection<DebugReflection>
+struct RttiAware : pro::facade_builder
+    ::add_direct_reflection<RttiReflector>
+    ::add_indirect_reflection<RttiReflector>
     ::build {};
 
 int main() {
-  pro::proxy<TestFacade> p1 = std::make_shared<int>(123);
-  pro::proxy_reflect<DebugReflection>(p1).PrintDebugInfo();  // Prints: "Pointer type: St10shared_ptrIiE"
-                                                             //         "Element type: i" (assuming GCC)
-
-  double v = 3.14;
-  pro::proxy<TestFacade> p2 = &v;
-  pro::proxy_reflect<DebugReflection>(p2).PrintDebugInfo();  // Prints: "Pointer type: Pd"
-                                                             //         "Element type: d" (assuming GCC)
+  int a = 123;
+  pro::proxy<RttiAware> p = &a;
+  std::cout << p.GetTypeName() << "\n";  // Prints: "Pi" (assuming GCC)
+  std::cout << p->GetTypeName() << "\n";  // Prints: "i" (assuming GCC)
 }
 ```
 
diff --git a/docs/proxy.md b/docs/proxy.md
index 71805ef..5fd85c7 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -7,7 +7,7 @@ class proxy;
 
 Class template `proxy` is a general-purpose polymorphic wrapper for C++ objects. Unlike other polymorphic wrappers in the C++ standard (e.g., [`std::function`](https://en.cppreference.com/w/cpp/utility/functional/function), [`std::move_only_function`](https://en.cppreference.com/w/cpp/utility/functional/move_only_function), [`std::any`](https://en.cppreference.com/w/cpp/utility/any), etc.), `proxy` is based on pointer semantics. It supports flexible lifetime management without runtime [garbage collection (GC)](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)) at runtime, and offers best-in-class code generation quality, extendibility and accessibility.
 
-To instantiate `proxy<F>`, `F` shall model [concept `facade`](facade.md). As per `facade<F>`, `typename F::convention_types` shall be a [tuple-like](https://en.cppreference.com/w/cpp/utility/tuple/tuple-like) type containing any number of distinct types `Cs`. For each type `C` in `Cs`, if `C` meets the [*ProAccessible* requirements](ProAccessible.md) of `F`, `typename C::template accessor<F>` is inherited by `proxy<F>` when `C::is_direct` is `true`. Otherwise, it is inherited by the return type of [`operator*`](proxy/indirection.md) when `C::is_direct` is `false`. Implementation of accessors can call [`access_proxy`](access_proxy.md) to access the `proxy` object. It is recommended to use [`facade_builder`](basic_facade_builder.md) to define a facade type.
+To instantiate `proxy<F>`, `F` shall model [concept `facade`](facade.md). As per `facade<F>`, `typename F::convention_types` shall be a [tuple-like](https://en.cppreference.com/w/cpp/utility/tuple/tuple-like) type containing any number of distinct types `Cs`, and `typename F::reflection_types` shall be a [tuple-like](https://en.cppreference.com/w/cpp/utility/tuple/tuple-like) type containing any number of distinct types `Rs`. For each type `T` in `Cs` or `Rs`, if `T` meets the [*ProAccessible* requirements](ProAccessible.md) of `F`, `typename T::template accessor<F>` is inherited by `proxy<F>` when `T::is_direct` is `true`. Otherwise, it is inherited by the return type of [`operator*`](proxy/indirection.md) when `T::is_direct` is `false`. Implementation of accessors can call [`access_proxy`](access_proxy.md) to access the `proxy` object. It is recommended to use [`facade_builder`](basic_facade_builder.md) to define a facade type.
 
 Any instance of `proxy<F>` at any given point in time either *contains a value* or *does not contain a value*. If a `proxy<F>` *contains a value*, the type of the value shall be a pointer type `P`  where [`proxiable<P, F>`](proxiable.md) is `true`, and the value is guaranteed to be allocated as part of the `proxy` object footprint, i.e. no dynamic memory allocation occurs. However, `P` may allocate during its construction, depending on its implementation.
 
diff --git a/docs/proxy_reflect.md b/docs/proxy_reflect.md
index b94a6f5..5e84808 100644
--- a/docs/proxy_reflect.md
+++ b/docs/proxy_reflect.md
@@ -2,10 +2,10 @@
 
 ```cpp
 template <class R, class F>
-const R& proxy_reflect(const proxy<F>& p) noexcept;
+/* see below */ proxy_reflect(const proxy<F>& p) noexcept;
 ```
 
-Retrieves a value of type `R` constructed from [`std::in_place_type<P>`](https://en.cppreference.com/w/cpp/utility/in_place), where `P` is the type of the contained value of `p`. `R` is required to be defined in `typename F::reflection_types`. The behavior is undefined if `p` does not contain a value.
+Let `P` be the type of the contained value of `p`. Retrieves a value of type `const typename R::reflector_type&` constructed from [`std::in_place_type<T>`](https://en.cppreference.com/w/cpp/utility/in_place), where `T` is `P` when `R::is_direct` is `true`, or otherwise `T` is `typename std::pointer_traits<P>::element_type` when `R::is_direct` is `false`. `R` is required to be defined in `typename F::reflection_types`. The behavior is undefined if `p` does not contain a value.
 
 The reference obtained from `proxy_reflect()` may be invalidated if `p` is subsequently modified.
 
@@ -22,24 +22,34 @@ This function is useful when only metadata deduced from a type is needed. While
 
 #include "proxy.h"
 
-struct TraitsRefl {
-  template <class P>
-  constexpr explicit TraitsRefl(std::in_place_type_t<P>)
-      : Copyable(std::is_copy_constructible_v<P>) {}
-
-  const bool Copyable;
+class CopyabilityReflector {
+ public:
+  template <class T>
+  constexpr explicit CopyabilityReflector(std::in_place_type_t<T>)
+      : copyable_(std::is_copy_constructible_v<T>) {}
+
+  template <class F, class R>
+  struct accessor {
+    bool IsCopyable() const noexcept {
+      const CopyabilityReflector& self = pro::proxy_reflect<R>(pro::access_proxy<F>(*this));
+      return self.copyable_;
+    }
+  };
+
+ private:
+  bool copyable_;
 };
 
-struct TestFacade : pro::facade_builder
-    ::add_reflection<TraitsRefl>
+struct CopyabilityAware : pro::facade_builder
+    ::add_direct_reflection<CopyabilityReflector>
     ::build {};
 
 int main() {
-  pro::proxy<TestFacade> p1 = std::make_unique<int>();
-  std::cout << std::boolalpha << pro::proxy_reflect<TraitsRefl>(p1).Copyable << "\n";  // Prints: "false"
+  pro::proxy<CopyabilityAware> p1 = std::make_unique<int>();
+  std::cout << std::boolalpha << p1.IsCopyable() << "\n";  // Prints: "false"
 
-  pro::proxy<TestFacade> p2 = std::make_shared<int>();
-  std::cout << pro::proxy_reflect<TraitsRefl>(p2).Copyable << "\n";  // Prints: "true"
+  pro::proxy<CopyabilityAware> p2 = std::make_shared<int>();
+  std::cout << p2.IsCopyable() << "\n";  // Prints: "true"
 }
 ```
 
diff --git a/docs/specifications.md b/docs/specifications.md
index 4795d8d..8224fa9 100644
--- a/docs/specifications.md
+++ b/docs/specifications.md
@@ -34,12 +34,13 @@ This document provides the API specifications for the C++ library Proxy (version
 
 ## Macros
 
-| Name                                                | Description                                                  |
-| --------------------------------------------------- | ------------------------------------------------------------ |
-| [`PRO_DEF_MEM_DISPATCH`](PRO_DEF_MEM_DISPATCH.md)   | Defines a dispatch type for member function call expressions with accessibility |
-| [`PRO_DEF_FREE_DISPATCH`](PRO_DEF_FREE_DISPATCH.md) | Defines a dispatch type for free function call expressions with accessibility |
-| [`PRO_DEF_WEAK_DISPATCH`](PRO_DEF_WEAK_DISPATCH.md) | Defines a weak dispatch type with a default implementation   |
-| [`__msft_lib_proxy`](msft_lib_proxy.md)             | Feature test macro                                           |
+| Name                                                         | Description                                                  |
+| ------------------------------------------------------------ | ------------------------------------------------------------ |
+| [`PRO_DEF_MEM_DISPATCH`](PRO_DEF_MEM_DISPATCH.md)            | Defines a dispatch type for member function call expressions with accessibility |
+| [`PRO_DEF_FREE_DISPATCH`](PRO_DEF_FREE_DISPATCH.md)          | Defines a dispatch type for free function call expressions with accessibility |
+| [`PRO_DEF_FREE_AS_MEM_DISPATCH`](PRO_DEF_FREE_AS_MEM_DISPATCH.md) | Defines a dispatch type for free function call expressions with accessibility via a member function |
+| [`PRO_DEF_WEAK_DISPATCH`](PRO_DEF_WEAK_DISPATCH.md)          | Defines a weak dispatch type with a default implementation   |
+| [`__msft_lib_proxy`](msft_lib_proxy.md)                      | Feature test macro                                           |
 
 ## Named Requirements
 
@@ -47,6 +48,7 @@ This document provides the API specifications for the C++ library Proxy (version
 | --------------------------------------------- | ------------------------------------------------------------ |
 | [*ProBasicFacade*](ProBasicFacade.md)         | Specifies that a type potentially models a "facade" of `proxy` |
 | [*ProBasicConvention*](ProBasicConvention.md) | Specifies that a type potentially models a "convention"      |
+| [*ProBasicReflection*](ProBasicReflection.md) | Specifies that a type potentially models a "reflection"      |
 | [*ProFacade*](ProFacade.md)                   | Specifies that a type models a "facade" of `proxy`           |
 | [*ProConvention*](ProConvention.md)           | Specifies that a type models a "convention"                  |
 | [*ProReflection*](ProReflection.md)           | Specifies that a type models a "reflection"                  |
diff --git a/proxy.h b/proxy.h
index 099c8ad..16ef19c 100644
--- a/proxy.h
+++ b/proxy.h
@@ -333,10 +333,10 @@ template <class... Ms>
 using composite_meta =
     recursive_reduction_t<meta_reduction_t, composite_meta_impl<>, Ms...>;
 
-template <class C>
-consteval bool is_conv_is_direct_well_formed() {
-  if constexpr (requires { { C::is_direct } -> std::same_as<const bool&>; }) {
-    if constexpr (is_consteval([] { return C::is_direct; })) {
+template <class T>
+consteval bool is_is_direct_well_formed() {
+  if constexpr (requires { { T::is_direct } -> std::same_as<const bool&>; }) {
+    if constexpr (is_consteval([] { return T::is_direct; })) {
       return true;
     }
   }
@@ -363,12 +363,49 @@ template <class C>
           typename C::dispatch_type;
           typename C::overload_types;
         } &&
-        is_conv_is_direct_well_formed<C>() &&
+        is_is_direct_well_formed<C>() &&
         std::is_trivial_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 <class P>
+using ptr_element_t = typename std::pointer_traits<P>::element_type;
+template <class R>
+struct refl_meta {
+  template <class P> requires(R::is_direct)
+  constexpr explicit refl_meta(std::in_place_type_t<P>)
+      : reflector(std::in_place_type<P>) {}
+  template <class P> requires(!R::is_direct)
+  constexpr explicit refl_meta(std::in_place_type_t<P>)
+      : reflector(std::in_place_type<ptr_element_t<P>>) {}
+
+  typename R::reflector_type reflector;
+};
+
+template <class R, class T, bool IS_DIRECT>
+consteval bool is_reflector_well_formed() {
+  if constexpr (IS_DIRECT) {
+    if constexpr (std::is_constructible_v<R, std::in_place_type_t<T>>) {
+      if constexpr (is_consteval([] { return R{std::in_place_type<T>}; })) {
+        return true;
+      }
+    }
+  } else if constexpr (requires { typename ptr_element_t<T>; }) {
+    return is_reflector_well_formed<R, ptr_element_t<T>, true>();
+  }
+  return false;
+}
+template <class R> struct refl_traits : inapplicable_traits {};
+template <class R>
+    requires(requires { typename R::reflector_type; } &&
+        is_is_direct_well_formed<R>())
+struct refl_traits<R> : applicable_traits {
+  template <class P>
+  static constexpr bool applicable_ptr =
+      is_reflector_well_formed<typename R::reflector_type, P, R::is_direct>();
+};
+
 template <bool NE>
 struct copyability_meta_provider {
   template <class P>
@@ -423,25 +460,42 @@ class ___PRO_ENFORCE_EBO composite_accessor_impl : public As... {
       = default;
 };
 
-template <template <class> class TA, class O, class I>
+template <class SFINAE, class T, class... Args>
+struct sfinae_accessor_traits : std::type_identity<void> {};
+template <class T, class... Args>
+struct sfinae_accessor_traits<
+    std::void_t<typename T::template accessor<Args...>>, T, Args...>
+    : std::type_identity<typename T::template accessor<Args...>> {};
+template <class T, class... Args>
+using accessor_t = typename sfinae_accessor_traits<void, T, Args...>::type;
+
+template <bool IS_DIRECT, class F, class O, class I>
 struct composite_accessor_reduction : std::type_identity<O> {};
-template <template <class> class TA, class... As, class I>
-    requires(requires { typename TA<I>; } && std::is_trivial_v<TA<I>> &&
-        !std::is_final_v<TA<I>>)
-struct composite_accessor_reduction<TA, composite_accessor_impl<As...>, I>
-    { using type = composite_accessor_impl<As..., TA<I>>; };
+template <bool IS_DIRECT, class F, class... As, class I>
+    requires(IS_DIRECT == I::is_direct && std::is_trivial_v<accessor_t<I, F>> &&
+        !std::is_final_v<accessor_t<I, F>>)
+struct composite_accessor_reduction<
+    IS_DIRECT, F, composite_accessor_impl<As...>, I>
+    { using type = composite_accessor_impl<As..., accessor_t<I, F>>; };
 template <bool IS_DIRECT, class F>
 struct composite_accessor_helper {
-  template <class C> requires(C::is_direct == IS_DIRECT)
-  using single_accessor = typename C::template accessor<F>;
   template <class O, class I>
   using reduction_t =
-      typename composite_accessor_reduction<single_accessor, O, I>::type;
+      typename composite_accessor_reduction<IS_DIRECT, F, O, I>::type;
 };
-template <bool IS_DIRECT, class F, class... Cs>
+template <bool IS_DIRECT, class F, class... Ts>
 using composite_accessor = recursive_reduction_t<
       composite_accessor_helper<IS_DIRECT, F>::template reduction_t,
-      composite_accessor_impl<>, Cs...>;
+      composite_accessor_impl<>, Ts...>;
+
+template <class A1, class A2> struct composite_accessor_merge_traits;
+template <class... A1, class... A2>
+struct composite_accessor_merge_traits<
+    composite_accessor_impl<A1...>, composite_accessor_impl<A2...>>
+    : std::type_identity<composite_accessor_impl<A1..., A2...>> {};
+template <class A1, class A2>
+using merged_composite_accessor =
+    typename composite_accessor_merge_traits<A1, A2>::type;
 
 template <class F>
 consteval bool is_facade_constraints_well_formed() {
@@ -454,25 +508,14 @@ consteval bool is_facade_constraints_well_formed() {
   }
   return false;
 }
-template <class R, class P>
-consteval bool is_reflection_type_well_formed() {
-  if constexpr (std::is_constructible_v<R, std::in_place_type_t<P>>) {
-    if constexpr (is_consteval([] { return R{std::in_place_type<P>}; })) {
-      return true;
-    }
-  }
-  return false;
-}
 struct empty_proxy_base {};
 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 indirect_accessor = composite_accessor<false, F, Cs...>;
-  using direct_accessor = composite_accessor<true, F, Cs...>;
-  using base = std::conditional_t<std::is_same_v<direct_accessor,
-      composite_accessor_impl<>>, empty_proxy_base, direct_accessor>;
+  using conv_indirect_accessor = composite_accessor<false, F, Cs...>;
+  using conv_direct_accessor = composite_accessor<true, F, Cs...>;
 
   template <class P>
   static constexpr bool conv_applicable_ptr =
@@ -480,11 +523,13 @@ struct facade_conv_traits_impl<F, Cs...> : applicable_traits {
 };
 template <class F, class... Rs>
 struct facade_refl_traits_impl {
-  using refl_meta = composite_meta<Rs...>;
+  using refl_meta = composite_meta<details::refl_meta<Rs>...>;
+  using refl_indirect_accessor = composite_accessor<false, F, Rs...>;
+  using refl_direct_accessor = composite_accessor<true, F, Rs...>;
 
   template <class P>
   static constexpr bool refl_applicable_ptr =
-      (is_reflection_type_well_formed<Rs, P>() && ...);
+      (refl_traits<Rs>::template applicable_ptr<P> && ...);
 };
 template <class F> struct facade_traits : inapplicable_traits {};
 template <class F>
@@ -512,6 +557,14 @@ struct facade_traits<F>
   using meta = composite_meta<copyability_meta, relocatability_meta,
       destructibility_meta, typename facade_traits::conv_meta,
       typename facade_traits::refl_meta>;
+  using indirect_accessor = merged_composite_accessor<
+      typename facade_traits::conv_indirect_accessor,
+      typename facade_traits::refl_indirect_accessor>;
+  using direct_accessor = merged_composite_accessor<
+      typename facade_traits::conv_direct_accessor,
+      typename facade_traits::refl_direct_accessor>;
+  using base = std::conditional_t<std::is_same_v<direct_accessor,
+      composite_accessor_impl<>>, empty_proxy_base, direct_accessor>;
   static constexpr bool has_indirection = !std::is_same_v<
       typename facade_traits::indirect_accessor, composite_accessor_impl<>>;
 };
@@ -831,6 +884,12 @@ decltype(auto) proxy_invoke(const proxy<F>&& p, Args&&... args) {
       std::forward<const proxy<F>>(p), std::forward<Args>(args)...);
 }
 
+template <class R, class F>
+const auto& proxy_reflect(const proxy<F>& p) noexcept {
+  return static_cast<const details::refl_meta<R>&>(
+      details::proxy_helper<F>::get_meta(p)).reflector;
+}
+
 template <class F, class A>
 proxy<F>& access_proxy(A& a) noexcept {
   return details::proxy_helper<F>::template access<
@@ -852,10 +911,6 @@ const proxy<F>&& access_proxy(const A&& a) noexcept {
       A, details::qualifier_type::const_rv>(std::forward<const A>(a));
 }
 
-template <class R, class F>
-const R& proxy_reflect(const proxy<F>& p) noexcept
-    { return details::proxy_helper<F>::get_meta(p); }
-
 namespace details {
 
 template <class T>
@@ -1153,7 +1208,14 @@ struct conv_impl {
   using dispatch_type = D;
   using overload_types = std::tuple<Os...>;
   template <class F>
-  using accessor = typename D::template accessor<F, conv_impl, Os...>;
+  using accessor = accessor_t<D, F, conv_impl, Os...>;
+};
+template <bool IS_DIRECT, class R>
+struct refl_impl {
+  static constexpr bool is_direct = IS_DIRECT;
+  using reflector_type = R;
+  template <class F>
+  using accessor = accessor_t<R, F, refl_impl>;
 };
 template <class Cs, class Rs, proxiable_ptr_constraints C>
 struct facade_impl {
@@ -1283,8 +1345,13 @@ struct basic_facade_builder {
           (details::overload_traits<Os>::applicable && ...))
   using add_convention = add_indirect_convention<D, Os...>;
   template <class R>
-  using add_reflection = basic_facade_builder<
-      Cs, details::add_tuple_t<Rs, R>, C>;
+  using add_indirect_reflection = basic_facade_builder<
+      Cs, details::add_tuple_t<Rs, details::refl_impl<false, R>>, C>;
+  template <class R>
+  using add_direct_reflection = basic_facade_builder<
+      Cs, details::add_tuple_t<Rs, details::refl_impl<true, R>>, C>;
+  template <class R>
+  using add_reflection = add_indirect_reflection<R>;
   template <facade F, bool WithUpwardConversion = false>
   using add_facade = basic_facade_builder<
       details::merge_facade_conv_t<Cs, F, WithUpwardConversion>,
diff --git a/samples/PRO_DEF_FREE_AS_MEM_DISPATCH.cpp b/samples/PRO_DEF_FREE_AS_MEM_DISPATCH.cpp
new file mode 100644
index 0000000..c112bd4
--- /dev/null
+++ b/samples/PRO_DEF_FREE_AS_MEM_DISPATCH.cpp
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// This file contains example code from PRO_DEF_FREE_AS_MEM_DISPATCH.md.
+
+#include <iostream>
+#include <string>
+
+#include "proxy.h"
+
+PRO_DEF_FREE_AS_MEM_DISPATCH(FreeToString, std::to_string, ToString);
+
+struct Stringable : pro::facade_builder
+    ::add_convention<FreeToString, std::string()>
+    ::build {};
+
+int main() {
+  pro::proxy<Stringable> p = pro::make_proxy<Stringable>(123);
+  std::cout << p->ToString() << "\n";  // Prints: "123"
+}
diff --git a/samples/basic_facade_builder/add_reflection.cpp b/samples/basic_facade_builder/add_reflection.cpp
index d5b70da..4823729 100644
--- a/samples/basic_facade_builder/add_reflection.cpp
+++ b/samples/basic_facade_builder/add_reflection.cpp
@@ -7,34 +7,31 @@
 
 #include "proxy.h"
 
-class DebugReflection {
+class RttiReflector {
  public:
-  template <class P>
-  constexpr explicit DebugReflection(std::in_place_type_t<P>)
-      : pointer_type_(typeid(P)),
-        element_type_(typeid(typename std::pointer_traits<P>::element_type)) {}
+  template <class T>
+  constexpr explicit RttiReflector(std::in_place_type_t<T>) : type_(typeid(T)) {}
 
-  void PrintDebugInfo() const {
-    std::cout << "Pointer type: " << pointer_type_.name() << "\n";
-    std::cout << "Element type: " << element_type_.name() << "\n";
-  }
+  template <class F, class R>
+  struct accessor {
+    const char* GetTypeName() const noexcept {
+      const RttiReflector& self = pro::proxy_reflect<R>(pro::access_proxy<F>(*this));
+      return self.type_.name();
+    }
+  };
 
  private:
-  const std::type_info& pointer_type_;
-  const std::type_info& element_type_;
+  const std::type_info& type_;
 };
 
-struct TestFacade : pro::facade_builder
-    ::add_reflection<DebugReflection>
+struct RttiAware : pro::facade_builder
+    ::add_direct_reflection<RttiReflector>
+    ::add_indirect_reflection<RttiReflector>
     ::build {};
 
 int main() {
-  pro::proxy<TestFacade> p1 = std::make_shared<int>(123);
-  pro::proxy_reflect<DebugReflection>(p1).PrintDebugInfo();  // Prints: "Pointer type: St10shared_ptrIiE"
-                                                             //         "Element type: i" (assuming GCC)
-
-  double v = 3.14;
-  pro::proxy<TestFacade> p2 = &v;
-  pro::proxy_reflect<DebugReflection>(p2).PrintDebugInfo();  // Prints: "Pointer type: Pd"
-                                                             //         "Element type: d" (assuming GCC)
+  int a = 123;
+  pro::proxy<RttiAware> p = &a;
+  std::cout << p.GetTypeName() << "\n";  // Prints: "Pi" (assuming GCC)
+  std::cout << p->GetTypeName() << "\n";  // Prints: "i" (assuming GCC)
 }
diff --git a/samples/proxy_reflect.cpp b/samples/proxy_reflect.cpp
index 04f844f..1f17e4c 100644
--- a/samples/proxy_reflect.cpp
+++ b/samples/proxy_reflect.cpp
@@ -8,22 +8,32 @@
 
 #include "proxy.h"
 
-struct TraitsRefl {
-  template <class P>
-  constexpr explicit TraitsRefl(std::in_place_type_t<P>)
-      : Copyable(std::is_copy_constructible_v<P>) {}
+class CopyabilityReflector {
+ public:
+  template <class T>
+  constexpr explicit CopyabilityReflector(std::in_place_type_t<T>)
+      : copyable_(std::is_copy_constructible_v<T>) {}
 
-  const bool Copyable;
+  template <class F, class R>
+  struct accessor {
+    bool IsCopyable() const noexcept {
+      const CopyabilityReflector& self = pro::proxy_reflect<R>(pro::access_proxy<F>(*this));
+      return self.copyable_;
+    }
+  };
+
+ private:
+  bool copyable_;
 };
 
-struct TestFacade : pro::facade_builder
-    ::add_reflection<TraitsRefl>
+struct CopyabilityAware : pro::facade_builder
+    ::add_direct_reflection<CopyabilityReflector>
     ::build {};
 
 int main() {
-  pro::proxy<TestFacade> p1 = std::make_unique<int>();
-  std::cout << std::boolalpha << pro::proxy_reflect<TraitsRefl>(p1).Copyable << "\n";  // Prints: "false"
+  pro::proxy<CopyabilityAware> p1 = std::make_unique<int>();
+  std::cout << std::boolalpha << p1.IsCopyable() << "\n";  // Prints: "false"
 
-  pro::proxy<TestFacade> p2 = std::make_shared<int>();
-  std::cout << pro::proxy_reflect<TraitsRefl>(p2).Copyable << "\n";  // Prints: "true"
+  pro::proxy<CopyabilityAware> p2 = std::make_shared<int>();
+  std::cout << p2.IsCopyable() << "\n";  // Prints: "true"
 }
diff --git a/tests/proxy_creation_tests.cpp b/tests/proxy_creation_tests.cpp
index a7d2d59..b16b9f8 100644
--- a/tests/proxy_creation_tests.cpp
+++ b/tests/proxy_creation_tests.cpp
@@ -8,18 +8,25 @@
 
 namespace {
 
-struct SboObserver {
+struct SboReflector {
  public:
   template <class T>
-  constexpr explicit SboObserver(std::in_place_type_t<pro::details::inplace_ptr<T>>)
+  constexpr explicit SboReflector(std::in_place_type_t<pro::details::inplace_ptr<T>>)
       : SboEnabled(true), AllocatorAllocatesForItself(false) {}
   template <class T, class Alloc>
-  constexpr explicit SboObserver(std::in_place_type_t<pro::details::allocated_ptr<T, Alloc>>)
+  constexpr explicit SboReflector(std::in_place_type_t<pro::details::allocated_ptr<T, Alloc>>)
       : SboEnabled(false), AllocatorAllocatesForItself(false) {}
   template <class T, class Alloc>
-  constexpr explicit SboObserver(std::in_place_type_t<pro::details::compact_ptr<T, Alloc>>)
+  constexpr explicit SboReflector(std::in_place_type_t<pro::details::compact_ptr<T, Alloc>>)
       : SboEnabled(false), AllocatorAllocatesForItself(true) {}
 
+  template <class F, class R>
+  struct accessor {
+    const SboReflector& ReflectSbo() const noexcept {
+      return pro::proxy_reflect<R>(pro::access_proxy<F>(*this));
+    }
+  };
+
   bool SboEnabled;
   bool AllocatorAllocatesForItself;
 };
@@ -30,7 +37,7 @@ struct TestLargeStringable : pro::facade_builder
     ::add_convention<utils::spec::FreeToString, std::string()>
     ::support_relocation<pro::constraint_level::nontrivial>
     ::support_copy<pro::constraint_level::nontrivial>
-    ::add_reflection<SboObserver>
+    ::add_direct_reflection<SboReflector>
     ::build {};
 
 struct TestSmallStringable : pro::facade_builder
@@ -100,7 +107,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_FromValue) {
     auto p = pro::make_proxy_inplace<spec::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -115,7 +122,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_InPlace) {
     auto p = pro::make_proxy_inplace<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -130,7 +137,7 @@ 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(ToString(*p), "Session 1");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -147,10 +154,10 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
+    ASSERT_TRUE(p1.ReflectSbo().SboEnabled);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_TRUE(p2.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -169,7 +176,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_TRUE(p2.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -187,8 +194,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_FromValue) {
     auto p = pro::allocate_proxy<spec::TestSmallStringable>(std::allocator<void>{}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -203,8 +210,8 @@ 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(ToString(*p), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -219,8 +226,8 @@ 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(ToString(*p), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -237,12 +244,12 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p1.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p1.ReflectSbo().AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p2.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p2.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -261,8 +268,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p2.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p2.ReflectSbo().AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -279,8 +286,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_FromValue) {
     auto p = pro::allocate_proxy<spec::TestSmallStringable>(std::pmr::polymorphic_allocator<>{&memory_pool}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -296,8 +303,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_InPlace) {
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -313,8 +320,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_InPlaceInitializerL
     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(ToString(*p), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -332,12 +339,12 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p1).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p1.ReflectSbo().SboEnabled);
+    ASSERT_TRUE(p1.ReflectSbo().AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p2.ReflectSbo().SboEnabled);
+    ASSERT_TRUE(p2.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -357,8 +364,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p2.ReflectSbo().SboEnabled);
+    ASSERT_TRUE(p2.ReflectSbo().AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -374,7 +381,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_FromValue) {
     auto p = pro::make_proxy<spec::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -389,7 +396,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlace) {
     auto p = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -404,7 +411,7 @@ 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(ToString(*p), "Session 1");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(p.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -421,10 +428,10 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
+    ASSERT_TRUE(p1.ReflectSbo().SboEnabled);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_TRUE(p2.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -443,7 +450,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_TRUE(p2.ReflectSbo().SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -461,8 +468,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_FromValue) {
     auto p = pro::make_proxy<spec::TestSmallStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 2");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -477,8 +484,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlace) {
     auto p = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(*p), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -493,8 +500,8 @@ 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(ToString(*p), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -511,12 +518,12 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p1.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p1.ReflectSbo().AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p2.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p2.ReflectSbo().AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -535,8 +542,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 1");
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
-    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
+    ASSERT_FALSE(p2.ReflectSbo().SboEnabled);
+    ASSERT_FALSE(p2.ReflectSbo().AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
diff --git a/tests/proxy_lifetime_tests.cpp b/tests/proxy_lifetime_tests.cpp
index 8351c3c..e2a953e 100644
--- a/tests/proxy_lifetime_tests.cpp
+++ b/tests/proxy_lifetime_tests.cpp
@@ -22,7 +22,7 @@ struct TestTrivialFacade : pro::facade_builder
     ::build {};
 
 struct TestRttiFacade : pro::facade_builder
-    ::add_reflection<utils::RttiReflection>
+    ::add_direct_reflection<utils::RttiReflector>
     ::add_facade<TestFacade, true>
     ::build {};
 
@@ -1038,7 +1038,7 @@ TEST(ProxyLifetimeTests, Test_UpwardCopyConvension_FromValue) {
     pro::proxy<TestFacade> p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(*p1), "Session 1");
-    ASSERT_STREQ(pro::proxy_reflect<utils::RttiReflection>(p1).GetName(), typeid(utils::LifetimeTracker::Session).name());
+    ASSERT_STREQ(p1.GetTypeName(), typeid(utils::LifetimeTracker::Session).name());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(*p2), "Session 2");
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
diff --git a/tests/proxy_reflection_tests.cpp b/tests/proxy_reflection_tests.cpp
index 34a5fc0..2a30da0 100644
--- a/tests/proxy_reflection_tests.cpp
+++ b/tests/proxy_reflection_tests.cpp
@@ -9,15 +9,22 @@
 
 namespace {
 
-struct TraitsReflection {
+struct TraitsReflector {
  public:
-  template <class P>
-  constexpr explicit TraitsReflection(std::in_place_type_t<P>)
-      : is_default_constructible_(std::is_default_constructible_v<P>),
-        is_copy_constructible_(std::is_copy_constructible_v<P>),
-        is_nothrow_move_constructible_(std::is_nothrow_move_constructible_v<P>),
-        is_nothrow_destructible_(std::is_nothrow_destructible_v<P>),
-        is_trivial_(std::is_trivial_v<P>) {}
+  template <class T>
+  constexpr explicit TraitsReflector(std::in_place_type_t<T>)
+      : is_default_constructible_(std::is_default_constructible_v<T>),
+        is_copy_constructible_(std::is_copy_constructible_v<T>),
+        is_nothrow_move_constructible_(std::is_nothrow_move_constructible_v<T>),
+        is_nothrow_destructible_(std::is_nothrow_destructible_v<T>),
+        is_trivial_(std::is_trivial_v<T>) {}
+
+  template <class F, class R>
+  struct accessor {
+    const TraitsReflector& ReflectTraits() const noexcept {
+      return pro::proxy_reflect<R>(pro::access_proxy<F>(*this));
+    }
+  };
 
   bool is_default_constructible_;
   bool is_copy_constructible_;
@@ -27,11 +34,12 @@ struct TraitsReflection {
 };
 
 struct TestRttiFacade : pro::facade_builder
-    ::add_reflection<utils::RttiReflection>
+    ::add_reflection<utils::RttiReflector>
+    ::add_direct_reflection<utils::RttiReflector>
     ::build {};
 
 struct TestTraitsFacade : pro::facade_builder
-    ::add_reflection<TraitsReflection>
+    ::add_direct_reflection<TraitsReflector>
     ::build {};
 
 }  // namespace
@@ -39,29 +47,31 @@ struct TestTraitsFacade : pro::facade_builder
 TEST(ProxyReflectionTests, TestRtti_RawPtr) {
   int foo = 123;
   pro::proxy<TestRttiFacade> p = &foo;
-  ASSERT_STREQ(pro::proxy_reflect<utils::RttiReflection>(p).GetName(), typeid(int*).name());
+  ASSERT_STREQ(p.GetTypeName(), typeid(int*).name());
+  ASSERT_STREQ(p->GetTypeName(), typeid(int).name());
 }
 
 TEST(ProxyReflectionTests, TestRtti_FancyPtr) {
   pro::proxy<TestRttiFacade> p = std::make_unique<double>(1.23);
-  ASSERT_STREQ(pro::proxy_reflect<utils::RttiReflection>(p).GetName(), typeid(std::unique_ptr<double>).name());
+  ASSERT_STREQ(p.GetTypeName(), typeid(std::unique_ptr<double>).name());
+  ASSERT_STREQ(p->GetTypeName(), typeid(double).name());
 }
 
 TEST(ProxyReflectionTests, TestTraits_RawPtr) {
   int foo = 123;
   pro::proxy<TestTraitsFacade> p = &foo;
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_default_constructible_, true);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_copy_constructible_, true);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_nothrow_move_constructible_, true);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_nothrow_destructible_, true);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_trivial_, true);
+  ASSERT_EQ(p.ReflectTraits().is_default_constructible_, true);
+  ASSERT_EQ(p.ReflectTraits().is_copy_constructible_, true);
+  ASSERT_EQ(p.ReflectTraits().is_nothrow_move_constructible_, true);
+  ASSERT_EQ(p.ReflectTraits().is_nothrow_destructible_, true);
+  ASSERT_EQ(p.ReflectTraits().is_trivial_, true);
 }
 
 TEST(ProxyReflectionTests, TestTraits_FancyPtr) {
   pro::proxy<TestTraitsFacade> p = std::make_unique<double>(1.23);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_default_constructible_, true);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_copy_constructible_, false);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_nothrow_move_constructible_, true);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_nothrow_destructible_, true);
-  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_trivial_, false);
+  ASSERT_EQ(p.ReflectTraits().is_default_constructible_, true);
+  ASSERT_EQ(p.ReflectTraits().is_copy_constructible_, false);
+  ASSERT_EQ(p.ReflectTraits().is_nothrow_move_constructible_, true);
+  ASSERT_EQ(p.ReflectTraits().is_nothrow_destructible_, true);
+  ASSERT_EQ(p.ReflectTraits().is_trivial_, false);
 }
diff --git a/tests/proxy_traits_tests.cpp b/tests/proxy_traits_tests.cpp
index 6008e09..88689ef 100644
--- a/tests/proxy_traits_tests.cpp
+++ b/tests/proxy_traits_tests.cpp
@@ -159,7 +159,7 @@ struct ReflectionOfSmallPtr {
   constexpr ReflectionOfSmallPtr(std::in_place_type_t<P>) {}
 };
 struct RelocatableFacadeWithReflection : pro::facade_builder
-    ::add_reflection<ReflectionOfSmallPtr>
+    ::add_direct_reflection<ReflectionOfSmallPtr>
     ::build {};
 static_assert(!pro::proxiable<MockMovablePtr, RelocatableFacadeWithReflection>);
 static_assert(!pro::proxiable<MockCopyablePtr, RelocatableFacadeWithReflection>);
diff --git a/tests/utils.h b/tests/utils.h
index d269a1d..c6d6292 100644
--- a/tests/utils.h
+++ b/tests/utils.h
@@ -92,13 +92,18 @@ struct Stringable : pro::facade_builder
 
 }  // namespace spec
 
-class RttiReflection {
+class RttiReflector {
  public:
   template <class T>
-  constexpr explicit RttiReflection(std::in_place_type_t<T>)
-      : type_(typeid(T)) {}
+  constexpr explicit RttiReflector(std::in_place_type_t<T>) : type_(typeid(T)) {}
 
-  const char* GetName() const noexcept { return type_.name(); }
+  template <class F, class R>
+  struct accessor {
+    const char* GetTypeName() const noexcept {
+      const RttiReflector& self = pro::proxy_reflect<R>(pro::access_proxy<F>(*this));
+      return self.type_.name();
+    }
+  };
 
  private:
   const std::type_info& type_;