From 584fafed96340b14253ffbcb7847652755ebbb9a Mon Sep 17 00:00:00 2001
From: Stephen Berry <stephenberry.developer@gmail.com>
Date: Mon, 27 Apr 2026 17:45:39 -0500
Subject: [PATCH] std_tuple_protocol

---
 include/glaze/beve/read.hpp                 |  18 ++-
 include/glaze/beve/size.hpp                 |  14 +-
 include/glaze/beve/write.hpp                |  14 +-
 include/glaze/cbor/read.hpp                 |  14 +-
 include/glaze/cbor/write.hpp                |  14 +-
 include/glaze/eetf/read.hpp                 |  14 +-
 include/glaze/eetf/write.hpp                |  14 +-
 include/glaze/json/flatten_map.hpp          |  12 +-
 include/glaze/json/jmespath.hpp             |  16 +-
 include/glaze/json/ndjson.hpp               |  30 ++--
 include/glaze/json/read.hpp                 |  17 +-
 include/glaze/json/schema.hpp               |   6 +-
 include/glaze/json/write.hpp                |  20 ++-
 include/glaze/jsonb/read.hpp                |  17 +-
 include/glaze/jsonb/write.hpp               |  14 +-
 include/glaze/msgpack/read.hpp              |  14 +-
 include/glaze/msgpack/write.hpp             |  14 +-
 include/glaze/toml/write.hpp                |  20 ++-
 include/glaze/util/tuple.hpp                |  21 +++
 include/glaze/yaml/read.hpp                 |  16 +-
 include/glaze/yaml/write.hpp                |  27 ++--
 tests/json_test/CMakeLists.txt              |   8 +
 tests/json_test/std_tuple_protocol_test.cpp | 164 ++++++++++++++++++++
 23 files changed, 400 insertions(+), 118 deletions(-)
 create mode 100644 tests/json_test/std_tuple_protocol_test.cpp

diff --git a/include/glaze/beve/read.hpp b/include/glaze/beve/read.hpp
index 4d77b62012..be9982c9d4 100644
--- a/include/glaze/beve/read.hpp
+++ b/include/glaze/beve/read.hpp
@@ -2096,7 +2096,7 @@ namespace glz
    };
 
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct from<BEVE, T> final
    {
       template <auto Opts>
@@ -2113,17 +2113,23 @@ namespace glz
          ++it;
 
          using V = std::decay_t<T>;
-         constexpr auto N = glz::tuple_size_v<V>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<V> && !tuple_t<V>;
+         constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<V>;
+            else
+               return glz::tuple_size_v<V>;
+         }();
          if constexpr (Opts.partial_read) {
             const auto n = int_from_compressed(ctx, it, end);
             if (bool(ctx.error)) [[unlikely]] {
                return;
             }
 
-            if constexpr (is_std_tuple<T>) {
+            if constexpr (use_std_protocol) {
                for_each_short_circuit<N>([&]<auto I>() {
                   if (I < n) {
-                     parse<BEVE>::op<Opts>(std::get<I>(value), ctx, it, end);
+                     parse<BEVE>::op<Opts>(get<I>(value), ctx, it, end);
                      return false; // continue
                   }
                   return true; // short circuit
@@ -2149,8 +2155,8 @@ namespace glz
                return;
             }
 
-            if constexpr (is_std_tuple<T>) {
-               for_each<N>([&]<size_t I>() { parse<BEVE>::op<Opts>(std::get<I>(value), ctx, it, end); });
+            if constexpr (use_std_protocol) {
+               for_each<N>([&]<size_t I>() { parse<BEVE>::op<Opts>(get<I>(value), ctx, it, end); });
             }
             else {
                for_each<N>([&]<size_t I>() { parse<BEVE>::op<Opts>(glz::get<I>(value), ctx, it, end); });
diff --git a/include/glaze/beve/size.hpp b/include/glaze/beve/size.hpp
index cbc86c9e9b..4117ffebb7 100644
--- a/include/glaze/beve/size.hpp
+++ b/include/glaze/beve/size.hpp
@@ -788,20 +788,26 @@ namespace glz
    };
 
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct calculate_size<BEVE, T>
    {
       template <auto Opts>
       [[nodiscard]] static size_t op(auto&& value, size_t offset = 0)
       {
-         static constexpr auto N = glz::tuple_size_v<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<std::remove_cvref_t<T>>;
+            else
+               return glz::tuple_size_v<T>;
+         }();
 
          size_t result = 1; // generic_array tag
          result += compressed_int_size<N>(); // element count
 
-         if constexpr (is_std_tuple<T>) {
+         if constexpr (use_std_protocol) {
             [&]<size_t... I>(std::index_sequence<I...>) {
-               ((result += calculate_size<BEVE, void>::template op<Opts>(std::get<I>(value), offset + result)), ...);
+               ((result += calculate_size<BEVE, void>::template op<Opts>(get<I>(value), offset + result)), ...);
             }(std::make_index_sequence<N>{});
          }
          else {
diff --git a/include/glaze/beve/write.hpp b/include/glaze/beve/write.hpp
index b577c1ef8c..9c6ec5fa5b 100644
--- a/include/glaze/beve/write.hpp
+++ b/include/glaze/beve/write.hpp
@@ -1582,7 +1582,7 @@ namespace glz
    };
 
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct to<BEVE, T> final
    {
       template <auto Opts, class B>
@@ -1593,15 +1593,21 @@ namespace glz
          }
          dump<tag::generic_array>(b, ix);
 
-         static constexpr auto N = glz::tuple_size_v<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<std::remove_cvref_t<T>>;
+            else
+               return glz::tuple_size_v<T>;
+         }();
          dump_compressed_int<N>(ctx, b, ix);
          if (bool(ctx.error)) [[unlikely]] {
             return;
          }
 
-         if constexpr (is_std_tuple<T>) {
+         if constexpr (use_std_protocol) {
             [&]<size_t... I>(std::index_sequence<I...>) {
-               ((serialize<BEVE>::op<Opts>(std::get<I>(value), ctx, b, ix), bool(ctx.error) ? void() : void()), ...);
+               ((serialize<BEVE>::op<Opts>(get<I>(value), ctx, b, ix), bool(ctx.error) ? void() : void()), ...);
             }(std::make_index_sequence<N>{});
          }
          else {
diff --git a/include/glaze/cbor/read.hpp b/include/glaze/cbor/read.hpp
index 6024b72484..5c0e587c75 100644
--- a/include/glaze/cbor/read.hpp
+++ b/include/glaze/cbor/read.hpp
@@ -1461,7 +1461,7 @@ namespace glz
 
    // Tuples
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct from<CBOR, T> final
    {
       template <auto Opts>
@@ -1487,7 +1487,13 @@ namespace glz
          }
 
          using V = std::decay_t<T>;
-         static constexpr auto N = glz::tuple_size_v<V>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<V> && !tuple_t<V>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<V>;
+            else
+               return glz::tuple_size_v<V>;
+         }();
 
          uint64_t count = cbor_detail::decode_arg(ctx, it, end, additional_info);
          if (bool(ctx.error)) [[unlikely]]
@@ -1498,8 +1504,8 @@ namespace glz
             return;
          }
 
-         if constexpr (is_std_tuple<T>) {
-            for_each<N>([&]<size_t I>() { parse<CBOR>::op<Opts>(std::get<I>(value), ctx, it, end); });
+         if constexpr (use_std_protocol) {
+            for_each<N>([&]<size_t I>() { parse<CBOR>::op<Opts>(get<I>(value), ctx, it, end); });
          }
          else {
             for_each<N>([&]<size_t I>() { parse<CBOR>::op<Opts>(glz::get<I>(value), ctx, it, end); });
diff --git a/include/glaze/cbor/write.hpp b/include/glaze/cbor/write.hpp
index ec25bc452a..7a7184c809 100644
--- a/include/glaze/cbor/write.hpp
+++ b/include/glaze/cbor/write.hpp
@@ -875,20 +875,26 @@ namespace glz
 
    // Tuples
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct to<CBOR, T> final
    {
       template <auto Opts>
       static void op(auto&& value, is_context auto&& ctx, auto&& b, auto& ix)
       {
-         static constexpr auto N = glz::tuple_size_v<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<std::remove_cvref_t<T>>;
+            else
+               return glz::tuple_size_v<T>;
+         }();
          if (!cbor_detail::encode_arg_cx<N>(ctx, cbor::major::array, b, ix)) [[unlikely]] {
             return;
          }
 
-         if constexpr (is_std_tuple<T>) {
+         if constexpr (use_std_protocol) {
             [&]<size_t... I>(std::index_sequence<I...>) {
-               (serialize<CBOR>::op<Opts>(std::get<I>(value), ctx, b, ix), ...);
+               (serialize<CBOR>::op<Opts>(get<I>(value), ctx, b, ix), ...);
             }(std::make_index_sequence<N>{});
          }
          else {
diff --git a/include/glaze/eetf/read.hpp b/include/glaze/eetf/read.hpp
index 2751b5a29c..32fe180322 100644
--- a/include/glaze/eetf/read.hpp
+++ b/include/glaze/eetf/read.hpp
@@ -230,7 +230,7 @@ namespace glz
    };
 
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct from<EETF, T> final
    {
       template <auto Opts>
@@ -257,15 +257,21 @@ namespace glz
          it += index;
 
          using V = std::decay_t<T>;
-         constexpr auto N = glz::tuple_size_v<V>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<V> && !tuple_t<V>;
+         constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<V>;
+            else
+               return glz::tuple_size_v<V>;
+         }();
 
          if (fields_count != N) {
             ctx.error = error_code::syntax_error;
             return;
          }
 
-         if constexpr (is_std_tuple<T>) {
-            for_each<N>([&]<size_t I>() { parse<EETF>::op<Opts>(std::get<I>(value), ctx, it, end); });
+         if constexpr (use_std_protocol) {
+            for_each<N>([&]<size_t I>() { parse<EETF>::op<Opts>(get<I>(value), ctx, it, end); });
          }
          else {
             for_each<N>([&]<size_t I>() { parse<EETF>::op<Opts>(glz::get<I>(value), ctx, it, end); });
diff --git a/include/glaze/eetf/write.hpp b/include/glaze/eetf/write.hpp
index cdb9f2a068..26b290c45d 100644
--- a/include/glaze/eetf/write.hpp
+++ b/include/glaze/eetf/write.hpp
@@ -127,7 +127,7 @@ namespace glz
    };
 
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct to<EETF, T> final
    {
       template <auto Opts, class V, class... Args>
@@ -142,16 +142,22 @@ namespace glz
          requires(check_no_header(Opts))
       GLZ_ALWAYS_INLINE static void op(auto&& value, Ctx&& ctx, Args&&... args) noexcept
       {
-         static constexpr auto N = glz::tuple_size_v<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<std::remove_cvref_t<T>>;
+            else
+               return glz::tuple_size_v<T>;
+         }();
 
          encode_tuple_header(N, ctx, std::forward<Args>(args)...);
          if (bool(ctx.error)) [[unlikely]] {
             return;
          }
 
-         if constexpr (is_std_tuple<T>) {
+         if constexpr (use_std_protocol) {
             [&]<size_t... I>(std::index_sequence<I...>) {
-               (serialize<EETF>::op<Opts>(std::get<I>(value), ctx, args...), ...);
+               (serialize<EETF>::op<Opts>(get<I>(value), ctx, args...), ...);
             }(std::make_index_sequence<N>{});
          }
          else {
diff --git a/include/glaze/json/flatten_map.hpp b/include/glaze/json/flatten_map.hpp
index 78e3606bca..963199628c 100644
--- a/include/glaze/json/flatten_map.hpp
+++ b/include/glaze/json/flatten_map.hpp
@@ -65,13 +65,13 @@ namespace glz
             write_flatten_map_elements<Opts>(get_member(value, glz::get<I>(meta_v<V>)), ctx, b, ix, first);
          });
       }
-      else if constexpr (is_std_tuple<V>) {
-         static constexpr auto N = glz::tuple_size_v<V>;
+      else if constexpr (std_tuple_protocol<V> && !tuple_t<V>) {
+         static constexpr auto N = std::tuple_size_v<V>;
          for_each<N>([&]<size_t I>() {
             if (bool(ctx.error)) [[unlikely]] {
                return;
             }
-            write_flatten_map_elements<Opts>(std::get<I>(value), ctx, b, ix, first);
+            write_flatten_map_elements<Opts>(get<I>(value), ctx, b, ix, first);
          });
       }
       else if constexpr (tuple_t<V>) {
@@ -177,13 +177,13 @@ namespace glz
             read_flatten_map_elements<Opts>(get_member(value, glz::get<I>(meta_v<V>)), ctx, it, end, first);
          });
       }
-      else if constexpr (is_std_tuple<V>) {
-         static constexpr auto N = glz::tuple_size_v<V>;
+      else if constexpr (std_tuple_protocol<V> && !tuple_t<V>) {
+         static constexpr auto N = std::tuple_size_v<V>;
          for_each<N>([&]<size_t I>() {
             if (bool(ctx.error)) [[unlikely]] {
                return;
             }
-            read_flatten_map_elements<Opts>(std::get<I>(value), ctx, it, end, first);
+            read_flatten_map_elements<Opts>(get<I>(value), ctx, it, end, first);
          });
       }
       else if constexpr (tuple_t<V>) {
diff --git a/include/glaze/json/jmespath.hpp b/include/glaze/json/jmespath.hpp
index 9de5674158..6e8a0d7283 100644
--- a/include/glaze/json/jmespath.hpp
+++ b/include/glaze/json/jmespath.hpp
@@ -425,14 +425,14 @@ namespace glz
    {
       template <auto Opts = opts{}, class T>
          requires(Opts.format == JSON && not readable_array_t<T> &&
-                  not(tuple_t<std::decay_t<T>> || is_std_tuple<std::decay_t<T>>))
+                  not(tuple_t<std::decay_t<T>> || std_tuple_protocol<std::decay_t<T>>))
       inline void handle_slice(const jmespath::ArrayParseResult&, T&&, context& ctx, auto&&, auto&&)
       {
          ctx.error = error_code::syntax_error;
       }
 
       template <auto Opts = opts{}, class T>
-         requires(Opts.format == JSON && (tuple_t<std::decay_t<T>> || is_std_tuple<std::decay_t<T>>))
+         requires(Opts.format == JSON && (tuple_t<std::decay_t<T>> || std_tuple_protocol<std::decay_t<T>>))
       inline void handle_slice(const jmespath::ArrayParseResult& decomposed_key, T&& value, context& ctx, auto&& it,
                                auto end)
       {
@@ -462,7 +462,13 @@ namespace glz
 
          // Iterate tuple elements
          using TupleType = std::decay_t<T>;
-         constexpr size_t N = glz::tuple_size_v<TupleType>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<TupleType> && !tuple_t<TupleType>;
+         constexpr size_t N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<TupleType>;
+            else
+               return glz::tuple_size_v<TupleType>;
+         }();
 
          for_each<N>([&]<size_t I>() {
             if (bool(ctx.error)) return;
@@ -499,8 +505,8 @@ namespace glz
                return;
             }
 
-            if constexpr (is_std_tuple<TupleType>) {
-               parse<Opts.format>::template op<Opts>(std::get<I>(value), ctx, it, end);
+            if constexpr (use_std_protocol) {
+               parse<Opts.format>::template op<Opts>(get<I>(value), ctx, it, end);
             }
             else {
                parse<Opts.format>::template op<Opts>(glz::get<I>(value), ctx, it, end);
diff --git a/include/glaze/json/ndjson.hpp b/include/glaze/json/ndjson.hpp
index aea424c0da..53dae00f86 100644
--- a/include/glaze/json/ndjson.hpp
+++ b/include/glaze/json/ndjson.hpp
@@ -106,7 +106,7 @@ namespace glz
    };
 
    template <class T>
-      requires glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>
+      requires glaze_array_t<T> || tuple_t<T> || std_tuple_protocol<T>
    struct from<NDJSON, T>
    {
       template <auto Opts>
@@ -116,10 +116,14 @@ namespace glz
             return;
          }
 
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
          static constexpr auto N = []() constexpr {
             if constexpr (glaze_array_t<T>) {
                return reflect<T>::size;
             }
+            else if constexpr (use_std_protocol) {
+               return std::tuple_size_v<T>;
+            }
             else {
                return glz::tuple_size_v<T>;
             }
@@ -148,8 +152,8 @@ namespace glz
             if constexpr (I != 0) {
                read_new_lines();
             }
-            if constexpr (is_std_tuple<T>) {
-               parse<JSON>::op<Opts>(std::get<I>(value), ctx, it, end);
+            if constexpr (use_std_protocol) {
+               parse<JSON>::op<Opts>(get<I>(value), ctx, it, end);
             }
             else if constexpr (glaze_array_t<T>) {
                parse<JSON>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, it, end);
@@ -223,29 +227,17 @@ namespace glz
    };
 
    template <class T>
-      requires is_std_tuple<std::decay_t<T>>
+      requires(std_tuple_protocol<std::decay_t<T>> && !tuple_t<std::decay_t<T>> && !glaze_array_t<std::decay_t<T>>)
    struct to<NDJSON, T>
    {
       template <auto Opts, class... Args>
       static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
-         static constexpr auto N = []() constexpr {
-            if constexpr (glaze_array_t<std::decay_t<T>>) {
-               return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
-            }
-            else {
-               return glz::tuple_size_v<std::decay_t<T>>;
-            }
-         }();
-
          using V = std::decay_t<T>;
+         static constexpr auto N = std::tuple_size_v<V>;
+
          for_each<N>([&]<auto I>() {
-            if constexpr (glaze_array_t<V>) {
-               serialize<JSON>::op<Opts>(value.*std::get<I>(meta_v<V>), ctx, std::forward<Args>(args)...);
-            }
-            else {
-               serialize<JSON>::op<Opts>(std::get<I>(value), ctx, std::forward<Args>(args)...);
-            }
+            serialize<JSON>::op<Opts>(get<I>(value), ctx, std::forward<Args>(args)...);
             constexpr bool needs_new_line = I < N - 1;
             if constexpr (needs_new_line) {
                dump('\n', std::forward<Args>(args)...);
diff --git a/include/glaze/json/read.hpp b/include/glaze/json/read.hpp
index c1f3a68dfc..85749e0124 100644
--- a/include/glaze/json/read.hpp
+++ b/include/glaze/json/read.hpp
@@ -2642,16 +2642,20 @@ namespace glz
    };
 
    template <class T>
-      requires glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>
+      requires glaze_array_t<T> || tuple_t<T> || std_tuple_protocol<T>
    struct from<JSON, T>
    {
       template <auto Opts>
       static void op(auto& value, is_context auto&& ctx, auto&& it, auto end)
       {
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
          static constexpr auto N = []() constexpr {
             if constexpr (glaze_array_t<T>) {
                return reflect<T>::size;
             }
+            else if constexpr (use_std_protocol) {
+               return std::tuple_size_v<T>;
+            }
             else {
                return glz::tuple_size_v<T>;
             }
@@ -2691,8 +2695,8 @@ namespace glz
                   return true;
                }
             }
-            if constexpr (is_std_tuple<T>) {
-               parse<JSON>::op<ws_handled<Opts>()>(std::get<I>(value), ctx, it, end);
+            if constexpr (use_std_protocol) {
+               parse<JSON>::op<ws_handled<Opts>()>(get<I>(value), ctx, it, end);
                if (bool(ctx.error)) [[unlikely]]
                   return true;
             }
@@ -3452,7 +3456,8 @@ namespace glz
    concept variant_object_type = json_object<T>;
 
    template <class T>
-   concept variant_array_type = array_t<remove_meta_wrapper_t<T>> || glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>;
+   concept variant_array_type =
+      array_t<remove_meta_wrapper_t<T>> || glaze_array_t<T> || tuple_t<T> || std_tuple_protocol<T>;
 
    template <class T>
    concept variant_null_type = null_t<T>;
@@ -3624,8 +3629,8 @@ namespace glz
                         found_match = true;
                      }
                      else if constexpr (not Options.null_terminated) {
-                        constexpr bool is_complete_type =
-                           num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> || tuple_t<V> || is_std_tuple<V>;
+                        constexpr bool is_complete_type = num_t<V> || bool_t<V> || string_t<V> || std::is_enum_v<V> ||
+                                                          tuple_t<V> || std_tuple_protocol<V>;
 
                         if constexpr (is_complete_type) {
                            if (ctx.error == error_code::end_reached && it > copy_it) {
diff --git a/include/glaze/json/schema.hpp b/include/glaze/json/schema.hpp
index a556b83058..bb0bbe216f 100644
--- a/include/glaze/json/schema.hpp
+++ b/include/glaze/json/schema.hpp
@@ -849,18 +849,22 @@ namespace glz
       };
 
       template <class T>
-         requires glaze_array_t<std::decay_t<T>> || tuple_t<std::decay_t<T>> || is_std_tuple<std::decay_t<T>>
+         requires glaze_array_t<std::decay_t<T>> || tuple_t<std::decay_t<T>> || std_tuple_protocol<std::decay_t<T>>
       struct to_json_schema<T>
       {
          template <auto Opts>
          static void op(auto& s, auto& defs)
          {
             using V = std::decay_t<T>;
+            static constexpr bool use_std_protocol = std_tuple_protocol<V> && !tuple_t<V>;
             s.type = sv{"array"};
             static constexpr auto N = []() constexpr {
                if constexpr (glaze_array_t<V>) {
                   return glz::tuple_size_v<meta_t<V>>;
                }
+               else if constexpr (use_std_protocol) {
+                  return std::tuple_size_v<V>;
+               }
                else {
                   return glz::tuple_size_v<V>;
                }
diff --git a/include/glaze/json/write.hpp b/include/glaze/json/write.hpp
index 8fd5b8d465..c766812546 100644
--- a/include/glaze/json/write.hpp
+++ b/include/glaze/json/write.hpp
@@ -1854,18 +1854,23 @@ namespace glz
    };
 
    template <class T>
-      requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || is_std_tuple<T>
+      requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || std_tuple_protocol<std::decay_t<T>>
    struct to<JSON, T>
    {
       template <auto Opts, class... Args>
       static void op(auto&& value, is_context auto&& ctx, Args&&... args)
       {
+         using V = std::decay_t<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<V> && !tuple_t<V>;
          static constexpr auto N = []() constexpr {
-            if constexpr (glaze_array_t<std::decay_t<T>>) {
-               return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
+            if constexpr (glaze_array_t<V>) {
+               return glz::tuple_size_v<meta_t<V>>;
+            }
+            else if constexpr (use_std_protocol) {
+               return std::tuple_size_v<V>;
             }
             else {
-               return glz::tuple_size_v<std::decay_t<T>>;
+               return glz::tuple_size_v<V>;
             }
          }();
 
@@ -1876,14 +1881,13 @@ namespace glz
                dump_newline_indent(check_indentation_char(Opts), ctx.depth, args...);
             }
          }
-         using V = std::decay_t<T>;
          for_each<N>([&]<size_t I>() {
             if constexpr (glaze_array_t<V>) {
                serialize<JSON>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, args...);
             }
-            else if constexpr (is_std_tuple<T>) {
-               using Value = core_t<decltype(std::get<I>(value))>;
-               to<JSON, Value>::template op<Opts>(std::get<I>(value), ctx, args...);
+            else if constexpr (use_std_protocol) {
+               using Value = core_t<decltype(get<I>(value))>;
+               to<JSON, Value>::template op<Opts>(get<I>(value), ctx, args...);
             }
             else {
                using Value = core_t<decltype(glz::get<I>(value))>;
diff --git a/include/glaze/jsonb/read.hpp b/include/glaze/jsonb/read.hpp
index 183676002d..33487a9bef 100644
--- a/include/glaze/jsonb/read.hpp
+++ b/include/glaze/jsonb/read.hpp
@@ -738,7 +738,7 @@ namespace glz
 
    // Tuples
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct from<JSONB, T> final
    {
       template <auto Opts>
@@ -759,11 +759,18 @@ namespace glz
          }
          const auto stop = it + sz;
 
-         static constexpr auto N = glz::tuple_size_v<std::decay_t<T>>;
-         if constexpr (is_std_tuple<T>) {
+         using V = std::decay_t<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<V> && !tuple_t<V>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<V>;
+            else
+               return glz::tuple_size_v<V>;
+         }();
+         if constexpr (use_std_protocol) {
             for_each<N>([&]<size_t I>() {
                if (bool(ctx.error)) return;
-               parse<JSONB>::op<Opts>(std::get<I>(value), ctx, it, end);
+               parse<JSONB>::op<Opts>(get<I>(value), ctx, it, end);
             });
          }
          else {
@@ -1019,7 +1026,7 @@ namespace glz
       {};
       template <class T>
       struct is_jsonb_variant_array : std::bool_constant<writable_array_t<T> || readable_array_t<T> || tuple_t<T> ||
-                                                         is_std_tuple<T> || glaze_array_t<T>>
+                                                         std_tuple_protocol<T> || glaze_array_t<T>>
       {};
       template <class T>
       struct is_jsonb_variant_object : std::bool_constant<writable_map_t<T> || readable_map_t<T> || pair_t<T> ||
diff --git a/include/glaze/jsonb/write.hpp b/include/glaze/jsonb/write.hpp
index 60e27d276b..746756d396 100644
--- a/include/glaze/jsonb/write.hpp
+++ b/include/glaze/jsonb/write.hpp
@@ -246,7 +246,7 @@ namespace glz
 
    // Tuples
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct to<JSONB, T> final
    {
       template <auto Opts>
@@ -258,10 +258,16 @@ namespace glz
          }
          const size_t payload_start = ix;
 
-         static constexpr auto N = glz::tuple_size_v<T>;
-         if constexpr (is_std_tuple<T>) {
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<std::remove_cvref_t<T>>;
+            else
+               return glz::tuple_size_v<T>;
+         }();
+         if constexpr (use_std_protocol) {
             [&]<size_t... I>(std::index_sequence<I...>) {
-               (serialize<JSONB>::op<Opts>(std::get<I>(value), ctx, b, ix), ...);
+               (serialize<JSONB>::op<Opts>(get<I>(value), ctx, b, ix), ...);
             }(std::make_index_sequence<N>{});
          }
          else {
diff --git a/include/glaze/msgpack/read.hpp b/include/glaze/msgpack/read.hpp
index ca21657fb2..01ff1ce992 100644
--- a/include/glaze/msgpack/read.hpp
+++ b/include/glaze/msgpack/read.hpp
@@ -976,7 +976,7 @@ namespace glz
    };
 
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct from<MSGPACK, T>
    {
       template <auto Opts, class Value, is_context Ctx, class It, class End>
@@ -986,14 +986,20 @@ namespace glz
          if (!msgpack::read_array_length(ctx, tag, it, end, len)) {
             return;
          }
-         static constexpr auto N = glz::tuple_size_v<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<std::remove_cvref_t<T>>;
+            else
+               return glz::tuple_size_v<T>;
+         }();
          if (len != N) {
             ctx.error = error_code::syntax_error;
             return;
          }
-         if constexpr (is_std_tuple<T>) {
+         if constexpr (use_std_protocol) {
             [&]<size_t... I>(std::index_sequence<I...>) {
-               (parse<MSGPACK>::template op<Opts>(std::get<I>(value), ctx, it, end), ...);
+               (parse<MSGPACK>::template op<Opts>(get<I>(value), ctx, it, end), ...);
             }(std::make_index_sequence<N>{});
          }
          else {
diff --git a/include/glaze/msgpack/write.hpp b/include/glaze/msgpack/write.hpp
index 1935a7b5c3..f54f5a005a 100644
--- a/include/glaze/msgpack/write.hpp
+++ b/include/glaze/msgpack/write.hpp
@@ -1003,20 +1003,26 @@ namespace glz
    };
 
    template <class T>
-      requires(tuple_t<T> || is_std_tuple<T>)
+      requires(tuple_t<T> || std_tuple_protocol<T>)
    struct to<MSGPACK, T>
    {
       template <auto Opts, class Value, is_context Ctx, class B, class IX>
       GLZ_ALWAYS_INLINE static void op(Value&& value, Ctx&& ctx, B&& b, IX&& ix)
       {
-         static constexpr auto N = glz::tuple_size_v<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
+         static constexpr auto N = []() constexpr {
+            if constexpr (use_std_protocol)
+               return std::tuple_size_v<std::remove_cvref_t<T>>;
+            else
+               return glz::tuple_size_v<T>;
+         }();
          if (!msgpack::detail::write_array_header(ctx, N, b, ix)) [[unlikely]] {
             return;
          }
-         if constexpr (is_std_tuple<T>) {
+         if constexpr (use_std_protocol) {
             [&]<size_t... I>(std::index_sequence<I...>) {
                ((void)(bool(ctx.error) ? void()
-                                       : (serialize<MSGPACK>::op<Opts>(std::get<I>(value), ctx, b, ix), void())),
+                                       : (serialize<MSGPACK>::op<Opts>(get<I>(value), ctx, b, ix), void())),
                 ...);
             }(std::make_index_sequence<N>{});
          }
diff --git a/include/glaze/toml/write.hpp b/include/glaze/toml/write.hpp
index b45cc87055..d9fcf3d528 100644
--- a/include/glaze/toml/write.hpp
+++ b/include/glaze/toml/write.hpp
@@ -1283,18 +1283,23 @@ namespace glz
    };
 
    template <class T>
-      requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || is_std_tuple<T>
+      requires glaze_array_t<T> || tuple_t<std::decay_t<T>> || std_tuple_protocol<std::decay_t<T>>
    struct to<TOML, T>
    {
       template <auto Opts, class B>
       static void op(auto&& value, is_context auto&& ctx, B&& b, auto& ix)
       {
+         using V = std::decay_t<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<V> && !tuple_t<V>;
          static constexpr auto N = []() constexpr {
-            if constexpr (glaze_array_t<std::decay_t<T>>) {
-               return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
+            if constexpr (glaze_array_t<V>) {
+               return glz::tuple_size_v<meta_t<V>>;
+            }
+            else if constexpr (use_std_protocol) {
+               return std::tuple_size_v<V>;
             }
             else {
-               return glz::tuple_size_v<std::decay_t<T>>;
+               return glz::tuple_size_v<V>;
             }
          }();
 
@@ -1302,7 +1307,6 @@ namespace glz
             return;
          }
          dump('[', b, ix);
-         using V = std::decay_t<T>;
          for_each<N>([&]<size_t I>() {
             if (bool(ctx.error)) [[unlikely]] {
                return;
@@ -1310,9 +1314,9 @@ namespace glz
             if constexpr (glaze_array_t<V>) {
                serialize<TOML>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, b, ix);
             }
-            else if constexpr (is_std_tuple<T>) {
-               using Value = core_t<decltype(std::get<I>(value))>;
-               to<TOML, Value>::template op<Opts>(std::get<I>(value), ctx, b, ix);
+            else if constexpr (use_std_protocol) {
+               using Value = core_t<decltype(get<I>(value))>;
+               to<TOML, Value>::template op<Opts>(get<I>(value), ctx, b, ix);
             }
             else {
                using Value = core_t<decltype(glz::get<I>(value))>;
diff --git a/include/glaze/util/tuple.hpp b/include/glaze/util/tuple.hpp
index b56bee40dd..048bf2f9dc 100644
--- a/include/glaze/util/tuple.hpp
+++ b/include/glaze/util/tuple.hpp
@@ -5,6 +5,7 @@
 
 #include <tuple>
 
+#include "glaze/concepts/container_concepts.hpp"
 #include "glaze/reflection/get_name.hpp"
 #include "glaze/tuplet/tuple.hpp"
 #include "glaze/util/for_each.hpp"
@@ -15,6 +16,26 @@ namespace glz
    template <class T>
    concept is_std_tuple = is_specialization_v<T, std::tuple>;
 
+   namespace detail
+   {
+      // Unqualified `get<0>(t)` resolves via ADL: std types are found in namespace std,
+      // user types via their own associated namespaces. Matches the structured-bindings
+      // tuple-protocol lookup rule ([dcl.struct.bind]).
+      template <class T>
+      concept has_adl_tuple_get = requires(T&& t) { get<0>(static_cast<T&&>(t)); };
+   }
+
+   // True for any non-pair, non-range type that satisfies the standard tuple protocol:
+   // std::tuple_size<T>::value is well-formed, std::tuple_element<0, T>::type is
+   // well-formed, and ADL get<0>(t) is callable. This includes std::tuple as well
+   // as user-defined types that opt in by specializing std::tuple_size /
+   // std::tuple_element and providing an ADL `get<I>`.
+   template <class T>
+   concept std_tuple_protocol = requires {
+      std::tuple_size<std::remove_cvref_t<T>>::value;
+      typename std::tuple_element<0, std::remove_cvref_t<T>>::type;
+   } && detail::has_adl_tuple_get<T> && !pair_t<T> && !range<T>;
+
    // TODO: This doesn't appear to be used. Should it be removed?
    template <class Type>
    concept is_schema_class = requires {
diff --git a/include/glaze/yaml/read.hpp b/include/glaze/yaml/read.hpp
index 76c9c8c1d2..65bb0fb479 100644
--- a/include/glaze/yaml/read.hpp
+++ b/include/glaze/yaml/read.hpp
@@ -3709,7 +3709,7 @@ namespace glz
 
    // Tuples (std::tuple, glaze_array_t, tuple_t)
    template <class T>
-      requires(glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>)
+      requires(glaze_array_t<T> || tuple_t<T> || std_tuple_protocol<T>)
    struct from<YAML, T>
    {
       template <auto Opts, class It>
@@ -3718,10 +3718,14 @@ namespace glz
          if (bool(ctx.error)) [[unlikely]]
             return;
 
+         static constexpr bool use_std_protocol = std_tuple_protocol<T> && !tuple_t<T>;
          static constexpr auto N = []() constexpr {
             if constexpr (glaze_array_t<T>) {
                return reflect<T>::size;
             }
+            else if constexpr (use_std_protocol) {
+               return std::tuple_size_v<T>;
+            }
             else {
                return glz::tuple_size_v<T>;
             }
@@ -3778,9 +3782,9 @@ namespace glz
                   yaml::skip_ws_and_newlines(it, end);
                }
 
-               if constexpr (is_std_tuple<T>) {
+               if constexpr (use_std_protocol) {
                   using element_t = std::tuple_element_t<I, std::remove_cvref_t<T>>;
-                  from<YAML, element_t>::template op<yaml::flow_context_on<Opts>()>(std::get<I>(value), ctx, it, end);
+                  from<YAML, element_t>::template op<yaml::flow_context_on<Opts>()>(get<I>(value), ctx, it, end);
                }
                else if constexpr (glaze_array_t<T>) {
                   using element_t = std::decay_t<decltype(get_member(value, glz::get<I>(meta_v<T>)))>;
@@ -3841,9 +3845,9 @@ namespace glz
                   (
                      [&]<size_t I>() {
                         if (I == index) {
-                           if constexpr (is_std_tuple<T>) {
+                           if constexpr (use_std_protocol) {
                               using element_t = std::tuple_element_t<I, std::remove_cvref_t<T>>;
-                              from<YAML, element_t>::template op<Opts>(std::get<I>(value), ctx, it, end);
+                              from<YAML, element_t>::template op<Opts>(get<I>(value), ctx, it, end);
                            }
                            else if constexpr (glaze_array_t<T>) {
                               using element_t = std::decay_t<decltype(get_member(value, glz::get<I>(meta_v<T>)))>;
@@ -4665,7 +4669,7 @@ namespace glz
 
    template <class T>
    concept yaml_variant_array_type =
-      array_t<remove_meta_wrapper_t<T>> || glaze_array_t<T> || tuple_t<T> || is_std_tuple<T>;
+      array_t<remove_meta_wrapper_t<T>> || glaze_array_t<T> || tuple_t<T> || std_tuple_protocol<T>;
 
    template <class T>
    concept yaml_variant_null_type = null_t<T>;
diff --git a/include/glaze/yaml/write.hpp b/include/glaze/yaml/write.hpp
index 366e285076..7305d809df 100644
--- a/include/glaze/yaml/write.hpp
+++ b/include/glaze/yaml/write.hpp
@@ -725,18 +725,23 @@ namespace glz
 
    // Tuples (std::tuple, glaze_array_t, tuple_t)
    template <class T>
-      requires(glaze_array_t<T> || tuple_t<std::decay_t<T>> || is_std_tuple<T>)
+      requires(glaze_array_t<T> || tuple_t<std::decay_t<T>> || std_tuple_protocol<std::decay_t<T>>)
    struct to<YAML, T>
    {
       template <auto Opts, class B>
       static void op(auto&& value, is_context auto&& ctx, B&& b, auto& ix)
       {
+         using V = std::decay_t<T>;
+         static constexpr bool use_std_protocol = std_tuple_protocol<V> && !tuple_t<V>;
          static constexpr auto N = []() constexpr {
-            if constexpr (glaze_array_t<std::decay_t<T>>) {
-               return glz::tuple_size_v<meta_t<std::decay_t<T>>>;
+            if constexpr (glaze_array_t<V>) {
+               return glz::tuple_size_v<meta_t<V>>;
+            }
+            else if constexpr (use_std_protocol) {
+               return std::tuple_size_v<V>;
             }
             else {
-               return glz::tuple_size_v<std::decay_t<T>>;
+               return glz::tuple_size_v<V>;
             }
          }();
 
@@ -747,7 +752,6 @@ namespace glz
             }
             dump('[', b, ix);
 
-            using V = std::decay_t<T>;
             for_each<N>([&]<size_t I>() {
                if (bool(ctx.error)) [[unlikely]]
                   return;
@@ -760,9 +764,9 @@ namespace glz
                   serialize<YAML>::op<yaml::flow_context_on<Opts>()>(get_member(value, glz::get<I>(meta_v<T>)), ctx, b,
                                                                      ix);
                }
-               else if constexpr (is_std_tuple<T>) {
-                  using element_t = core_t<decltype(std::get<I>(value))>;
-                  to<YAML, element_t>::template op<yaml::flow_context_on<Opts>()>(std::get<I>(value), ctx, b, ix);
+               else if constexpr (use_std_protocol) {
+                  using element_t = core_t<decltype(get<I>(value))>;
+                  to<YAML, element_t>::template op<yaml::flow_context_on<Opts>()>(get<I>(value), ctx, b, ix);
                }
                else {
                   using element_t = core_t<decltype(glz::get<I>(value))>;
@@ -780,7 +784,6 @@ namespace glz
                indent_level = ctx.indent_level;
             }
 
-            using V = std::decay_t<T>;
             for_each<N>([&]<size_t I>() {
                if (bool(ctx.error)) [[unlikely]]
                   return;
@@ -806,15 +809,15 @@ namespace glz
                      serialize<YAML>::op<Opts>(get_member(value, glz::get<I>(meta_v<T>)), ctx, b, ix);
                   }
                }
-               else if constexpr (is_std_tuple<T>) {
+               else if constexpr (use_std_protocol) {
                   using element_t = std::decay_t<std::tuple_element_t<I, std::remove_cvref_t<T>>>;
                   if constexpr (yaml::is_simple_type<element_t>()) {
-                     to<YAML, element_t>::template op<Opts>(std::get<I>(value), ctx, b, ix);
+                     to<YAML, element_t>::template op<Opts>(get<I>(value), ctx, b, ix);
                      dump('\n', b, ix);
                   }
                   else {
                      dump('\n', b, ix);
-                     to<YAML, element_t>::template op<Opts>(std::get<I>(value), ctx, b, ix);
+                     to<YAML, element_t>::template op<Opts>(get<I>(value), ctx, b, ix);
                   }
                }
                else {
diff --git a/tests/json_test/CMakeLists.txt b/tests/json_test/CMakeLists.txt
index b96c75263e..de6edc0fb8 100644
--- a/tests/json_test/CMakeLists.txt
+++ b/tests/json_test/CMakeLists.txt
@@ -175,3 +175,11 @@ add_executable(non_aggregate_reflection_test non_aggregate_reflection_test.cpp)
 target_link_libraries(non_aggregate_reflection_test PRIVATE glz_test_common)
 
 add_test(NAME non_aggregate_reflection_test COMMAND non_aggregate_reflection_test)
+
+## Standard tuple protocol test - discussion #2530
+
+add_executable(std_tuple_protocol_test std_tuple_protocol_test.cpp)
+
+target_link_libraries(std_tuple_protocol_test PRIVATE glz_test_common)
+
+add_test(NAME std_tuple_protocol_test COMMAND std_tuple_protocol_test)
diff --git a/tests/json_test/std_tuple_protocol_test.cpp b/tests/json_test/std_tuple_protocol_test.cpp
new file mode 100644
index 0000000000..387e3f0852
--- /dev/null
+++ b/tests/json_test/std_tuple_protocol_test.cpp
@@ -0,0 +1,164 @@
+// Glaze Library
+// Test that user-defined types implementing the standard C++ tuple protocol
+// (std::tuple_size, std::tuple_element, ADL get<I>) are treated as tuples
+// without requiring duplicate glz:: specializations.
+// See https://github.com/stephenberry/glaze/discussions/2530
+
+#include <cstddef>
+#include <string>
+#include <tuple>
+#include <utility>
+
+#include "glaze/glaze.hpp"
+#include "glaze/cbor.hpp"
+#include "glaze/msgpack.hpp"
+#include "ut/ut.hpp"
+
+using namespace ut;
+
+namespace user_ns
+{
+   class MyTuple
+   {
+     public:
+      MyTuple() = default;
+      MyTuple(int x, double y, std::string z) : x_(x), y_(y), z_(std::move(z)) {}
+
+      int& x() & { return x_; }
+      double& y() & { return y_; }
+      std::string& z() & { return z_; }
+
+      const int& x() const& { return x_; }
+      const double& y() const& { return y_; }
+      const std::string& z() const& { return z_; }
+
+      bool operator==(const MyTuple&) const = default;
+
+     private:
+      int x_{};
+      double y_{};
+      std::string z_{};
+   };
+
+   // ADL get — found by unqualified name lookup in the same namespace as MyTuple.
+   template <std::size_t I>
+   decltype(auto) get(MyTuple& t)
+   {
+      if constexpr (I == 0)
+         return t.x();
+      else if constexpr (I == 1)
+         return t.y();
+      else
+         return t.z();
+   }
+
+   template <std::size_t I>
+   decltype(auto) get(const MyTuple& t)
+   {
+      if constexpr (I == 0)
+         return t.x();
+      else if constexpr (I == 1)
+         return t.y();
+      else
+         return t.z();
+   }
+
+   template <std::size_t I>
+   decltype(auto) get(MyTuple&& t)
+   {
+      if constexpr (I == 0)
+         return std::move(t).x();
+      else if constexpr (I == 1)
+         return std::move(t).y();
+      else
+         return std::move(t).z();
+   }
+}
+
+// Standard tuple protocol customization: specializing these in namespace std
+// is explicitly permitted by the standard for program-defined types.
+template <>
+struct std::tuple_size<user_ns::MyTuple> : std::integral_constant<std::size_t, 3>
+{};
+
+template <>
+struct std::tuple_element<0, user_ns::MyTuple>
+{
+   using type = int;
+};
+
+template <>
+struct std::tuple_element<1, user_ns::MyTuple>
+{
+   using type = double;
+};
+
+template <>
+struct std::tuple_element<2, user_ns::MyTuple>
+{
+   using type = std::string;
+};
+
+suite std_tuple_protocol = [] {
+   "concept detects std-protocol types"_test = [] {
+      static_assert(glz::std_tuple_protocol<user_ns::MyTuple>);
+      static_assert(glz::std_tuple_protocol<std::tuple<int, double>>);
+      static_assert(not glz::std_tuple_protocol<std::pair<int, double>>); // pair has its own path
+      static_assert(not glz::std_tuple_protocol<std::array<int, 3>>); // array goes through range path
+      static_assert(not glz::std_tuple_protocol<int>);
+   };
+
+   "json roundtrip via std tuple protocol"_test = [] {
+      user_ns::MyTuple t{42, 3.14, "answer"};
+      std::string buffer;
+      expect(not glz::write_json(t, buffer));
+      expect(buffer == R"([42,3.14,"answer"])");
+
+      user_ns::MyTuple t2;
+      expect(glz::read_json(t2, buffer) == glz::error_code::none);
+      expect(t == t2);
+   };
+
+   "std::tuple still roundtrips"_test = [] {
+      auto t = std::make_tuple(1, 2.5, std::string("ok"));
+      decltype(t) t2;
+      std::string buffer;
+      expect(not glz::write_json(t, buffer));
+      expect(glz::read_json(t2, buffer) == glz::error_code::none);
+      expect(t == t2);
+   };
+
+   "std::pair stays a pair (object), not a tuple (array)"_test = [] {
+      std::pair<std::string, int> p{"key", 9};
+      std::string buffer;
+      expect(not glz::write_json(p, buffer));
+      // pair_t serializer writes {"key":9}, not ["key",9]
+      expect(buffer == R"({"key":9})");
+   };
+
+   "beve roundtrip"_test = [] {
+      user_ns::MyTuple t{42, 3.14, "answer"};
+      auto buffer = glz::write_beve(t).value_or(std::string{});
+      user_ns::MyTuple t2;
+      expect(glz::read_beve(t2, buffer) == glz::error_code::none);
+      expect(t == t2);
+   };
+
+   "cbor roundtrip"_test = [] {
+      user_ns::MyTuple t{42, 3.14, "answer"};
+      auto buffer = glz::write_cbor(t).value_or(std::string{});
+      user_ns::MyTuple t2;
+      expect(glz::read_cbor(t2, buffer) == glz::error_code::none);
+      expect(t == t2);
+   };
+
+   "msgpack roundtrip"_test = [] {
+      user_ns::MyTuple t{42, 3.14, "answer"};
+      auto buffer = glz::write_msgpack(t).value_or(std::string{});
+      user_ns::MyTuple t2;
+      expect(glz::read_msgpack(t2, buffer) == glz::error_code::none);
+      expect(t == t2);
+   };
+};
+
+int main() { return 0; }