diff --git a/README.md b/README.md
index 2864566..76fc294 100644
--- a/README.md
+++ b/README.md
@@ -18,17 +18,17 @@ The "proxy" is a single-header, cross-platform C++ library that Microsoft uses t
 
 The "proxy" is a header-only C++20 library. Once you set the language level of your compiler not earlier than C++20 and get the header file ([proxy.h](proxy.h)), you are all set. You can also install the library via [vcpkg](https://github.com/microsoft/vcpkg/), which is a C++ library manager invented by Microsoft, by searching for "proxy" (see [vcpkg.info](https://vcpkg.info/port/proxy)).
 
-The majority of the library is defined in namespace `pro`. Some macros are provided (currently not included in the proposal of standardization) to simplify the definiton of `proxy` prior to C++26. Here is a demo showing how to use this library to implement runtime polymorphism in a different way from the traditional inheritance-based approach:
+The majority of the library is defined in namespace `pro`. Some macros are provided (currently not included in the proposal for standardization) to simplify the definition of `proxy` prior to C++26. Here is a demo showing how to use this library to implement runtime polymorphism in a different way from the traditional inheritance-based approach:
 
 ```cpp
-// Abstraction (poly is short for polymorphism)
-namespace poly {
+// Specifications of abstraction
+namespace spec {
 
 PRO_DEF_MEMBER_DISPATCH(Draw, void(std::ostream& out));
 PRO_DEF_MEMBER_DISPATCH(Area, double() noexcept);
 PRO_DEF_FACADE(Drawable, PRO_MAKE_DISPATCH_PACK(Draw, Area));
 
-}  // namespace poly
+}  // namespace spec
 
 // Implementation
 class Rectangle {
@@ -45,36 +45,36 @@ class Rectangle {
 };
 
 // Client - Consumer
-std::string PrintDrawableToString(pro::proxy<poly::Drawable> p) {
+std::string PrintDrawableToString(pro::proxy<spec::Drawable> p) {
   std::stringstream result;
   result << "shape = ";
-  p.invoke<poly::Draw>(result);
-  result << ", area = " << p.invoke<poly::Area>();
+  p.invoke<spec::Draw>(result);
+  result << ", area = " << p.invoke<spec::Area>();
   return std::move(result).str();
 }
 
 // Client - Producer
-pro::proxy<poly::Drawable> CreateRectangleAsDrawable(int width, int height) {
+pro::proxy<spec::Drawable> CreateRectangleAsDrawable(int width, int height) {
   Rectangle rect;
   rect.SetWidth(width);
   rect.SetHeight(height);
-  return pro::make_proxy<poly::Drawable>(rect);
+  return pro::make_proxy<spec::Drawable>(rect);
 }
 ```
 
 Here is another demo showing how to define overloads in a dispatch. Note that `.invoke<>` can be ommitted when only 1 dispatch is defined in a facade:
 
 ```cpp
-// Abstraction (poly is short for polymorphism)
-namespace poly {
+// Specifications of abstraction
+namespace spec {
 
 PRO_DEF_MEMBER_DISPATCH(Log, void(const char*), void(const char*, const std::exception&));
 PRO_DEF_FACADE(Logger, Log);
 
-}  // namespace poly
+}  // namespace spec
 
 // Client - Consumer
-void MyVerboseFunction(pro::proxy<poly::Logger> logger) {
+void MyVerboseFunction(pro::proxy<spec::Logger> logger) {
   logger("hello");
   try {
     throw std::runtime_error{"runtime error!"};
@@ -104,8 +104,8 @@ int main() {
 By design, the body of a dispatch could be any code. While member function is one useful pattern supported by macro `PRO_DEF_MEMBER_DISPATCH`, free function is also supported with another macro `PRO_DEF_FREE_DISPATCH`. The following example uses `PRO_DEF_FREE_DISPATCH` and `std::invoke` to implement similar function wrapper as `std::function` and `std::move_only_function` and supports multiple overloads.
 
 ```cpp
-// Abstraction (poly is short for polymorphism)
-namespace poly {
+// Specifications of abstraction
+namespace spec {
 
 template <class... Overloads>
 PRO_DEF_FREE_DISPATCH(Call, std::invoke, Overloads...);
@@ -114,14 +114,14 @@ PRO_DEF_FACADE(MovableCallable, Call<Overloads...>);
 template <class... Overloads>
 PRO_DEF_FACADE(CopyableCallable, Call<Overloads...>, pro::copyable_ptr_constraints);
 
-}  // namespace poly
+}  // namespace spec
 
 // MyFunction has similar functionality as std::function but supports multiple overloads
 // MyMoveOnlyFunction has similar functionality as std::move_only_function but supports multiple overloads
 template <class... Overloads>
-using MyFunction = pro::proxy<poly::MovableCallable<Overloads...>>;
+using MyFunction = pro::proxy<spec::CopyableCallable<Overloads...>>;
 template <class... Overloads>
-using MyMoveOnlyFunction = pro::proxy<poly::CopyableCallable<Overloads...>>;
+using MyMoveOnlyFunction = pro::proxy<spec::MovableCallable<Overloads...>>;
 
 int main() {
   auto f = [](auto&&... v) {
diff --git a/proxy.h b/proxy.h
index 147398d..3b0a063 100644
--- a/proxy.h
+++ b/proxy.h
@@ -64,13 +64,15 @@ consteval bool is_tuple_like_well_formed() {
   return false;
 }
 
-template <template <class...> class T, class TL, class Is> struct instantiated;
-template <template <class...> class T, class TL, std::size_t... Is>
-struct instantiated<T, TL, std::index_sequence<Is...>>
-    { using type = T<std::tuple_element_t<Is, TL>...>; };
-template <template <class...> class T, class TL>
-using instantiated_t = typename instantiated<
-    T, TL, std::make_index_sequence<std::tuple_size_v<TL>>>::type;
+template <template <class...> class T, class TL, class Is, class... Args>
+struct instantiated_traits;
+template <template <class...> class T, class TL, std::size_t... Is,
+    class... Args>
+struct instantiated_traits<T, TL, std::index_sequence<Is...>, Args...>
+    { using type = T<Args..., std::tuple_element_t<Is, TL>...>; };
+template <template <class...> class T, class TL, class... Args>
+using instantiated_t = typename instantiated_traits<
+    T, TL, std::make_index_sequence<std::tuple_size_v<TL>>, Args...>::type;
 
 template <class T>
 consteval bool has_copyability(constraint_level level) {
@@ -221,27 +223,25 @@ struct composite_meta : Ms... {
       { first_applicable_t<nullable_traits, Ms...>::reset(); }
 };
 
-template <class D>
-struct dispatch_helper {
-  template <class... Os> struct traits : inapplicable_traits {};
-  template <class... Os>
-      requires(sizeof...(Os) > 0u && (overload_traits<Os>::applicable && ...))
-  struct traits<Os...> : applicable_traits {
-   private:
-    struct overload_resolver : overload_traits<Os>::resolver...
-        { using overload_traits<Os>::resolver::operator()...; };
-
-   public:
-    using meta = composite_meta<dispatcher_meta<
-        typename overload_traits<Os>::template meta_provider<D>>...>;
-    template <class... Args>
-    using matched_overload =
-        std::remove_pointer_t<std::invoke_result_t<overload_resolver, Args...>>;
+template <class D, class... Os>
+struct dispatch_traits_impl : inapplicable_traits {};
+template <class D, class... Os>
+    requires(sizeof...(Os) > 0u && (overload_traits<Os>::applicable && ...))
+struct dispatch_traits_impl<D, Os...> : applicable_traits {
+ private:
+  struct overload_resolver : overload_traits<Os>::resolver...
+      { using overload_traits<Os>::resolver::operator()...; };
 
-    template <class P>
-    static constexpr bool applicable_ptr =
-        (overload_traits<Os>::template applicable_ptr<D, P> && ...);
-  };
+ public:
+  using meta = composite_meta<dispatcher_meta<
+      typename overload_traits<Os>::template meta_provider<D>>...>;
+  template <class... Args>
+  using matched_overload =
+      std::remove_pointer_t<std::invoke_result_t<overload_resolver, Args...>>;
+
+  template <class P>
+  static constexpr bool applicable_ptr =
+      (overload_traits<Os>::template applicable_ptr<D, P> && ...);
 };
 template <class D> struct dispatch_traits : inapplicable_traits {};
 template <class D>
@@ -249,7 +249,7 @@ template <class D>
         is_tuple_like_well_formed<typename D::overload_types>() &&
         std::is_trivially_default_constructible_v<D>)
 struct dispatch_traits<D> : instantiated_t<
-    dispatch_helper<D>::template traits, typename D::overload_types> {};
+    dispatch_traits_impl, typename D::overload_types, D> {};
 
 template <constraint_level C> struct copyability_meta_provider;
 template <>
@@ -331,34 +331,33 @@ template <class... Ds>
 struct default_dispatch_traits { using default_dispatch = void; };
 template <class D>
 struct default_dispatch_traits<D> { using default_dispatch = D; };
-template <class F>
-struct facade_helper {
-  template <class... Ds> struct traits : inapplicable_traits {};
-  template <class... Ds> requires(dispatch_traits<Ds>::applicable && ...)
-  struct traits<Ds...> : applicable_traits, default_dispatch_traits<Ds...> {
-    using copyability_meta = lifetime_meta<
-        copyability_meta_provider, F::constraints.copyability>;
-    using relocatability_meta = lifetime_meta<
-        relocatability_meta_provider, F::constraints.relocatability>;
-    using destructibility_meta = lifetime_meta<
-        destructibility_meta_provider, F::constraints.destructibility>;
-    using meta = recursive_reduction_t<facade_meta_reduction,
-        composite_meta<>, copyability_meta, relocatability_meta,
-        destructibility_meta, typename dispatch_traits<Ds>::meta...,
-        typename F::reflection_type>;
-
-    template <class D>
-    static constexpr bool has_dispatch = (std::is_same_v<D, Ds> || ...);
-    template <class P>
-    static constexpr bool applicable_ptr =
-        sizeof(P) <= F::constraints.max_size &&
-        alignof(P) <= F::constraints.max_align &&
-        has_copyability<P>(F::constraints.copyability) &&
-        has_relocatability<P>(F::constraints.relocatability) &&
-        has_destructibility<P>(F::constraints.destructibility) &&
-        (dispatch_traits<Ds>::template applicable_ptr<P> && ...) &&
-        is_reflection_type_well_formed<typename F::reflection_type, P>();
-  };
+template <class F, class... Ds>
+struct facade_traits_impl : inapplicable_traits {};
+template <class F, class... Ds> requires(dispatch_traits<Ds>::applicable && ...)
+struct facade_traits_impl<F, Ds...>
+    : applicable_traits, default_dispatch_traits<Ds...> {
+  using copyability_meta = lifetime_meta<
+      copyability_meta_provider, F::constraints.copyability>;
+  using relocatability_meta = lifetime_meta<
+      relocatability_meta_provider, F::constraints.relocatability>;
+  using destructibility_meta = lifetime_meta<
+      destructibility_meta_provider, F::constraints.destructibility>;
+  using meta = recursive_reduction_t<facade_meta_reduction,
+      composite_meta<>, copyability_meta, relocatability_meta,
+      destructibility_meta, typename dispatch_traits<Ds>::meta...,
+      typename F::reflection_type>;
+
+  template <class D>
+  static constexpr bool has_dispatch = (std::is_same_v<D, Ds> || ...);
+  template <class P>
+  static constexpr bool applicable_ptr =
+      sizeof(P) <= F::constraints.max_size &&
+      alignof(P) <= F::constraints.max_align &&
+      has_copyability<P>(F::constraints.copyability) &&
+      has_relocatability<P>(F::constraints.relocatability) &&
+      has_destructibility<P>(F::constraints.destructibility) &&
+      (dispatch_traits<Ds>::template applicable_ptr<P> && ...) &&
+      is_reflection_type_well_formed<typename F::reflection_type, P>();
 };
 template <class F> struct facade_traits : inapplicable_traits {};
 template <class F>
@@ -370,7 +369,7 @@ template <class F>
         } && is_tuple_like_well_formed<typename F::dispatch_types>() &&
         is_facade_constraints_well_formed<F>())
 struct facade_traits<F> : instantiated_t<
-    facade_helper<F>::template traits, typename F::dispatch_types> {};
+    facade_traits_impl, typename F::dispatch_types, F> {};
 
 using ptr_prototype = void*[2];
 
@@ -818,18 +817,14 @@ struct dispatch_prototype_helper {
 };
 
 template <class O, class I> struct flat_reduction : std::type_identity<O> {};
-template <class O>
-struct flat_reduction_helper {
-  template <class... Is>
-  using type = recursive_reduction<flat_reduction, O, Is...>;
-};
+template <class O, class... Is>
+struct flat_reduction_impl : recursive_reduction<flat_reduction, O, Is...> {};
 template <class... Os, class I>
     requires(!is_tuple_like_well_formed<I>() && (!std::is_same_v<I, Os> && ...))
 struct flat_reduction<std::tuple<Os...>, I>
     : std::type_identity<std::tuple<Os..., I>> {};
 template <class O, class I> requires(is_tuple_like_well_formed<I>())
-struct flat_reduction<O, I>
-    : instantiated_t<flat_reduction_helper<O>::template type, I> {};
+struct flat_reduction<O, I> : instantiated_t<flat_reduction_impl, I, O> {};
 template <class O, class I>
 struct overloads_reduction : std::type_identity<O> {};
 template <class O, class I> requires(requires { typename I::overload_types; })
diff --git a/samples/resource_dictionary/main.cpp b/samples/resource_dictionary/main.cpp
index 7b50e9d..0c49f32 100644
--- a/samples/resource_dictionary/main.cpp
+++ b/samples/resource_dictionary/main.cpp
@@ -5,14 +5,14 @@
 
 #include <proxy/proxy.h>
 
-namespace poly {
+namespace spec {
 
 PRO_DEF_MEMBER_DISPATCH(at, std::string(int));
 PRO_DEF_FACADE(Dictionary, at);
 
-}  // namespace poly
+}  // namespace spec
 
-void demo_print(pro::proxy<poly::Dictionary> dictionary) {
+void demo_print(pro::proxy<spec::Dictionary> dictionary) {
   std::cout << dictionary(1) << std::endl;
 }
 
diff --git a/tests/proxy_creation_tests.cpp b/tests/proxy_creation_tests.cpp
index d564862..50009cc 100644
--- a/tests/proxy_creation_tests.cpp
+++ b/tests/proxy_creation_tests.cpp
@@ -8,8 +8,6 @@
 
 namespace {
 
-namespace poly {
-
 struct SboObserver {
  public:
   template <class T>
@@ -26,16 +24,18 @@ struct SboObserver {
   bool AllocatorAllocatesForItself;
 };
 
-PRO_DEF_FACADE(TestSmallStringable, utils::poly::ToString, pro::proxiable_ptr_constraints{
+namespace spec {
+
+PRO_DEF_FACADE(TestSmallStringable, utils::spec::ToString, pro::proxiable_ptr_constraints{
     .max_size = sizeof(void*),
     .max_align = alignof(void*),
     .copyability = pro::constraint_level::nontrivial,
     .relocatability = pro::constraint_level::nothrow,
     .destructibility = pro::constraint_level::nothrow,
   }, SboObserver);
-PRO_DEF_FACADE(TestLargeStringable, utils::poly::ToString, pro::copyable_ptr_constraints, SboObserver);
+PRO_DEF_FACADE(TestLargeStringable, utils::spec::ToString, pro::copyable_ptr_constraints, SboObserver);
 
-}  // namespace poly
+}  // namespace spec
 
 PRO_DEF_MEMBER_DISPATCH(MemFn0, void(int) noexcept);
 PRO_DEF_FACADE(TestMemFn0, MemFn0);
@@ -73,7 +73,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithSBO_FromValue) {
   utils::LifetimeTracker::Session session{ &tracker };
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::allocate_proxy<poly::TestLargeStringable>(std::allocator<void>{}, session);
+    auto p = pro::allocate_proxy<spec::TestLargeStringable>(std::allocator<void>{}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 2");
     ASSERT_TRUE(p.reflect().SboEnabled);
@@ -88,7 +88,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithSBO_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::allocate_proxy<poly::TestLargeStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
+    auto p = pro::allocate_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_TRUE(p.reflect().SboEnabled);
@@ -103,7 +103,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithSBO_InPlaceInitializerList) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::allocate_proxy<poly::TestLargeStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, { 1, 2, 3 }, &tracker);
+    auto p = pro::allocate_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, { 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_TRUE(p.reflect().SboEnabled);
@@ -118,7 +118,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithSBO_Lifetime_Copy) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::allocate_proxy<poly::TestLargeStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
+    auto p1 = pro::allocate_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
@@ -139,7 +139,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithSBO_Lifetime_Move) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::allocate_proxy<poly::TestLargeStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
+    auto p1 = pro::allocate_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
@@ -160,7 +160,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_DirectAllocator_FromValue)
   utils::LifetimeTracker::Session session{ &tracker };
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::allocate_proxy<poly::TestSmallStringable>(std::allocator<void>{}, session);
+    auto p = pro::allocate_proxy<spec::TestSmallStringable>(std::allocator<void>{}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 2");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -176,7 +176,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_DirectAllocator_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::allocate_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
+    auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -192,7 +192,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_DirectAllocator_InPlaceIni
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::allocate_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, { 1, 2, 3 }, & tracker);
+    auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, { 1, 2, 3 }, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -208,7 +208,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_DirectAllocator_Lifetime_C
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::allocate_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
+    auto p1 = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
@@ -231,7 +231,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_DirectAllocator_Lifetime_M
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::allocate_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
+    auto p1 = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
@@ -252,7 +252,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_IndirectAllocator_FromValu
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy<poly::TestSmallStringable>(std::pmr::polymorphic_allocator<>{&memory_pool}, session);
+    auto p = pro::allocate_proxy<spec::TestSmallStringable>(std::pmr::polymorphic_allocator<>{&memory_pool}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 2");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -269,7 +269,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_IndirectAllocator_InPlace)
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
+    auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -286,7 +286,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_IndirectAllocator_InPlaceI
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p = pro::allocate_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, { 1, 2, 3 }, & tracker);
+    auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, { 1, 2, 3 }, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -303,7 +303,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_IndirectAllocator_Lifetime
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
+    auto p1 = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
@@ -327,7 +327,7 @@ TEST(ProxyCreationTests, TestAllocateProxy_WithoutSBO_IndirectAllocator_Lifetime
   std::vector<utils::LifetimeOperation> expected_ops;
   {
     std::pmr::unsynchronized_pool_resource memory_pool;
-    auto p1 = pro::allocate_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
+    auto p1 = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
@@ -347,7 +347,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_FromValue) {
   utils::LifetimeTracker::Session session{ &tracker };
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::make_proxy<poly::TestLargeStringable>(session);
+    auto p = pro::make_proxy<spec::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 2");
     ASSERT_TRUE(p.reflect().SboEnabled);
@@ -362,7 +362,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy<poly::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
+    auto p = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_TRUE(p.reflect().SboEnabled);
@@ -377,7 +377,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlaceInitializerList) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy<poly::TestLargeStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
+    auto p = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_TRUE(p.reflect().SboEnabled);
@@ -392,7 +392,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Copy) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy<poly::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
+    auto p1 = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
@@ -413,7 +413,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Move) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy<poly::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
+    auto p1 = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
@@ -434,7 +434,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_FromValue) {
   utils::LifetimeTracker::Session session{ &tracker };
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
   {
-    auto p = pro::make_proxy<poly::TestSmallStringable>(session);
+    auto p = pro::make_proxy<spec::TestSmallStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 2");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -450,7 +450,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlace) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
+    auto p = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -466,7 +466,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlaceInitializerList) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p = pro::make_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
+    auto p = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(p.invoke(), "Session 1");
     ASSERT_FALSE(p.reflect().SboEnabled);
@@ -482,7 +482,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Copy) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
+    auto p1 = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
@@ -505,7 +505,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Move) {
   utils::LifetimeTracker tracker;
   std::vector<utils::LifetimeOperation> expected_ops;
   {
-    auto p1 = pro::make_proxy<poly::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
+    auto p1 = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     auto p2 = std::move(p1);
     ASSERT_FALSE(p1.has_value());
diff --git a/tests/proxy_integration_tests.cpp b/tests/proxy_integration_tests.cpp
index be6f01d..fdab257 100644
--- a/tests/proxy_integration_tests.cpp
+++ b/tests/proxy_integration_tests.cpp
@@ -13,13 +13,13 @@
 
 namespace {
 
-namespace poly {
+namespace spec {
 
 PRO_DEF_MEMBER_DISPATCH(Draw, void(std::ostream&));
 PRO_DEF_MEMBER_DISPATCH(Area, double() noexcept);
 PRO_DEF_FACADE(Drawable, PRO_MAKE_DISPATCH_PACK(Draw, Area));
 
-}  // namespace poly
+}  // namespace spec
 
 class Rectangle {
  public:
@@ -50,11 +50,11 @@ class Point {
   constexpr double Area() const noexcept { return 0; }
 };
 
-std::string PrintDrawableToString(pro::proxy<poly::Drawable> p) {
+std::string PrintDrawableToString(pro::proxy<spec::Drawable> p) {
   std::stringstream result;
   result << std::fixed << std::setprecision(5) << "shape = ";
-  p.invoke<poly::Draw>(result);
-  result << ", area = " << p.invoke<poly::Area>();
+  p.invoke<spec::Draw>(result);
+  result << ", area = " << p.invoke<spec::Area>();
   return std::move(result).str();
 }
 
@@ -81,7 +81,7 @@ std::vector<std::string> ParseCommand(const std::string& s) {
   return result;
 }
 
-pro::proxy<poly::Drawable> MakeDrawableFromCommand(const std::string& s) {
+pro::proxy<spec::Drawable> MakeDrawableFromCommand(const std::string& s) {
   std::vector<std::string> parsed = ParseCommand(s);
   if (!parsed.empty()) {
     if (parsed[0u] == "Rectangle") {
@@ -100,7 +100,7 @@ pro::proxy<poly::Drawable> MakeDrawableFromCommand(const std::string& s) {
       if (parsed.size() == 2u) {
         Circle circle;
         circle.SetRadius(std::stod(parsed[1u]));
-        return pro::make_proxy<poly::Drawable>(circle);
+        return pro::make_proxy<spec::Drawable>(circle);
       }
     } else if (parsed[0u] == "Point") {
       if (parsed.size() == 1u) {
@@ -115,7 +115,7 @@ pro::proxy<poly::Drawable> MakeDrawableFromCommand(const std::string& s) {
 }  // namespace
 
 TEST(ProxyIntegrationTests, TestDrawable) {
-  pro::proxy<poly::Drawable> p = MakeDrawableFromCommand("Rectangle 2 3");
+  pro::proxy<spec::Drawable> p = MakeDrawableFromCommand("Rectangle 2 3");
   std::string s = PrintDrawableToString(std::move(p));
   ASSERT_EQ(s, "shape = {Rectangle: width = 2.00000, height = 3.00000}, area = 6.00000");
 
diff --git a/tests/proxy_invocation_tests.cpp b/tests/proxy_invocation_tests.cpp
index 657738d..25c4c45 100644
--- a/tests/proxy_invocation_tests.cpp
+++ b/tests/proxy_invocation_tests.cpp
@@ -13,7 +13,7 @@
 
 namespace {
 
-namespace poly {
+namespace spec {
 
 template <class... Os>
 PRO_DEF_FREE_DISPATCH(Call, std::invoke, Os...);
@@ -41,7 +41,7 @@ struct Append {
   }
 };
 
-}  // namespace poly
+}  // namespace spec
 
 template <class F, class D, bool NE, class... Args>
 concept InvocableWithDispatch =
@@ -57,19 +57,19 @@ concept InvocableWithoutDispatch =
 };
 
 // Static assertions for a facade of a single dispatch
-static_assert(InvocableWithDispatch<poly::Callable<int(double)>, poly::Call<int(double)>, false, double>);
-static_assert(!InvocableWithDispatch<poly::Callable<int(double)>, poly::Call<int(double)>, false, std::nullptr_t>);  // Wrong arguments
-static_assert(!InvocableWithoutDispatch<poly::Callable<int(double)>, false, std::nullptr_t>);  // Wrong arguments
-static_assert(!InvocableWithDispatch<poly::Callable<int(double)>, int(double), false, double>);  // Wrong dispatch
-static_assert(InvocableWithoutDispatch<poly::Callable<int(double)>, false, float>);  // Invoking without specifying a dispatch
-static_assert(InvocableWithoutDispatch<poly::Callable<int(double), void(int) noexcept>, true, int>);  // Invoking noexcept overloads
-static_assert(InvocableWithoutDispatch<poly::Callable<int(double), void(int) noexcept>, false, double>);  // Invoking overloads that may throw
+static_assert(InvocableWithDispatch<spec::Callable<int(double)>, spec::Call<int(double)>, false, double>);
+static_assert(!InvocableWithDispatch<spec::Callable<int(double)>, spec::Call<int(double)>, false, std::nullptr_t>);  // Wrong arguments
+static_assert(!InvocableWithoutDispatch<spec::Callable<int(double)>, false, std::nullptr_t>);  // Wrong arguments
+static_assert(!InvocableWithDispatch<spec::Callable<int(double)>, int(double), false, double>);  // Wrong dispatch
+static_assert(InvocableWithoutDispatch<spec::Callable<int(double)>, false, float>);  // Invoking without specifying a dispatch
+static_assert(InvocableWithoutDispatch<spec::Callable<int(double), void(int) noexcept>, true, int>);  // Invoking noexcept overloads
+static_assert(InvocableWithoutDispatch<spec::Callable<int(double), void(int) noexcept>, false, double>);  // Invoking overloads that may throw
 
 // Static assertions for a facade of multiple dispatches
-static_assert(InvocableWithDispatch<poly::Iterable<int>, poly::GetSize, true>);
-static_assert(!InvocableWithDispatch<poly::Iterable<int>, poly::ForEach<int>, false, pro::proxy<poly::Callable<void(double&)>>>);  // Wrong arguments
-static_assert(!InvocableWithDispatch<poly::Iterable<int>, poly::Append<int>, false>);  // Wrong dispatch
-static_assert(!InvocableWithoutDispatch<poly::Iterable<int>, false>);  // Invoking without specifying a dispatch
+static_assert(InvocableWithDispatch<spec::Iterable<int>, spec::GetSize, true>);
+static_assert(!InvocableWithDispatch<spec::Iterable<int>, spec::ForEach<int>, false, pro::proxy<spec::Callable<void(double&)>>>);  // Wrong arguments
+static_assert(!InvocableWithDispatch<spec::Iterable<int>, spec::Append<int>, false>);  // Wrong dispatch
+static_assert(!InvocableWithoutDispatch<spec::Iterable<int>, false>);  // Invoking without specifying a dispatch
 
 template <class... Args>
 std::vector<std::type_index> GetTypeIndices()
@@ -89,7 +89,7 @@ TEST(ProxyInvocationTests, TestArgumentForwarding) {
     arg2_received = std::move(v);
     return expected_result;
   };
-  pro::proxy<poly::Callable<int(std::string, std::vector<int>)>> p = &f;
+  pro::proxy<spec::Callable<int(std::string, std::vector<int>)>> p = &f;
   int result = p.invoke(arg1, std::move(arg2));
   ASSERT_TRUE(p.has_value());
   ASSERT_EQ(arg1_received, arg1);
@@ -102,7 +102,7 @@ TEST(ProxyInvocationTests, TestThrow) {
   const char* expected_error_message = "My exception";
   auto f = [&] { throw std::runtime_error{ expected_error_message }; };
   bool exception_thrown = false;
-  pro::proxy<poly::Callable<void()>> p = &f;
+  pro::proxy<spec::Callable<void()>> p = &f;
   try {
     p.invoke();
   } catch (const std::runtime_error& e) {
@@ -115,45 +115,45 @@ TEST(ProxyInvocationTests, TestThrow) {
 
 TEST(ProxyInvocationTests, TestMultipleDispatches_Unique) {
   std::list<int> l = { 1, 2, 3 };
-  pro::proxy<poly::Iterable<int>> p = &l;
-  ASSERT_EQ(p.invoke<poly::GetSize>(), 3);
+  pro::proxy<spec::Iterable<int>> p = &l;
+  ASSERT_EQ(p.invoke<spec::GetSize>(), 3);
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
-  p.invoke<poly::ForEach<int>>(&accumulate_sum);
+  p.invoke<spec::ForEach<int>>(&accumulate_sum);
   ASSERT_EQ(sum, 6);
 }
 
 TEST(ProxyInvocationTests, TestMultipleDispatches_Duplicated) {
-  using SomeCombination = std::tuple<poly::ForEach<int>, std::tuple<poly::GetSize, poly::ForEach<int>>>;
-  PRO_DEF_FACADE(DuplicatedIterable, PRO_MAKE_DISPATCH_PACK(poly::ForEach<int>, SomeCombination, poly::ForEach<int>, poly::GetSize, poly::GetSize));
+  using SomeCombination = std::tuple<spec::ForEach<int>, std::tuple<spec::GetSize, spec::ForEach<int>>>;
+  PRO_DEF_FACADE(DuplicatedIterable, PRO_MAKE_DISPATCH_PACK(spec::ForEach<int>, SomeCombination, spec::ForEach<int>, spec::GetSize, spec::GetSize));
   static_assert(sizeof(pro::details::facade_traits<DuplicatedIterable>::meta) ==
-      sizeof(pro::details::facade_traits<poly::Iterable<int>>::meta));
+      sizeof(pro::details::facade_traits<spec::Iterable<int>>::meta));
   std::list<int> l = { 1, 2, 3 };
   pro::proxy<DuplicatedIterable> p = &l;
-  ASSERT_EQ(p.invoke<poly::GetSize>(), 3);
+  ASSERT_EQ(p.invoke<spec::GetSize>(), 3);
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
-  p.invoke<poly::ForEach<int>>(&accumulate_sum);
+  p.invoke<spec::ForEach<int>>(&accumulate_sum);
   ASSERT_EQ(sum, 6);
 }
 
 TEST(ProxyInvocationTests, TestRecursiveDefinition) {
   std::list<int> l = { 1, 2, 3 };
-  pro::proxy<poly::Container<int>> p = &l;
-  ASSERT_EQ(p.invoke<poly::GetSize>(), 3);
+  pro::proxy<spec::Container<int>> p = &l;
+  ASSERT_EQ(p.invoke<spec::GetSize>(), 3);
   int sum = 0;
   auto accumulate_sum = [&](int x) { sum += x; };
-  p.invoke<poly::ForEach<int>>(&accumulate_sum);
+  p.invoke<spec::ForEach<int>>(&accumulate_sum);
   ASSERT_EQ(sum, 6);
-  p.invoke<poly::Append<int>>(4).invoke<poly::Append<int>>(5).invoke<poly::Append<int>>(6);
-  ASSERT_EQ(p.invoke<poly::GetSize>(), 6);
+  p.invoke<spec::Append<int>>(4).invoke<spec::Append<int>>(5).invoke<spec::Append<int>>(6);
+  ASSERT_EQ(p.invoke<spec::GetSize>(), 6);
   sum = 0;
-  p.invoke<poly::ForEach<int>>(&accumulate_sum);
+  p.invoke<spec::ForEach<int>>(&accumulate_sum);
   ASSERT_EQ(sum, 21);
 }
 
 TEST(ProxyInvocationTests, TestOverloadResolution) {
-  PRO_DEF_COMBINED_DISPATCH(OverloadedCall, poly::Call<void(int)>, poly::Call<void(double)>, poly::Call<void(char*)>, poly::Call<void(const char*)>, poly::Call<void(std::string, int)>);
+  PRO_DEF_COMBINED_DISPATCH(OverloadedCall, spec::Call<void(int)>, spec::Call<void(double)>, spec::Call<void(char*)>, spec::Call<void(const char*)>, spec::Call<void(std::string, int)>);
   PRO_DEF_FACADE(OverloadedCallable, OverloadedCall);
   std::vector<std::type_index> side_effect;
   auto p = pro::make_proxy<OverloadedCallable>([&](auto&&... args)
@@ -174,7 +174,7 @@ TEST(ProxyInvocationTests, TestOverloadResolution) {
 
 TEST(ProxyInvocationTests, TestNoexcept) {
   std::vector<std::type_index> side_effect;
-  auto p = pro::make_proxy<poly::Callable<void(int) noexcept, void(double)>>([&](auto&&... args) noexcept
+  auto p = pro::make_proxy<spec::Callable<void(int) noexcept, void(double)>>([&](auto&&... args) noexcept
     { side_effect = GetTypeIndices<std::decay_t<decltype(args)>...>(); });
   static_assert(noexcept(p(123)));
   p(123);
@@ -186,7 +186,7 @@ TEST(ProxyInvocationTests, TestNoexcept) {
 }
 
 TEST(ProxyInvocationTests, TestFunctionPointer) {
-  struct TestFacade : poly::Callable<std::vector<std::type_index>()> {};
+  struct TestFacade : spec::Callable<std::vector<std::type_index>()> {};
   pro::proxy<TestFacade> p{ &GetTypeIndices<int, double> };
   auto ret = p();
   ASSERT_EQ(ret, (GetTypeIndices<int, double>()));
@@ -194,7 +194,7 @@ TEST(ProxyInvocationTests, TestFunctionPointer) {
 
 TEST(ProxyInvocationTests, TestCombinationWithIncompleteDispatch) {
   constexpr auto not_implemented = [](auto&&...) { throw std::runtime_error{ "Not implemented!" }; };
-  PRO_DEF_COMBINED_DISPATCH(WeakCall, poly::Call<void()>, decltype(not_implemented));
+  PRO_DEF_COMBINED_DISPATCH(WeakCall, spec::Call<void()>, decltype(not_implemented));
   PRO_DEF_FACADE(WeakCallable, WeakCall);
   {
     int side_effect = 0;
diff --git a/tests/proxy_lifetime_tests.cpp b/tests/proxy_lifetime_tests.cpp
index 47f8a2f..71bc97c 100644
--- a/tests/proxy_lifetime_tests.cpp
+++ b/tests/proxy_lifetime_tests.cpp
@@ -7,7 +7,7 @@
 
 namespace {
 
-PRO_DEF_FACADE(TestFacade, utils::poly::ToString, pro::copyable_ptr_constraints);
+PRO_DEF_FACADE(TestFacade, utils::spec::ToString, pro::copyable_ptr_constraints);
 
 }  // namespace
 
diff --git a/tests/proxy_traits_tests.cpp b/tests/proxy_traits_tests.cpp
index 59e14ef..2530c9c 100644
--- a/tests/proxy_traits_tests.cpp
+++ b/tests/proxy_traits_tests.cpp
@@ -170,7 +170,7 @@ PRO_DEF_FACADE(FacadeWithRuntimeReflection, PRO_MAKE_DISPATCH_PACK(), pro::reloc
 static_assert(!pro::proxiable<MockTrivialPtr, FacadeWithRuntimeReflection>);
 
 struct FacadeWithTupleLikeDispatches {
-  using dispatch_types = std::array<utils::poly::ToString, 1>;
+  using dispatch_types = std::array<utils::spec::ToString, 1>;
   static constexpr auto constraints = pro::relocatable_ptr_constraints;
   using reflection_type = void;
 };
diff --git a/tests/utils.h b/tests/utils.h
index ed62de5..e1dcab7 100644
--- a/tests/utils.h
+++ b/tests/utils.h
@@ -80,12 +80,12 @@ class LifetimeTracker {
   std::vector<LifetimeOperation> ops_;
 };
 
-namespace poly {
+namespace spec {
 
 using std::to_string;
 PRO_DEF_FREE_DISPATCH(ToString, to_string, std::string());
 
-}  // namespace poly
+}  // namespace spec
 
 }  // namespace utils