diff --git a/.github/workflows/bvt-appleclang-arm64e.yml b/.github/workflows/bvt-appleclang-arm64e.yml
new file mode 100644
index 00000000..bb611a79
--- /dev/null
+++ b/.github/workflows/bvt-appleclang-arm64e.yml
@@ -0,0 +1,39 @@
+on:
+  workflow_call:
+  workflow_dispatch:
+
+jobs:
+  bvt-appleclang-arm64e:
+    runs-on: macos-26
+    steps:
+    - uses: actions/checkout@v7
+
+    - name: Check toolchain versions
+      run: |
+        cc --version
+        xcodebuild -version
+        cmake --version
+        ninja --version
+
+    - name: Build and run test with AppleClang (arm64e with PAC) on cmake
+      run: |
+        cmake --preset default -DCMAKE_CXX_STANDARD=23 -DPROXY_BUILD_MODULES=FALSE -DCMAKE_OSX_ARCHITECTURES=arm64e
+        cmake --build --preset default -j
+        ctest --preset default -j
+        mkdir build/cmake/drop
+        bash ./tools/dump_build_env.sh c++ build/cmake/drop/env-info.json
+
+    - name: Build and run freestanding test with AppleClang (arm64e with PAC) on cmake
+      run: |
+        cmake --preset freestanding -DCMAKE_CXX_STANDARD=23 -DPROXY_BUILD_MODULES=FALSE -DCMAKE_OSX_ARCHITECTURES=arm64e
+        cmake --build --preset freestanding -j
+        ctest --preset freestanding -j
+
+    - name: Run benchmarks
+      run: build/cmake/benchmarks/msft_proxy_benchmarks --benchmark_min_warmup_time=0.1 --benchmark_min_time=0.1s --benchmark_repetitions=30 --benchmark_enable_random_interleaving=true --benchmark_report_aggregates_only=true --benchmark_format=json > build/cmake/drop/benchmarking-results.json
+
+    - name: Archive benchmarking results
+      uses: actions/upload-artifact@v7
+      with:
+        name: drop-apple-pac
+        path: build/cmake/drop/
diff --git a/.github/workflows/pipeline-ci.yml b/.github/workflows/pipeline-ci.yml
index f1863b7f..70ea9412 100644
--- a/.github/workflows/pipeline-ci.yml
+++ b/.github/workflows/pipeline-ci.yml
@@ -33,6 +33,10 @@ jobs:
     name: Run BVT with AppleClang
     if: github.event_name != 'push' || github.repository == 'ngcpp/proxy'
 
+  run-bvt-appleclang-arm64e:
+    uses: ./.github/workflows/bvt-appleclang-arm64e.yml
+    name: Run BVT with AppleClang (arm64e with PAC)
+
   run-bvt-nvhpc:
     uses: ./.github/workflows/bvt-nvhpc.yml
     name: Run BVT with NVHPC
@@ -56,4 +60,4 @@ jobs:
   report:
     uses: ./.github/workflows/bvt-report.yml
     name: Generate report
-    needs: [run-bvt-gcc, run-bvt-clang, run-bvt-msvc, run-bvt-appleclang, run-bvt-nvhpc, run-bvt-oneapi]
+    needs: [run-bvt-gcc, run-bvt-clang, run-bvt-msvc, run-bvt-appleclang, run-bvt-appleclang-arm64e, run-bvt-nvhpc, run-bvt-oneapi]
diff --git a/.gitignore b/.gitignore
index 3b200638..e9ff578c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,5 @@
 # Ignore build directories
-build/
+/build*
 Testing/
 
 # Python bytecode cache
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 94d89765..aeac43e6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -120,7 +120,7 @@ if(BUILD_TESTING)
       -Wall
       -Wextra
       -Wpedantic
-      $<$<CXX_COMPILER_ID:Clang>:-Wno-c++2b-extensions>
+      $<$<CXX_COMPILER_ID:Clang,AppleClang>:-Wno-c++2b-extensions>
     )
     set(PROXY_STRICT_WARNING_FLAGS ${PROXY_BUILD_FLAGS} -Werror)
   endif()
diff --git a/docs/spec/basic_facade_builder/build.md b/docs/spec/basic_facade_builder/build.md
index 68d36a1f..4fa34ae2 100644
--- a/docs/spec/basic_facade_builder/build.md
+++ b/docs/spec/basic_facade_builder/build.md
@@ -59,10 +59,8 @@ int main() {
   static_assert(std::is_nothrow_move_constructible_v<pro::proxy<CopyableBase>>);
   static_assert(std::is_nothrow_destructible_v<pro::proxy<CopyableBase>>);
 
-  static_assert(
-      std::is_trivially_copy_constructible_v<pro::proxy<TrivialBase>>);
-  static_assert(
-      std::is_trivially_move_constructible_v<pro::proxy<TrivialBase>>);
+  static_assert(std::is_nothrow_copy_constructible_v<pro::proxy<TrivialBase>>);
+  static_assert(std::is_nothrow_move_constructible_v<pro::proxy<TrivialBase>>);
   static_assert(std::is_trivially_destructible_v<pro::proxy<TrivialBase>>);
 }
 ```
diff --git a/include/proxy/v4/detail/compatibility_check.h b/include/proxy/v4/detail/compatibility_check.h
index 0c06083b..1740b3ae 100644
--- a/include/proxy/v4/detail/compatibility_check.h
+++ b/include/proxy/v4/detail/compatibility_check.h
@@ -25,4 +25,12 @@ static_assert(sizeof(derived) == sizeof(char),
 } // namespace pro::inline v4::detail::compatibility_check
 #endif
 
+#ifdef __has_feature
+#if __has_feature(ptrauth_calls) &&                                            \
+    (!defined(__PTRAUTH__) || !__has_include(<ptrauth.h>))
+#error "The Pointer Authentication feature is incomplete"
+#endif // __has_feature(ptrauth_calls) && (!defined(__PTRAUTH__) ||
+       // !__has_include(<ptrauth.h>))
+#endif // __has_feature
+
 #endif // MSFT_PROXY_V4_DETAIL_COMPATIBILITY_CHECK_H_
diff --git a/include/proxy/v4/detail/core.h b/include/proxy/v4/detail/core.h
index 31c2ae2e..00b87943 100644
--- a/include/proxy/v4/detail/core.h
+++ b/include/proxy/v4/detail/core.h
@@ -17,6 +17,7 @@
 #include <utility>
 
 #include "../proxy_macros.h"
+#include "./facade_meta_traits.h"
 
 #if __has_cpp_attribute(msvc::no_unique_address)
 #define PRO4D_NO_UNIQUE_ADDRESS_ATTRIBUTE msvc::no_unique_address
@@ -39,6 +40,9 @@ namespace detail {
 template <class F>
 struct basic_facade_traits;
 
+template <class F>
+struct meta_storage;
+
 } // namespace detail
 
 enum class constraint_level { none, nontrivial, nothrow, trivial };
@@ -79,12 +83,12 @@ template <template <class, class> class R, class O, class I, class... Is>
 struct recursive_reduction<R, O, I, Is...>
     : recursive_reduction<R, R<O, I>, Is...> {};
 template <template <class, class> class R, class O, class... Is>
-using recursive_reduction_t = typename recursive_reduction<R, O, Is...>::type;
+using recursive_reduction_t = recursive_reduction<R, O, Is...>::type;
 
 template <template <class...> class R, class... Args>
 struct reduction_traits {
   template <class O, class I>
-  using type = typename R<Args..., O, I>::type;
+  using type = R<Args..., O, I>::type;
 };
 
 template <class O, class I>
@@ -137,8 +141,7 @@ template <template <class...> class T, class... Ts, class... Args>
 struct specialization_type_traits<T, std::tuple<Ts...>, Args...>
     : std::type_identity<T<Args..., Ts...>> {};
 template <template <class...> class T, class TL, class... Args>
-using specialization_t =
-    typename specialization_type_traits<T, TL, Args...>::type;
+using specialization_t = specialization_type_traits<T, TL, Args...>::type;
 
 enum class qualifier_type { lv, const_lv, rv, const_rv };
 template <class T, qualifier_type Q>
@@ -154,9 +157,7 @@ template <class T>
 struct add_qualifier_traits<T, qualifier_type::const_rv>
     : std::type_identity<const T&&> {};
 template <class T, qualifier_type Q>
-using add_qualifier_t = typename add_qualifier_traits<T, Q>::type;
-template <class T, qualifier_type Q>
-using add_qualifier_ptr_t = std::remove_reference_t<add_qualifier_t<T, Q>>*;
+using add_qualifier_t = add_qualifier_traits<T, Q>::type;
 
 template <class T, constraint_level CL>
 struct copyability_traits : inapplicable_traits {};
@@ -232,19 +233,20 @@ struct proxy_helper {
     proxy<F>& p_;
   };
 
-  template <class M, class F>
-  static const M& get_meta(const proxy<F>& p) noexcept {
+  template <class F>
+  static const meta_storage<F>& get_meta(const proxy<F>& p) noexcept {
     assert(p.has_value());
-    return static_cast<const M&>(*p.meta_.operator->());
+    return p.meta_;
   }
-  template <class M, class F>
-  static const M& get_meta(const proxy_indirect_accessor<F>& p) noexcept {
-    return get_meta<M>(as_proxy<F, qualifier_type::const_lv>(p));
+  template <class F>
+  static const meta_storage<F>&
+      get_meta(const proxy_indirect_accessor<F>& p) noexcept {
+    return get_meta(as_proxy<F, qualifier_type::const_lv>(p));
   }
   template <class P, class F, qualifier_type Q>
   static add_qualifier_t<P, Q> get_ptr(add_qualifier_t<proxy<F>, Q> p) {
     return static_cast<add_qualifier_t<P, Q>>(
-        *std::launder(reinterpret_cast<add_qualifier_ptr_t<P, Q>>(p.ptr_)));
+        reinterpret_cast<add_qualifier_t<P, Q>>(*std::launder(p.ptr_)));
   }
   template <class P, class F1, class F2>
   static void trivially_relocate(proxy<F1>& from, proxy<F2>& to) noexcept {
@@ -260,7 +262,7 @@ template <class P, qualifier_type Q>
 struct operand_traits<P, false, Q>
     : std::type_identity<decltype(*std::declval<add_qualifier_t<P, Q>>())> {};
 template <class P, bool IsDirect, qualifier_type Q>
-using operand_t = typename operand_traits<P, IsDirect, Q>::type;
+using operand_t = operand_traits<P, IsDirect, Q>::type;
 template <class P, bool IsDirect, class D, qualifier_type Q, bool NE, class R,
           class... Args>
 concept invocable_dispatch =
@@ -322,7 +324,7 @@ template <class R, class... Args>
 struct overload_traits<R(Args...) const && noexcept>
     : overload_traits_impl<qualifier_type::const_rv, true, R, Args...> {};
 template <class O>
-using ret_t = typename overload_traits<O>::return_type;
+using ret_t = overload_traits<O>::return_type;
 
 template <class O>
 struct overload_substitution_traits : inapplicable_traits {
@@ -337,7 +339,7 @@ struct overload_substitution_traits<facade_aware_overload_t<O>>
 };
 template <class O, class F>
 using substituted_overload_t =
-    typename overload_substitution_traits<O>::template type<F>;
+    overload_substitution_traits<O>::template type<F>;
 template <class O>
 concept extended_overload = overload_traits<O>::applicable ||
                             overload_substitution_traits<O>::applicable;
@@ -348,32 +350,6 @@ consteval void diagnose_proxiable_required_convention_not_implemented() {
                 "not proxiable due to a required convention not implemented");
 }
 
-template <class ProP, class D, class O>
-struct conv_meta;
-#define PRO4D_DEF_CONV_META(oq, pq, ne, ...)                                   \
-  template <class ProP, class D, class R, class... Args>                       \
-  struct conv_meta<ProP, D, R(Args...) oq ne> {                                \
-    conv_meta() = default;                                                     \
-    template <class P>                                                         \
-    constexpr explicit conv_meta(std::in_place_type_t<P>)                      \
-        : invoke([](ProP pq self, Args... args) ne -> R {                      \
-            return reinterpret_invoke<P, D, R>(static_cast<ProP pq>(self),     \
-                                               std::forward<Args>(args)...);   \
-          }) {}                                                                \
-                                                                               \
-    R (*invoke)(ProP pq, Args...) ne;                                          \
-  }
-PRO4D_DEF_OVERLOAD_SPECIALIZATIONS(PRO4D_DEF_CONV_META)
-#undef PRO4D_DEF_CONV_META
-
-template <class... Ms>
-struct PRO4D_ENFORCE_EBO composite_meta : Ms... {
-  composite_meta() = default;
-  template <class P>
-  constexpr explicit composite_meta(std::in_place_type_t<P>)
-      : Ms(std::in_place_type<P>)... {}
-};
-
 template <class T>
 consteval bool is_is_direct_well_formed() {
   if constexpr (requires {
@@ -416,13 +392,13 @@ struct a11y_traits<std::void_t<typename T::template accessor<Args...>>, T,
                    Args...>
     : a11y_traits_impl<typename T::template accessor<Args...>> {};
 template <class T, class... Args>
-using accessor_t = typename a11y_traits<void, T, Args...>::type;
+using accessor_t = a11y_traits<void, T, Args...>::type;
 
 template <class C, class F, class... Os>
 struct conv_traits_impl {
   static_assert((overload_traits<substituted_overload_t<Os, F>>::applicable &&
                  ...));
-  using meta = composite_meta<conv_meta<
+  using meta = std::tuple<invoker<
       std::conditional_t<C::is_direct, proxy<F>, proxy_indirect_accessor<F>>,
       typename C::dispatch_type, substituted_overload_t<Os, F>>...>;
   template <class T>
@@ -513,12 +489,12 @@ template <class F, class D, class ONE, class OE, constraint_level C>
 struct lifetime_meta_traits : std::type_identity<void> {};
 template <class F, class D, class ONE, class OE>
 struct lifetime_meta_traits<F, D, ONE, OE, constraint_level::nothrow>
-    : std::type_identity<conv_meta<proxy<F>, D, ONE>> {};
+    : std::type_identity<invoker<proxy<F>, D, ONE>> {};
 template <class F, class D, class ONE, class OE>
 struct lifetime_meta_traits<F, D, ONE, OE, constraint_level::nontrivial>
-    : std::type_identity<conv_meta<proxy<F>, D, OE>> {};
+    : std::type_identity<invoker<proxy<F>, D, OE>> {};
 template <class F, class D, class ONE, class OE, constraint_level C>
-using lifetime_meta_t = typename lifetime_meta_traits<F, D, ONE, OE, C>::type;
+using lifetime_meta_t = lifetime_meta_traits<F, D, ONE, OE, C>::type;
 
 template <class... As>
 struct PRO4D_ENFORCE_EBO composite_accessor : As... {};
@@ -536,7 +512,7 @@ struct conv_accessor_traits<C, F, true>
     : std::type_identity<
           typename conv_traits<C, F>::template accessor<proxy<F>>> {};
 template <class C, class F, bool IsDirect>
-using conv_accessor_t = typename conv_accessor_traits<C, F, IsDirect>::type;
+using conv_accessor_t = conv_accessor_traits<C, F, IsDirect>::type;
 
 template <class R, class F, bool IsDirect>
 struct refl_accessor_traits : std::type_identity<void> {};
@@ -552,7 +528,7 @@ struct refl_accessor_traits<R, F, true>
     : std::type_identity<accessor_t<typename R::reflector_type, proxy<F>,
                                     typename R::reflector_type>> {};
 template <class R, class F, bool IsDirect>
-using refl_accessor_t = typename refl_accessor_traits<R, F, IsDirect>::type;
+using refl_accessor_t = refl_accessor_traits<R, F, IsDirect>::type;
 
 template <class T>
 concept pointer_like = (std::is_pointer_v<T> ||
@@ -648,7 +624,7 @@ struct basic_facade_traits<F> : applicable_traits {};
 template <class F, class... Cs>
 struct facade_conv_traits_impl {
   using conv_meta =
-      composite_t<composite_meta<>, typename conv_traits<Cs, F>::meta...>;
+      composite_t<std::tuple<>, typename conv_traits<Cs, F>::meta...>;
   using conv_indirect_accessor =
       composite_t<composite_accessor<>, conv_accessor_t<Cs, F, false>...>;
   using conv_direct_accessor =
@@ -665,7 +641,7 @@ struct facade_conv_traits_impl {
 };
 template <class F, class... Rs>
 struct facade_refl_traits_impl {
-  using refl_meta = composite_meta<
+  using refl_meta = std::tuple<
       reflection_meta<Rs::is_direct, typename Rs::reflector_type>...>;
   using refl_indirect_accessor =
       composite_t<composite_accessor<>, refl_accessor_t<Rs, F, false>...>;
@@ -690,15 +666,18 @@ struct facade_traits : specialization_t<facade_conv_traits_impl,
                                         typename F::convention_types, F>,
                        specialization_t<facade_refl_traits_impl,
                                         typename F::reflection_types, F> {
-  using meta = composite_t<
-      composite_meta<>,
-      lifetime_meta_t<F, copy_dispatch, void(proxy<F>&) const noexcept,
-                      void(proxy<F>&) const, F::copyability>,
-      lifetime_meta_t<F, relocate_dispatch, void(proxy<F>&) && noexcept,
-                      void(proxy<F>&) &&, F::relocatability>,
-      lifetime_meta_t<F, destroy_dispatch, void() noexcept, void(),
-                      F::destructibility>,
-      typename facade_traits::conv_meta, typename facade_traits::refl_meta>;
+  using meta_storage_base = specialization_t<
+      compact_facade_meta_traits::storage,
+      composite_t<
+          std::tuple<>,
+          lifetime_meta_t<F, copy_dispatch, void(proxy<F>&) const noexcept,
+                          void(proxy<F>&) const, F::copyability>,
+          lifetime_meta_t<F, relocate_dispatch, void(proxy<F>&) && noexcept,
+                          void(proxy<F>&) &&, F::relocatability>,
+          lifetime_meta_t<F, destroy_dispatch, void() noexcept, void(),
+                          F::destructibility>,
+          typename facade_traits::conv_meta,
+          typename facade_traits::refl_meta>>;
   using indirect_accessor =
       composite_t<typename facade_traits::conv_indirect_accessor,
                   typename facade_traits::refl_indirect_accessor>;
@@ -728,47 +707,11 @@ struct facade_traits : specialization_t<facade_conv_traits_impl,
       facade_traits::template refl_applicable_ptr<P>;
 };
 
-using ptr_prototype = void* [2];
-
-template <class M>
-struct meta_ptr_indirect_impl {
-  meta_ptr_indirect_impl() = default;
-  template <class P>
-  explicit meta_ptr_indirect_impl(std::in_place_type_t<P>)
-      : ptr_(&storage<P>) {}
-  bool has_value() const noexcept { return ptr_ != nullptr; }
-  void reset() noexcept { ptr_ = nullptr; }
-  const M* operator->() const noexcept { return ptr_; }
-
-private:
-  const M* ptr_;
-  template <class P>
-  static inline const M storage{std::in_place_type<P>};
-};
-template <class M, class DM>
-struct meta_ptr_direct_impl : private M {
-  using M::M;
-  bool has_value() const noexcept { return this->DM::invoke != nullptr; }
-  void reset() noexcept { this->DM::invoke = nullptr; }
-  const M* operator->() const noexcept { return this; }
+template <class F>
+struct meta_storage : facade_traits<F>::meta_storage_base {
+  using base = facade_traits<F>::meta_storage_base;
+  using base::base;
 };
-template <class M>
-struct meta_ptr_traits_impl : std::type_identity<meta_ptr_indirect_impl<M>> {};
-template <class ProP, class D, class O, class... Ms>
-struct meta_ptr_traits_impl<composite_meta<conv_meta<ProP, D, O>, Ms...>>
-    : std::type_identity<
-          meta_ptr_direct_impl<composite_meta<conv_meta<ProP, D, O>, Ms...>,
-                               conv_meta<ProP, D, O>>> {};
-template <class M>
-struct meta_ptr_traits : std::type_identity<meta_ptr_indirect_impl<M>> {};
-template <class M>
-  requires(sizeof(M) <= sizeof(ptr_prototype) &&
-           alignof(M) <= alignof(ptr_prototype) &&
-           std::is_nothrow_default_constructible_v<M> &&
-           std::is_trivially_copyable_v<M>)
-struct meta_ptr_traits<M> : meta_ptr_traits_impl<M> {};
-template <class M>
-using meta_ptr = typename meta_ptr_traits<M>::type;
 
 template <class T>
 class inplace_ptr {
@@ -796,16 +739,16 @@ class inplace_ptr {
 
 template <class D, class O, class P, class... Args>
 ret_t<O> invoke_impl(P&& p, Args&&... args) {
-  return proxy_helper::get_meta<conv_meta<std::remove_cvref_t<P>, D, O>>(p)
-      .invoke(std::forward<P>(p), std::forward<Args>(args)...);
+  return proxy_helper::get_meta(p)
+      .template get<invoker<std::remove_cvref_t<P>, D, O>>()(
+          std::forward<P>(p), std::forward<Args>(args)...);
 }
 template <class F, qualifier_type Q>
 add_qualifier_t<proxy<F>, Q>
     as_proxy(add_qualifier_t<proxy_indirect_accessor<F>, Q> p) {
   return static_cast<add_qualifier_t<proxy<F>, Q>>(
-      *reinterpret_cast<
-          add_qualifier_ptr_t<inplace_ptr<proxy_indirect_accessor<F>>, Q>>(
-          std::addressof(p)));
+      reinterpret_cast<
+          add_qualifier_t<inplace_ptr<proxy_indirect_accessor<F>>, Q>>(p));
 }
 template <class P, class F, bool IsDirect, qualifier_type Q>
 operand_t<P, IsDirect, Q> get_operand(proxy_accessor<F, IsDirect, Q> p) {
@@ -921,7 +864,8 @@ class proxy_indirect_accessor
   }
   template <class R>
   friend const R& reflect(const proxy_indirect_accessor& p) noexcept {
-    return detail::proxy_helper::get_meta<detail::reflection_meta<false, R>>(p)
+    return detail::proxy_helper::get_meta(p)
+        .template get<detail::reflection_meta<false, R>>()
         .reflector;
   }
 };
@@ -1159,7 +1103,8 @@ class proxy : public detail::facade_traits<F>::direct_accessor,
   }
   template <class R>
   friend const R& reflect(const proxy& p) noexcept {
-    return detail::proxy_helper::get_meta<detail::reflection_meta<true, R>>(p)
+    return detail::proxy_helper::get_meta(p)
+        .template get<detail::reflection_meta<true, R>>()
         .reflector;
   }
 
@@ -1210,8 +1155,7 @@ class proxy : public detail::facade_traits<F>::direct_accessor,
     P& result = *std::construct_at(reinterpret_cast<P*>(ptr_),
                                    std::forward<Args>(args)...);
     if constexpr (proxiable<P, F>) {
-      meta_ = detail::meta_ptr<typename detail::facade_traits<F>::meta>{
-          std::in_place_type<P>};
+      meta_ = detail::meta_storage<F>{std::in_place_type<P>};
     } else {
       detail::facade_traits<F>::template diagnose_proxiable_noreturn<P>();
     }
@@ -1238,7 +1182,7 @@ class proxy : public detail::facade_traits<F>::direct_accessor,
     *std::move(cself);
   })
 
-  detail::meta_ptr<typename detail::facade_traits<F>::meta> meta_;
+  detail::meta_storage<F> meta_;
   alignas(F::max_align) std::byte ptr_[F::max_size];
 };
 
diff --git a/include/proxy/v4/detail/facade_creation.h b/include/proxy/v4/detail/facade_creation.h
index 870fb2d9..6e82c86d 100644
--- a/include/proxy/v4/detail/facade_creation.h
+++ b/include/proxy/v4/detail/facade_creation.h
@@ -29,6 +29,8 @@ consteval std::size_t max_align_of(std::size_t value) {
   return value < alignof(std::max_align_t) ? value : alignof(std::max_align_t);
 }
 
+using ptr_prototype = void* [2];
+
 template <class T, class U>
 using merge_tuple_t = specialization_t<add_tuple_t, U, T>;
 template <class C1, class C2>
@@ -54,7 +56,7 @@ struct add_conv_reduction<std::tuple<Cs...>, std::tuple<>, C>
                      conv_impl<C::is_direct, typename C::dispatch_type>, C>>> {
 };
 template <class Cs, class C>
-using add_conv_t = typename add_conv_reduction<std::tuple<>, Cs, C>::type;
+using add_conv_t = add_conv_reduction<std::tuple<>, Cs, C>::type;
 
 template <class F, constraint_level CL>
 using copy_conversion_overload =
@@ -82,7 +84,7 @@ struct add_substitution_conv<Cs, F, constraint_level::none,
 template <class Cs1, class... Cs2>
 using merge_conv_tuple_t = recursive_reduction_t<add_conv_t, Cs1, Cs2...>;
 template <class Cs, class F, bool WithSubstitution>
-using merge_facade_conv_t = typename add_substitution_conv<
+using merge_facade_conv_t = add_substitution_conv<
     specialization_t<merge_conv_tuple_t, typename F::convention_types, Cs>, F,
     WithSubstitution ? F::copyability : constraint_level::none,
     (WithSubstitution && F::copyability != constraint_level::trivial)
diff --git a/include/proxy/v4/detail/facade_meta_traits.h b/include/proxy/v4/detail/facade_meta_traits.h
new file mode 100644
index 00000000..5ae8157c
--- /dev/null
+++ b/include/proxy/v4/detail/facade_meta_traits.h
@@ -0,0 +1,255 @@
+// Copyright (c) 2022-2026 Microsoft Corporation.
+// Copyright (c) 2026-Present Next Gen C++ Foundation.
+// Licensed under the MIT License.
+
+#ifndef MSFT_PROXY_V4_DETAIL_FACADE_META_TRAITS_H_
+#define MSFT_PROXY_V4_DETAIL_FACADE_META_TRAITS_H_
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+#ifdef __has_feature
+#if __has_feature(ptrauth_calls)
+#include <ptrauth.h>
+#define PRO4D_HAS_PAC
+#endif // __has_feature(ptrauth_calls)
+#endif // __has_feature
+
+#include "../proxy_macros.h"
+
+namespace pro::inline v4 {
+
+namespace detail {
+
+#ifdef PRO4D_HAS_PAC
+template <class O, class Disc>
+class code_ptr {
+public:
+  code_ptr() = default;
+  template <class F>
+  explicit code_ptr(const F& f) noexcept
+      : p_(ptrauth_sign_unauthenticated(
+            ptrauth_strip(static_cast<O*>(f), ptrauth_key_function_pointer),
+            ptrauth_key_function_pointer, schema())) {}
+  code_ptr(const code_ptr& rhs) noexcept
+      : p_(ptrauth_auth_and_resign(rhs.p_, ptrauth_key_function_pointer,
+                                   rhs.schema(), ptrauth_key_function_pointer,
+                                   schema())) {}
+  code_ptr& operator=(const code_ptr& rhs) noexcept {
+    p_ = ptrauth_auth_and_resign(rhs.p_, ptrauth_key_function_pointer,
+                                 rhs.schema(), ptrauth_key_function_pointer,
+                                 schema());
+    return *this;
+  }
+  code_ptr& operator=(std::nullptr_t) noexcept {
+    p_ = nullptr;
+    return *this;
+  }
+  bool operator==(std::nullptr_t) const noexcept { return p_ == nullptr; }
+  template <class... Args>
+  decltype(auto) operator()(Args&&... args) const {
+    return ptrauth_auth_function(p_, ptrauth_key_function_pointer,
+                                 schema())(std::forward<Args>(args)...);
+  }
+
+private:
+  ptrauth_extra_data_t schema() const noexcept {
+    return ptrauth_blend_discriminator(&p_, ptrauth_type_discriminator(Disc));
+  }
+
+  O* p_;
+};
+
+template <class T, class Disc>
+class meta_ptr {
+public:
+  meta_ptr() = default;
+  explicit meta_ptr(const T* p) noexcept
+      : p_(ptrauth_sign_unauthenticated(p, ptrauth_key_cxx_vtable_pointer,
+                                        schema())) {}
+  meta_ptr(const meta_ptr& rhs) noexcept
+      : p_(ptrauth_auth_and_resign(rhs.p_, ptrauth_key_cxx_vtable_pointer,
+                                   rhs.schema(), ptrauth_key_cxx_vtable_pointer,
+                                   schema())) {}
+  meta_ptr& operator=(const meta_ptr& rhs) noexcept {
+    p_ = ptrauth_auth_and_resign(rhs.p_, ptrauth_key_cxx_vtable_pointer,
+                                 rhs.schema(), ptrauth_key_cxx_vtable_pointer,
+                                 schema());
+    return *this;
+  }
+  meta_ptr& operator=(std::nullptr_t) noexcept {
+    p_ = nullptr;
+    return *this;
+  }
+  bool operator==(std::nullptr_t) const noexcept { return p_ == nullptr; }
+  const T& operator*() const noexcept {
+    return *ptrauth_auth_data(p_, ptrauth_key_cxx_vtable_pointer, schema());
+  }
+
+private:
+  ptrauth_extra_data_t schema() const noexcept {
+    return ptrauth_blend_discriminator(&p_, ptrauth_type_discriminator(Disc));
+  }
+
+  const T* p_;
+};
+#else
+template <class O, class Disc>
+using code_ptr = O*;
+
+template <class T, class Disc>
+using meta_ptr = const T*;
+#endif // PRO4D_HAS_PAC
+
+template <class T>
+concept nullable = requires(T v, const T cv) {
+  { v.reset() } noexcept;
+  { cv.has_value() } noexcept -> std::same_as<bool>;
+};
+
+template <class O, class Disc>
+struct invoker_base {
+  invoker_base() = default;
+  template <class F>
+  constexpr explicit invoker_base(const F& f) : p_(f) {}
+  void reset() noexcept { p_ = nullptr; }
+  bool has_value() const noexcept { return p_ != nullptr; }
+  template <class... Args>
+  decltype(auto) operator()(Args&&... args) const {
+    return p_(std::forward<Args>(args)...);
+  }
+
+private:
+  code_ptr<O, Disc> p_;
+};
+
+template <class ProP, class D, class O>
+struct invoker;
+#define PRO4D_DEF_INVOKER(oq, pq, ne, ...)                                     \
+  template <class ProP, class D, class R, class... Args>                       \
+  struct invoker<ProP, D, R(Args...) oq ne>                                    \
+      : invoker_base<R(ProP pq, Args...) ne, R (*)(ProP pq, D, Args...) ne> {  \
+    invoker() = default;                                                       \
+    template <class P>                                                         \
+    constexpr explicit invoker(std::in_place_type_t<P>)                        \
+        : invoker_base<R(ProP pq, Args...) ne, R (*)(ProP pq, D, Args...) ne>( \
+              [](ProP pq self, Args... args) ne -> R {                         \
+                return reinterpret_invoke<P, D, R>(                            \
+                    static_cast<ProP pq>(self), std::forward<Args>(args)...);  \
+              }) {}                                                            \
+  }
+PRO4D_DEF_OVERLOAD_SPECIALIZATIONS(PRO4D_DEF_INVOKER)
+#undef PRO4D_DEF_INVOKER
+
+struct sentinel_meta {
+  sentinel_meta() = default;
+  template <class P>
+  explicit sentinel_meta(std::in_place_type_t<P>) noexcept : v_(1) {}
+  void reset() noexcept { v_ = 0; }
+  bool has_value() const noexcept { return v_; }
+
+private:
+  std::ptrdiff_t v_;
+};
+
+template <nullable First, class... Rest>
+struct PRO4D_ENFORCE_EBO inline_meta_storage : First, Rest... {
+  using First::has_value;
+  using First::reset;
+
+  constexpr inline_meta_storage() noexcept {}
+  template <class P>
+  constexpr explicit inline_meta_storage(std::in_place_type_t<P>)
+      : First(std::in_place_type<P>), Rest(std::in_place_type<P>)... {}
+  inline_meta_storage(const inline_meta_storage& rhs) noexcept
+      : inline_meta_storage() {
+    if (static_cast<const First&>(rhs).has_value()) {
+      static_cast<First&>(*this) = static_cast<const First&>(rhs);
+      ((static_cast<Rest&>(*this) = static_cast<const Rest&>(rhs)), ...);
+    } else {
+      static_cast<First&>(*this).reset();
+    }
+  }
+  inline_meta_storage& operator=(const inline_meta_storage& rhs) noexcept {
+    if (static_cast<const First&>(rhs).has_value()) {
+      static_cast<First&>(*this) = static_cast<const First&>(rhs);
+      ((static_cast<Rest&>(*this) = static_cast<const Rest&>(rhs)), ...);
+    } else {
+      static_cast<First&>(*this).reset();
+    }
+    return *this;
+  }
+  template <class M>
+  const M& get() const noexcept {
+    return static_cast<const M&>(*this);
+  }
+};
+template <nullable First>
+struct inline_meta_storage<First> : First {
+  using First::First;
+
+  template <class M>
+  const M& get() const noexcept {
+    return static_cast<const M&>(*this);
+  }
+};
+
+template <class... Ms>
+struct static_meta_storage {
+  static_meta_storage() = default;
+  template <class P>
+  explicit static_meta_storage(std::in_place_type_t<P>)
+      : ptr_(std::addressof(storage<P>)) {}
+  bool has_value() const noexcept { return ptr_ != nullptr; }
+  void reset() noexcept { ptr_ = nullptr; }
+  template <class M>
+  const M& get() const noexcept {
+    return (*ptr_).template get<M>();
+  }
+
+private:
+  meta_ptr<inline_meta_storage<Ms...>, void (*)(Ms...)> ptr_;
+
+  template <class P>
+  static inline const inline_meta_storage<Ms...> storage{std::in_place_type<P>};
+};
+
+template <class... Ms>
+struct compact_meta_storage_traits
+    : std::type_identity<static_meta_storage<Ms...>> {};
+template <nullable M>
+struct compact_meta_storage_traits<M>
+    : std::type_identity<inline_meta_storage<M>> {};
+template <>
+struct compact_meta_storage_traits<>
+    : std::type_identity<inline_meta_storage<sentinel_meta>> {};
+
+template <class... Ms>
+struct flat_meta_storage_traits
+    : std::type_identity<inline_meta_storage<sentinel_meta, Ms...>> {};
+template <nullable M, class... Ms>
+struct flat_meta_storage_traits<M, Ms...>
+    : std::type_identity<inline_meta_storage<M, Ms...>> {};
+
+} // namespace detail
+
+struct compact_facade_meta_traits {
+  template <class ProP, class D, class O>
+  using invoker = detail::invoker<ProP, D, O>;
+
+  template <class... Ms>
+  using storage = detail::compact_meta_storage_traits<Ms...>::type;
+};
+
+struct flat_facade_meta_traits {
+  template <class ProP, class D, class O>
+  using invoker = detail::invoker<ProP, D, O>;
+
+  template <class... Ms>
+  using storage = detail::flat_meta_storage_traits<Ms...>::type;
+};
+
+} // namespace pro::inline v4
+
+#endif // MSFT_PROXY_V4_DETAIL_FACADE_META_TRAITS_H_
diff --git a/include/proxy/v4/detail/skills.h b/include/proxy/v4/detail/skills.h
index 67d9a4c0..4de7ad91 100644
--- a/include/proxy/v4/detail/skills.h
+++ b/include/proxy/v4/detail/skills.h
@@ -117,8 +117,8 @@ struct format_traits {
     }
 
     template <class P, class CompatibleFormatContext>
-    auto format(const P& p, CompatibleFormatContext& fc) const ->
-        typename CompatibleFormatContext::iterator {
+    auto format(const P& p, CompatibleFormatContext& fc) const
+        -> CompatibleFormatContext::iterator {
       return invoke<dispatch, overload<CharT>>(p, spec_, fc);
     }
 
@@ -137,7 +137,7 @@ template <>
 struct std_format_context_traits<wchar_t>
     : std::type_identity<std::wformat_context> {};
 template <class CharT>
-using std_format_context = typename std_format_context_traits<CharT>::type;
+using std_format_context = std_format_context_traits<CharT>::type;
 struct std_format_traits
     : format_traits<std::formatter, std::basic_string_view,
                     std::basic_format_parse_context, std_format_context> {};
@@ -250,46 +250,46 @@ namespace skills {
 
 #ifdef PRO4D_HAS_FORMAT
 template <class FB>
-using format = typename FB::template add_convention<
-    detail::std_format_traits::dispatch,
-    detail::std_format_traits::overload<char>>;
+using format =
+    FB::template add_convention<detail::std_format_traits::dispatch,
+                                detail::std_format_traits::overload<char>>;
 
 template <class FB>
-using wformat = typename FB::template add_convention<
-    detail::std_format_traits::dispatch,
-    detail::std_format_traits::overload<wchar_t>>;
+using wformat =
+    FB::template add_convention<detail::std_format_traits::dispatch,
+                                detail::std_format_traits::overload<wchar_t>>;
 #endif // PRO4D_HAS_FORMAT
 
 #if __cpp_rtti >= 199711L
 template <class FB>
-using indirect_rtti = typename FB::template add_indirect_convention<
+using indirect_rtti = FB::template add_indirect_convention<
     detail::proxy_cast_dispatch, void(detail::proxy_cast_context) &,
     void(detail::proxy_cast_context) const&,
     void(detail::proxy_cast_context) &&>::
     template add_indirect_reflection<detail::proxy_typeid_reflector>;
 
 template <class FB>
-using direct_rtti = typename FB::template add_direct_convention<
-    detail::proxy_cast_dispatch, void(detail::proxy_cast_context) &,
-    void(detail::proxy_cast_context) const&,
-    void(detail::proxy_cast_context) &&>::
-    template add_direct_reflection<detail::proxy_typeid_reflector>;
+using direct_rtti =
+    FB::template add_direct_convention<detail::proxy_cast_dispatch,
+                                       void(detail::proxy_cast_context) &,
+                                       void(detail::proxy_cast_context) const&,
+                                       void(detail::proxy_cast_context) &&>::
+        template add_direct_reflection<detail::proxy_typeid_reflector>;
 
 template <class FB>
 using rtti = indirect_rtti<FB>;
 #endif // __cpp_rtti >= 199711L
 
 template <class FB>
-using slim =
-    typename FB::template restrict_layout<sizeof(void*), alignof(void*)>;
+using slim = FB::template restrict_layout<sizeof(void*), alignof(void*)>;
 
 template <class FB>
-using as_view = typename FB::template add_direct_convention<
+using as_view = FB::template add_direct_convention<
     detail::view_conversion_dispatch,
     facade_aware_overload_t<detail::view_conversion_overload>>;
 
 template <class FB>
-using as_weak = typename FB::template add_direct_convention<
+using as_weak = FB::template add_direct_convention<
     detail::weak_conversion_dispatch,
     facade_aware_overload_t<detail::weak_conversion_overload>>;
 
diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel
index 9ecbd9ac..bad8dc9a 100644
--- a/tests/BUILD.bazel
+++ b/tests/BUILD.bazel
@@ -23,6 +23,7 @@ cc_test(
         "proxy_integration_tests.cpp",
         "proxy_invocation_tests.cpp",
         "proxy_lifetime_tests.cpp",
+        "proxy_pac_tests.cpp",
         "proxy_reflection_tests.cpp",
         "proxy_regression_tests.cpp",
         "proxy_rtti_tests.cpp",
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 49eafc2f..434789b7 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -21,6 +21,7 @@ add_executable(
   proxy_integration_tests.cpp
   proxy_invocation_tests.cpp
   proxy_lifetime_tests.cpp
+  proxy_pac_tests.cpp
   proxy_reflection_tests.cpp
   proxy_regression_tests.cpp
   proxy_rtti_tests.cpp
diff --git a/tests/meson.build b/tests/meson.build
index df7f405e..7486537c 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -6,6 +6,7 @@ test_srcs = files(
   'proxy_integration_tests.cpp',
   'proxy_invocation_tests.cpp',
   'proxy_lifetime_tests.cpp',
+  'proxy_pac_tests.cpp',
   'proxy_reflection_tests.cpp',
   'proxy_regression_tests.cpp',
   'proxy_rtti_tests.cpp',
diff --git a/tests/proxy_invocation_tests.cpp b/tests/proxy_invocation_tests.cpp
index 6c7b911b..16521bd7 100644
--- a/tests/proxy_invocation_tests.cpp
+++ b/tests/proxy_invocation_tests.cpp
@@ -218,9 +218,8 @@ TEST(ProxyInvocationTests, TestMultipleDispatches_Duplicated) {
         ::add_convention<detail::FreeForEach,
                          void(std::function<void(int&)>)> //
         ::build {};
-  static_assert(
-      sizeof(pro::detail::facade_traits<DuplicatedIterable>::meta) ==
-      sizeof(pro::detail::facade_traits<detail::Iterable<int>>::meta));
+  static_assert(sizeof(pro::detail::meta_storage<DuplicatedIterable>) ==
+                sizeof(pro::detail::meta_storage<detail::Iterable<int>>));
   std::list<int> l = {1, 2, 3};
   pro::proxy<DuplicatedIterable> p = &l;
   ASSERT_EQ(Size(*p), std::size_t{3});
diff --git a/tests/proxy_pac_tests.cpp b/tests/proxy_pac_tests.cpp
new file mode 100644
index 00000000..53bf2058
--- /dev/null
+++ b/tests/proxy_pac_tests.cpp
@@ -0,0 +1,129 @@
+// Copyright (c) 2022-2026 Microsoft Corporation.
+// Copyright (c) 2026-Present Next Gen C++ Foundation.
+// Licensed under the MIT License.
+
+#include <proxy/proxy.h>
+
+#ifdef PRO4D_HAS_PAC
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <gtest/gtest.h>
+#include <memory>
+#include <utility>
+
+namespace proxy_pac_tests_detail {
+
+template <pro::facade F>
+constexpr bool IsInlineMetaPreferred = pro::detail::specialization_of<
+    typename pro::detail::facade_traits<F>::meta_storage_base,
+    pro::detail::inline_meta_storage>;
+
+template <class T>
+auto GetRawBytes(const T& v) noexcept {
+  std::array<std::byte, sizeof(T)> result;
+  std::memcpy(result.data(), std::addressof(v), sizeof(T));
+  return result;
+}
+
+template <pro::facade F>
+void CorruptMeta(pro::proxy<F>& p) noexcept {
+  const pro::detail::meta_storage<F>& meta =
+      pro::detail::proxy_helper::get_meta(p);
+  std::byte* target = reinterpret_cast<std::byte*>(
+      const_cast<pro::detail::meta_storage<F>*>(std::addressof(meta)));
+  std::uintptr_t word;
+  std::memcpy(&word, target, sizeof(word));
+  word ^= std::uintptr_t{1} << 54u; // Within the PAC bits for any VA size
+  std::memcpy(target, &word, sizeof(word));
+}
+
+template <pro::facade F>
+void BitwiseCopy(pro::proxy<F>& from, pro::proxy<F>& to) {
+  assert(from.has_value() && !to.has_value());
+  std::memcpy(static_cast<void*>(&to), static_cast<const void*>(&from),
+              sizeof(from));
+}
+
+// No conventions and a nothrow destructor: a single signed destroy invoker
+// lives inline in the proxy.
+struct DefaultFacade : pro::facade_builder::build {};
+static_assert(IsInlineMetaPreferred<DefaultFacade>);
+
+// Non-trivial copyability adds more metas than fit inline, so the proxy stores
+// a signed pointer to out-of-line static meta storage.
+struct CopyableFacade : pro::facade_builder                               //
+                        ::support_copy<pro::constraint_level::nontrivial> //
+                        ::build {};
+static_assert(!IsInlineMetaPreferred<CopyableFacade>);
+
+} // namespace proxy_pac_tests_detail
+
+namespace detail = proxy_pac_tests_detail;
+
+TEST(ProxyPacTests, TestBinaryRepresentation_InlineMetaStorage) {
+  pro::proxy<detail::DefaultFacade> p1 = std::make_shared<int>(123);
+  auto p1_data = detail::GetRawBytes(p1);
+  auto p2 = std::move(p1);
+  auto p2_data = detail::GetRawBytes(p2);
+
+  // Pointer authentication signs the stored metadata with address diversity, so
+  // a genuine relocation re-signs it and the raw bytes of the signed meta
+  // change
+  EXPECT_NE(p1_data, p2_data);
+}
+
+TEST(ProxyPacTests, TestBinaryRepresentation_StaticMetaStorage) {
+  pro::proxy<detail::CopyableFacade> p1 = std::make_shared<int>(123);
+  auto p1_data = detail::GetRawBytes(p1);
+  auto p2 = p1;
+  auto p2_data = detail::GetRawBytes(p2);
+
+  // Both inline metadata and static metadata has pointer authentication
+  EXPECT_NE(p1_data, p2_data);
+}
+
+TEST(ProxyPacTests, TestBitFlipAttack_InlineMetaStorage) {
+  EXPECT_DEATH(
+      {
+        int a = 123;
+        pro::proxy<detail::DefaultFacade> p = &a;
+        detail::CorruptMeta(p);
+      },
+      "");
+}
+
+TEST(ProxyPacTests, TestBitFlipAttack_StaticMetaStorage) {
+  EXPECT_DEATH(
+      {
+        int a = 123;
+        pro::proxy<detail::CopyableFacade> p = &a;
+        detail::CorruptMeta(p);
+      },
+      "");
+}
+
+TEST(ProxyPacTests, TestRelocationAttack_InlineMetaStorage) {
+  EXPECT_DEATH(
+      {
+        int a = 123;
+        pro::proxy<detail::DefaultFacade> p1 = &a;
+        pro::proxy<detail::DefaultFacade> p2;
+        detail::BitwiseCopy(p1, p2);
+      },
+      "");
+}
+
+TEST(ProxyPacTests, TestRelocationAttack_StaticMetaStorage) {
+  EXPECT_DEATH(
+      {
+        int a = 123;
+        pro::proxy<detail::CopyableFacade> p1 = &a;
+        pro::proxy<detail::CopyableFacade> p2;
+        detail::BitwiseCopy(p1, p2);
+      },
+      "");
+}
+#endif // PRO4D_HAS_PAC
diff --git a/tests/proxy_traits_tests.cpp b/tests/proxy_traits_tests.cpp
index b671fb1e..cc13c6ba 100644
--- a/tests/proxy_traits_tests.cpp
+++ b/tests/proxy_traits_tests.cpp
@@ -89,8 +89,7 @@ static_assert(
 static_assert(std::is_nothrow_constructible_v<
               pro::proxy<DefaultFacade>, std::in_place_type_t<MockFunctionPtr>,
               MockFunctionPtr>);
-static_assert(sizeof(pro::proxy<DefaultFacade>) ==
-              3 * sizeof(void*)); // VTABLE should be embeded
+static_assert(sizeof(pro::proxy<DefaultFacade>) == 3 * sizeof(void*));
 
 static_assert(!std::is_copy_constructible_v<pro::proxy<DefaultFacade>>);
 static_assert(!std::is_copy_assignable_v<pro::proxy<DefaultFacade>>);
@@ -170,8 +169,7 @@ static_assert(std::is_nothrow_constructible_v<pro::proxy<CopyableFacade>,
                                               MockFunctionPtr>);
 static_assert(
     std::is_nothrow_assignable_v<pro::proxy<CopyableFacade>, MockFunctionPtr>);
-static_assert(sizeof(pro::proxy<CopyableFacade>) ==
-              4 * sizeof(void*)); // VTABLE should be embeded
+static_assert(sizeof(pro::proxy<CopyableFacade>) == 3 * sizeof(void*));
 
 struct CopyableSmallFacade
     : pro::facade_builder                               //
@@ -203,8 +201,7 @@ static_assert(
     std::is_constructible_v<pro::proxy<CopyableSmallFacade>, MockFunctionPtr>);
 static_assert(
     std::is_assignable_v<pro::proxy<CopyableSmallFacade>, MockFunctionPtr>);
-static_assert(sizeof(pro::proxy<CopyableSmallFacade>) ==
-              3 * sizeof(void*)); // VTABLE should be embeded
+static_assert(sizeof(pro::proxy<CopyableSmallFacade>) == 2 * sizeof(void*));
 
 struct TrivialFacade : pro::facade_builder                                   //
                        ::restrict_layout<sizeof(void*), alignof(void*)>      //
@@ -212,14 +209,19 @@ struct TrivialFacade : pro::facade_builder                                   //
                        ::support_relocation<pro::constraint_level::trivial>  //
                        ::support_destruction<pro::constraint_level::trivial> //
                        ::build {};
+#ifdef PRO4D_HAS_PAC
+static_assert(std::is_nothrow_copy_constructible_v<pro::proxy<TrivialFacade>>);
+static_assert(std::is_nothrow_copy_assignable_v<pro::proxy<TrivialFacade>>);
+static_assert(std::is_nothrow_move_constructible_v<pro::proxy<TrivialFacade>>);
+static_assert(std::is_nothrow_move_assignable_v<pro::proxy<TrivialFacade>>);
+#else
 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>>);
 static_assert(
     std::is_trivially_move_constructible_v<pro::proxy<TrivialFacade>>);
-static_assert(std::is_nothrow_move_assignable_v<pro::proxy<TrivialFacade>>);
 static_assert(std::is_trivially_move_assignable_v<pro::proxy<TrivialFacade>>);
+#endif // PRO4D_HAS_PAC
 static_assert(std::is_trivially_destructible_v<pro::proxy<TrivialFacade>>);
 static_assert(!pro::proxiable<MockMovablePtr, TrivialFacade>);
 static_assert(!pro::proxiable<MockCopyablePtr, TrivialFacade>);
@@ -244,9 +246,7 @@ static_assert(std::is_nothrow_constructible_v<pro::proxy<TrivialFacade>,
                                               MockFunctionPtr>);
 static_assert(
     std::is_nothrow_assignable_v<pro::proxy<TrivialFacade>, MockFunctionPtr>);
-static_assert(sizeof(pro::proxy<TrivialFacade>) ==
-              2 * sizeof(void*)); // VTABLE should be eliminated, but a
-                                  // placeholder is required
+static_assert(sizeof(pro::proxy<TrivialFacade>) == 2 * sizeof(void*));
 
 struct ReflectionOfSmallPtr {
   template <class P>
diff --git a/tests/proxy_view_tests.cpp b/tests/proxy_view_tests.cpp
index 69875994..17148b27 100644
--- a/tests/proxy_view_tests.cpp
+++ b/tests/proxy_view_tests.cpp
@@ -30,14 +30,19 @@ static_assert(
     SupportsToString<decltype(*std::declval<pro::proxy<TestFacade>>())>);
 static_assert(sizeof(pro::proxy<TestFacade>) == 3 * sizeof(void*));
 
+#ifdef PRO4D_HAS_PAC
+static_assert(
+    std::is_nothrow_copy_constructible_v<pro::proxy_view<TestFacade>>);
+#else
 static_assert(
     std::is_trivially_copy_constructible_v<pro::proxy_view<TestFacade>>);
+#endif // PRO4D_HAS_PAC
 static_assert(std::is_trivially_destructible_v<pro::proxy_view<TestFacade>>);
 static_assert(SupportsIntPlusEqual<
               decltype(*std::declval<pro::proxy_view<TestFacade>>())>);
 static_assert(
     SupportsToString<decltype(*std::declval<pro::proxy_view<TestFacade>>())>);
-static_assert(sizeof(pro::proxy_view<TestFacade>) == 3 * sizeof(void*));
+static_assert(sizeof(pro::proxy_view<TestFacade>) == 2 * sizeof(void*));
 
 static_assert(std::is_nothrow_convertible_v<pro::proxy<TestFacade>&,
                                             pro::proxy_view<TestFacade>>);
diff --git a/tools/report_generator/report-config.json b/tools/report_generator/report-config.json
index f9023c04..c04d2240 100644
--- a/tools/report_generator/report-config.json
+++ b/tools/report_generator/report-config.json
@@ -23,6 +23,11 @@
       "InfoPath": "artifacts/drop-appleclang/env-info.json",
       "BenchmarkingResultsPath": "artifacts/drop-appleclang/benchmarking-results.json"
     },
+    {
+      "Description": "AppleClang on macOS (arm64e with PAC)",
+      "InfoPath": "artifacts/drop-apple-pac/env-info.json",
+      "BenchmarkingResultsPath": "artifacts/drop-apple-pac/benchmarking-results.json"
+    },
     {
       "Description": "NVIDIA HPC on Ubuntu",
       "InfoPath": "artifacts/drop-nvhpc/env-info.json",