diff --git a/docs/spec/ProBasicConvention.md b/docs/spec/ProBasicConvention.md
index 1b4dc248..6786e1fc 100644
--- a/docs/spec/ProBasicConvention.md
+++ b/docs/spec/ProBasicConvention.md
@@ -2,11 +2,11 @@
 
 A type `C` meets the *ProBasicConvention* requirements if the following expressions are well-formed and have the specified semantics.
 
-| Expressions                  | Semantics                                                    |
-| ---------------------------- | ------------------------------------------------------------ |
-| `C::is_direct`               | A [core constant expression](https://en.cppreference.com/w/cpp/language/constant_expression) of type `bool`, specifying whether the convention applies to a pointer type itself (`true`), or the element type of a pointer type (`false`). |
-| `typename C::dispatch_type`  | A type that defines how the calls are forwarded to the concrete types. Shall be *nothrow-default-constructible* and *nothrow-destructible*. |
-| `typename C::overload_types` | A [tuple-like](https://en.cppreference.com/w/cpp/utility/tuple/tuple-like) type of one or more distinct types `Os`. Each type `O` in `Os` shall meet the [*ProOverload* requirements](ProOverload.md). |
+| Expressions                                      | Semantics                                                    |
+| ------------------------------------------------ | ------------------------------------------------------------ |
+| `C::is_direct`                                   | A [core constant expression](https://en.cppreference.com/w/cpp/language/constant_expression) of type `bool`, specifying whether the convention applies to a pointer type itself (`true`), or the element type of a pointer type (`false`). |
+| `typename C::dispatch_type`                      | A type that defines how the calls are forwarded to the concrete types. Shall be *nothrow-default-constructible* and *nothrow-destructible*. |
+| `typename C::overload_type`<br />*(since 5.0.0)* | A type that meets the [*ProOverload* requirements](ProOverload.md). |
 
 ## See Also
 
diff --git a/docs/spec/ProConvention.md b/docs/spec/ProConvention.md
index 65734671..2d2ac7c3 100644
--- a/docs/spec/ProConvention.md
+++ b/docs/spec/ProConvention.md
@@ -4,7 +4,7 @@ A type `C` meets the *ProConvention* requirements of a type `P` if `C` meets the
 
 | Expressions                  | Semantics                                                    |
 | ---------------------------- | ------------------------------------------------------------ |
-| `typename C::overload_types` | A [tuple-like](https://en.cppreference.com/w/cpp/utility/tuple/tuple-like) type that contains one or more distinct types `Os`. Each type `O` in `Os` shall meet the [*ProOverload* requirements](ProOverload.md), and<br />- when `C::is_direct` is `true`, `typename C::dispatch_type` shall meet the [*ProDispatch* requirements](ProDispatch.md) of `P` and `O`, <br />- or otherwise, when `C::is_direct` is `false`, let `QP` be a qualified reference type of `P` with the *cv ref* qualifiers defined by `O` (`QP` is an lvalue reference type if `O` does not define a *ref* qualifier), `qp` be a value of `QP`, `*std::forward<QP>(qp)` shall be well-formed, and `typename C::dispatch_type` shall meet the [*ProDispatch* requirements](ProDispatch.md) of `decltype(*std::forward<QP>(qp))` and `O`. |
+| `typename C::overload_type`  | A type `O` that meets the [*ProOverload* requirements](ProOverload.md), where<br />- when `C::is_direct` is `true`, `typename C::dispatch_type` shall meet the [*ProDispatch* requirements](ProDispatch.md) of `P` and `O`, <br />- or otherwise, when `C::is_direct` is `false`, let `QP` be a qualified reference type of `P` with the *cv ref* qualifiers defined by `O` (`QP` is an lvalue reference type if `O` does not define a *ref* qualifier), `qp` be a value of `QP`, `*std::forward<QP>(qp)` shall be well-formed, and `typename C::dispatch_type` shall meet the [*ProDispatch* requirements](ProDispatch.md) of `decltype(*std::forward<QP>(qp))` and `O`. |
 
 ## See Also
 
diff --git a/docs/spec/basic_facade_builder/add_convention.md b/docs/spec/basic_facade_builder/add_convention.md
index 0797eeca..c432c9d6 100644
--- a/docs/spec/basic_facade_builder/add_convention.md
+++ b/docs/spec/basic_facade_builder/add_convention.md
@@ -14,18 +14,20 @@ using add_direct_convention = basic_facade_builder</* see below */>;
 The alias templates `add_convention`, `add_indirect_convention`, and `add_direct_convention` of `basic_facade_builder<Cs, Rs, MaxSize, MaxAlign, Copyability, Relocatability, Destructibility>` add convention types to the template parameters. The expression inside `requires` is equivalent to `sizeof...(Os) > 0u` and each type in `Os` meets the [*ProOverload* requirements](../ProOverload.md). Let `F` be a facade type,
 
 - `add_convention` is equivalent to `add_indirect_convention`.
-- `add_indirect_convention` merges an implementation-defined convention type `IC` into `Cs`, where:
+- `add_indirect_convention` merges an implementation-defined convention type `IC` into `Cs` for each type `O` in `Os`, where:
   - `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<proxy_indirect_accessor<F>, D, `[`substituted-overload<Os, F>`](../ProOverload.md)`...>` if applicable.
-- `add_direct_convention` merges an implementation-defined convention type `IC` into `Cs`, where:
+  - `typename IC::overload_type` is `O`.
+- `add_direct_convention` merges an implementation-defined convention type `IC` into `Cs` for each type `O` in `Os`, 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<proxy<F>, D, `[`substituted-overload<Os, F>`](../ProOverload.md)`...>` if applicable.
+  - `typename IC::overload_type` is `O`.
 
-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.
+When `Cs` already contains a convention type identical to `IC`, the template parameters shall not change.
+
+Let `F` be a facade type. The accessor a convention contributes to a [`proxy`](../proxy/README.md) of `F` is formed per dispatch type rather than per convention: let `Gs` be the types in `Cs` that share `IC::is_direct` and `typename IC::dispatch_type`, and `GOs` be their `overload_type`s in order of first appearance. The accessor is `typename D::template accessor<proxy_indirect_accessor<F>, D, `[`substituted-overload<GOs, F>`](../ProOverload.md)`...>` when `IC::is_direct` is `false`, or `typename D::template accessor<proxy<F>, D, `[`substituted-overload<GOs, F>`](../ProOverload.md)`...>` when it is `true`, if applicable.
+
+*Since 5.0.0*: each type in `Os` produces its own convention type, rather than one convention type carrying a tuple-like `overload_types`.
 
 ## Notes
 
diff --git a/docs/spec/proxy/README.md b/docs/spec/proxy/README.md
index 5e56583f..c32fc567 100644
--- a/docs/spec/proxy/README.md
+++ b/docs/spec/proxy/README.md
@@ -15,9 +15,11 @@ Any instance of `proxy<F>` at any given point in time either *contains a value*
 
 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 `C` in `Cs`, if `C::is_direct` is `true` and `typename C::dispatch_type` meets the [*ProAccessible* requirements](../ProAccessible.md) of `proxy<F>, typename C::dispatch_type, substituted-overload-types...`, `typename C::dispatch_type::template accessor<proxy<F>, typename C::dispatch_type, substituted-overload-types...>` is inherited by `proxy<F>`. Let `Os...` be the element types of `typename C::overload_types`, `substituted-overload-types...` is [`substituted-overload<Os, F>...`](../ProOverload.md).
+- For each distinct dispatch type `D` among the types `C` in `Cs` where `C::is_direct` is `true`, let `Os...` be the overload types of those conventions with duplicates removed, and `substituted-overload-types...` be [`substituted-overload<Os, F>...`](../ProOverload.md). If `D` meets the [*ProAccessible* requirements](../ProAccessible.md) of `proxy<F>, D, substituted-overload-types...`, `typename D::template accessor<proxy<F>, D, substituted-overload-types...>` is inherited by `proxy<F>`.
 - For each type `R` in `Rs`, if `R::is_direct` is `true` and `typename R::reflector_type` meets the [*ProAccessible* requirements](../ProAccessible.md) of `proxy<F>, typename R::reflector_type`, `typename R::reflector_type::template accessor<proxy<F>, typename R::reflector_type` is inherited by `proxy<F>`.
 
+*Since 5.0.0*: the accessor of a dispatch type is formed from the overload types of every convention in `Cs` sharing that dispatch type, rather than from a single convention.
+
 ## Member Types
 
 | Name                               | Description |
diff --git a/docs/spec/proxy/friend_invoke.md b/docs/spec/proxy/friend_invoke.md
index be6fd290..8b8aff89 100644
--- a/docs/spec/proxy/friend_invoke.md
+++ b/docs/spec/proxy/friend_invoke.md
@@ -21,7 +21,7 @@ There shall be a convention type `Conv` defined in `typename F::convention_types
 
 - `Conv::is_direct` is `true`, and
 - `typename Conv::dispatch_type` is `D`, and
-- there shall be an overload type `O1` defined in `typename Conv::overload_types` where [`substituted-overload`](../ProOverload.md)`<O1, F>` is `O`.
+- [`substituted-overload`](../ProOverload.md)`<typename Conv::overload_type, F>` is `O`.
 
 This function is not visible to ordinary [unqualified](https://en.cppreference.com/w/cpp/language/unqualified_lookup) or [qualified lookup](https://en.cppreference.com/w/cpp/language/qualified_lookup). It can only be found by [argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl) when `proxy<F>` is an associated class of the arguments.
 
diff --git a/docs/spec/proxy_indirect_accessor/README.md b/docs/spec/proxy_indirect_accessor/README.md
index fbab8dca..fff00f44 100644
--- a/docs/spec/proxy_indirect_accessor/README.md
+++ b/docs/spec/proxy_indirect_accessor/README.md
@@ -12,9 +12,11 @@ class proxy_indirect_accessor;
 
 Class template `proxy_indirect_accessor` provides indirection accessibility for `proxy`. 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 `C` in `Cs`, if `C::is_direct` is `false` and `typename C::dispatch_type` meets the [*ProAccessible* requirements](../ProAccessible.md) of `proxy_indirect_accessor<F>, typename C::dispatch_type, substituted-overload-types...`, `typename C::dispatch_type::template accessor<proxy<F>, typename C::dispatch_type, substituted-overload-types...>` is inherited by `proxy_indirect_accessor<F>`. Let `Os...` be the element types of `typename C::overload_types`, `substituted-overload-types...` is [`substituted-overload<Os, F>...`](../ProOverload.md).
+- For each distinct dispatch type `D` among the types `C` in `Cs` where `C::is_direct` is `false`, let `Os...` be the overload types of those conventions with duplicates removed, and `substituted-overload-types...` be [`substituted-overload<Os, F>...`](../ProOverload.md). If `D` meets the [*ProAccessible* requirements](../ProAccessible.md) of `proxy_indirect_accessor<F>, D, substituted-overload-types...`, `typename D::template accessor<proxy_indirect_accessor<F>, D, substituted-overload-types...>` is inherited by `proxy_indirect_accessor<F>`.
 - For each type `R` in `Rs`, if `R::is_direct` is `false` and `typename R::reflector_type` meets the [*ProAccessible* requirements](../ProAccessible.md) of `proxy_indirect_accessor<F>, typename R::reflector_type`, `typename R::reflector_type::template accessor<proxy_indirect_accessor<F>, typename R::reflector_type` is inherited by `proxy_indirect_accessor<F>`.
 
+*Since 5.0.0*: the accessor of a dispatch type is formed from the overload types of every convention in `Cs` sharing that dispatch type, rather than from a single convention.
+
 ## Member Functions
 
 | Name                    | Description                               |
diff --git a/docs/spec/proxy_indirect_accessor/friend_invoke.md b/docs/spec/proxy_indirect_accessor/friend_invoke.md
index 0a5e9f1c..f57877f2 100644
--- a/docs/spec/proxy_indirect_accessor/friend_invoke.md
+++ b/docs/spec/proxy_indirect_accessor/friend_invoke.md
@@ -21,7 +21,7 @@ There shall be a convention type `Conv` defined in `typename F::convention_types
 
 - `Conv::is_direct` is `false`, and
 - `typename Conv::dispatch_type` is `D`, and
-- there shall be an overload type `O1` defined in `typename Conv::overload_types` where [`substituted-overload`](../ProOverload.md)`<O1, F>` is `O`.
+- [`substituted-overload`](../ProOverload.md)`<typename Conv::overload_type, F>` is `O`.
 
 This function is not visible to ordinary [unqualified](https://en.cppreference.com/w/cpp/language/unqualified_lookup) or [qualified lookup](https://en.cppreference.com/w/cpp/language/qualified_lookup). It can only be found by [argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl) when `proxy_indirect_accessor<F>` is an associated class of the arguments.
 
diff --git a/include/proxy/v4/detail/core.h b/include/proxy/v4/detail/core.h
index 00b87943..0cd9f41f 100644
--- a/include/proxy/v4/detail/core.h
+++ b/include/proxy/v4/detail/core.h
@@ -77,19 +77,44 @@ struct inapplicable_traits {
   static constexpr bool applicable = false;
 };
 
-template <template <class, class> class R, class O, class... Is>
+template <template <class...> class T, class TL, class Is, class... Args>
+struct specialization_type_traits_impl;
+template <template <class...> class T, class TL, std::size_t... Is,
+          class... Args>
+struct specialization_type_traits_impl<T, TL, std::index_sequence<Is...>,
+                                       Args...>
+    : std::type_identity<T<Args..., std::tuple_element_t<Is, TL>...>> {};
+template <template <class...> class T, class TL, class... Args>
+struct specialization_type_traits
+    : specialization_type_traits_impl<
+          T, TL, std::make_index_sequence<std::tuple_size_v<TL>>, Args...> {};
+template <template <class...> class T, class... Ts, class... Args>
+struct specialization_type_traits<T, std::tuple<Ts...>, Args...>
+    : std::type_identity<T<Args..., Ts...>> {};
+template <template <class...> class T, class TL, class... Args>
+using specialization_t = specialization_type_traits<T, TL, Args...>::type;
+
+template <template <class, class, class...> class R, class... Args>
+struct reduction_t;
+template <class R, class O, class... Is>
 struct recursive_reduction : std::type_identity<O> {};
-template <template <class, class> class R, class O, class I, class... Is>
-struct recursive_reduction<R, O, I, Is...>
-    : recursive_reduction<R, R<O, I>, Is...> {};
-template <template <class, class> class R, class O, class... Is>
+template <template <class, class, class...> class R, class... Args, class O,
+          class I, class... Is>
+struct recursive_reduction<reduction_t<R, Args...>, O, I, Is...>
+    : recursive_reduction<reduction_t<R, Args...>,
+                          typename R<O, I, Args...>::type, Is...> {};
+template <class R, class O, class... Is>
 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 = R<Args..., O, I>::type;
-};
+template <class O, class I, class R>
+struct flattening_reduction : specialization_t<recursive_reduction, I, R, O> {};
+template <class R, class... Tss>
+struct flattening_merge : std::type_identity<std::tuple<>> {};
+template <class R, class Ts, class... Tss>
+struct flattening_merge<R, Ts, Tss...>
+    : recursive_reduction<reduction_t<flattening_reduction, R>, Ts, Tss...> {};
+template <class R, class... Tss>
+using flattening_merge_t = flattening_merge<R, Tss...>::type;
 
 template <class O, class I>
 struct composition_reduction : std::type_identity<O> {};
@@ -100,8 +125,18 @@ template <template <class...> class T, class... Os, class... Is>
 struct composition_reduction<T<Os...>, T<Is...>>
     : std::type_identity<T<Os..., Is...>> {};
 template <class T, class... Us>
-using composite_t = recursive_reduction_t<
-    reduction_traits<composition_reduction>::template type, T, Us...>;
+using composite_t =
+    recursive_reduction_t<reduction_t<composition_reduction>, T, Us...>;
+
+template <class O, class I>
+struct add_tuple_reduction : std::type_identity<O> {};
+template <class... Os, class I>
+  requires(!std::is_same_v<I, Os> && ...)
+struct add_tuple_reduction<std::tuple<Os...>, I>
+    : std::type_identity<std::tuple<Os..., I>> {};
+template <class... Tss>
+using merge_tuples_t =
+    flattening_merge_t<reduction_t<add_tuple_reduction>, Tss...>;
 
 template <class Expr>
 consteval bool is_consteval(Expr) {
@@ -126,23 +161,6 @@ consteval bool is_tuple_like_well_formed() {
   return false;
 }
 
-template <template <class...> class T, class TL, class Is, class... Args>
-struct specialization_type_traits_impl;
-template <template <class...> class T, class TL, std::size_t... Is,
-          class... Args>
-struct specialization_type_traits_impl<T, TL, std::index_sequence<Is...>,
-                                       Args...>
-    : std::type_identity<T<Args..., std::tuple_element_t<Is, TL>...>> {};
-template <template <class...> class T, class TL, class... Args>
-struct specialization_type_traits
-    : specialization_type_traits_impl<
-          T, TL, std::make_index_sequence<std::tuple_size_v<TL>>, Args...> {};
-template <template <class...> class T, class... Ts, class... Args>
-struct specialization_type_traits<T, std::tuple<Ts...>, Args...>
-    : std::type_identity<T<Args..., Ts...>> {};
-template <template <class...> class T, class TL, class... Args>
-using specialization_t = specialization_type_traits<T, TL, Args...>::type;
-
 enum class qualifier_type { lv, const_lv, rv, const_rv };
 template <class T, qualifier_type Q>
 struct add_qualifier_traits;
@@ -362,22 +380,13 @@ consteval bool is_is_direct_well_formed() {
   return false;
 }
 
-template <class C, class... Os>
-struct basic_conv_traits_impl : inapplicable_traits {};
-template <class C, extended_overload... Os>
-  requires(sizeof...(Os) > 0u)
-struct basic_conv_traits_impl<C, Os...> : applicable_traits {};
-template <class C>
-struct basic_conv_traits : inapplicable_traits {};
 template <class C>
-  requires(requires {
-    { typename C::dispatch_type() } noexcept;
-    typename C::overload_types;
-  } && is_is_direct_well_formed<C>() &&
-           is_tuple_like_well_formed<typename C::overload_types>())
-struct basic_conv_traits<C>
-    : specialization_t<basic_conv_traits_impl, typename C::overload_types, C> {
-};
+concept basic_convention =
+    requires {
+      { typename C::dispatch_type() } noexcept;
+      typename C::overload_type;
+    } && is_is_direct_well_formed<C>() &&
+    extended_overload<typename C::overload_type>;
 
 template <class T>
 struct a11y_traits_impl
@@ -391,38 +400,43 @@ template <class T, class... Args>
 struct a11y_traits<std::void_t<typename T::template accessor<Args...>>, T,
                    Args...>
     : a11y_traits_impl<typename T::template accessor<Args...>> {};
-template <class T, class... Args>
-using accessor_t = 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 = 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>
-  using accessor =
-      accessor_t<typename C::dispatch_type, T, typename C::dispatch_type,
-                 substituted_overload_t<Os, F>...>;
+template <class ProP, class T, class... Args>
+using accessor_t = a11y_traits<void, T, ProP, T, Args...>::type;
+
+template <class D, class... Os>
+struct conv_group;
+template <class G, class P, class F>
+struct conv_accessor_traits;
+template <class D, class... Os, class P, class F>
+struct conv_accessor_traits<conv_group<D, Os...>, P, F>
+    : std::type_identity<accessor_t<P, D, substituted_overload_t<Os, F>...>> {};
+
+template <class G, class D>
+struct conv_group_match_traits : inapplicable_traits {};
+template <class D, class... Os>
+struct conv_group_match_traits<conv_group<D, Os...>, D> : applicable_traits {};
+
+template <class G1, class G2>
+struct conv_group_merge_traits : std::type_identity<G1> {};
+template <class D, class... Os1, class... Os2>
+struct conv_group_merge_traits<conv_group<D, Os1...>, conv_group<D, Os2...>>
+    : specialization_type_traits<
+          conv_group, merge_tuples_t<std::tuple<Os1...>, std::tuple<Os2...>>,
+          D> {};
 
-  template <class P>
-  static consteval void diagnose_proxiable() {
-    ((diagnose_proxiable_required_convention_not_implemented<
-         P, F, C::is_direct, typename C::dispatch_type,
-         substituted_overload_t<Os, F>>()),
-     ...);
-  }
-
-  template <class P>
-  static constexpr bool applicable_ptr =
-      (overload_traits<substituted_overload_t<Os, F>>::template applicable_ptr<
-           P, C::is_direct, typename C::dispatch_type> &&
-       ...);
-};
-template <class C, class F>
-struct conv_traits
-    : specialization_t<conv_traits_impl, typename C::overload_types, C, F> {};
+template <class O, class I>
+struct conv_groups_reduction;
+template <class... Gs, class D, class... Os>
+  requires(conv_group_match_traits<Gs, D>::applicable || ...)
+struct conv_groups_reduction<std::tuple<Gs...>, conv_group<D, Os...>>
+    : std::type_identity<std::tuple<typename conv_group_merge_traits<
+          Gs, conv_group<D, Os...>>::type...>> {};
+template <class... Gs, class I>
+struct conv_groups_reduction<std::tuple<Gs...>, I>
+    : std::type_identity<std::tuple<Gs..., I>> {};
+template <class... Gss>
+using conv_groups_merge_t =
+    flattening_merge_t<reduction_t<conv_groups_reduction>, Gss...>;
 
 template <bool IsDirect, class R>
 struct reflection_meta {
@@ -499,36 +513,15 @@ using lifetime_meta_t = lifetime_meta_traits<F, D, ONE, OE, C>::type;
 template <class... As>
 struct PRO4D_ENFORCE_EBO composite_accessor : As... {};
 
-template <class C, class F, bool IsDirect>
-struct conv_accessor_traits : std::type_identity<void> {};
-template <class C, class F>
-  requires(!C::is_direct)
-struct conv_accessor_traits<C, F, false>
-    : std::type_identity<typename conv_traits<C, F>::template accessor<
-          proxy_indirect_accessor<F>>> {};
-template <class C, class F>
-  requires(C::is_direct)
-struct conv_accessor_traits<C, F, true>
-    : std::type_identity<
-          typename conv_traits<C, F>::template accessor<proxy<F>>> {};
-template <class C, class F, bool IsDirect>
-using conv_accessor_t = conv_accessor_traits<C, F, IsDirect>::type;
-
-template <class R, class F, bool IsDirect>
-struct refl_accessor_traits : std::type_identity<void> {};
-template <class R, class F>
-  requires(!R::is_direct)
-struct refl_accessor_traits<R, F, false>
-    : std::type_identity<
-          accessor_t<typename R::reflector_type, proxy_indirect_accessor<F>,
-                     typename R::reflector_type>> {};
-template <class R, class F>
-  requires(R::is_direct)
-struct refl_accessor_traits<R, F, true>
-    : std::type_identity<accessor_t<typename R::reflector_type, proxy<F>,
-                                    typename R::reflector_type>> {};
-template <class R, class F, bool IsDirect>
-using refl_accessor_t = refl_accessor_traits<R, F, IsDirect>::type;
+template <class P, class F, class... Gs>
+using conv_accessors_t =
+    composite_t<composite_accessor<>,
+                typename conv_accessor_traits<Gs, P, F>::type...>;
+
+template <class P, class... Rs>
+using refl_accessors_t =
+    composite_t<composite_accessor<>,
+                accessor_t<P, typename Rs::reflector_type>...>;
 
 template <class T>
 concept pointer_like = (std::is_pointer_v<T> ||
@@ -597,7 +590,7 @@ consteval bool is_facade_constraints_well_formed() {
 template <class... Cs>
 struct basic_facade_conv_traits_impl : inapplicable_traits {};
 template <class... Cs>
-  requires(basic_conv_traits<Cs>::applicable && ...)
+  requires(basic_convention<Cs> && ...)
 struct basic_facade_conv_traits_impl<Cs...> : applicable_traits {};
 template <class... Rs>
 struct basic_facade_refl_traits_impl : inapplicable_traits {};
@@ -623,30 +616,53 @@ struct basic_facade_traits<F> : applicable_traits {};
 
 template <class F, class... Cs>
 struct facade_conv_traits_impl {
-  using conv_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 =
-      composite_t<composite_accessor<>, conv_accessor_t<Cs, F, true>...>;
+  static_assert(
+      (overload_traits<
+           substituted_overload_t<typename Cs::overload_type, F>>::applicable &&
+       ...),
+      "a facade-aware overload did not substitute into a valid overload");
+  using conv_meta = std::tuple<invoker<
+      std::conditional_t<Cs::is_direct, proxy<F>, proxy_indirect_accessor<F>>,
+      typename Cs::dispatch_type,
+      substituted_overload_t<typename Cs::overload_type, F>>...>;
+  using indirect_conv_groups = conv_groups_merge_t<
+      std::tuple<>,
+      composite_t<
+          std::tuple<>,
+          std::conditional_t<Cs::is_direct, void,
+                             conv_group<typename Cs::dispatch_type,
+                                        typename Cs::overload_type>>...>>;
+  using direct_conv_groups = conv_groups_merge_t<
+      std::tuple<>,
+      composite_t<std::tuple<>,
+                  std::conditional_t<Cs::is_direct,
+                                     conv_group<typename Cs::dispatch_type,
+                                                typename Cs::overload_type>,
+                                     void>...>>;
 
   template <class P>
   static consteval void diagnose_proxiable_conv() {
-    (conv_traits<Cs, F>::template diagnose_proxiable<P>(), ...);
+    (diagnose_proxiable_required_convention_not_implemented<
+         P, F, Cs::is_direct, typename Cs::dispatch_type,
+         substituted_overload_t<typename Cs::overload_type, F>>(),
+     ...);
   }
 
   template <class P>
   static constexpr bool conv_applicable_ptr =
-      (conv_traits<Cs, F>::template applicable_ptr<P> && ...);
+      (overload_traits<substituted_overload_t<typename Cs::overload_type, F>>::
+           template applicable_ptr<P, Cs::is_direct,
+                                   typename Cs::dispatch_type> &&
+       ...);
 };
 template <class F, class... Rs>
 struct facade_refl_traits_impl {
   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>...>;
-  using refl_direct_accessor =
-      composite_t<composite_accessor<>, refl_accessor_t<Rs, F, true>...>;
+  using indirect_refls =
+      composite_t<std::tuple<>, std::conditional_t<Rs::is_direct, void, Rs>...>;
+  using direct_refls =
+      composite_t<std::tuple<>, std::conditional_t<Rs::is_direct, Rs, void>...>;
 
   template <class P>
   static consteval void diagnose_proxiable_refl() {
@@ -678,12 +694,17 @@ struct facade_traits : specialization_t<facade_conv_traits_impl,
                           F::destructibility>,
           typename facade_traits::conv_meta,
           typename facade_traits::refl_meta>>;
-  using indirect_accessor =
-      composite_t<typename facade_traits::conv_indirect_accessor,
-                  typename facade_traits::refl_indirect_accessor>;
-  using direct_accessor =
-      composite_t<typename facade_traits::conv_direct_accessor,
-                  typename facade_traits::refl_direct_accessor>;
+  using indirect_accessor = composite_t<
+      specialization_t<conv_accessors_t,
+                       typename facade_traits::indirect_conv_groups,
+                       proxy_indirect_accessor<F>, F>,
+      specialization_t<refl_accessors_t, typename facade_traits::indirect_refls,
+                       proxy_indirect_accessor<F>>>;
+  using direct_accessor = composite_t<
+      specialization_t<conv_accessors_t,
+                       typename facade_traits::direct_conv_groups, proxy<F>, F>,
+      specialization_t<refl_accessors_t, typename facade_traits::direct_refls,
+                       proxy<F>>>;
 
   template <class P>
   [[noreturn]] static consteval void diagnose_proxiable_noreturn() {
@@ -1305,11 +1326,11 @@ struct cast_dispatch_base {
 };
 #undef PRO4D_DEF_CAST_ACCESSOR
 
-template <bool IsDirect, class D, class... Os>
+template <bool IsDirect, class D, class O>
 struct conv_impl {
   static constexpr bool is_direct = IsDirect;
   using dispatch_type = D;
-  using overload_types = std::tuple<Os...>;
+  using overload_type = O;
 };
 template <bool IsDirect, class R>
 struct refl_impl {
@@ -1329,27 +1350,6 @@ struct facade_impl {
   static constexpr constraint_level destructibility = Destructibility;
 };
 
-template <class O, class I>
-struct add_tuple_reduction : std::type_identity<O> {};
-template <class... Os, class I>
-  requires(!std::is_same_v<I, Os> && ...)
-struct add_tuple_reduction<std::tuple<Os...>, I>
-    : std::type_identity<std::tuple<Os..., I>> {};
-template <class O, class... Is>
-using add_tuple_t =
-    recursive_reduction_t<reduction_traits<add_tuple_reduction>::template type,
-                          O, Is...>;
-
-template <bool IsDirect, class D>
-struct conv_specialization_helper {
-  template <class... Os>
-  using type = conv_impl<IsDirect, D, Os...>;
-};
-template <bool IsDirect, class D, class Os>
-using conv_specialization_t =
-    specialization_t<conv_specialization_helper<IsDirect, D>::template type,
-                     Os>;
-
 template <class LR, class CLR, class RR, class CRR>
 class observer_ptr {
 public:
@@ -1371,25 +1371,22 @@ class observer_ptr {
 template <class O>
 using observer_substitution_overload =
     proxy_view<typename ret_t<O>::facade_type>() const noexcept;
-template <class... Os>
-using observer_substitution_conv = conv_specialization_t<
-    true, substitution_dispatch,
-    add_tuple_t<std::tuple<>, observer_substitution_overload<Os>...>>;
-
 template <class C>
 struct observer_conv_traits : std::type_identity<void> {};
 template <class C>
   requires(C::is_direct &&
            std::is_same_v<typename C::dispatch_type, substitution_dispatch>)
 struct observer_conv_traits<C>
-    : std::type_identity<specialization_t<observer_substitution_conv,
-                                          typename C::overload_types>> {};
+    : std::type_identity<conv_impl<
+          true, substitution_dispatch,
+          observer_substitution_overload<typename C::overload_type>>> {};
 template <class C>
   requires(!C::is_direct)
 struct observer_conv_traits<C> : std::type_identity<C> {};
 template <class... Cs>
-using observer_conv_types =
-    composite_t<std::tuple<>, typename observer_conv_traits<Cs>::type...>;
+using observer_conv_types = merge_tuples_t<
+    std::tuple<>,
+    composite_t<std::tuple<>, typename observer_conv_traits<Cs>::type...>>;
 template <class... Rs>
 using observer_refl_types =
     composite_t<std::tuple<>, std::conditional_t<Rs::is_direct, void, Rs>...>;
@@ -1418,23 +1415,19 @@ struct weak_substitution_overload_traits;
       : std::type_identity<weak_proxy<F>() oq ne> {};
 PRO4D_DEF_OVERLOAD_SPECIALIZATIONS(PRO4D_DEF_WEAK_SUBSTITUTION_OVERLOAD_TRAITS)
 #undef PRO4D_DEF_WEAK_SUBSTITUTION_OVERLOAD_TRAITS
-template <class... Os>
-using weak_substitution_conv =
-    conv_impl<true, substitution_dispatch,
-              typename weak_substitution_overload_traits<Os>::type...>;
-
 template <class C>
 struct weak_conv_traits : std::type_identity<void> {};
 template <class C>
   requires(C::is_direct &&
            std::is_same_v<typename C::dispatch_type, substitution_dispatch>)
 struct weak_conv_traits<C>
-    : std::type_identity<specialization_t<weak_substitution_conv,
-                                          typename C::overload_types>> {};
+    : std::type_identity<conv_impl<true, substitution_dispatch,
+                                   typename weak_substitution_overload_traits<
+                                       typename C::overload_type>::type>> {};
 template <class F, class... Cs>
-using weak_conv_types = composite_t<
+using weak_conv_types = merge_tuples_t<
     std::tuple<conv_impl<true, weak_mem_lock, proxy<F>() const noexcept>>,
-    typename weak_conv_traits<Cs>::type...>;
+    composite_t<std::tuple<>, typename weak_conv_traits<Cs>::type...>>;
 
 } // namespace detail
 
diff --git a/include/proxy/v4/detail/facade_creation.h b/include/proxy/v4/detail/facade_creation.h
index 6e82c86d..a86a2140 100644
--- a/include/proxy/v4/detail/facade_creation.h
+++ b/include/proxy/v4/detail/facade_creation.h
@@ -31,33 +31,6 @@ consteval std::size_t max_align_of(std::size_t value) {
 
 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>
-using merge_conv_t = conv_specialization_t<
-    C1::is_direct, typename C1::dispatch_type,
-    merge_tuple_t<typename C1::overload_types, typename C2::overload_types>>;
-
-template <class Cs1, class C2, class C>
-struct add_conv_reduction;
-template <class... Cs1, class C2, class... Cs3, class C>
-struct add_conv_reduction<std::tuple<Cs1...>, std::tuple<C2, Cs3...>, C>
-    : add_conv_reduction<std::tuple<Cs1..., C2>, std::tuple<Cs3...>, C> {};
-template <class... Cs1, class C2, class... Cs3, class C>
-  requires(
-      C::is_direct == C2::is_direct &&
-      std::is_same_v<typename C::dispatch_type, typename C2::dispatch_type>)
-struct add_conv_reduction<std::tuple<Cs1...>, std::tuple<C2, Cs3...>, C>
-    : std::type_identity<std::tuple<Cs1..., merge_conv_t<C2, C>, Cs3...>> {};
-template <class... Cs, class C>
-struct add_conv_reduction<std::tuple<Cs...>, std::tuple<>, C>
-    : std::type_identity<std::tuple<
-          Cs..., merge_conv_t<
-                     conv_impl<C::is_direct, typename C::dispatch_type>, C>>> {
-};
-template <class Cs, class C>
-using add_conv_t = add_conv_reduction<std::tuple<>, Cs, C>::type;
-
 template <class F, constraint_level CL>
 using copy_conversion_overload =
     proxy<F>() const& noexcept(CL >= constraint_level::nothrow);
@@ -66,26 +39,25 @@ using move_conversion_overload =
     proxy<F>() && noexcept(CL >= constraint_level::nothrow);
 template <class Cs, class F, constraint_level CCL, constraint_level RCL>
 struct add_substitution_conv
-    : std::type_identity<add_conv_t<
-          Cs, conv_specialization_t<
-                  true, substitution_dispatch,
-                  composite_t<
-                      std::tuple<>,
-                      std::conditional_t<CCL == constraint_level::none, void,
-                                         copy_conversion_overload<F, CCL>>,
-                      std::conditional_t<RCL == constraint_level::none, void,
-                                         move_conversion_overload<F, RCL>>>>>> {
+    : std::type_identity<merge_tuples_t<
+          Cs, composite_t<std::tuple<>,
+                          std::conditional_t<
+                              CCL == constraint_level::none, void,
+                              conv_impl<true, substitution_dispatch,
+                                        copy_conversion_overload<F, CCL>>>,
+                          std::conditional_t<
+                              RCL == constraint_level::none, void,
+                              conv_impl<true, substitution_dispatch,
+                                        move_conversion_overload<F, RCL>>>>>> {
 };
 template <class Cs, class F>
 struct add_substitution_conv<Cs, F, constraint_level::none,
                              constraint_level::none> : std::type_identity<Cs> {
 };
 
-template <class Cs1, class... Cs2>
-using merge_conv_tuple_t = recursive_reduction_t<add_conv_t, Cs1, Cs2...>;
 template <class Cs, class F, bool WithSubstitution>
 using merge_facade_conv_t = add_substitution_conv<
-    specialization_t<merge_conv_tuple_t, typename F::convention_types, Cs>, F,
+    merge_tuples_t<Cs, typename F::convention_types>, F,
     WithSubstitution ? F::copyability : constraint_level::none,
     (WithSubstitution && F::copyability != constraint_level::trivial)
         ? F::relocatability
@@ -108,24 +80,25 @@ struct basic_facade_builder {
   template <class D, detail::extended_overload... Os>
     requires(sizeof...(Os) > 0u)
   using add_indirect_convention = basic_facade_builder<
-      detail::add_conv_t<Cs, detail::conv_impl<false, D, Os...>>, Rs, MaxSize,
-      MaxAlign, Copyability, Relocatability, Destructibility>;
+      detail::merge_tuples_t<Cs,
+                             std::tuple<detail::conv_impl<false, D, Os>...>>,
+      Rs, MaxSize, MaxAlign, Copyability, Relocatability, Destructibility>;
   template <class D, detail::extended_overload... Os>
     requires(sizeof...(Os) > 0u)
   using add_direct_convention = basic_facade_builder<
-      detail::add_conv_t<Cs, detail::conv_impl<true, D, Os...>>, Rs, MaxSize,
-      MaxAlign, Copyability, Relocatability, Destructibility>;
+      detail::merge_tuples_t<Cs, std::tuple<detail::conv_impl<true, D, Os>...>>,
+      Rs, MaxSize, MaxAlign, Copyability, Relocatability, Destructibility>;
   template <class D, detail::extended_overload... Os>
     requires(sizeof...(Os) > 0u)
   using add_convention = add_indirect_convention<D, Os...>;
   template <class R>
   using add_indirect_reflection = basic_facade_builder<
-      Cs, detail::add_tuple_t<Rs, detail::refl_impl<false, R>>, MaxSize,
-      MaxAlign, Copyability, Relocatability, Destructibility>;
+      Cs, detail::merge_tuples_t<Rs, std::tuple<detail::refl_impl<false, R>>>,
+      MaxSize, MaxAlign, Copyability, Relocatability, Destructibility>;
   template <class R>
   using add_direct_reflection = basic_facade_builder<
-      Cs, detail::add_tuple_t<Rs, detail::refl_impl<true, R>>, MaxSize,
-      MaxAlign, Copyability, Relocatability, Destructibility>;
+      Cs, detail::merge_tuples_t<Rs, std::tuple<detail::refl_impl<true, R>>>,
+      MaxSize, MaxAlign, Copyability, Relocatability, Destructibility>;
   template <class R>
   using add_reflection = add_indirect_reflection<R>;
   template <facade F, bool WithSubstitution = false>
@@ -133,7 +106,7 @@ struct basic_facade_builder {
       detail::merge_facade_conv_t<
           Cs, F,
           detail::add_facade_deprecation_traits<WithSubstitution>::value>,
-      detail::merge_tuple_t<Rs, typename F::reflection_types>,
+      detail::merge_tuples_t<Rs, typename F::reflection_types>,
       detail::merge_size(MaxSize, F::max_size),
       detail::merge_size(MaxAlign, F::max_align),
       detail::merge_constraint(Copyability, F::copyability),
@@ -142,7 +115,7 @@ struct basic_facade_builder {
   template <facade F>
   using add_facade_with_substitution = basic_facade_builder<
       detail::merge_facade_conv_t<Cs, F, true>,
-      detail::merge_tuple_t<Rs, typename F::reflection_types>,
+      detail::merge_tuples_t<Rs, typename F::reflection_types>,
       detail::merge_size(MaxSize, F::max_size),
       detail::merge_size(MaxAlign, F::max_align),
       detail::merge_constraint(Copyability, F::copyability),
diff --git a/tests/proxy_traits_tests.cpp b/tests/proxy_traits_tests.cpp
index cc13c6ba..1d18a3c7 100644
--- a/tests/proxy_traits_tests.cpp
+++ b/tests/proxy_traits_tests.cpp
@@ -280,7 +280,7 @@ struct FacadeWithTupleLikeConventions {
   struct ToStringConvention {
     static constexpr bool is_direct = false;
     using dispatch_type = utils::spec::FreeToString;
-    using overload_types = std::tuple<std::string()>;
+    using overload_type = std::string();
   };
   using convention_types = std::array<ToStringConvention, 1>;
   using reflection_types = std::tuple<>;