From 31efa6dcc9c3b9c8c46a2a4cde98637979fae892 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@outlook.com>
Date: Sat, 15 Aug 2026 15:43:48 +0800
Subject: [PATCH] Give each convention a single overload type

A convention used to carry a tuple-like overload_types, so adding a
convention had to search Cs for an existing convention with the same
is_direct and dispatch_type and merge the overload lists into it. That
merge is the only reason add_conv_t, merge_conv_t, add_conv_reduction,
and conv_specialization_t exist.

Replace overload_types with a single overload_type, so add_convention
contributes one convention per overload and merging a convention into Cs
becomes deduplicating concatenation. Duplicates are still collapsed, so
build() is unaffected at both compile time and run time.

Accessors still have to be formed per dispatch type, or a dispatch with
several overloads would contribute several accessor bases instead of one
overload set. Regroup the conventions by dispatch type via conv_group
and conv_groups_merge_t just before generating the accessors, which also
keeps overload shadowing working.

Generalize the reduction helpers to carry extra arguments (reduction_t)
and add flattening_merge_t, which merge_tuples_t and conv_groups_merge_t
are both expressed in terms of.

This changes the ProBasicConvention and ProConvention requirements, so a
hand-written convention type must be updated.
---
 docs/spec/ProBasicConvention.md               |  10 +-
 docs/spec/ProConvention.md                    |   2 +-
 .../basic_facade_builder/add_convention.md    |  16 +-
 docs/spec/proxy/README.md                     |   4 +-
 docs/spec/proxy/friend_invoke.md              |   2 +-
 docs/spec/proxy_indirect_accessor/README.md   |   4 +-
 .../proxy_indirect_accessor/friend_invoke.md  |   2 +-
 include/proxy/v4/detail/core.h                | 323 +++++++++---------
 include/proxy/v4/detail/facade_creation.h     |  71 ++--
 tests/proxy_traits_tests.cpp                  |   2 +-
 10 files changed, 204 insertions(+), 232 deletions(-)

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<>;