From 06acecca921da9ae7fe25224a73fcdee3f454ef3 Mon Sep 17 00:00:00 2001
From: FrozenlemonTee <1115306170@qq.com>
Date: Mon, 23 Mar 2026 12:35:03 +0800
Subject: [PATCH 01/14] docs: Update current plan directory path in copilot
 instructions

Signed-off-by: FrozenlemonTee <1115306170@qq.com>
---
 .github/copilot-instructions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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/`
 
 ## 说明
 

From ec9b072e0fded943228cb8b1a12963cc73272c2e Mon Sep 17 00:00:00 2001
From: FrozenlemonTee <1115306170@qq.com>
Date: Mon, 23 Mar 2026 12:46:56 +0800
Subject: [PATCH 02/14] docs: Add implementation plan for primitives module
 with milestones and acceptance criteria

Signed-off-by: FrozenlemonTee <1115306170@qq.com>
---
 .agents/docs/plans/implementation-plan.md | 82 +++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 .agents/docs/plans/implementation-plan.md

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 完成

From ab28749722094d6bbba6fee249e9a95945be30fc Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 19:21:07 +0800
Subject: [PATCH 03/14] docs: Update policy category references in traits
 implementation

---
 src/primitive/traits.cppm | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/primitive/traits.cppm b/src/primitive/traits.cppm
index e1fb5b4..aa77ac5 100644
--- a/src/primitive/traits.cppm
+++ b/src/primitive/traits.cppm
@@ -34,13 +34,13 @@ 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...>;
+      policy::resolve_policy_t<policy::category::value, Policies...>;
   using type_policy =
-      policy::resolve_policy_t<policy_category::type, Policies...>;
+      policy::resolve_policy_t<policy::category::type, Policies...>;
   using error_policy =
-      policy::resolve_policy_t<policy_category::error, Policies...>;
+      policy::resolve_policy_t<policy::category::error, Policies...>;
   using concurrency_policy =
-      policy::resolve_policy_t<policy_category::concurrency, Policies...>;
+      policy::resolve_policy_t<policy::category::concurrency, Policies...>;
 };
 
 } // namespace mcpplibs::primitives::meta

From c9f99aa53d5e3b7cd5d87d960bdc95eeead88ded Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 20:27:21 +0800
Subject: [PATCH 04/14] refactor: Simplify traits implementation by introducing
 primitive_traits_impl

---
 src/primitive/traits.cppm | 38 +++++++++++++++++++++++---------------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/src/primitive/traits.cppm b/src/primitive/traits.cppm
index aa77ac5..b4ee72b 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,21 +48,8 @@ using default_policies =
     std::tuple<policy::defaults::value, policy::defaults::type,
                policy::defaults::error, policy::defaults::concurrency>;
 
-template <typename T> struct traits;
-
-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>
+using traits = details::primitive_traits_impl<std::remove_cvref_t<T>>;
 
 } // namespace mcpplibs::primitives::meta
 

From 35f52111b0058468629e3775ca5d7262d556a842 Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 20:56:01 +0800
Subject: [PATCH 05/14] refactor: Introduce concepts for primitive types in
 traits implementation

---
 src/primitive/traits.cppm | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/src/primitive/traits.cppm b/src/primitive/traits.cppm
index b4ee72b..8ecb4fe 100644
--- a/src/primitive/traits.cppm
+++ b/src/primitive/traits.cppm
@@ -51,6 +51,43 @@ using default_policies =
 template <typename T>
 using traits = details::primitive_traits_impl<std::remove_cvref_t<T>>;
 
+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.

From fb4c004e2612f86897eb6e2a550d10916e30abe9 Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 20:56:31 +0800
Subject: [PATCH 06/14] refactor: Add tests for meta traits and primitive
 concepts in primitives module

---
 tests/basic/test_underlying.cpp | 57 +++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

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

From 2d762fc5f40e4a310d9b6c09350876e7928ec0a1 Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 21:02:43 +0800
Subject: [PATCH 07/14] refactor: Replace primitive_instance concept with
 primitive_type in dispatcher and operators

---
 src/operations/dispatcher.cppm | 15 ++++++---------
 src/operations/operators.cppm  |  3 +++
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/operations/dispatcher.cppm b/src/operations/dispatcher.cppm
index 9fdaa33..4b17d41 100644
--- a/src/operations/dispatcher.cppm
+++ b/src/operations/dispatcher.cppm
@@ -15,13 +15,8 @@ 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, primitives::meta::primitive_type Lhs,
+          primitives::meta::primitive_type Rhs,
           typename ErrorPayload = policy::error::kind>
 struct dispatcher_meta {
   using lhs_primitive = std::remove_cvref_t<Lhs>;
@@ -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/operators.cppm b/src/operations/operators.cppm
index 67f8b40..13e418d 100644
--- a/src/operations/operators.cppm
+++ b/src/operations/operators.cppm
@@ -61,6 +61,9 @@ constexpr auto decode_three_way_code(CommonRep const &code) -> Ordering {
 
 } // namespace details
 
+template <typename T>
+concept primitive_instance = meta::primitive_type<T>;
+
 template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 using primitive_dispatch_result_t = std::expected<meta::make_primitive_t<

From 439f074a29c154734d4616a01b0acf7f7d3a449a Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 21:08:35 +0800
Subject: [PATCH 08/14] refactor: Remove redundant namespace qualifiers for
 primitive types in dispatcher

---
 src/operations/dispatcher.cppm | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/operations/dispatcher.cppm b/src/operations/dispatcher.cppm
index 4b17d41..7947265 100644
--- a/src/operations/dispatcher.cppm
+++ b/src/operations/dispatcher.cppm
@@ -15,15 +15,15 @@ import mcpplibs.primitives.underlying;
 
 export namespace mcpplibs::primitives::operations {
 
-template <operation OpTag, primitives::meta::primitive_type Lhs,
-          primitives::meta::primitive_type 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;
@@ -31,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> &&

From 17d3984a28ce02cd6dd45356db3547529b5df3bc Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 21:08:46 +0800
Subject: [PATCH 09/14] refactor: Replace primitive_instance concept with
 meta::primitive_type in operators module

---
 src/operations/operators.cppm | 298 +++++++++++++++++-----------------
 1 file changed, 148 insertions(+), 150 deletions(-)

diff --git a/src/operations/operators.cppm b/src/operations/operators.cppm
index 13e418d..6907db8 100644
--- a/src/operations/operators.cppm
+++ b/src/operations/operators.cppm
@@ -61,10 +61,7 @@ constexpr auto decode_three_way_code(CommonRep const &code) -> Ordering {
 
 } // namespace details
 
-template <typename T>
-concept primitive_instance = meta::primitive_type<T>;
-
-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>
 using primitive_dispatch_result_t = std::expected<meta::make_primitive_t<
         typename dispatcher_meta<OpTag, Lhs, Rhs, ErrorPayload>::common_rep,
@@ -74,11 +71,11 @@ using primitive_dispatch_result_t = std::expected<meta::make_primitive_t<
 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 =
@@ -86,7 +83,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<
@@ -94,7 +91,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,
@@ -102,28 +99,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> {
@@ -139,14 +136,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> {
@@ -155,7 +152,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,
@@ -166,54 +163,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,
@@ -221,21 +218,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,
@@ -243,14 +240,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,
@@ -258,7 +255,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,
@@ -266,28 +263,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,
@@ -296,21 +293,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,
@@ -318,21 +315,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,
@@ -340,21 +337,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,
@@ -362,21 +359,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,
@@ -384,21 +381,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,
@@ -406,14 +403,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,
@@ -421,21 +418,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,
@@ -443,21 +440,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,
@@ -465,7 +462,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> {
@@ -483,7 +480,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> {
@@ -492,7 +489,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> {
@@ -501,7 +498,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> {
@@ -535,70 +532,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> {
@@ -610,13 +607,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;
@@ -627,13 +624,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;
@@ -644,33 +641,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,
@@ -679,22 +676,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,
@@ -703,22 +700,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,
@@ -727,21 +724,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,
@@ -750,21 +747,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,
@@ -773,7 +770,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> {
@@ -781,14 +778,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,
@@ -797,21 +794,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,
@@ -820,21 +817,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,
@@ -843,21 +840,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,
@@ -866,21 +863,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,
@@ -889,7 +886,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> {
@@ -898,14 +895,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,
@@ -914,21 +911,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,
@@ -937,21 +934,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> {
@@ -959,82 +956,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
+

From 570e309be2f32c7450fdfd6514f08d93f568ccd6 Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 21:13:18 +0800
Subject: [PATCH 10/14] refactor: Move underlying_operand concept into
 operations namespace

---
 src/operations/operators.cppm | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/operations/operators.cppm b/src/operations/operators.cppm
index 6907db8..ff2430c 100644
--- a/src/operations/operators.cppm
+++ b/src/operations/operators.cppm
@@ -17,6 +17,13 @@ import mcpplibs.primitives.policy.handler;
 import mcpplibs.primitives.policy.impl;
 import mcpplibs.primitives.underlying.traits;
 
+namespace mcpplibs::primitives::operations {
+
+template <typename T>
+concept underlying_operand = underlying_type<std::remove_cvref_t<T>>;
+
+} // namespace mcpplibs::primitives::operations
+
 export namespace mcpplibs::primitives::operations {
 
 namespace details {
@@ -68,9 +75,6 @@ using primitive_dispatch_result_t = std::expected<meta::make_primitive_t<
         typename meta::traits<Lhs>::policies>,
     ErrorPayload>;
 
-template <typename T>
-concept underlying_operand = underlying_type<std::remove_cvref_t<T>>;
-
 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>;

From facfac2414a600aeae53e5ba311f15d61697f486 Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 21:19:33 +0800
Subject: [PATCH 11/14] refactor: Improve apply_runtime_fence function
 parameter types and condition check

---
 src/operations/invoker.cppm | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/operations/invoker.cppm b/src/operations/invoker.cppm
index 7c84208..c203769 100644
--- a/src/operations/invoker.cppm
+++ b/src/operations/invoker.cppm
@@ -781,13 +781,13 @@ 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);
   }
 }

From c675829b95cd4851ab0241dace10280083d6ba48 Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 21:41:34 +0800
Subject: [PATCH 12/14] refactor: Make details not exported

---
 src/operations/invoker.cppm   | 9 ++++++---
 src/operations/operators.cppm | 8 ++++----
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/operations/invoker.cppm b/src/operations/invoker.cppm
index c203769..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,
@@ -792,7 +791,11 @@ constexpr auto apply_runtime_fence(const bool enabled,
   }
 }
 
-} // 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 ff2430c..3ec2bf9 100644
--- a/src/operations/operators.cppm
+++ b/src/operations/operators.cppm
@@ -22,10 +22,6 @@ namespace mcpplibs::primitives::operations {
 template <typename T>
 concept underlying_operand = underlying_type<std::remove_cvref_t<T>>;
 
-} // namespace mcpplibs::primitives::operations
-
-export namespace mcpplibs::primitives::operations {
-
 namespace details {
 template <typename CommonRep, typename = void> struct three_way_ordering {
   using type = std::strong_ordering;
@@ -68,6 +64,10 @@ constexpr auto decode_three_way_code(CommonRep const &code) -> Ordering {
 
 } // namespace details
 
+} // 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<

From f648925168a4281925c9b330d5fbad7ea0d294bb Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 22:11:28 +0800
Subject: [PATCH 13/14] refactor: Move atomic reference utilities into details
 namespace

---
 src/policy/impl.cppm | 146 +++++++++++++++++++++----------------------
 1 file changed, 73 insertions(+), 73 deletions(-)

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

From 33d9eb9a6bbe4ca11e7a7a71ee23ccf16a15b765 Mon Sep 17 00:00:00 2001
From: FrozenLemonTee <frozenlemontee@gmail.com>
Date: Mon, 23 Mar 2026 23:27:07 +0800
Subject: [PATCH 14/14] refactor: Remove unused type aliases in operators
 module

---
 src/operations/operators.cppm | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/operations/operators.cppm b/src/operations/operators.cppm
index 3ec2bf9..86bc2a6 100644
--- a/src/operations/operators.cppm
+++ b/src/operations/operators.cppm
@@ -510,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()) {