diff --git a/.gitignore b/.gitignore
index 6ee39a1..7ccb09e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,6 +48,7 @@ CMakeCache.txt
 CMakeFiles/
 cmake_install.cmake
 Makefile
+cmake-build-*/
 
 # IDE
 /.idea
diff --git a/src/conversion/conversion.cppm b/src/conversion/conversion.cppm
index cdd5a47..7e0df8f 100644
--- a/src/conversion/conversion.cppm
+++ b/src/conversion/conversion.cppm
@@ -4,3 +4,5 @@ export module mcpplibs.primitives.conversion;
 
 export import mcpplibs.primitives.conversion.traits;
 export import mcpplibs.primitives.conversion.underlying;
+export import mcpplibs.primitives.conversion.mixing;
+export import mcpplibs.primitives.conversion.primitive;
diff --git a/src/conversion/mixing.cppm b/src/conversion/mixing.cppm
new file mode 100644
index 0000000..0b87eee
--- /dev/null
+++ b/src/conversion/mixing.cppm
@@ -0,0 +1,124 @@
+module;
+
+#include <expected>
+#include <type_traits>
+
+export module mcpplibs.primitives.conversion.mixing;
+
+import mcpplibs.primitives.conversion.traits;
+import mcpplibs.primitives.conversion.underlying;
+import mcpplibs.primitives.primitive;
+import mcpplibs.primitives.underlying;
+
+namespace mcpplibs::primitives::conversion::details {
+
+template <meta::primitive_type Primitive>
+using primitive_value_t =
+  meta::traits<std::remove_cvref_t<Primitive>>::value_type;
+
+template <meta::primitive_type Dest, underlying_type Src, typename Caster>
+constexpr auto cast_to_primitive_value(Src value, Caster caster) noexcept
+    -> std::remove_cvref_t<Dest> {
+  using dest_type = std::remove_cvref_t<Dest>;
+  using dest_value_type = primitive_value_t<dest_type>;
+
+  return dest_type{caster.template operator()<dest_value_type>(value)};
+}
+
+template <meta::primitive_type Dest, underlying_type Src, typename Caster>
+constexpr auto cast_to_primitive_result(Src value, Caster caster)
+    -> cast_result<std::remove_cvref_t<Dest>> {
+  using dest_type = std::remove_cvref_t<Dest>;
+  using dest_value_type = primitive_value_t<dest_type>;
+
+  auto const converted = caster.template operator()<dest_value_type>(value);
+  if (!converted.has_value()) {
+    return std::unexpected(converted.error());
+  }
+
+  return dest_type{*converted};
+}
+
+} // namespace mcpplibs::primitives::conversion::details
+
+export namespace mcpplibs::primitives::conversion {
+
+template <meta::primitive_type Dest, underlying_type Src>
+constexpr auto unchecked_cast(Src value) noexcept -> std::remove_cvref_t<Dest> {
+  return details::cast_to_primitive_value<Dest>(
+      value, []<underlying_type DestValue, underlying_type SrcValue>(
+                 SrcValue source) {
+        return conversion::unchecked_cast<DestValue>(source);
+      });
+}
+
+template <underlying_type Dest, meta::primitive_type Src>
+constexpr auto unchecked_cast(Src const &value) noexcept -> std::remove_cv_t<Dest> {
+  return conversion::unchecked_cast<std::remove_cv_t<Dest>>(value.load());
+}
+
+template <meta::primitive_type Dest, underlying_type Src>
+constexpr auto checked_cast(Src value)
+    -> cast_result<std::remove_cvref_t<Dest>> {
+  return details::cast_to_primitive_result<Dest>(
+      value, []<underlying_type DestValue, underlying_type SrcValue>(
+                 SrcValue source) {
+        return conversion::checked_cast<DestValue>(source);
+      });
+}
+
+template <underlying_type Dest, meta::primitive_type Src>
+constexpr auto checked_cast(Src const &value)
+    -> cast_result<std::remove_cv_t<Dest>> {
+  return conversion::checked_cast<std::remove_cv_t<Dest>>(value.load());
+}
+
+template <meta::primitive_type Dest, underlying_type Src>
+constexpr auto saturating_cast(Src value) noexcept
+    -> std::remove_cvref_t<Dest> {
+  return details::cast_to_primitive_value<Dest>(
+      value, []<underlying_type DestValue, underlying_type SrcValue>(
+                 SrcValue source) {
+        return conversion::saturating_cast<DestValue>(source);
+      });
+}
+
+template <underlying_type Dest, meta::primitive_type Src>
+constexpr auto saturating_cast(Src const &value) noexcept
+    -> std::remove_cv_t<Dest> {
+  return conversion::saturating_cast<std::remove_cv_t<Dest>>(value.load());
+}
+
+template <meta::primitive_type Dest, underlying_type Src>
+constexpr auto truncating_cast(Src value) noexcept
+    -> std::remove_cvref_t<Dest> {
+  return details::cast_to_primitive_value<Dest>(
+      value, []<underlying_type DestValue, underlying_type SrcValue>(
+                 SrcValue source) {
+        return conversion::truncating_cast<DestValue>(source);
+      });
+}
+
+template <underlying_type Dest, meta::primitive_type Src>
+constexpr auto truncating_cast(Src const &value) noexcept
+    -> std::remove_cv_t<Dest> {
+  return conversion::truncating_cast<std::remove_cv_t<Dest>>(value.load());
+}
+
+template <meta::primitive_type Dest, underlying_type Src>
+constexpr auto exact_cast(Src value)
+    -> cast_result<std::remove_cvref_t<Dest>> {
+  return details::cast_to_primitive_result<Dest>(
+      value, []<underlying_type DestValue, underlying_type SrcValue>(
+                 SrcValue source) {
+        return conversion::exact_cast<DestValue>(source);
+      });
+}
+
+template <underlying_type Dest, meta::primitive_type Src>
+constexpr auto exact_cast(Src const &value)
+    -> cast_result<std::remove_cv_t<Dest>> {
+  return conversion::exact_cast<std::remove_cv_t<Dest>>(value.load());
+}
+
+} // namespace mcpplibs::primitives::conversion
diff --git a/src/conversion/primitive.cppm b/src/conversion/primitive.cppm
new file mode 100644
index 0000000..16cd4ad
--- /dev/null
+++ b/src/conversion/primitive.cppm
@@ -0,0 +1,43 @@
+module;
+
+#include <type_traits>
+
+export module mcpplibs.primitives.conversion.primitive;
+
+import mcpplibs.primitives.conversion.traits;
+import mcpplibs.primitives.conversion.mixing;
+import mcpplibs.primitives.primitive;
+
+export namespace mcpplibs::primitives::conversion {
+
+template <meta::primitive_type Dest, meta::primitive_type Src>
+constexpr auto unchecked_cast(Src const &value) noexcept
+    -> std::remove_cvref_t<Dest> {
+  return conversion::unchecked_cast<std::remove_cvref_t<Dest>>(value.load());
+}
+
+template <meta::primitive_type Dest, meta::primitive_type Src>
+constexpr auto checked_cast(Src const &value)
+    -> cast_result<std::remove_cvref_t<Dest>> {
+  return conversion::checked_cast<std::remove_cvref_t<Dest>>(value.load());
+}
+
+template <meta::primitive_type Dest, meta::primitive_type Src>
+constexpr auto saturating_cast(Src const &value) noexcept
+    -> std::remove_cvref_t<Dest> {
+  return conversion::saturating_cast<std::remove_cvref_t<Dest>>(value.load());
+}
+
+template <meta::primitive_type Dest, meta::primitive_type Src>
+constexpr auto truncating_cast(Src const &value) noexcept
+    -> std::remove_cvref_t<Dest> {
+  return conversion::truncating_cast<std::remove_cvref_t<Dest>>(value.load());
+}
+
+template <meta::primitive_type Dest, meta::primitive_type Src>
+constexpr auto exact_cast(Src const &value)
+    -> cast_result<std::remove_cvref_t<Dest>> {
+  return conversion::exact_cast<std::remove_cvref_t<Dest>>(value.load());
+}
+
+} // namespace mcpplibs::primitives::conversion
diff --git a/src/conversion/underlying.cppm b/src/conversion/underlying.cppm
index e610cf7..8563588 100644
--- a/src/conversion/underlying.cppm
+++ b/src/conversion/underlying.cppm
@@ -10,7 +10,7 @@ module;
 export module mcpplibs.primitives.conversion.underlying;
 
 import mcpplibs.primitives.conversion.traits;
-import mcpplibs.primitives.underlying.traits;
+import mcpplibs.primitives.underlying;
 
 namespace mcpplibs::primitives::conversion::details {
 
@@ -19,130 +19,167 @@ concept statically_castable = requires(SrcRep value) {
   static_cast<std::remove_cvref_t<DestRep>>(value);
 };
 
-template <typename DestRep, typename SrcRep>
-concept builtin_numeric_pair =
-    std_numeric<DestRep> && std_numeric<SrcRep>;
+template <underlying_type T>
+using underlying_rep_t = underlying::traits<std::remove_cv_t<T>>::rep_type;
+
+template <typename Rep, typename Candidate>
+concept builtin_numeric_proxy_candidate =
+    std_numeric<Candidate> && has_common_rep<Rep, Candidate> &&
+    !std::same_as<common_rep_t<Rep, Candidate>, void> &&
+    std::same_as<common_rep_t<Rep, Candidate>, std::remove_cv_t<Candidate>> &&
+    statically_castable<Candidate, Rep>;
+
+template <typename Rep, typename... Candidates>
+struct builtin_numeric_proxy;
+
+template <typename Rep>
+struct builtin_numeric_proxy<Rep> {
+  using type = void;
+};
+
+template <typename Rep, typename Candidate, typename... Candidates>
+struct builtin_numeric_proxy<Rep, Candidate, Candidates...> {
+  using type = std::conditional_t<
+      builtin_numeric_proxy_candidate<Rep, Candidate>, Candidate,
+      typename builtin_numeric_proxy<Rep, Candidates...>::type>;
+};
+
+template <typename Rep>
+using integer_builtin_proxy_t =
+  builtin_numeric_proxy<Rep, short, unsigned short, int,
+                                   unsigned int, long, unsigned long,
+                                   long long, unsigned long long>::type;
 
-template <std_integer DestRep, std_integer SrcRep>
+template <typename Rep>
+using floating_builtin_proxy_t =
+  builtin_numeric_proxy<Rep, float, double, long double>::type;
+
+template <std_numeric DestRep, std_numeric SrcRep>
 constexpr auto numeric_risk(SrcRep value)
     -> std::optional<risk::kind> {
   using dest_type = std::remove_cvref_t<DestRep>;
   using src_type = std::remove_cvref_t<SrcRep>;
 
-  if constexpr (std::is_signed_v<src_type>) {
-    auto const signed_value = static_cast<std::intmax_t>(value);
-    if constexpr (std::is_signed_v<dest_type>) {
-      if (signed_value <
-          static_cast<std::intmax_t>(std::numeric_limits<dest_type>::min())) {
-        return risk::kind::underflow;
-      }
-      if (signed_value >
-          static_cast<std::intmax_t>(std::numeric_limits<dest_type>::max())) {
-        return risk::kind::overflow;
+  if constexpr (std_integer<dest_type> && std_integer<src_type>) {
+    if constexpr (std::is_signed_v<src_type>) {
+      auto const signed_value = static_cast<std::intmax_t>(value);
+      if constexpr (std::is_signed_v<dest_type>) {
+        if (signed_value <
+            static_cast<std::intmax_t>(std::numeric_limits<dest_type>::min())) {
+          return risk::kind::underflow;
+        }
+        if (signed_value >
+            static_cast<std::intmax_t>(std::numeric_limits<dest_type>::max())) {
+          return risk::kind::overflow;
+        }
+        return std::nullopt;
+      } else {
+        if (signed_value < 0) {
+          return risk::kind::underflow;
+        }
+
+        if (static_cast<std::uintmax_t>(signed_value) >
+            static_cast<std::uintmax_t>(
+                std::numeric_limits<dest_type>::max())) {
+          return risk::kind::overflow;
+        }
+        return std::nullopt;
       }
-      return std::nullopt;
     } else {
-      if (signed_value < 0) {
-        return risk::kind::underflow;
-      }
-
-      if (static_cast<std::uintmax_t>(signed_value) >
+      auto const unsigned_value = static_cast<std::uintmax_t>(value);
+      if (unsigned_value >
           static_cast<std::uintmax_t>(std::numeric_limits<dest_type>::max())) {
         return risk::kind::overflow;
       }
       return std::nullopt;
     }
-  } else {
-    auto const unsigned_value = static_cast<std::uintmax_t>(value);
-    if (unsigned_value >
-        static_cast<std::uintmax_t>(std::numeric_limits<dest_type>::max())) {
-      return risk::kind::overflow;
+  } else if constexpr (std_integer<dest_type> && std_floating<src_type>) {
+    if (std::isnan(value)) {
+      return risk::kind::domain_error;
+    }
+    if (std::isinf(value)) {
+      return value < static_cast<src_type>(0) ? risk::kind::underflow
+                                              : risk::kind::overflow;
     }
-    return std::nullopt;
-  }
-}
-
-template <std_integer DestRep, std_floating SrcRep>
-constexpr auto numeric_risk(SrcRep value)
-    -> std::optional<risk::kind> {
-  using dest_type = std::remove_cvref_t<DestRep>;
-  using src_type = std::remove_cvref_t<SrcRep>;
 
-  if (std::isnan(value)) {
-    return risk::kind::domain_error;
-  }
-  if (std::isinf(value)) {
-    return value < static_cast<src_type>(0) ? risk::kind::underflow
-                                            : risk::kind::overflow;
-  }
+    auto const normalized = static_cast<long double>(value);
+    auto const min_value =
+        static_cast<long double>(std::numeric_limits<dest_type>::lowest());
+    auto const max_value =
+        static_cast<long double>(std::numeric_limits<dest_type>::max());
 
-  auto const normalized = static_cast<long double>(value);
-  auto const min_value =
-      static_cast<long double>(std::numeric_limits<dest_type>::lowest());
-  auto const max_value =
-      static_cast<long double>(std::numeric_limits<dest_type>::max());
+    if (normalized < min_value) {
+      return risk::kind::underflow;
+    }
+    if (normalized > max_value) {
+      return risk::kind::overflow;
+    }
+  } else if constexpr (std_floating<dest_type> && std_integer<src_type>) {
+    auto const converted = static_cast<dest_type>(value);
+    if (std::isinf(converted)) {
+      return value < static_cast<src_type>(0) ? risk::kind::underflow
+                                              : risk::kind::overflow;
+    }
 
-  if (normalized < min_value) {
-    return risk::kind::underflow;
-  }
-  if (normalized > max_value) {
-    return risk::kind::overflow;
-  }
-  return std::nullopt;
-}
+    auto const roundtrip = static_cast<src_type>(converted);
+    if (roundtrip != value) {
+      return risk::kind::precision_loss;
+    }
+  } else {
+    if (std::isnan(value)) {
+      return std::nullopt;
+    }
+    if (std::isinf(value)) {
+      return std::nullopt;
+    }
 
-template <std_floating DestRep, std_integer SrcRep>
-constexpr auto numeric_risk(SrcRep value)
-    -> std::optional<risk::kind> {
-  using dest_type = std::remove_cvref_t<DestRep>;
-  using src_type = std::remove_cvref_t<SrcRep>;
+    auto const normalized = static_cast<long double>(value);
+    auto const min_value =
+        static_cast<long double>(std::numeric_limits<dest_type>::lowest());
+    auto const max_value =
+        static_cast<long double>(std::numeric_limits<dest_type>::max());
 
-  auto const converted = static_cast<dest_type>(value);
-  if (std::isinf(converted)) {
-    return value < static_cast<src_type>(0) ? risk::kind::underflow
-                                            : risk::kind::overflow;
-  }
+    if (normalized < min_value) {
+      return risk::kind::underflow;
+    }
+    if (normalized > max_value) {
+      return risk::kind::overflow;
+    }
 
-  auto const roundtrip = static_cast<src_type>(converted);
-  if (roundtrip != value) {
-    return risk::kind::precision_loss;
+    auto const converted = static_cast<dest_type>(value);
+    auto const roundtrip = static_cast<std::remove_cvref_t<SrcRep>>(converted);
+    if (roundtrip != value) {
+      return risk::kind::precision_loss;
+    }
   }
 
   return std::nullopt;
 }
 
-template <std_floating DestRep, std_floating SrcRep>
-constexpr auto numeric_risk(SrcRep value)
+template <numeric_underlying_type Dest, numeric_underlying_type Src>
+constexpr auto numeric_underlying_risk(Src value)
     -> std::optional<risk::kind> {
-  using dest_type = std::remove_cvref_t<DestRep>;
-
-  if (std::isnan(value)) {
-    return std::nullopt;
-  }
-  if (std::isinf(value)) {
-    return std::nullopt;
-  }
-
-  auto const normalized = static_cast<long double>(value);
-  auto const min_value =
-      static_cast<long double>(std::numeric_limits<dest_type>::lowest());
-  auto const max_value =
-      static_cast<long double>(std::numeric_limits<dest_type>::max());
-
-  if (normalized < min_value) {
-    return risk::kind::underflow;
-  }
-  if (normalized > max_value) {
-    return risk::kind::overflow;
-  }
-
-  auto const converted = static_cast<dest_type>(value);
-  auto const roundtrip = static_cast<std::remove_cvref_t<SrcRep>>(converted);
-  if (roundtrip != value) {
-    return risk::kind::precision_loss;
+  using src_type = std::remove_cv_t<Src>;
+  using dest_type = std::remove_cv_t<Dest>;
+  using src_rep_type = underlying_rep_t<src_type>;
+  using dest_rep_type = underlying_rep_t<dest_type>;
+  using src_builtin_rep_type = std::conditional_t<
+      integer_underlying_type<src_type>, integer_builtin_proxy_t<src_rep_type>,
+      floating_builtin_proxy_t<src_rep_type>>;
+  using dest_builtin_rep_type = std::conditional_t<
+      integer_underlying_type<dest_type>,
+      integer_builtin_proxy_t<dest_rep_type>,
+      floating_builtin_proxy_t<dest_rep_type>>;
+
+  if constexpr (std::same_as<src_builtin_rep_type, void> ||
+                std::same_as<dest_builtin_rep_type, void>) {
+    static_cast<void>(value);
+    return risk::kind::invalid_type_combination;
+  } else {
+    auto const source_rep = underlying::traits<src_type>::to_rep(value);
+    return numeric_risk<dest_builtin_rep_type>(
+        static_cast<src_builtin_rep_type>(source_rep));
   }
-
-  return std::nullopt;
 }
 
 template <numeric_underlying_type DestRep, numeric_underlying_type SrcRep>
@@ -160,7 +197,7 @@ constexpr auto checked_rep_cast(SrcRep value)
   using dest_type = std::remove_cvref_t<DestRep>;
   using src_type = std::remove_cvref_t<SrcRep>;
 
-  if constexpr (builtin_numeric_pair<dest_type, src_type>) {
+  if constexpr (std_numeric<dest_type> && std_numeric<src_type>) {
     if (auto const kind = numeric_risk<dest_type>(value); kind.has_value()) {
       return std::unexpected(*kind);
     }
@@ -176,7 +213,7 @@ constexpr auto saturating_rep_cast(SrcRep value) noexcept
   using dest_type = std::remove_cvref_t<DestRep>;
   using src_type = std::remove_cvref_t<SrcRep>;
 
-  if constexpr (builtin_numeric_pair<dest_type, src_type>) {
+  if constexpr (std_numeric<dest_type> && std_numeric<src_type>) {
     if (auto const kind = numeric_risk<dest_type>(value); kind.has_value()) {
       if (*kind == risk::kind::overflow) {
         return std::numeric_limits<dest_type>::max();
@@ -234,7 +271,7 @@ constexpr auto exact_rep_cast(SrcRep value)
   using dest_type = std::remove_cvref_t<DestRep>;
   using src_type = std::remove_cvref_t<SrcRep>;
 
-  if constexpr (!builtin_numeric_pair<dest_type, src_type>) {
+  if constexpr (!(std_numeric<dest_type> && std_numeric<src_type>)) {
     return std::unexpected(risk::kind::invalid_type_combination);
   } else {
     if (auto const kind = numeric_risk<dest_type>(value); kind.has_value()) {
@@ -279,68 +316,13 @@ constexpr auto cast_underlying_result(Src value, RepCaster rep_caster)
 
 export namespace mcpplibs::primitives::conversion {
 
-template <std_integer DestRep, std_integer SrcRep>
-constexpr auto numeric_risk(SrcRep value)
-    -> std::optional<risk::kind> {
-  return details::numeric_risk<DestRep>(value);
-}
-
-template <std_integer DestRep, std_floating SrcRep>
-constexpr auto numeric_risk(SrcRep value)
-    -> std::optional<risk::kind> {
-  return details::numeric_risk<DestRep>(value);
-}
-
-template <std_floating DestRep, std_integer SrcRep>
-constexpr auto numeric_risk(SrcRep value)
-    -> std::optional<risk::kind> {
-  return details::numeric_risk<DestRep>(value);
-}
-
-template <std_floating DestRep, std_floating SrcRep>
+template <numeric_underlying_type DestRep, numeric_underlying_type SrcRep>
 constexpr auto numeric_risk(SrcRep value)
     -> std::optional<risk::kind> {
-  return details::numeric_risk<DestRep>(value);
-}
-
-template <std_numeric DestRep, std_numeric SrcRep>
-  requires details::statically_castable<DestRep, SrcRep>
-constexpr auto unchecked_cast(SrcRep value) noexcept
-    -> std::remove_cvref_t<DestRep> {
-  return details::unchecked_rep_cast<DestRep>(value);
-}
-
-template <std_numeric DestRep, std_numeric SrcRep>
-  requires details::statically_castable<DestRep, SrcRep>
-constexpr auto checked_cast(SrcRep value)
-    -> cast_result<std::remove_cvref_t<DestRep>> {
-  return details::checked_rep_cast<DestRep>(value);
-}
-
-template <std_numeric DestRep, std_numeric SrcRep>
-  requires details::statically_castable<DestRep, SrcRep>
-constexpr auto saturating_cast(SrcRep value) noexcept
-    -> std::remove_cvref_t<DestRep> {
-  return details::saturating_rep_cast<DestRep>(value);
-}
-
-template <std_numeric DestRep, std_numeric SrcRep>
-  requires details::statically_castable<DestRep, SrcRep>
-constexpr auto truncating_cast(SrcRep value) noexcept
-    -> std::remove_cvref_t<DestRep> {
-  return details::truncating_rep_cast<DestRep>(value);
-}
-
-template <std_numeric DestRep, std_numeric SrcRep>
-  requires details::statically_castable<DestRep, SrcRep>
-constexpr auto exact_cast(SrcRep value)
-    -> cast_result<std::remove_cvref_t<DestRep>> {
-  return details::exact_rep_cast<DestRep>(value);
+  return details::numeric_underlying_risk<DestRep>(value);
 }
 
 template <underlying_type Dest, underlying_type Src>
-  requires(!details::builtin_numeric_pair<std::remove_cv_t<Dest>,
-                                          std::remove_cv_t<Src>>)
 constexpr auto unchecked_cast(Src value) noexcept -> Dest {
   return details::cast_underlying_value<Dest>(
       value, []<typename DestRep, typename SrcRep>(SrcRep rep) {
@@ -349,8 +331,6 @@ constexpr auto unchecked_cast(Src value) noexcept -> Dest {
 }
 
 template <underlying_type Dest, underlying_type Src>
-  requires(!details::builtin_numeric_pair<std::remove_cv_t<Dest>,
-                                          std::remove_cv_t<Src>>)
 constexpr auto checked_cast(Src value) -> cast_result<Dest> {
   return details::cast_underlying_result<Dest>(
       value, []<typename DestRep, typename SrcRep>(SrcRep rep) {
@@ -359,8 +339,6 @@ constexpr auto checked_cast(Src value) -> cast_result<Dest> {
 }
 
 template <underlying_type Dest, underlying_type Src>
-  requires(!details::builtin_numeric_pair<std::remove_cv_t<Dest>,
-                                          std::remove_cv_t<Src>>)
 constexpr auto saturating_cast(Src value) noexcept -> Dest {
   return details::cast_underlying_value<Dest>(
       value, []<typename DestRep, typename SrcRep>(SrcRep rep) {
@@ -369,8 +347,6 @@ constexpr auto saturating_cast(Src value) noexcept -> Dest {
 }
 
 template <underlying_type Dest, underlying_type Src>
-  requires(!details::builtin_numeric_pair<std::remove_cv_t<Dest>,
-                                          std::remove_cv_t<Src>>)
 constexpr auto truncating_cast(Src value) noexcept -> Dest {
   return details::cast_underlying_value<Dest>(
       value, []<typename DestRep, typename SrcRep>(SrcRep rep) {
@@ -379,8 +355,6 @@ constexpr auto truncating_cast(Src value) noexcept -> Dest {
 }
 
 template <underlying_type Dest, underlying_type Src>
-  requires(!details::builtin_numeric_pair<std::remove_cv_t<Dest>,
-                                          std::remove_cv_t<Src>>)
 constexpr auto exact_cast(Src value) -> cast_result<Dest> {
   return details::cast_underlying_result<Dest>(
       value, []<typename DestRep, typename SrcRep>(SrcRep rep) {
diff --git a/tests/basic/conversion/primitive/test_primitive_casts.cpp b/tests/basic/conversion/primitive/test_primitive_casts.cpp
new file mode 100644
index 0000000..716b618
--- /dev/null
+++ b/tests/basic/conversion/primitive/test_primitive_casts.cpp
@@ -0,0 +1,49 @@
+#include <gtest/gtest.h>
+#include <limits>
+
+import mcpplibs.primitives.underlying;
+
+#include "../../support/conversion_box_types.hpp"
+
+import mcpplibs.primitives.conversion;
+import mcpplibs.primitives.policy;
+import mcpplibs.primitives.primitive;
+
+using namespace mcpplibs::primitives;
+using namespace mcpplibs::primitives::test_support::conversion;
+
+TEST(ConversionPrimitiveTest, CheckedCastBetweenPrimitivesUsesRepBridge) {
+  using src_t =
+      primitive<SignedBox, policy::value::checked, policy::error::expected>;
+  using dest_t =
+      primitive<UnsignedBox, policy::value::checked, policy::error::expected>;
+
+  auto const ok = conversion::checked_cast<dest_t>(src_t{SignedBox{42}});
+  ASSERT_TRUE(ok.has_value());
+  EXPECT_EQ(ok->load().value, 42);
+
+  auto const bad = conversion::checked_cast<dest_t>(src_t{SignedBox{-1}});
+  ASSERT_FALSE(bad.has_value());
+  EXPECT_EQ(bad.error(), conversion::risk::kind::underflow);
+}
+
+TEST(ConversionPrimitiveTest,
+     TruncatingAndExactCastBetweenPrimitivesFollowUnderlyingRules) {
+  using float_t =
+      primitive<FloatBox, policy::value::checked, policy::error::expected>;
+  using signed_t =
+      primitive<SignedBox, policy::value::checked, policy::error::expected>;
+
+  auto const truncated = conversion::truncating_cast<signed_t>(
+      float_t{FloatBox{12.75}});
+  EXPECT_EQ(truncated.load().value, 12);
+
+  auto const exact = conversion::exact_cast<signed_t>(float_t{FloatBox{12.0}});
+  ASSERT_TRUE(exact.has_value());
+  EXPECT_EQ(exact->load().value, 12);
+
+  auto const bad_exact = conversion::exact_cast<signed_t>(
+      float_t{FloatBox{std::numeric_limits<double>::quiet_NaN()}});
+  ASSERT_FALSE(bad_exact.has_value());
+  EXPECT_EQ(bad_exact.error(), conversion::risk::kind::domain_error);
+}
diff --git a/tests/basic/conversion/primitive_underlying/test_mixed_casts.cpp b/tests/basic/conversion/primitive_underlying/test_mixed_casts.cpp
new file mode 100644
index 0000000..2be54ca
--- /dev/null
+++ b/tests/basic/conversion/primitive_underlying/test_mixed_casts.cpp
@@ -0,0 +1,41 @@
+#include <gtest/gtest.h>
+
+import mcpplibs.primitives.underlying;
+
+#include "../../support/conversion_box_types.hpp"
+
+import mcpplibs.primitives.conversion;
+import mcpplibs.primitives.policy;
+import mcpplibs.primitives.primitive;
+
+using namespace mcpplibs::primitives;
+using namespace mcpplibs::primitives::test_support::conversion;
+
+TEST(ConversionPrimitiveUnderlyingTest,
+     CheckedCastSupportsUnderlyingToPrimitiveBridge) {
+  using value_t =
+      primitive<UnsignedBox, policy::value::checked, policy::error::expected>;
+
+  auto const ok = conversion::checked_cast<value_t>(SignedBox{42});
+  ASSERT_TRUE(ok.has_value());
+  EXPECT_EQ(ok->load().value, 42);
+
+  auto const bad = conversion::checked_cast<value_t>(SignedBox{-1});
+  ASSERT_FALSE(bad.has_value());
+  EXPECT_EQ(bad.error(), conversion::risk::kind::underflow);
+}
+
+TEST(ConversionPrimitiveUnderlyingTest,
+     PrimitiveToUnderlyingCastsReuseUnderlyingConversion) {
+  using value_t =
+      primitive<SignedBox, policy::value::checked, policy::error::expected>;
+
+  auto const ok = conversion::checked_cast<UnsignedBox>(value_t{SignedBox{42}});
+  ASSERT_TRUE(ok.has_value());
+  EXPECT_EQ(ok->value, 42);
+
+  auto const truncated =
+      conversion::truncating_cast<SignedBox>(primitive<FloatBox>{
+          FloatBox{12.75}});
+  EXPECT_EQ(truncated.value, 12);
+}
diff --git a/tests/basic/conversion/traits/test_numeric_risk.cpp b/tests/basic/conversion/traits/test_numeric_risk.cpp
index dac2918..58e4fbd 100644
--- a/tests/basic/conversion/traits/test_numeric_risk.cpp
+++ b/tests/basic/conversion/traits/test_numeric_risk.cpp
@@ -4,8 +4,11 @@
 
 import mcpplibs.primitives.conversion.traits;
 import mcpplibs.primitives.conversion.underlying;
+import mcpplibs.primitives.underlying;
 
+#include "../../support/conversion_box_types.hpp"
 using namespace mcpplibs::primitives;
+using namespace mcpplibs::primitives::test_support::conversion;
 
 TEST(ConversionRiskTest, NumericRiskDetectsOverflowAndUnderflow) {
   auto const overflow = conversion::numeric_risk<std::uint16_t>(70000);
@@ -28,3 +31,26 @@ TEST(ConversionRiskTest, NumericRiskDetectsDomainAndPrecisionLoss) {
   ASSERT_TRUE(precision.has_value());
   EXPECT_EQ(*precision, conversion::risk::kind::precision_loss);
 }
+
+TEST(ConversionRiskTest, NumericRiskSupportsUnderlyingRepBridge) {
+  auto const underflow = conversion::numeric_risk<UnsignedBox>(SignedBox{-1});
+  ASSERT_TRUE(underflow.has_value());
+  EXPECT_EQ(*underflow, conversion::risk::kind::underflow);
+
+  auto const domain = conversion::numeric_risk<SignedBox>(
+      FloatBox{std::numeric_limits<double>::quiet_NaN()});
+  ASSERT_TRUE(domain.has_value());
+  EXPECT_EQ(*domain, conversion::risk::kind::domain_error);
+}
+
+TEST(ConversionRiskTest, NumericRiskSupportsBuiltinProxyRepBridge) {
+  auto const underflow =
+      conversion::numeric_risk<UnsignedBox>(BridgedIntBox{IntBridgeRep{-1}});
+  ASSERT_TRUE(underflow.has_value());
+  EXPECT_EQ(*underflow, conversion::risk::kind::underflow);
+
+  auto const domain = conversion::numeric_risk<BridgedIntBox>(
+      BridgedFloatBox{FloatBridgeRep{std::numeric_limits<double>::quiet_NaN()}});
+  ASSERT_TRUE(domain.has_value());
+  EXPECT_EQ(*domain, conversion::risk::kind::domain_error);
+}
diff --git a/tests/basic/conversion/underlying/test_underlying_casts.cpp b/tests/basic/conversion/underlying/test_underlying_casts.cpp
index 19580ac..106bb86 100644
--- a/tests/basic/conversion/underlying/test_underlying_casts.cpp
+++ b/tests/basic/conversion/underlying/test_underlying_casts.cpp
@@ -6,7 +6,6 @@ import mcpplibs.primitives.conversion.traits;
 import mcpplibs.primitives.conversion.underlying;
 
 #include "../../support/conversion_box_types.hpp"
-
 using namespace mcpplibs::primitives;
 using namespace mcpplibs::primitives::test_support::conversion;
 
diff --git a/tests/basic/primitive/traits/test_meta_traits.cpp b/tests/basic/primitive/traits/test_meta_traits.cpp
index 59a4fe1..90ebbf9 100644
--- a/tests/basic/primitive/traits/test_meta_traits.cpp
+++ b/tests/basic/primitive/traits/test_meta_traits.cpp
@@ -5,7 +5,6 @@ import mcpplibs.primitives.primitive;
 import mcpplibs.primitives.policy;
 
 #include "../../support/underlying_custom_types.hpp"
-
 using namespace mcpplibs::primitives;
 
 TEST(PrimitiveTraitsTest, MetaTraitsExposeValueTypeAndPrimitiveMetadata) {
diff --git a/tests/basic/support/conversion_box_types.hpp b/tests/basic/support/conversion_box_types.hpp
index 504bdbb..354da56 100644
--- a/tests/basic/support/conversion_box_types.hpp
+++ b/tests/basic/support/conversion_box_types.hpp
@@ -16,6 +16,80 @@ struct FloatBox {
   double value;
 };
 
+struct IntBridgeRep {
+  int value;
+
+  friend constexpr auto operator+(IntBridgeRep lhs,
+                                  IntBridgeRep rhs) noexcept -> IntBridgeRep {
+    return IntBridgeRep{lhs.value + rhs.value};
+  }
+
+  friend constexpr auto operator-(IntBridgeRep lhs,
+                                  IntBridgeRep rhs) noexcept -> IntBridgeRep {
+    return IntBridgeRep{lhs.value - rhs.value};
+  }
+
+  friend constexpr auto operator*(IntBridgeRep lhs,
+                                  IntBridgeRep rhs) noexcept -> IntBridgeRep {
+    return IntBridgeRep{lhs.value * rhs.value};
+  }
+
+  friend constexpr auto operator/(IntBridgeRep lhs,
+                                  IntBridgeRep rhs) noexcept -> IntBridgeRep {
+    return IntBridgeRep{lhs.value / rhs.value};
+  }
+
+  friend constexpr auto operator==(IntBridgeRep lhs,
+                                   IntBridgeRep rhs) noexcept -> bool {
+    return lhs.value == rhs.value;
+  }
+
+  constexpr explicit operator int() const noexcept { return value; }
+};
+
+struct FloatBridgeRep {
+  double value;
+
+  friend constexpr auto operator+(FloatBridgeRep lhs,
+                                  FloatBridgeRep rhs) noexcept
+      -> FloatBridgeRep {
+    return FloatBridgeRep{lhs.value + rhs.value};
+  }
+
+  friend constexpr auto operator-(FloatBridgeRep lhs,
+                                  FloatBridgeRep rhs) noexcept
+      -> FloatBridgeRep {
+    return FloatBridgeRep{lhs.value - rhs.value};
+  }
+
+  friend constexpr auto operator*(FloatBridgeRep lhs,
+                                  FloatBridgeRep rhs) noexcept
+      -> FloatBridgeRep {
+    return FloatBridgeRep{lhs.value * rhs.value};
+  }
+
+  friend constexpr auto operator/(FloatBridgeRep lhs,
+                                  FloatBridgeRep rhs) noexcept
+      -> FloatBridgeRep {
+    return FloatBridgeRep{lhs.value / rhs.value};
+  }
+
+  friend constexpr auto operator==(FloatBridgeRep lhs,
+                                   FloatBridgeRep rhs) noexcept -> bool {
+    return lhs.value == rhs.value;
+  }
+
+  constexpr explicit operator double() const noexcept { return value; }
+};
+
+struct BridgedIntBox {
+  IntBridgeRep value;
+};
+
+struct BridgedFloatBox {
+  FloatBridgeRep value;
+};
+
 } // namespace mcpplibs::primitives::test_support::conversion
 
 template <>
@@ -78,3 +152,76 @@ struct mcpplibs::primitives::underlying::traits<
 
   static constexpr auto is_valid_rep(rep_type) noexcept -> bool { return true; }
 };
+
+template <>
+struct mcpplibs::primitives::underlying::traits<
+    mcpplibs::primitives::test_support::conversion::BridgedIntBox> {
+  using value_type =
+      mcpplibs::primitives::test_support::conversion::BridgedIntBox;
+  using rep_type =
+      mcpplibs::primitives::test_support::conversion::IntBridgeRep;
+
+  static constexpr bool enabled = true;
+  static constexpr auto kind = mcpplibs::primitives::underlying::category::integer;
+
+  static constexpr auto to_rep(value_type value) noexcept -> rep_type {
+    return value.value;
+  }
+
+  static constexpr auto from_rep(rep_type value) noexcept -> value_type {
+    return value_type{value};
+  }
+
+  static constexpr auto is_valid_rep(rep_type) noexcept -> bool { return true; }
+};
+
+template <>
+struct mcpplibs::primitives::underlying::traits<
+    mcpplibs::primitives::test_support::conversion::BridgedFloatBox> {
+  using value_type =
+      mcpplibs::primitives::test_support::conversion::BridgedFloatBox;
+  using rep_type =
+      mcpplibs::primitives::test_support::conversion::FloatBridgeRep;
+
+  static constexpr bool enabled = true;
+  static constexpr auto kind =
+      mcpplibs::primitives::underlying::category::floating;
+
+  static constexpr auto to_rep(value_type value) noexcept -> rep_type {
+    return value.value;
+  }
+
+  static constexpr auto from_rep(rep_type value) noexcept -> value_type {
+    return value_type{value};
+  }
+
+  static constexpr auto is_valid_rep(rep_type) noexcept -> bool { return true; }
+};
+
+template <>
+struct mcpplibs::primitives::underlying::common_rep_traits<
+    mcpplibs::primitives::test_support::conversion::IntBridgeRep, int> {
+  using type = int;
+  static constexpr bool enabled = true;
+};
+
+template <>
+struct mcpplibs::primitives::underlying::common_rep_traits<
+    int, mcpplibs::primitives::test_support::conversion::IntBridgeRep> {
+  using type = int;
+  static constexpr bool enabled = true;
+};
+
+template <>
+struct mcpplibs::primitives::underlying::common_rep_traits<
+    mcpplibs::primitives::test_support::conversion::FloatBridgeRep, double> {
+  using type = double;
+  static constexpr bool enabled = true;
+};
+
+template <>
+struct mcpplibs::primitives::underlying::common_rep_traits<
+    double, mcpplibs::primitives::test_support::conversion::FloatBridgeRep> {
+  using type = double;
+  static constexpr bool enabled = true;
+};
diff --git a/tests/basic/underlying/common_rep/test_common_rep_and_type_policy.cpp b/tests/basic/underlying/common_rep/test_common_rep_and_type_policy.cpp
index d68b755..218791b 100644
--- a/tests/basic/underlying/common_rep/test_common_rep_and_type_policy.cpp
+++ b/tests/basic/underlying/common_rep/test_common_rep_and_type_policy.cpp
@@ -6,7 +6,6 @@ import mcpplibs.primitives.policy;
 import mcpplibs.primitives.operations.impl;
 
 #include "../../support/underlying_custom_types.hpp"
-
 using namespace mcpplibs::primitives;
 using namespace mcpplibs::primitives::test_support::underlying;
 
diff --git a/tests/basic/underlying/traits/test_concepts_and_registration.cpp b/tests/basic/underlying/traits/test_concepts_and_registration.cpp
index fa0462e..aad2c65 100644
--- a/tests/basic/underlying/traits/test_concepts_and_registration.cpp
+++ b/tests/basic/underlying/traits/test_concepts_and_registration.cpp
@@ -3,7 +3,6 @@
 import mcpplibs.primitives.underlying;
 
 #include "../../support/underlying_custom_types.hpp"
-
 using namespace mcpplibs::primitives;
 using namespace mcpplibs::primitives::test_support::underlying;