diff --git a/include/proxy/v4/proxy.h b/include/proxy/v4/proxy.h
index 2b26da3..21f9c4c 100644
--- a/include/proxy/v4/proxy.h
+++ b/include/proxy/v4/proxy.h
@@ -2131,119 +2131,412 @@ using facade_builder =
                          details::invalid_cl, details::invalid_cl>;
 
 // =============================================================================
-// == Skill Extensions (skills::rtti, skills::format, etc.)                   ==
+// == Dispatch Extensions (operator_dispatch, weak_dispatch, etc.)            ==
 // =============================================================================
 
-#if __cpp_rtti >= 199711L
-class bad_proxy_cast : public std::bad_cast {
-public:
-  char const* what() const noexcept override {
-    return "pro::v4::bad_proxy_cast";
+namespace details {
+
+template <std::size_t N>
+struct sign {
+  consteval sign(const char (&str)[N + 1]) {
+    if (str[N] != '\0') {
+      PROD_UNREACHABLE();
+    }
+    for (std::size_t i = 0; i < N; ++i) {
+      value[i] = str[i];
+    }
   }
-};
-#endif // __cpp_rtti >= 199711L
 
-namespace details {
+  char value[N];
+};
+template <std::size_t N>
+sign(const char (&str)[N]) -> sign<N - 1u>;
 
-template <template <class...> class TT, class... Ctx>
-struct enabled_t {};
-template <class T, template <class...> class TT, class... Ctx>
-concept enabled_for = std::is_base_of_v<enabled_t<TT, Ctx...>, T>;
+// When std::reference_constructs_from_temporary_v (C++23) is not available, we
+// fall back to a conservative approximation that disallows binding a temporary
+// to a reference type if the source type is not a reference or if the source
+// and target reference types are not compatible.
+template <class T, class U>
+concept explicitly_convertible =
+    std::is_constructible_v<U, T> &&
+#if __cpp_lib_reference_from_temporary >= 202202L
+    !std::reference_constructs_from_temporary_v<U, T>;
+#else
+    (!std::is_reference_v<U> ||
+     (std::is_reference_v<T> &&
+      std::is_convertible_v<std::add_pointer_t<std::remove_reference_t<T>>,
+                            std::add_pointer_t<std::remove_reference_t<U>>>));
+#endif // __cpp_lib_reference_from_temporary >= 202202L
 
-struct view_conversion_dispatch : cast_dispatch_base<false, true> {
+struct noreturn_conversion {
   template <class T>
-  PRO4D_STATIC_CALL(auto, T& value) noexcept
-    requires(requires {
-      { std::addressof(*value) } noexcept;
-    })
-  {
-    return observer_ptr<decltype(*value), decltype(*std::as_const(value)),
-                        decltype(*std::move(value)),
-                        decltype(*std::move(std::as_const(value)))>{*value};
+  [[noreturn]] PRO4D_STATIC_CALL(T, std::in_place_type_t<T>) {
+    PROD_UNREACHABLE();
   }
 };
-template <class F>
-using view_conversion_overload = proxy_view<F>() & noexcept;
+using wildcard = converter<noreturn_conversion>;
 
-struct weak_conversion_dispatch : cast_dispatch_base<false, true> {
-  template <class P>
-  PRO4D_STATIC_CALL(auto, const P& self) noexcept
-    requires(requires(const typename P::weak_type& w) {
-      { w.lock() } noexcept;
-    } && std::is_convertible_v<const P&, typename P::weak_type>)
-  {
-    return converter{
-        [&self]<class F>(std::in_place_type_t<proxy<F>>) noexcept
-          requires(proxiable<typename P::weak_type, F>)
-        { return proxy<F>{std::in_place_type<typename P::weak_type>, self}; }};
-  }
-};
-template <class F>
-using weak_conversion_overload = weak_proxy<F>() const noexcept;
+} // namespace details
 
-template <template <class...> class Formatter,
-          template <class...> class StringView,
-          template <class...> class ParseContext,
-          template <class...> class FormatContext>
-struct format_traits {
-  template <class CharT>
-  using overload = typename FormatContext<CharT>::iterator(
-      StringView<CharT> spec, FormatContext<CharT>& fc) const;
+template <details::sign Sign, bool Rhs = false>
+struct operator_dispatch;
 
-  struct dispatch {
-    template <class T, class CharT>
-    PRO4D_STATIC_CALL(auto, const T& self, StringView<CharT> spec,
-                      FormatContext<CharT>& fc)
-      requires(std::is_default_constructible_v<Formatter<T, CharT>>)
-    {
-      Formatter<T, CharT> impl;
-      {
-        ParseContext<CharT> pc{spec};
-        impl.parse(pc);
-      }
-      return impl.format(self, fc);
-    }
+#define PROD_DEF_LHS_LEFT_OP_ACCESSOR(oq, pq, ne, ...)                         \
+  template <class P, class D, class R>                                         \
+  struct accessor<P, D, R() oq ne> {                                           \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
+    R __VA_ARGS__() oq ne {                                                    \
+      return invoke<D, R() oq ne>(static_cast<P pq>(*this));                   \
+    }                                                                          \
+  }
+#define PROD_DEF_LHS_UNARY_OP_ACCESSOR(oq, pq, ne, ...)                        \
+  template <class P, class D, class R>                                         \
+  struct accessor<P, D, R() oq ne> {                                           \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
+    decltype(auto) __VA_ARGS__() oq ne {                                       \
+      invoke<D, R() oq ne>(static_cast<P pq>(*this));                          \
+      return static_cast<P pq>(*this);                                         \
+    }                                                                          \
+  };                                                                           \
+  template <class P, class D, class R>                                         \
+  struct accessor<P, D, R(int) oq ne> {                                        \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
+    R __VA_ARGS__(int) oq ne {                                                 \
+      return invoke<D, R(int) oq ne>(static_cast<P pq>(*this), 0);             \
+    }                                                                          \
+  }
+#define PROD_DEF_LHS_BINARY_OP_ACCESSOR PRO4D_DEF_MEM_ACCESSOR
+#define PROD_DEF_LHS_ALL_OP_ACCESSOR PRO4D_DEF_MEM_ACCESSOR
+#define PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL(...)                               \
+  template <class T>                                                           \
+  PRO4D_STATIC_CALL(decltype(auto), T&& self)                                  \
+  PRO4D_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self))
+#define PROD_LHS_UNARY_OP_DISPATCH_BODY_IMPL(...)                              \
+  template <class T>                                                           \
+  PRO4D_STATIC_CALL(decltype(auto), T&& self)                                  \
+  PRO4D_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self)) template <class T> \
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, int)                             \
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self) __VA_ARGS__)
+#define PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL(...)                             \
+  template <class T, class Arg>                                                \
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                       \
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)                                 \
+                             __VA_ARGS__ std::forward<Arg>(arg))
+#define PROD_LHS_ALL_OP_DISPATCH_BODY_IMPL(...)                                \
+  PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                             \
+  PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)
+#define PROD_LHS_OP_DISPATCH_IMPL(type, ...)                                   \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, false> {                              \
+    PROD_LHS_##type##_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                       \
+        PRO4D_DEF_ACCESSOR_TEMPLATE(                                           \
+            MEM, PROD_DEF_LHS_##type##_OP_ACCESSOR, operator __VA_ARGS__)      \
+  };
 
-    template <class P, class D, class... Os>
-    struct PRO4D_ENFORCE_EBO accessor : accessor<P, D, Os>... {};
-    template <class P, class D>
-    struct accessor<P, D, overload<char>> : enabled_t<Formatter, char> {};
-    template <class P, class D>
-    struct accessor<P, D, overload<wchar_t>> : enabled_t<Formatter, wchar_t> {};
+#define PROD_DEF_RHS_OP_ACCESSOR(oq, pq, ne, ...)                              \
+  template <class P, class D, class R, class Arg>                              \
+  struct accessor<P, D, R(Arg) oq ne> {                                        \
+    friend R operator __VA_ARGS__(Arg arg, P pq self) ne {                     \
+      return invoke<D, R(Arg) oq ne>(static_cast<P pq>(self),                  \
+                                     std::forward<Arg>(arg));                  \
+    }                                                                          \
+    PRO4D_DEBUG(                                                             \
+      accessor() noexcept { std::ignore = &pro_symbol_guard; }               \
+                                                                             \
+    private:                                                                 \
+      static inline R pro_symbol_guard(Arg arg, P pq self) {                 \
+        return std::forward<Arg>(arg) __VA_ARGS__ static_cast<P pq>(self);   \
+      }                                                                      \
+    ) \
+  }
+#define PROD_RHS_OP_DISPATCH_IMPL(...)                                         \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, true> {                               \
+    template <class T, class Arg>                                              \
+    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
+    PRO4D_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                              \
+                               __VA_ARGS__ std::forward<T>(self))              \
+        PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PROD_DEF_RHS_OP_ACCESSOR,            \
+                                    __VA_ARGS__)                               \
   };
 
-  template <class CharT>
-  struct formatter {
-    constexpr auto parse(ParseContext<CharT>& pc) {
-      for (auto it = pc.begin(); it != pc.end(); ++it) {
-        if (*it == '}') {
-          spec_ = StringView<CharT>{pc.begin(), it + 1};
-          return it;
-        }
-      }
-      return pc.end();
-    }
+#define PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(...)                             \
+  PROD_LHS_OP_DISPATCH_IMPL(ALL, __VA_ARGS__)                                  \
+  PROD_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
 
-    template <class P, class CompatibleFormatContext>
-    auto format(const P& p, CompatibleFormatContext& fc) const ->
-        typename CompatibleFormatContext::iterator {
-      return invoke<dispatch, overload<CharT>>(p, spec_, fc);
-    }
+#define PROD_BINARY_OP_DISPATCH_IMPL(...)                                      \
+  PROD_LHS_OP_DISPATCH_IMPL(BINARY, __VA_ARGS__)                               \
+  PROD_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
 
-  private:
-    StringView<CharT> spec_;
+#define PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR(oq, pq, ne, ...)                   \
+  template <class P, class D, class R, class Arg>                              \
+  struct accessor<P, D, R(Arg) oq ne> {                                        \
+    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
+    decltype(auto) __VA_ARGS__(Arg arg) oq ne {                                \
+      invoke<D, R(Arg) oq ne>(static_cast<P pq>(*this),                        \
+                              std::forward<Arg>(arg));                         \
+      return static_cast<P pq>(*this);                                         \
+    }                                                                          \
+  }
+#define PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR(oq, pq, ne, ...)                   \
+  template <class P, class D, class R, class Arg>                              \
+  struct accessor<P, D, R(Arg&) oq ne> {                                       \
+    friend Arg& operator __VA_ARGS__(Arg& arg, P pq self) ne {                 \
+      invoke<D, R(Arg&) oq ne>(static_cast<P pq>(self), arg);                  \
+      return arg;                                                              \
+    }                                                                          \
+    PRO4D_DEBUG(                                                               \
+        accessor() noexcept { std::ignore = &pro_symbol_guard; }               \
+                                                                               \
+        private : static inline Arg& pro_symbol_guard(                         \
+            Arg& arg,                                                          \
+            P pq self) { return arg __VA_ARGS__ static_cast<P pq>(self); })    \
+  }
+#define PROD_ASSIGNMENT_OP_DISPATCH_IMPL(...)                                  \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, false> {                              \
+    template <class T, class Arg>                                              \
+    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
+    PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)                               \
+                               __VA_ARGS__ std::forward<Arg>(arg))             \
+        PRO4D_DEF_ACCESSOR_TEMPLATE(                                           \
+            MEM, PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR, operator __VA_ARGS__)    \
+  };                                                                           \
+  template <>                                                                  \
+  struct operator_dispatch<#__VA_ARGS__, true> {                               \
+    template <class T, class Arg>                                              \
+    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
+    PRO4D_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                              \
+                               __VA_ARGS__ std::forward<T>(self))              \
+        PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR, \
+                                    __VA_ARGS__)                               \
   };
-};
 
-#ifdef PRO4D_HAS_FORMAT
-template <class CharT>
-struct std_format_context_traits;
-template <>
-struct std_format_context_traits<char>
-    : std::type_identity<std::format_context> {};
-template <>
-struct std_format_context_traits<wchar_t>
-    : std::type_identity<std::wformat_context> {};
+PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(+)
+PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(-)
+PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(*)
+PROD_BINARY_OP_DISPATCH_IMPL(/)
+PROD_BINARY_OP_DISPATCH_IMPL(%)
+PROD_LHS_OP_DISPATCH_IMPL(UNARY, ++)
+PROD_LHS_OP_DISPATCH_IMPL(UNARY, --)
+PROD_BINARY_OP_DISPATCH_IMPL(==)
+PROD_BINARY_OP_DISPATCH_IMPL(!=)
+PROD_BINARY_OP_DISPATCH_IMPL(>)
+PROD_BINARY_OP_DISPATCH_IMPL(<)
+PROD_BINARY_OP_DISPATCH_IMPL(>=)
+PROD_BINARY_OP_DISPATCH_IMPL(<=)
+PROD_BINARY_OP_DISPATCH_IMPL(<=>)
+PROD_LHS_OP_DISPATCH_IMPL(LEFT, !)
+PROD_BINARY_OP_DISPATCH_IMPL(&&)
+PROD_BINARY_OP_DISPATCH_IMPL(||)
+PROD_LHS_OP_DISPATCH_IMPL(LEFT, ~)
+PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(&)
+PROD_BINARY_OP_DISPATCH_IMPL(|)
+PROD_BINARY_OP_DISPATCH_IMPL(^)
+PROD_BINARY_OP_DISPATCH_IMPL(<<)
+PROD_BINARY_OP_DISPATCH_IMPL(>>)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(+=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(-=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(*=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(/=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(%=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(&=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(|=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(^=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(<<=)
+PROD_ASSIGNMENT_OP_DISPATCH_IMPL(>>=)
+PROD_BINARY_OP_DISPATCH_IMPL(, )
+PROD_BINARY_OP_DISPATCH_IMPL(->*)
+
+template <>
+struct operator_dispatch<"()", false> {
+  template <class T, class... Args>
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)(std::forward<Args>(args)...))
+      PRO4D_DEF_ACCESSOR_TEMPLATE(MEM, PRO4D_DEF_MEM_ACCESSOR, operator())
+};
+template <>
+struct operator_dispatch<"[]", false> {
+#if __cpp_multidimensional_subscript >= 202110L
+  template <class T, class... Args>
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Args>(args)...])
+#else
+  template <class T, class Arg>
+  PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)
+  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Arg>(arg)])
+#endif // __cpp_multidimensional_subscript >= 202110L
+      PRO4D_DEF_ACCESSOR_TEMPLATE(MEM, PRO4D_DEF_MEM_ACCESSOR, operator[])
+};
+
+#undef PROD_ASSIGNMENT_OP_DISPATCH_IMPL
+#undef PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR
+#undef PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR
+#undef PROD_BINARY_OP_DISPATCH_IMPL
+#undef PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL
+#undef PROD_RHS_OP_DISPATCH_IMPL
+#undef PROD_DEF_RHS_OP_ACCESSOR
+#undef PROD_LHS_OP_DISPATCH_IMPL
+#undef PROD_LHS_ALL_OP_DISPATCH_BODY_IMPL
+#undef PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL
+#undef PROD_LHS_UNARY_OP_DISPATCH_BODY_IMPL
+#undef PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL
+#undef PROD_DEF_LHS_ALL_OP_ACCESSOR
+#undef PROD_DEF_LHS_BINARY_OP_ACCESSOR
+#undef PROD_DEF_LHS_UNARY_OP_ACCESSOR
+#undef PROD_DEF_LHS_LEFT_OP_ACCESSOR
+
+struct implicit_conversion_dispatch
+    : details::cast_dispatch_base<false, false> {
+  template <class T>
+  PRO4D_STATIC_CALL(T&&, T&& self) noexcept {
+    return std::forward<T>(self);
+  }
+};
+struct explicit_conversion_dispatch : details::cast_dispatch_base<true, false> {
+  template <class T>
+  PRO4D_STATIC_CALL(auto, T&& self) noexcept {
+    return details::converter{
+        [&self]<class U>(std::in_place_type_t<U>) noexcept(
+            std::is_nothrow_constructible_v<U, T>) -> U
+          requires(details::explicitly_convertible < T &&, U >)
+        { return static_cast<U>(std::forward<T>(self)); }};
+  }
+};
+using conversion_dispatch = explicit_conversion_dispatch;
+
+class not_implemented : public std::exception {
+public:
+  char const* what() const noexcept override {
+    return "pro::v4::not_implemented";
+  }
+};
+
+template <class D>
+struct weak_dispatch : D {
+  using D::operator();
+  template <class... Args>
+  [[noreturn]] PRO4D_STATIC_CALL(details::wildcard, Args&&...)
+    requires(!std::is_invocable_v<D, Args...>)
+  {
+    PRO4D_THROW(not_implemented{});
+  }
+};
+
+// =============================================================================
+// == Skill Extensions (skills::rtti, skills::format, etc.)                   ==
+// =============================================================================
+
+#if __cpp_rtti >= 199711L
+class bad_proxy_cast : public std::bad_cast {
+public:
+  char const* what() const noexcept override {
+    return "pro::v4::bad_proxy_cast";
+  }
+};
+#endif // __cpp_rtti >= 199711L
+
+namespace details {
+
+template <template <class...> class TT, class... Ctx>
+struct enabled_t {};
+template <class T, template <class...> class TT, class... Ctx>
+concept enabled_for = std::is_base_of_v<enabled_t<TT, Ctx...>, T>;
+
+struct view_conversion_dispatch : cast_dispatch_base<false, true> {
+  template <class T>
+  PRO4D_STATIC_CALL(auto, T& value) noexcept
+    requires(requires {
+      { std::addressof(*value) } noexcept;
+    })
+  {
+    return observer_ptr<decltype(*value), decltype(*std::as_const(value)),
+                        decltype(*std::move(value)),
+                        decltype(*std::move(std::as_const(value)))>{*value};
+  }
+};
+template <class F>
+using view_conversion_overload = proxy_view<F>() & noexcept;
+
+struct weak_conversion_dispatch : cast_dispatch_base<false, true> {
+  template <class P>
+  PRO4D_STATIC_CALL(auto, const P& self) noexcept
+    requires(requires(const typename P::weak_type& w) {
+      { w.lock() } noexcept;
+    } && std::is_convertible_v<const P&, typename P::weak_type>)
+  {
+    return converter{
+        [&self]<class F>(std::in_place_type_t<proxy<F>>) noexcept
+          requires(proxiable<typename P::weak_type, F>)
+        { return proxy<F>{std::in_place_type<typename P::weak_type>, self}; }};
+  }
+};
+template <class F>
+using weak_conversion_overload = weak_proxy<F>() const noexcept;
+
+template <template <class...> class Formatter,
+          template <class...> class StringView,
+          template <class...> class ParseContext,
+          template <class...> class FormatContext>
+struct format_traits {
+  template <class CharT>
+  using overload = typename FormatContext<CharT>::iterator(
+      StringView<CharT> spec, FormatContext<CharT>& fc) const;
+
+  struct dispatch {
+    template <class T, class CharT>
+    PRO4D_STATIC_CALL(auto, const T& self, StringView<CharT> spec,
+                      FormatContext<CharT>& fc)
+      requires(std::is_default_constructible_v<Formatter<T, CharT>>)
+    {
+      Formatter<T, CharT> impl;
+      {
+        ParseContext<CharT> pc{spec};
+        impl.parse(pc);
+      }
+      return impl.format(self, fc);
+    }
+
+    template <class P, class D, class... Os>
+    struct PRO4D_ENFORCE_EBO accessor : accessor<P, D, Os>... {};
+    template <class P, class D>
+    struct accessor<P, D, overload<char>> : enabled_t<Formatter, char> {};
+    template <class P, class D>
+    struct accessor<P, D, overload<wchar_t>> : enabled_t<Formatter, wchar_t> {};
+  };
+
+  template <class CharT>
+  struct formatter {
+    constexpr auto parse(ParseContext<CharT>& pc) {
+      for (auto it = pc.begin(); it != pc.end(); ++it) {
+        if (*it == '}') {
+          spec_ = StringView<CharT>{pc.begin(), it + 1};
+          return it;
+        }
+      }
+      return pc.end();
+    }
+
+    template <class P, class CompatibleFormatContext>
+    auto format(const P& p, CompatibleFormatContext& fc) const ->
+        typename CompatibleFormatContext::iterator {
+      return invoke<dispatch, overload<CharT>>(p, spec_, fc);
+    }
+
+  private:
+    StringView<CharT> spec_;
+  };
+};
+
+#ifdef PRO4D_HAS_FORMAT
+template <class CharT>
+struct std_format_context_traits;
+template <>
+struct std_format_context_traits<char>
+    : std::type_identity<std::format_context> {};
+template <>
+struct std_format_context_traits<wchar_t>
+    : std::type_identity<std::wformat_context> {};
 template <class CharT>
 using std_format_context = typename std_format_context_traits<CharT>::type;
 struct std_format_traits
@@ -2403,299 +2696,6 @@ using as_weak = typename FB::template add_direct_convention<
 
 } // namespace skills
 
-// =============================================================================
-// == Dispatch Extensions (operator_dispatch, weak_dispatch, etc.)            ==
-// =============================================================================
-
-namespace details {
-
-template <std::size_t N>
-struct sign {
-  consteval sign(const char (&str)[N + 1]) {
-    if (str[N] != '\0') {
-      PROD_UNREACHABLE();
-    }
-    for (std::size_t i = 0; i < N; ++i) {
-      value[i] = str[i];
-    }
-  }
-
-  char value[N];
-};
-template <std::size_t N>
-sign(const char (&str)[N]) -> sign<N - 1u>;
-
-// When std::reference_constructs_from_temporary_v (C++23) is not available, we
-// fall back to a conservative approximation that disallows binding a temporary
-// to a reference type if the source type is not a reference or if the source
-// and target reference types are not compatible.
-template <class T, class U>
-concept explicitly_convertible =
-    std::is_constructible_v<U, T> &&
-#if __cpp_lib_reference_from_temporary >= 202202L
-    !std::reference_constructs_from_temporary_v<U, T>;
-#else
-    (!std::is_reference_v<U> ||
-     (std::is_reference_v<T> &&
-      std::is_convertible_v<std::add_pointer_t<std::remove_reference_t<T>>,
-                            std::add_pointer_t<std::remove_reference_t<U>>>));
-#endif // __cpp_lib_reference_from_temporary >= 202202L
-
-struct noreturn_conversion {
-  template <class T>
-  [[noreturn]] PRO4D_STATIC_CALL(T, std::in_place_type_t<T>) {
-    PROD_UNREACHABLE();
-  }
-};
-using wildcard = converter<noreturn_conversion>;
-
-} // namespace details
-
-template <details::sign Sign, bool Rhs = false>
-struct operator_dispatch;
-
-#define PROD_DEF_LHS_LEFT_OP_ACCESSOR(oq, pq, ne, ...)                         \
-  template <class P, class D, class R>                                         \
-  struct accessor<P, D, R() oq ne> {                                           \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
-    R __VA_ARGS__() oq ne {                                                    \
-      return invoke<D, R() oq ne>(static_cast<P pq>(*this));                   \
-    }                                                                          \
-  }
-#define PROD_DEF_LHS_UNARY_OP_ACCESSOR(oq, pq, ne, ...)                        \
-  template <class P, class D, class R>                                         \
-  struct accessor<P, D, R() oq ne> {                                           \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
-    decltype(auto) __VA_ARGS__() oq ne {                                       \
-      invoke<D, R() oq ne>(static_cast<P pq>(*this));                          \
-      return static_cast<P pq>(*this);                                         \
-    }                                                                          \
-  };                                                                           \
-  template <class P, class D, class R>                                         \
-  struct accessor<P, D, R(int) oq ne> {                                        \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
-    R __VA_ARGS__(int) oq ne {                                                 \
-      return invoke<D, R(int) oq ne>(static_cast<P pq>(*this), 0);             \
-    }                                                                          \
-  }
-#define PROD_DEF_LHS_BINARY_OP_ACCESSOR PRO4D_DEF_MEM_ACCESSOR
-#define PROD_DEF_LHS_ALL_OP_ACCESSOR PRO4D_DEF_MEM_ACCESSOR
-#define PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL(...)                               \
-  template <class T>                                                           \
-  PRO4D_STATIC_CALL(decltype(auto), T&& self)                                  \
-  PRO4D_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self))
-#define PROD_LHS_UNARY_OP_DISPATCH_BODY_IMPL(...)                              \
-  template <class T>                                                           \
-  PRO4D_STATIC_CALL(decltype(auto), T&& self)                                  \
-  PRO4D_DIRECT_FUNC_IMPL(__VA_ARGS__ std::forward<T>(self)) template <class T> \
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, int)                             \
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self) __VA_ARGS__)
-#define PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL(...)                             \
-  template <class T, class Arg>                                                \
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                       \
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)                                 \
-                             __VA_ARGS__ std::forward<Arg>(arg))
-#define PROD_LHS_ALL_OP_DISPATCH_BODY_IMPL(...)                                \
-  PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                             \
-  PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)
-#define PROD_LHS_OP_DISPATCH_IMPL(type, ...)                                   \
-  template <>                                                                  \
-  struct operator_dispatch<#__VA_ARGS__, false> {                              \
-    PROD_LHS_##type##_OP_DISPATCH_BODY_IMPL(__VA_ARGS__)                       \
-        PRO4D_DEF_ACCESSOR_TEMPLATE(                                           \
-            MEM, PROD_DEF_LHS_##type##_OP_ACCESSOR, operator __VA_ARGS__)      \
-  };
-
-#define PROD_DEF_RHS_OP_ACCESSOR(oq, pq, ne, ...)                              \
-  template <class P, class D, class R, class Arg>                              \
-  struct accessor<P, D, R(Arg) oq ne> {                                        \
-    friend R operator __VA_ARGS__(Arg arg, P pq self) ne {                     \
-      return invoke<D, R(Arg) oq ne>(static_cast<P pq>(self),                  \
-                                     std::forward<Arg>(arg));                  \
-    }                                                                          \
-    PRO4D_DEBUG(                                                             \
-      accessor() noexcept { std::ignore = &pro_symbol_guard; }               \
-                                                                             \
-    private:                                                                 \
-      static inline R pro_symbol_guard(Arg arg, P pq self) {                 \
-        return std::forward<Arg>(arg) __VA_ARGS__ static_cast<P pq>(self);   \
-      }                                                                      \
-    ) \
-  }
-#define PROD_RHS_OP_DISPATCH_IMPL(...)                                         \
-  template <>                                                                  \
-  struct operator_dispatch<#__VA_ARGS__, true> {                               \
-    template <class T, class Arg>                                              \
-    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
-    PRO4D_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                              \
-                               __VA_ARGS__ std::forward<T>(self))              \
-        PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PROD_DEF_RHS_OP_ACCESSOR,            \
-                                    __VA_ARGS__)                               \
-  };
-
-#define PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(...)                             \
-  PROD_LHS_OP_DISPATCH_IMPL(ALL, __VA_ARGS__)                                  \
-  PROD_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
-
-#define PROD_BINARY_OP_DISPATCH_IMPL(...)                                      \
-  PROD_LHS_OP_DISPATCH_IMPL(BINARY, __VA_ARGS__)                               \
-  PROD_RHS_OP_DISPATCH_IMPL(__VA_ARGS__)
-
-#define PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR(oq, pq, ne, ...)                   \
-  template <class P, class D, class R, class Arg>                              \
-  struct accessor<P, D, R(Arg) oq ne> {                                        \
-    PRO4D_GEN_DEBUG_SYMBOL_FOR_MEM_ACCESSOR(__VA_ARGS__)                       \
-    decltype(auto) __VA_ARGS__(Arg arg) oq ne {                                \
-      invoke<D, R(Arg) oq ne>(static_cast<P pq>(*this),                        \
-                              std::forward<Arg>(arg));                         \
-      return static_cast<P pq>(*this);                                         \
-    }                                                                          \
-  }
-#define PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR(oq, pq, ne, ...)                   \
-  template <class P, class D, class R, class Arg>                              \
-  struct accessor<P, D, R(Arg&) oq ne> {                                       \
-    friend Arg& operator __VA_ARGS__(Arg& arg, P pq self) ne {                 \
-      invoke<D, R(Arg&) oq ne>(static_cast<P pq>(self), arg);                  \
-      return arg;                                                              \
-    }                                                                          \
-    PRO4D_DEBUG(                                                               \
-        accessor() noexcept { std::ignore = &pro_symbol_guard; }               \
-                                                                               \
-        private : static inline Arg& pro_symbol_guard(                         \
-            Arg& arg,                                                          \
-            P pq self) { return arg __VA_ARGS__ static_cast<P pq>(self); })    \
-  }
-#define PROD_ASSIGNMENT_OP_DISPATCH_IMPL(...)                                  \
-  template <>                                                                  \
-  struct operator_dispatch<#__VA_ARGS__, false> {                              \
-    template <class T, class Arg>                                              \
-    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
-    PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)                               \
-                               __VA_ARGS__ std::forward<Arg>(arg))             \
-        PRO4D_DEF_ACCESSOR_TEMPLATE(                                           \
-            MEM, PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR, operator __VA_ARGS__)    \
-  };                                                                           \
-  template <>                                                                  \
-  struct operator_dispatch<#__VA_ARGS__, true> {                               \
-    template <class T, class Arg>                                              \
-    PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)                     \
-    PRO4D_DIRECT_FUNC_IMPL(std::forward<Arg>(arg)                              \
-                               __VA_ARGS__ std::forward<T>(self))              \
-        PRO4D_DEF_ACCESSOR_TEMPLATE(FREE, PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR, \
-                                    __VA_ARGS__)                               \
-  };
-
-PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(+)
-PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(-)
-PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(*)
-PROD_BINARY_OP_DISPATCH_IMPL(/)
-PROD_BINARY_OP_DISPATCH_IMPL(%)
-PROD_LHS_OP_DISPATCH_IMPL(UNARY, ++)
-PROD_LHS_OP_DISPATCH_IMPL(UNARY, --)
-PROD_BINARY_OP_DISPATCH_IMPL(==)
-PROD_BINARY_OP_DISPATCH_IMPL(!=)
-PROD_BINARY_OP_DISPATCH_IMPL(>)
-PROD_BINARY_OP_DISPATCH_IMPL(<)
-PROD_BINARY_OP_DISPATCH_IMPL(>=)
-PROD_BINARY_OP_DISPATCH_IMPL(<=)
-PROD_BINARY_OP_DISPATCH_IMPL(<=>)
-PROD_LHS_OP_DISPATCH_IMPL(LEFT, !)
-PROD_BINARY_OP_DISPATCH_IMPL(&&)
-PROD_BINARY_OP_DISPATCH_IMPL(||)
-PROD_LHS_OP_DISPATCH_IMPL(LEFT, ~)
-PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL(&)
-PROD_BINARY_OP_DISPATCH_IMPL(|)
-PROD_BINARY_OP_DISPATCH_IMPL(^)
-PROD_BINARY_OP_DISPATCH_IMPL(<<)
-PROD_BINARY_OP_DISPATCH_IMPL(>>)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(+=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(-=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(*=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(/=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(%=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(&=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(|=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(^=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(<<=)
-PROD_ASSIGNMENT_OP_DISPATCH_IMPL(>>=)
-PROD_BINARY_OP_DISPATCH_IMPL(, )
-PROD_BINARY_OP_DISPATCH_IMPL(->*)
-
-template <>
-struct operator_dispatch<"()", false> {
-  template <class T, class... Args>
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)(std::forward<Args>(args)...))
-      PRO4D_DEF_ACCESSOR_TEMPLATE(MEM, PRO4D_DEF_MEM_ACCESSOR, operator())
-};
-template <>
-struct operator_dispatch<"[]", false> {
-#if __cpp_multidimensional_subscript >= 202110L
-  template <class T, class... Args>
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, Args&&... args)
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Args>(args)...])
-#else
-  template <class T, class Arg>
-  PRO4D_STATIC_CALL(decltype(auto), T&& self, Arg&& arg)
-  PRO4D_DIRECT_FUNC_IMPL(std::forward<T>(self)[std::forward<Arg>(arg)])
-#endif // __cpp_multidimensional_subscript >= 202110L
-      PRO4D_DEF_ACCESSOR_TEMPLATE(MEM, PRO4D_DEF_MEM_ACCESSOR, operator[])
-};
-
-#undef PROD_ASSIGNMENT_OP_DISPATCH_IMPL
-#undef PROD_DEF_RHS_ASSIGNMENT_OP_ACCESSOR
-#undef PROD_DEF_LHS_ASSIGNMENT_OP_ACCESSOR
-#undef PROD_BINARY_OP_DISPATCH_IMPL
-#undef PROD_EXTENDED_BINARY_OP_DISPATCH_IMPL
-#undef PROD_RHS_OP_DISPATCH_IMPL
-#undef PROD_DEF_RHS_OP_ACCESSOR
-#undef PROD_LHS_OP_DISPATCH_IMPL
-#undef PROD_LHS_ALL_OP_DISPATCH_BODY_IMPL
-#undef PROD_LHS_BINARY_OP_DISPATCH_BODY_IMPL
-#undef PROD_LHS_UNARY_OP_DISPATCH_BODY_IMPL
-#undef PROD_LHS_LEFT_OP_DISPATCH_BODY_IMPL
-#undef PROD_DEF_LHS_ALL_OP_ACCESSOR
-#undef PROD_DEF_LHS_BINARY_OP_ACCESSOR
-#undef PROD_DEF_LHS_UNARY_OP_ACCESSOR
-#undef PROD_DEF_LHS_LEFT_OP_ACCESSOR
-
-struct implicit_conversion_dispatch
-    : details::cast_dispatch_base<false, false> {
-  template <class T>
-  PRO4D_STATIC_CALL(T&&, T&& self) noexcept {
-    return std::forward<T>(self);
-  }
-};
-struct explicit_conversion_dispatch : details::cast_dispatch_base<true, false> {
-  template <class T>
-  PRO4D_STATIC_CALL(auto, T&& self) noexcept {
-    return details::converter{
-        [&self]<class U>(std::in_place_type_t<U>) noexcept(
-            std::is_nothrow_constructible_v<U, T>) -> U
-          requires(details::explicitly_convertible < T &&, U >)
-        { return static_cast<U>(std::forward<T>(self)); }};
-  }
-};
-using conversion_dispatch = explicit_conversion_dispatch;
-
-class not_implemented : public std::exception {
-public:
-  char const* what() const noexcept override {
-    return "pro::v4::not_implemented";
-  }
-};
-
-template <class D>
-struct weak_dispatch : D {
-  using D::operator();
-  template <class... Args>
-  [[noreturn]] PRO4D_STATIC_CALL(details::wildcard, Args&&...)
-    requires(!std::is_invocable_v<D, Args...>)
-  {
-    PRO4D_THROW(not_implemented{});
-  }
-};
-
 } // namespace pro::inline v4
 
 // =============================================================================