diff --git a/.agents/docs/plans/implementation-plan.md b/.agents/docs/plans/implementation-plan.md
new file mode 100644
index 0000000..55ea982
--- /dev/null
+++ b/.agents/docs/plans/implementation-plan.md
@@ -0,0 +1,82 @@
+# Primitives 下一步实现计划清单（2026-03-23）
+
+## 总体原则
+
+- [ ] 先定义稳定 API 边界，再落地实现
+- [ ] 每个能力都配套 tests + examples + docs
+- [ ] 高风险转换默认禁止隐式触发，只允许显式 API
+
+## M1. C API 互操作层（双向）
+
+### 工作清单
+
+- [ ] 定义稳定 C ABI（命名规范、导出宏、版本策略）
+- [ ] 设计双向能力：C 调用 primitives；primitives 适配并调用 C API
+- [ ] 统一错误模型（error code + 可选 message buffer）
+- [ ] 提供最小可用头文件：`include/mcpplibs/primitives/c_api.h`
+- [ ] 增加 C/C++ 混合构建测试（C 编译器 + C++ 链接）
+- [ ] 增加示例：`examples/c/basic.c`、`examples/cpp/use_c_api.cpp`
+
+### 验收标准
+
+- [ ] 纯 C 工程可链接并完成基础能力调用
+- [ ] C++ 对外部 C API 的适配调用行为可控、无未定义行为
+
+## M2. Concept/Traits 体系增强与元信息 API
+
+### 工作清单
+
+- [ ] 扩展 concept 分层（category/representation/policy-capability）
+- [ ] 完善 `traits<T>` 元信息（`kind`、`rep_type`、limits、policy tags）
+- [ ] 提供检测类 API（可转换性/是否有损/错误模型能力）
+- [ ] 统一 `constexpr` 查询入口，减少分散 traits 访问
+- [ ] 增加编译期测试矩阵（`static_assert` 覆盖）
+
+### 验收标准
+
+- [ ] 上层模块仅依赖公开 concept/traits，不依赖 `details::*`
+- [ ] 元信息可支撑转换层与算法层的约束判定
+
+## M3. 显式转换层（任意策略组适用）
+
+### 工作清单
+
+- [ ] 设计统一接口族（建议）：`explicit_cast`、`try_cast`、`checked_cast`
+- [ ] 支持任意策略组组合，不绑定特定策略实现
+- [ ] 风险可见化（截断/溢出/精度损失）并可程序化读取
+- [ ] 定义失败语义（错误码或 expected 风格，按策略可配置）
+- [ ] 建立转换矩阵测试（同类/跨类/跨策略组）
+
+### 验收标准
+
+- [ ] 所有跨类高风险转换必须走显式 API
+- [ ] 风险信息可在编译期或运行期被确定性获取
+
+## M4. 算法层（以 max/min 为起点）
+
+### 工作清单
+
+- [ ] 实现 `max`/`min`，并预留 `clamp`/`compare` 扩展位
+- [ ] 算法统一依赖 M2+M3 的公开接口，不绕过转换层
+- [ ] 支持同类与受约束的异类输入
+- [ ] 在可行范围保持 `constexpr`/`noexcept` 特性
+- [ ] 增加边界测试（极值、NaN、有符号/无符号混合）
+
+### 验收标准
+
+- [ ] 算法行为与策略约束一致
+- [ ] 风险路径始终显式、可审计
+
+## 建议推进顺序
+
+1. M2（先夯实约束与元信息基础）
+2. M1（建立跨语言边界）
+3. M3（收敛转换风险）
+4. M4（复用基础能力实现算法）
+
+## 总体完成跟踪
+
+- [ ] M1 完成
+- [ ] M2 完成
+- [ ] M3 完成
+- [ ] M4 完成
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 2b8024d..016ae56 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -14,7 +14,7 @@
 
 ## 正在进行中的计划
 
-- 当前计划目录：`../.github/prompts/`
+- 当前计划目录：`../.agents/docs/plans/`
 
 ## 说明
 
diff --git a/src/operations/dispatcher.cppm b/src/operations/dispatcher.cppm
index 9fdaa33..7947265 100644
--- a/src/operations/dispatcher.cppm
+++ b/src/operations/dispatcher.cppm
@@ -15,20 +15,15 @@ import mcpplibs.primitives.underlying;
 
 export namespace mcpplibs::primitives::operations {
 
-template <typename T>
-concept primitive_instance = requires {
-  typename primitives::meta::traits<
-      std::remove_cvref_t<T>>::value_type;
-};
-
-template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
+template <operation OpTag, meta::primitive_type Lhs,
+          meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 struct dispatcher_meta {
   using lhs_primitive = std::remove_cvref_t<Lhs>;
   using rhs_primitive = std::remove_cvref_t<Rhs>;
 
-  using lhs_traits = primitives::meta::traits<lhs_primitive>;
-  using rhs_traits = primitives::meta::traits<rhs_primitive>;
+  using lhs_traits = meta::traits<lhs_primitive>;
+  using rhs_traits = meta::traits<rhs_primitive>;
 
   using lhs_value_type = lhs_traits::value_type;
   using rhs_value_type = rhs_traits::value_type;
@@ -36,15 +31,15 @@ struct dispatcher_meta {
   using lhs_rep = underlying::traits<lhs_value_type>::rep_type;
   using rhs_rep = underlying::traits<rhs_value_type>::rep_type;
 
-  using lhs_type_policy = typename lhs_traits::type_policy;
-  using lhs_value_policy = typename lhs_traits::value_policy;
-  using lhs_error_policy = typename lhs_traits::error_policy;
-  using lhs_concurrency_policy = typename lhs_traits::concurrency_policy;
+  using lhs_type_policy = lhs_traits::type_policy;
+  using lhs_value_policy = lhs_traits::value_policy;
+  using lhs_error_policy = lhs_traits::error_policy;
+  using lhs_concurrency_policy = lhs_traits::concurrency_policy;
 
-  using rhs_type_policy = typename rhs_traits::type_policy;
-  using rhs_value_policy = typename rhs_traits::value_policy;
-  using rhs_error_policy = typename rhs_traits::error_policy;
-  using rhs_concurrency_policy = typename rhs_traits::concurrency_policy;
+  using rhs_type_policy = rhs_traits::type_policy;
+  using rhs_value_policy = rhs_traits::value_policy;
+  using rhs_error_policy = rhs_traits::error_policy;
+  using rhs_concurrency_policy = rhs_traits::concurrency_policy;
 
   static constexpr bool policy_group_consistent =
       std::is_same_v<lhs_type_policy, rhs_type_policy> &&
@@ -85,7 +80,8 @@ struct dispatcher_meta {
                                       ErrorPayload>;
 };
 
-template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
+template <operation OpTag, primitives::meta::primitive_type Lhs,
+          primitives::meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 using dispatch_result_t = std::expected<
     typename dispatcher_meta<OpTag, Lhs, Rhs, ErrorPayload>::common_rep,
@@ -93,7 +89,8 @@ using dispatch_result_t = std::expected<
 
 // Dispatcher pipeline: compile-time negotiation plus runtime chain
 // (concurrency -> value -> error) through selected policy handlers.
-template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
+template <operation OpTag, primitives::meta::primitive_type Lhs,
+          primitives::meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto dispatch(Lhs const &lhs, Rhs const &rhs)
     -> dispatch_result_t<OpTag, Lhs, Rhs, ErrorPayload> {
diff --git a/src/operations/invoker.cppm b/src/operations/invoker.cppm
index 7c84208..87c4258 100644
--- a/src/operations/invoker.cppm
+++ b/src/operations/invoker.cppm
@@ -17,9 +17,8 @@ import mcpplibs.primitives.policy.handler;
 import mcpplibs.primitives.policy.impl;
 import mcpplibs.primitives.policy.traits;
 
-export namespace mcpplibs::primitives::operations::runtime {
 
-namespace details {
+namespace mcpplibs::primitives::operations::runtime::details {
 
 template <typename CommonRep>
 constexpr auto make_error(policy::error::kind kind, char const *reason,
@@ -781,18 +780,22 @@ constexpr auto make_div_zero(char const *reason)
   return make_error<CommonRep>(policy::error::kind::divide_by_zero, reason);
 }
 
-constexpr auto apply_runtime_fence(bool enabled,
-                                   std::memory_order order) noexcept -> void {
+constexpr auto apply_runtime_fence(const bool enabled,
+                                   const std::memory_order order) noexcept -> void {
   if (!enabled) {
     return;
   }
 
-  if (!std::is_constant_evaluated()) {
+  if !consteval {
     std::atomic_thread_fence(order);
   }
 }
 
-} // namespace details
+} // namespace mcpplibs::primitives::operations::runtime::details
+
+
+
+export namespace mcpplibs::primitives::operations::runtime {
 
 template <operation OpTag, policy::value_policy ValuePolicy, typename CommonRep>
 struct op_binding {
diff --git a/src/operations/operators.cppm b/src/operations/operators.cppm
index 67f8b40..86bc2a6 100644
--- a/src/operations/operators.cppm
+++ b/src/operations/operators.cppm
@@ -17,7 +17,10 @@ import mcpplibs.primitives.policy.handler;
 import mcpplibs.primitives.policy.impl;
 import mcpplibs.primitives.underlying.traits;
 
-export namespace mcpplibs::primitives::operations {
+namespace mcpplibs::primitives::operations {
+
+template <typename T>
+concept underlying_operand = underlying_type<std::remove_cvref_t<T>>;
 
 namespace details {
 template <typename CommonRep, typename = void> struct three_way_ordering {
@@ -61,21 +64,22 @@ constexpr auto decode_three_way_code(CommonRep const &code) -> Ordering {
 
 } // namespace details
 
-template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
+} // namespace mcpplibs::primitives::operations
+
+export namespace mcpplibs::primitives::operations {
+
+template <operation OpTag, meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 using primitive_dispatch_result_t = std::expected<meta::make_primitive_t<
         typename dispatcher_meta<OpTag, Lhs, Rhs, ErrorPayload>::common_rep,
         typename meta::traits<Lhs>::policies>,
     ErrorPayload>;
 
-template <typename T>
-concept underlying_operand = underlying_type<std::remove_cvref_t<T>>;
-
-template <primitive_instance Primitive, underlying_operand Underlying>
+template <meta::primitive_type Primitive, underlying_operand Underlying>
 using mixed_bridge_primitive_t = meta::make_primitive_t<
     std::remove_cvref_t<Underlying>, typename meta::traits<Primitive>::policies>;
 
-template <operation OpTag, primitive_instance Primitive,
+template <operation OpTag, meta::primitive_type Primitive,
           underlying_operand Underlying,
           typename ErrorPayload = policy::error::kind>
 using mixed_primitive_dispatch_result_t =
@@ -83,7 +87,7 @@ using mixed_primitive_dispatch_result_t =
                                 mixed_bridge_primitive_t<Primitive, Underlying>,
                                 ErrorPayload>;
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 using three_way_dispatch_result_t = std::expected<
     details::three_way_ordering_t<
@@ -91,7 +95,7 @@ using three_way_dispatch_result_t = std::expected<
                                  ErrorPayload>::common_rep>,
     ErrorPayload>;
 
-template <primitive_instance Primitive, underlying_operand Underlying,
+template <meta::primitive_type Primitive, underlying_operand Underlying,
           typename ErrorPayload = policy::error::kind>
 using mixed_three_way_dispatch_result_t =
     three_way_dispatch_result_t<Primitive,
@@ -99,28 +103,28 @@ using mixed_three_way_dispatch_result_t =
                                 ErrorPayload>;
 
 template <operation OpTag, underlying_operand Underlying,
-          primitive_instance Primitive,
+          meta::primitive_type Primitive,
           typename ErrorPayload = policy::error::kind>
 using flipped_mixed_primitive_dispatch_result_t = primitive_dispatch_result_t<
     OpTag, mixed_bridge_primitive_t<Primitive, Underlying>, Primitive,
     ErrorPayload>;
 
-template <underlying_operand Underlying, primitive_instance Primitive,
+template <underlying_operand Underlying, meta::primitive_type Primitive,
           typename ErrorPayload = policy::error::kind>
 using flipped_mixed_three_way_dispatch_result_t = three_way_dispatch_result_t<
     mixed_bridge_primitive_t<Primitive, Underlying>, Primitive, ErrorPayload>;
 
-template <operation OpTag, primitive_instance Operand,
+template <operation OpTag, meta::primitive_type Operand,
           typename ErrorPayload = policy::error::kind>
 using unary_dispatch_result_t =
     primitive_dispatch_result_t<OpTag, Operand, Operand, ErrorPayload>;
 
-template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
+template <operation OpTag, meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload>
 constexpr auto apply_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<OpTag, Lhs, Rhs, ErrorPayload>;
 
-template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
+template <operation OpTag, meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<OpTag, Lhs, Rhs, ErrorPayload> {
@@ -136,14 +140,14 @@ constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
   return result_primitive{*raw};
 }
 
-template <operation OpTag, primitive_instance Operand,
+template <operation OpTag, meta::primitive_type Operand,
           typename ErrorPayload = policy::error::kind>
 constexpr auto apply(Operand const &operand)
     -> unary_dispatch_result_t<OpTag, Operand, ErrorPayload> {
   return apply<OpTag, Operand, Operand, ErrorPayload>(operand, operand);
 }
 
-template <operation OpTag, primitive_instance Lhs, underlying_operand Rhs,
+template <operation OpTag, meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<OpTag, Lhs, Rhs, ErrorPayload> {
@@ -152,7 +156,7 @@ constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
   return apply<OpTag, Lhs, bridge_rhs_t, ErrorPayload>(lhs, bridge_rhs);
 }
 
-template <operation OpTag, underlying_operand Lhs, primitive_instance Rhs,
+template <operation OpTag, underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<OpTag, Lhs, Rhs,
@@ -163,54 +167,54 @@ constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
 }
 
 // Unary operations
-template <primitive_instance Operand, typename ErrorPayload = policy::error::kind>
+template <meta::primitive_type Operand, typename ErrorPayload = policy::error::kind>
 constexpr auto increment(Operand &operand)
     -> unary_dispatch_result_t<Increment, Operand, ErrorPayload> {
   return apply_assign<Increment, Operand, Operand, ErrorPayload>(operand,
                                                                  operand);
 }
 
-template <primitive_instance Operand, typename ErrorPayload = policy::error::kind>
+template <meta::primitive_type Operand, typename ErrorPayload = policy::error::kind>
 constexpr auto decrement(Operand &operand)
     -> unary_dispatch_result_t<Decrement, Operand, ErrorPayload> {
   return apply_assign<Decrement, Operand, Operand, ErrorPayload>(operand,
                                                                  operand);
 }
 
-template <primitive_instance Operand, typename ErrorPayload = policy::error::kind>
+template <meta::primitive_type Operand, typename ErrorPayload = policy::error::kind>
 constexpr auto bit_not(Operand const &operand)
     -> unary_dispatch_result_t<BitwiseNot, Operand, ErrorPayload> {
   return apply<BitwiseNot, Operand, ErrorPayload>(operand);
 }
 
-template <primitive_instance Operand, typename ErrorPayload = policy::error::kind>
+template <meta::primitive_type Operand, typename ErrorPayload = policy::error::kind>
 constexpr auto unary_plus(Operand const &operand)
     -> unary_dispatch_result_t<UnaryPlus, Operand, ErrorPayload> {
   return apply<UnaryPlus, Operand, ErrorPayload>(operand);
 }
 
-template <primitive_instance Operand, typename ErrorPayload = policy::error::kind>
+template <meta::primitive_type Operand, typename ErrorPayload = policy::error::kind>
 constexpr auto unary_minus(Operand const &operand)
     -> unary_dispatch_result_t<UnaryMinus, Operand, ErrorPayload> {
   return apply<UnaryMinus, Operand, ErrorPayload>(operand);
 }
 
 // Binary arithmetic operations
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto add(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Addition, Lhs, Rhs, ErrorPayload> {
   return apply<Addition, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto add(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<Addition, Lhs, Rhs, ErrorPayload> {
   return apply<Addition, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto add(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<Addition, Lhs, Rhs,
@@ -218,21 +222,21 @@ constexpr auto add(Lhs const &lhs, Rhs const &rhs)
   return apply<Addition, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto sub(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Subtraction, Lhs, Rhs, ErrorPayload> {
   return apply<Subtraction, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto sub(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<Subtraction, Lhs, Rhs, ErrorPayload> {
   return apply<Subtraction, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto sub(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<Subtraction, Lhs, Rhs,
@@ -240,14 +244,14 @@ constexpr auto sub(Lhs const &lhs, Rhs const &rhs)
   return apply<Subtraction, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mul(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Multiplication, Lhs, Rhs, ErrorPayload> {
   return apply<Multiplication, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mul(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<Multiplication, Lhs, Rhs,
@@ -255,7 +259,7 @@ constexpr auto mul(Lhs const &lhs, Rhs const &rhs)
   return apply<Multiplication, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mul(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<Multiplication, Lhs, Rhs,
@@ -263,28 +267,28 @@ constexpr auto mul(Lhs const &lhs, Rhs const &rhs)
   return apply<Multiplication, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto div(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Division, Lhs, Rhs, ErrorPayload> {
   return apply<Division, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mod(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Modulus, Lhs, Rhs, ErrorPayload> {
   return apply<Modulus, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mod(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<Modulus, Lhs, Rhs, ErrorPayload> {
   return apply<Modulus, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mod(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<Modulus, Lhs, Rhs,
@@ -293,21 +297,21 @@ constexpr auto mod(Lhs const &lhs, Rhs const &rhs)
 }
 
 // Binary bitwise operations
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto shift_left(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<LeftShift, Lhs, Rhs, ErrorPayload> {
   return apply<LeftShift, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto shift_left(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<LeftShift, Lhs, Rhs, ErrorPayload> {
   return apply<LeftShift, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto shift_left(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<LeftShift, Lhs, Rhs,
@@ -315,21 +319,21 @@ constexpr auto shift_left(Lhs const &lhs, Rhs const &rhs)
   return apply<LeftShift, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto shift_right(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<RightShift, Lhs, Rhs, ErrorPayload> {
   return apply<RightShift, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto shift_right(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<RightShift, Lhs, Rhs, ErrorPayload> {
   return apply<RightShift, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto shift_right(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<RightShift, Lhs, Rhs,
@@ -337,21 +341,21 @@ constexpr auto shift_right(Lhs const &lhs, Rhs const &rhs)
   return apply<RightShift, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_and(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<BitwiseAnd, Lhs, Rhs, ErrorPayload> {
   return apply<BitwiseAnd, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_and(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<BitwiseAnd, Lhs, Rhs, ErrorPayload> {
   return apply<BitwiseAnd, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_and(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<BitwiseAnd, Lhs, Rhs,
@@ -359,21 +363,21 @@ constexpr auto bit_and(Lhs const &lhs, Rhs const &rhs)
   return apply<BitwiseAnd, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_or(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<BitwiseOr, Lhs, Rhs, ErrorPayload> {
   return apply<BitwiseOr, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_or(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<BitwiseOr, Lhs, Rhs, ErrorPayload> {
   return apply<BitwiseOr, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_or(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<BitwiseOr, Lhs, Rhs,
@@ -381,21 +385,21 @@ constexpr auto bit_or(Lhs const &lhs, Rhs const &rhs)
   return apply<BitwiseOr, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_xor(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<BitwiseXor, Lhs, Rhs, ErrorPayload> {
   return apply<BitwiseXor, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_xor(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<BitwiseXor, Lhs, Rhs, ErrorPayload> {
   return apply<BitwiseXor, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_xor(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<BitwiseXor, Lhs, Rhs,
@@ -403,14 +407,14 @@ constexpr auto bit_xor(Lhs const &lhs, Rhs const &rhs)
   return apply<BitwiseXor, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto div(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<Division, Lhs, Rhs, ErrorPayload> {
   return apply<Division, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto div(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<Division, Lhs, Rhs,
@@ -418,21 +422,21 @@ constexpr auto div(Lhs const &lhs, Rhs const &rhs)
   return apply<Division, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto equal(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Equal, Lhs, Rhs, ErrorPayload> {
   return apply<Equal, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto equal(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<Equal, Lhs, Rhs, ErrorPayload> {
   return apply<Equal, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto equal(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<Equal, Lhs, Rhs,
@@ -440,21 +444,21 @@ constexpr auto equal(Lhs const &lhs, Rhs const &rhs)
   return apply<Equal, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto not_equal(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<NotEqual, Lhs, Rhs, ErrorPayload> {
   return apply<NotEqual, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto not_equal(Lhs const &lhs, Rhs const &rhs)
     -> mixed_primitive_dispatch_result_t<NotEqual, Lhs, Rhs, ErrorPayload> {
   return apply<NotEqual, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto not_equal(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_primitive_dispatch_result_t<NotEqual, Lhs, Rhs,
@@ -462,7 +466,7 @@ constexpr auto not_equal(Lhs const &lhs, Rhs const &rhs)
   return apply<NotEqual, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
     -> three_way_dispatch_result_t<Lhs, Rhs, ErrorPayload> {
@@ -480,7 +484,7 @@ constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
   return details::decode_three_way_code<ordering, common_rep>(*raw);
 }
 
-template <primitive_instance Lhs, underlying_operand Rhs,
+template <meta::primitive_type Lhs, underlying_operand Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
     -> mixed_three_way_dispatch_result_t<Lhs, Rhs, ErrorPayload> {
@@ -489,7 +493,7 @@ constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
   return three_way_compare<Lhs, bridge_rhs_t, ErrorPayload>(lhs, bridge_rhs);
 }
 
-template <underlying_operand Lhs, primitive_instance Rhs,
+template <underlying_operand Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
     -> flipped_mixed_three_way_dispatch_result_t<Lhs, Rhs, ErrorPayload> {
@@ -498,7 +502,7 @@ constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
   return three_way_compare<bridge_lhs_t, Rhs, ErrorPayload>(bridge_lhs, rhs);
 }
 
-template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
+template <operation OpTag, meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto apply_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<OpTag, Lhs, Rhs, ErrorPayload> {
@@ -506,9 +510,6 @@ constexpr auto apply_assign(Lhs &lhs, Rhs const &rhs)
   using lhs_value_type = lhs_traits::value_type;
   using lhs_value_policy = lhs_traits::value_policy;
   using lhs_rep = underlying::traits<lhs_value_type>::rep_type;
-  using out_primitive = primitive_dispatch_result_t<OpTag, Lhs, Rhs,
-                                           ErrorPayload>::value_type;
-  using common_rep = meta::traits<out_primitive>::value_type;
 
   auto out = apply<OpTag, Lhs, Rhs, ErrorPayload>(lhs, rhs);
   if (!out.has_value()) {
@@ -532,70 +533,70 @@ constexpr auto apply_assign(Lhs &lhs, Rhs const &rhs)
   return out;
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto add_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Addition, Lhs, Rhs, ErrorPayload> {
   return apply_assign<Addition, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto sub_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Subtraction, Lhs, Rhs, ErrorPayload> {
   return apply_assign<Subtraction, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mul_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Multiplication, Lhs, Rhs, ErrorPayload> {
   return apply_assign<Multiplication, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto div_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Division, Lhs, Rhs, ErrorPayload> {
   return apply_assign<Division, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mod_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Modulus, Lhs, Rhs, ErrorPayload> {
   return apply_assign<Modulus, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto shift_left_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<LeftShift, Lhs, Rhs, ErrorPayload> {
   return apply_assign<LeftShift, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto shift_right_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<RightShift, Lhs, Rhs, ErrorPayload> {
   return apply_assign<RightShift, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_and_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<BitwiseAnd, Lhs, Rhs, ErrorPayload> {
   return apply_assign<BitwiseAnd, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_or_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<BitwiseOr, Lhs, Rhs, ErrorPayload> {
   return apply_assign<BitwiseOr, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
-template <primitive_instance Lhs, primitive_instance Rhs,
+template <meta::primitive_type Lhs, meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto bit_xor_assign(Lhs &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<BitwiseXor, Lhs, Rhs, ErrorPayload> {
@@ -607,13 +608,13 @@ constexpr auto bit_xor_assign(Lhs &lhs, Rhs const &rhs)
 export namespace mcpplibs::primitives::operators {
 
 // Unary operators
-template <operations::primitive_instance Operand>
+template <meta::primitive_type Operand>
 constexpr auto operator++(Operand &operand)
     -> operations::unary_dispatch_result_t<operations::Increment, Operand> {
   return operations::increment(operand);
 }
 
-template <operations::primitive_instance Operand>
+template <meta::primitive_type Operand>
 constexpr auto operator++(Operand &operand, int)
     -> operations::unary_dispatch_result_t<operations::Increment, Operand> {
   auto const before = operand;
@@ -624,13 +625,13 @@ constexpr auto operator++(Operand &operand, int)
   return before;
 }
 
-template <operations::primitive_instance Operand>
+template <meta::primitive_type Operand>
 constexpr auto operator--(Operand &operand)
     -> operations::unary_dispatch_result_t<operations::Decrement, Operand> {
   return operations::decrement(operand);
 }
 
-template <operations::primitive_instance Operand>
+template <meta::primitive_type Operand>
 constexpr auto operator--(Operand &operand, int)
     -> operations::unary_dispatch_result_t<operations::Decrement, Operand> {
   auto const before = operand;
@@ -641,33 +642,33 @@ constexpr auto operator--(Operand &operand, int)
   return before;
 }
 
-template <operations::primitive_instance Operand>
+template <meta::primitive_type Operand>
 constexpr auto operator+(Operand const &operand)
     -> operations::unary_dispatch_result_t<operations::UnaryPlus, Operand> {
   return operations::unary_plus(operand);
 }
 
-template <operations::primitive_instance Operand>
+template <meta::primitive_type Operand>
 constexpr auto operator-(Operand const &operand)
     -> operations::unary_dispatch_result_t<operations::UnaryMinus, Operand> {
   return operations::unary_minus(operand);
 }
 
-template <operations::primitive_instance Operand>
+template <meta::primitive_type Operand>
 constexpr auto operator~(Operand const &operand)
     -> operations::unary_dispatch_result_t<operations::BitwiseNot, Operand> {
   return operations::bit_not(operand);
 }
 
 // Binary arithmetic operators
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator+(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Addition, Lhs, Rhs> {
   return operations::add(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator+(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::Addition, Lhs,
@@ -676,22 +677,22 @@ constexpr auto operator+(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator+(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::Addition, Lhs, Rhs> {
   return operations::add(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator-(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Subtraction, Lhs,
                                                Rhs> {
   return operations::sub(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator-(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::Subtraction,
@@ -700,22 +701,22 @@ constexpr auto operator-(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator-(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::Subtraction, Lhs, Rhs> {
   return operations::sub(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator*(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Multiplication, Lhs,
                                                Rhs> {
   return operations::mul(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator*(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::Multiplication,
@@ -724,21 +725,21 @@ constexpr auto operator*(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator*(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::Multiplication, Lhs, Rhs> {
   return operations::mul(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator/(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Division, Lhs, Rhs> {
   return operations::div(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator/(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::Division, Lhs,
@@ -747,21 +748,21 @@ constexpr auto operator/(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator/(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::Division, Lhs, Rhs> {
   return operations::div(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator%(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Modulus, Lhs, Rhs> {
   return operations::mod(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator%(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::Modulus, Lhs,
@@ -770,7 +771,7 @@ constexpr auto operator%(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator%(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::Modulus, Lhs, Rhs> {
@@ -778,14 +779,14 @@ constexpr auto operator%(Lhs const &lhs, Rhs const &rhs)
 }
 
 // Binary bitwise operators
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator<<(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::LeftShift, Lhs, Rhs> {
   return operations::shift_left(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator<<(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::LeftShift, Lhs,
@@ -794,21 +795,21 @@ constexpr auto operator<<(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator<<(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::LeftShift, Lhs, Rhs> {
   return operations::shift_left(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator>>(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::RightShift, Lhs, Rhs> {
   return operations::shift_right(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator>>(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::RightShift, Lhs,
@@ -817,21 +818,21 @@ constexpr auto operator>>(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator>>(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::RightShift, Lhs, Rhs> {
   return operations::shift_right(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator&(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::BitwiseAnd, Lhs, Rhs> {
   return operations::bit_and(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator&(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::BitwiseAnd, Lhs,
@@ -840,21 +841,21 @@ constexpr auto operator&(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator&(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::BitwiseAnd, Lhs, Rhs> {
   return operations::bit_and(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator|(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::BitwiseOr, Lhs, Rhs> {
   return operations::bit_or(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator|(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::BitwiseOr, Lhs,
@@ -863,21 +864,21 @@ constexpr auto operator|(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator|(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::BitwiseOr, Lhs, Rhs> {
   return operations::bit_or(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator^(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::BitwiseXor, Lhs, Rhs> {
   return operations::bit_xor(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator^(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::BitwiseXor, Lhs,
@@ -886,7 +887,7 @@ constexpr auto operator^(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator^(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::BitwiseXor, Lhs, Rhs> {
@@ -895,14 +896,14 @@ constexpr auto operator^(Lhs const &lhs, Rhs const &rhs)
 
 // Binary comparison operators
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator==(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Equal, Lhs, Rhs> {
   return operations::equal(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator==(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::Equal, Lhs,
@@ -911,21 +912,21 @@ constexpr auto operator==(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator==(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<operations::Equal,
                                                              Lhs, Rhs> {
   return operations::equal(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator!=(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::NotEqual, Lhs, Rhs> {
   return operations::not_equal(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator!=(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_primitive_dispatch_result_t<operations::NotEqual, Lhs,
@@ -934,21 +935,21 @@ constexpr auto operator!=(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator!=(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_primitive_dispatch_result_t<
         operations::NotEqual, Lhs, Rhs> {
   return operations::not_equal(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator<=>(Lhs const &lhs, Rhs const &rhs)
     -> operations::three_way_dispatch_result_t<Lhs, Rhs> {
   return operations::three_way_compare(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
+template <meta::primitive_type Lhs,
           operations::underlying_operand Rhs>
 constexpr auto operator<=>(Lhs const &lhs, Rhs const &rhs)
     -> operations::mixed_three_way_dispatch_result_t<Lhs, Rhs> {
@@ -956,82 +957,83 @@ constexpr auto operator<=>(Lhs const &lhs, Rhs const &rhs)
 }
 
 template <operations::underlying_operand Lhs,
-          operations::primitive_instance Rhs>
+          meta::primitive_type Rhs>
 constexpr auto operator<=>(Lhs const &lhs, Rhs const &rhs)
     -> operations::flipped_mixed_three_way_dispatch_result_t<Lhs, Rhs> {
   return operations::three_way_compare(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator+=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Addition, Lhs, Rhs> {
   return operations::add_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator-=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Subtraction, Lhs,
                                                Rhs> {
   return operations::sub_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator*=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Multiplication, Lhs,
                                                Rhs> {
   return operations::mul_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator/=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Division, Lhs, Rhs> {
   return operations::div_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator%=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Modulus, Lhs, Rhs> {
   return operations::mod_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator<<=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::LeftShift, Lhs, Rhs> {
   return operations::shift_left_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator>>=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::RightShift, Lhs, Rhs> {
   return operations::shift_right_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator&=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::BitwiseAnd, Lhs, Rhs> {
   return operations::bit_and_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator|=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::BitwiseOr, Lhs, Rhs> {
   return operations::bit_or_assign(lhs, rhs);
 }
 
-template <operations::primitive_instance Lhs,
-          operations::primitive_instance Rhs>
+template <meta::primitive_type Lhs,
+          meta::primitive_type Rhs>
 constexpr auto operator^=(Lhs &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::BitwiseXor, Lhs, Rhs> {
   return operations::bit_xor_assign(lhs, rhs);
 }
 
 } // namespace mcpplibs::primitives::operators
+
diff --git a/src/policy/impl.cppm b/src/policy/impl.cppm
index ecd090a..df1299e 100644
--- a/src/policy/impl.cppm
+++ b/src/policy/impl.cppm
@@ -19,6 +19,79 @@ import mcpplibs.primitives.policy.traits;
 import mcpplibs.primitives.policy.handler;
 import mcpplibs.primitives.underlying.traits;
 
+namespace mcpplibs::primitives::policy::details {
+
+template <typename T, bool = std::is_trivially_copyable_v<T>>
+struct atomic_ref_alignment_compatible : std::false_type {};
+
+template <typename T>
+struct atomic_ref_alignment_compatible<T, true>
+    : std::bool_constant<(alignof(T) >=
+                          std::atomic_ref<T>::required_alignment)> {};
+
+template <typename T>
+inline constexpr bool atomic_ref_compatible_v =
+    atomic_ref_alignment_compatible<T>::value;
+
+template <typename T> constexpr void assert_atomic_ref_compatible() {
+  static_assert(std::is_trivially_copyable_v<T>,
+                "concurrency::handler atomic access requires trivially "
+                "copyable CommonRep");
+  static_assert(
+      atomic_ref_alignment_compatible<T>::value,
+      "concurrency::handler atomic access requires alignof(CommonRep) to "
+      "satisfy std::atomic_ref<CommonRep>::required_alignment");
+}
+
+template <typename T>
+concept has_underlying_rep_not_equal =
+    underlying_type<T> &&
+    requires(T const &lhs, T const &rhs) {
+      {
+        underlying::traits<std::remove_cv_t<T>>::to_rep(lhs) !=
+        underlying::traits<std::remove_cv_t<T>>::to_rep(rhs)
+      } -> std::convertible_to<bool>;
+    };
+
+template <typename T>
+inline constexpr bool none_compare_exchange_available_v =
+    has_underlying_rep_not_equal<T>;
+
+template <typename OpTag>
+inline constexpr bool is_arithmetic_operation_v =
+    operations::op_has_capability_v<OpTag, operations::capability::arithmetic>;
+
+template <typename T>
+inline constexpr bool is_boolean_or_character_v = std_bool<T> || std_char<T>;
+
+template <typename OpTag, typename LhsRep, typename RhsRep>
+inline constexpr bool rejects_arithmetic_for_boolean_or_character_v =
+    is_arithmetic_operation_v<OpTag> &&
+    (is_boolean_or_character_v<LhsRep> || is_boolean_or_character_v<RhsRep>);
+
+template <typename LhsRep, typename RhsRep>
+inline constexpr bool has_non_void_common_rep_v =
+    has_common_rep<LhsRep, RhsRep> &&
+    !std::same_as<common_rep_t<LhsRep, RhsRep>, void>;
+
+template <typename LhsRep, typename RhsRep>
+inline constexpr bool has_same_underlying_category_v =
+    underlying::traits<std::remove_cv_t<LhsRep>>::enabled &&
+    underlying::traits<std::remove_cv_t<RhsRep>>::enabled &&
+    (underlying::traits<std::remove_cv_t<LhsRep>>::kind ==
+     underlying::traits<std::remove_cv_t<RhsRep>>::kind);
+
+template <typename T>
+auto atomic_ref_load(T const &value, std::memory_order order) noexcept -> T {
+  assert_atomic_ref_compatible<T>();
+  // libc++ rejects std::atomic_ref<const T>; load through a non-mutating view.
+  auto &mutable_value = const_cast<T &>(value);
+  std::atomic_ref<T> ref(mutable_value);
+  return ref.load(order);
+}
+
+} // namespace mcpplibs::primitives::policy::details
+
 export namespace mcpplibs::primitives::policy {
 
 namespace value {
@@ -138,79 +211,6 @@ using error = error::throwing;
 using concurrency = concurrency::none;
 } // namespace defaults
 
-namespace details {
-
-template <typename T, bool = std::is_trivially_copyable_v<T>>
-struct atomic_ref_alignment_compatible : std::false_type {};
-
-template <typename T>
-struct atomic_ref_alignment_compatible<T, true>
-    : std::bool_constant<(alignof(T) >=
-                          std::atomic_ref<T>::required_alignment)> {};
-
-template <typename T>
-inline constexpr bool atomic_ref_compatible_v =
-    atomic_ref_alignment_compatible<T>::value;
-
-template <typename T> constexpr void assert_atomic_ref_compatible() {
-  static_assert(std::is_trivially_copyable_v<T>,
-                "concurrency::handler atomic access requires trivially "
-                "copyable CommonRep");
-  static_assert(
-      atomic_ref_alignment_compatible<T>::value,
-      "concurrency::handler atomic access requires alignof(CommonRep) to "
-      "satisfy std::atomic_ref<CommonRep>::required_alignment");
-}
-
-template <typename T>
-concept has_underlying_rep_not_equal =
-    underlying_type<T> &&
-    requires(T const &lhs, T const &rhs) {
-      {
-        underlying::traits<std::remove_cv_t<T>>::to_rep(lhs) !=
-        underlying::traits<std::remove_cv_t<T>>::to_rep(rhs)
-      } -> std::convertible_to<bool>;
-    };
-
-template <typename T>
-inline constexpr bool none_compare_exchange_available_v =
-    has_underlying_rep_not_equal<T>;
-
-template <typename OpTag>
-inline constexpr bool is_arithmetic_operation_v =
-    operations::op_has_capability_v<OpTag, operations::capability::arithmetic>;
-
-template <typename T>
-inline constexpr bool is_boolean_or_character_v = std_bool<T> || std_char<T>;
-
-template <typename OpTag, typename LhsRep, typename RhsRep>
-inline constexpr bool rejects_arithmetic_for_boolean_or_character_v =
-    is_arithmetic_operation_v<OpTag> &&
-    (is_boolean_or_character_v<LhsRep> || is_boolean_or_character_v<RhsRep>);
-
-template <typename LhsRep, typename RhsRep>
-inline constexpr bool has_non_void_common_rep_v =
-    has_common_rep<LhsRep, RhsRep> &&
-    !std::same_as<common_rep_t<LhsRep, RhsRep>, void>;
-
-template <typename LhsRep, typename RhsRep>
-inline constexpr bool has_same_underlying_category_v =
-    underlying::traits<std::remove_cv_t<LhsRep>>::enabled &&
-    underlying::traits<std::remove_cv_t<RhsRep>>::enabled &&
-    (underlying::traits<std::remove_cv_t<LhsRep>>::kind ==
-     underlying::traits<std::remove_cv_t<RhsRep>>::kind);
-
-template <typename T>
-auto atomic_ref_load(T const &value, std::memory_order order) noexcept -> T {
-  assert_atomic_ref_compatible<T>();
-  // libc++ rejects std::atomic_ref<const T>; load through a non-mutating view.
-  auto &mutable_value = const_cast<T &>(value);
-  std::atomic_ref<T> ref(mutable_value);
-  return ref.load(order);
-}
-
-} // namespace details
-
 // Default protocol specializations.
 template <operations::operation OpTag, typename LhsRep, typename RhsRep>
 struct type::handler<type::strict, OpTag, LhsRep, RhsRep> {
diff --git a/src/primitive/traits.cppm b/src/primitive/traits.cppm
index e1fb5b4..8ecb4fe 100644
--- a/src/primitive/traits.cppm
+++ b/src/primitive/traits.cppm
@@ -1,5 +1,6 @@
 module;
 #include <tuple>
+#include <type_traits>
 
 export module mcpplibs.primitives.primitive.traits;
 
@@ -9,6 +10,26 @@ import mcpplibs.primitives.policy.impl;
 import mcpplibs.primitives.policy.utility;
 import mcpplibs.primitives.underlying.traits;
 
+namespace mcpplibs::primitives::meta::details {
+
+template <typename T> struct primitive_traits_impl;
+
+template <underlying_type T, policy::policy_type... Policies>
+struct primitive_traits_impl<primitive<T, Policies...>> {
+  using value_type = T;
+  using policies = std::tuple<Policies...>;
+  using value_policy =
+      policy::resolve_policy_t<policy::category::value, Policies...>;
+  using type_policy =
+      policy::resolve_policy_t<policy::category::type, Policies...>;
+  using error_policy =
+      policy::resolve_policy_t<policy::category::error, Policies...>;
+  using concurrency_policy =
+      policy::resolve_policy_t<policy::category::concurrency, Policies...>;
+};
+
+} // namespace mcpplibs::primitives::meta::details
+
 // Public API exported from this module.
 export namespace mcpplibs::primitives::meta {
 using policy_category = policy::category;
@@ -27,22 +48,46 @@ using default_policies =
     std::tuple<policy::defaults::value, policy::defaults::type,
                policy::defaults::error, policy::defaults::concurrency>;
 
-template <typename T> struct traits;
+template <typename T>
+using traits = details::primitive_traits_impl<std::remove_cvref_t<T>>;
 
-template <underlying_type T, policy::policy_type... Policies>
-struct traits<primitive<T, Policies...>> {
-  using value_type = T;
-  using policies = std::tuple<Policies...>;
-  using value_policy =
-      policy::resolve_policy_t<policy_category::value, Policies...>;
-  using type_policy =
-      policy::resolve_policy_t<policy_category::type, Policies...>;
-  using error_policy =
-      policy::resolve_policy_t<policy_category::error, Policies...>;
-  using concurrency_policy =
-      policy::resolve_policy_t<policy_category::concurrency, Policies...>;
+template <typename T>
+concept primitive_type = requires {
+  typename traits<T>::value_type;
+  typename traits<T>::policies;
+  typename traits<T>::value_policy;
+  typename traits<T>::type_policy;
+  typename traits<T>::error_policy;
+  typename traits<T>::concurrency_policy;
 };
 
+template <typename T>
+concept boolean =
+    primitive_type<T> &&
+    (underlying::traits<typename traits<T>::value_type>::kind ==
+     underlying::category::boolean);
+
+template <typename T>
+concept character =
+    primitive_type<T> &&
+    (underlying::traits<typename traits<T>::value_type>::kind ==
+     underlying::category::character);
+
+template <typename T>
+concept integer =
+    primitive_type<T> &&
+    (underlying::traits<typename traits<T>::value_type>::kind ==
+     underlying::category::integer);
+
+template <typename T>
+concept floating =
+    primitive_type<T> &&
+    (underlying::traits<typename traits<T>::value_type>::kind ==
+     underlying::category::floating);
+
+template <typename T>
+concept numeric = integer<T> || floating<T>;
+
 } // namespace mcpplibs::primitives::meta
 
 // Backward-compatible aliases for existing downstream users.
diff --git a/tests/basic/test_underlying.cpp b/tests/basic/test_underlying.cpp
index 9a5c9d9..8ab7540 100644
--- a/tests/basic/test_underlying.cpp
+++ b/tests/basic/test_underlying.cpp
@@ -480,6 +480,63 @@ TEST(PrimitiveTraitsTest, LegacyPrimitiveTraitsNamespaceAliasesRemainAvailable)
   SUCCEED();
 }
 
+TEST(PrimitiveTraitsTest, MetaTraitsExposeValueTypeAndPrimitiveMetadata) {
+  using value_t = mcpplibs::primitives::primitive<
+      short, mcpplibs::primitives::policy::value::checked,
+      mcpplibs::primitives::policy::type::compatible,
+      mcpplibs::primitives::policy::error::expected,
+      mcpplibs::primitives::policy::concurrency::fenced>;
+  using traits_t = mcpplibs::primitives::meta::traits<value_t const &>;
+
+  static_assert(
+      std::same_as<typename traits_t::value_type, typename value_t::value_type>);
+  static_assert(std::same_as<typename traits_t::policies, typename value_t::policies>);
+  static_assert(std::same_as<typename traits_t::value_policy,
+                             mcpplibs::primitives::policy::value::checked>);
+  static_assert(std::same_as<typename traits_t::type_policy,
+                             mcpplibs::primitives::policy::type::compatible>);
+  static_assert(std::same_as<typename traits_t::error_policy,
+                             mcpplibs::primitives::policy::error::expected>);
+  static_assert(std::same_as<typename traits_t::concurrency_policy,
+                             mcpplibs::primitives::policy::concurrency::fenced>);
+
+  SUCCEED();
+}
+
+TEST(PrimitiveTraitsTest, MetaPrimitiveConceptsMatchUnderlyingCategory) {
+  using boolean_t = mcpplibs::primitives::primitive<bool>;
+  using character_t = mcpplibs::primitives::primitive<char>;
+  using integer_t = mcpplibs::primitives::primitive<int>;
+  using floating_t = mcpplibs::primitives::primitive<double>;
+
+  static_assert(mcpplibs::primitives::meta::primitive_type<boolean_t const &>);
+  static_assert(mcpplibs::primitives::meta::primitive_type<integer_t>);
+  static_assert(!mcpplibs::primitives::meta::primitive_type<int>);
+
+  static_assert(mcpplibs::primitives::meta::boolean<boolean_t>);
+  static_assert(!mcpplibs::primitives::meta::boolean<integer_t>);
+
+  static_assert(mcpplibs::primitives::meta::character<character_t>);
+  static_assert(!mcpplibs::primitives::meta::character<boolean_t>);
+
+  static_assert(mcpplibs::primitives::meta::integer<integer_t>);
+  static_assert(!mcpplibs::primitives::meta::integer<character_t>);
+
+  static_assert(mcpplibs::primitives::meta::floating<floating_t>);
+  static_assert(!mcpplibs::primitives::meta::floating<integer_t>);
+
+  static_assert(mcpplibs::primitives::meta::numeric<integer_t>);
+  static_assert(mcpplibs::primitives::meta::numeric<floating_t>);
+  static_assert(!mcpplibs::primitives::meta::numeric<boolean_t>);
+  static_assert(!mcpplibs::primitives::meta::numeric<character_t>);
+  static_assert(!mcpplibs::primitives::meta::numeric<int>);
+
+  EXPECT_TRUE((mcpplibs::primitives::meta::boolean<boolean_t>));
+  EXPECT_TRUE((mcpplibs::primitives::meta::character<character_t>));
+  EXPECT_TRUE((mcpplibs::primitives::meta::integer<integer_t>));
+  EXPECT_TRUE((mcpplibs::primitives::meta::floating<floating_t>));
+}
+
 TEST(PrimitiveTraitsTest,
      UnderlyingTypeRequiresValidRepTypeAndCategoryConsistency) {
   EXPECT_TRUE((mcpplibs::primitives::underlying::traits<BadRep>::enabled));