diff --git a/mcc_concepts.h b/mcc_concepts.h
index 8c97eaa..26e91ef 100644
--- a/mcc_concepts.h
+++ b/mcc_concepts.h
@@ -58,10 +58,23 @@ concept mcc_error_c = std::default_initializable<T> && (std::convertible_to<T, b
 
 
 template <mcc_error_c ErrT, mcc_error_c DefErrT>
-DefErrT mcc_deduced_err(ErrT const& err, DefErrT const& default_err)
+auto mcc_deduced_err(ErrT const& err, DefErrT const& default_err)
+// DefErrT mcc_deduced_err(ErrT const& err, DefErrT const& default_err)
 {
     if constexpr (std::same_as<ErrT, DefErrT>) {
         return err;
+    } else if constexpr (std::is_error_code_enum_v<DefErrT>) {
+        if constexpr (std::same_as<ErrT, std::error_code>) {
+            return err;
+        } else {
+            return default_err;
+        }
+    } else if constexpr (std::is_error_condition_enum_v<DefErrT>) {
+        if constexpr (std::same_as<ErrT, std::error_condition>) {
+            return err;
+        } else {
+            return default_err;
+        }
     } else {
         return default_err;
     }
diff --git a/mcc_coordinate.h b/mcc_coordinate.h
index 7fcd44d..7cff31e 100644
--- a/mcc_coordinate.h
+++ b/mcc_coordinate.h
@@ -587,7 +587,7 @@ public:
     }
 
 
-    error_t EO(mcc_angle_c auto* eo)
+    error_t EO(mcc_angle_c auto* eo) const
     {
         return cctEngine.equationOrigins(_epoch, eo);
     }
diff --git a/mcc_pzone_container.h b/mcc_pzone_container.h
index 0151c6a..3d65f12 100644
--- a/mcc_pzone_container.h
+++ b/mcc_pzone_container.h
@@ -115,7 +115,7 @@ public:
     {
         auto sptr = std::make_shared<decltype(zone)>(std::move(zone));
 
-        _inZoneFunc.emplace_back([sptr](MccSkyPoint const& pt, bool* res) {
+        _inZoneFunc.emplace_back([sptr](MccSkyPoint const& pt, bool* res) -> error_t {
             auto err = sptr->inPZone(pt, res);
             if (err) {
                 return mcc_deduced_err(err, MccPZoneContainerErrorCode::ERROR_INZONE_FUNC);
@@ -125,7 +125,7 @@ public:
         });
 
 
-        _timeToZoneFunc.emplace_back([sptr](MccSkyPoint const& pt, duration_t* res) {
+        _timeToZoneFunc.emplace_back([sptr](MccSkyPoint const& pt, duration_t* res) -> error_t {
             auto err = sptr->timeToPZone(pt, res);
             if (err) {
                 return mcc_deduced_err(err, MccPZoneContainerErrorCode::ERROR_TIMETO_FUNC);
@@ -135,7 +135,7 @@ public:
         });
 
 
-        _timeFromZoneFunc.emplace_back([sptr](MccSkyPoint const& pt, duration_t* res) {
+        _timeFromZoneFunc.emplace_back([sptr](MccSkyPoint const& pt, duration_t* res) -> error_t {
             auto err = sptr->timeFromPZone(pt, res);
             if (err) {
                 return mcc_deduced_err(err, MccPZoneContainerErrorCode::ERROR_TIMEFROM_FUNC);
diff --git a/mcc_serializer.h b/mcc_serializer.h
index dad96c6..f62e162 100644
--- a/mcc_serializer.h
+++ b/mcc_serializer.h
@@ -383,7 +383,7 @@ struct MccSerializer<VT> : MccSerializerBase {
                        VT const& value,
                        ParamsT const& params = mcc_serialization_params_t{})
     {
-        auto serialize_cpair = [&]<typename T>(T& cp) {
+        auto serialize_cpair = [&]<typename T>(T& cp) -> error_t {
             auto ccte_err = value.to(cp);
             if (ccte_err) {
                 return mcc_deduced_err(ccte_err, MccSerializerErrorCode::ERROR_COORD_TRANSFORM);
@@ -474,10 +474,12 @@ struct MccSerializer<VT> : MccSerializerBase {
         MccSkyAZZD azzd;
 
         // quantities in hour representation
-        MccSerializerBase::angleFormatFromCoordPairType<VT::pairKind, MccSerializerBase::CO_LON>(pars_h);
+        MccSerializerBase::angleFormatFromCoordPairType<MccCoordPairKind::COORDS_KIND_RADEC_ICRS,
+                                                        MccSerializerBase::CO_LON>(pars_h);
 
         // quantities in degree representation
-        MccSerializerBase::angleFormatFromCoordPairType<VT::pairKind, MccSerializerBase::CO_LON>(pars_d);
+        MccSerializerBase::angleFormatFromCoordPairType<MccCoordPairKind::COORDS_KIND_RADEC_ICRS,
+                                                        MccSerializerBase::CO_LON>(pars_d);
 
         MccSerializer<MccAngle> ang_sr;
 
@@ -590,14 +592,14 @@ struct MccSerializer<VT> : MccSerializerBase {
 
         // PCM X and Y
 
-        err = ang_sr(output, value.pcmCorrection.pcmX(), pars_d);
+        err = ang_sr(output, value.pcmCorrection.pcmX, pars_d);
         if (err) {
             return mcc_deduced_err(err, MccSerializerErrorCode::ERROR_UNDERLYING_SERIALIZER);
         }
 
         MccSerializerBase::addElemDelimiter(output, pars_h);
 
-        err = ang_sr(output, value.pcmCorrection.pcmY(), pars_d);
+        err = ang_sr(output, value.pcmCorrection.pcmY, pars_d);
         if (err) {
             return mcc_deduced_err(err, MccSerializerErrorCode::ERROR_UNDERLYING_SERIALIZER);
         }
diff --git a/tests/mcc_telemetry_test.cpp b/tests/mcc_telemetry_test.cpp
index 422c571..5933853 100644
--- a/tests/mcc_telemetry_test.cpp
+++ b/tests/mcc_telemetry_test.cpp
@@ -3,9 +3,9 @@
 #include <random>
 
 #include <mcc_pcm.h>
+#include <mcc_serializer.h>
 #include <mcc_telemetry.h>
 
-
 static std::random_device rd;
 static std::mt19937 gen(rd());
 static std::uniform_int_distribution<long> tm_distrib(100, 700);
@@ -62,16 +62,31 @@ struct hw_t {
 };
 
 template <>
-struct std::formatter<hw_t::hardware_movement_state_t, char>
-    : std::formatter<std::underlying_type_t<hw_t::hardware_movement_state_t>, char> {
+struct std::formatter<hw_t::hardware_movement_state_t, char> : std::formatter<std::string_view> {
     auto format(hw_t::hardware_movement_state_t e, auto& ctx) const
     {
-        return formatter<std::underlying_type_t<hw_t::hardware_movement_state_t>>::format(
-            std::underlying_type_t<hw_t::hardware_movement_state_t>(e), ctx);
+        return formatter<std::string_view>::format(e == hw_t::hardware_movement_state_t::HW_MOVE_ERROR      ? "ERROR"
+                                                   : e == hw_t::hardware_movement_state_t::HW_MOVE_STOPPED  ? "STOPPED"
+                                                   : e == hw_t::hardware_movement_state_t::HW_MOVE_STOPPING ? "STOPPING"
+                                                   : e == hw_t::hardware_movement_state_t::HW_MOVE_SLEWING  ? "SLEWING"
+                                                   : e == hw_t::hardware_movement_state_t::HW_MOVE_TRACKING ? "TRACKING"
+                                                                                                            : "UNKNOWN",
+                                                   ctx);
     }
 };
 
 
+// template <>
+// struct std::formatter<hw_t::hardware_movement_state_t, char>
+//     : std::formatter<std::underlying_type_t<hw_t::hardware_movement_state_t>, char> {
+//     auto format(hw_t::hardware_movement_state_t e, auto& ctx) const
+//     {
+//         return formatter<std::underlying_type_t<hw_t::hardware_movement_state_t>>::format(
+//             std::underlying_type_t<hw_t::hardware_movement_state_t>(e), ctx);
+//     }
+// };
+
+
 
 static_assert(mcc::mcc_hardware_c<hw_t>, "!!!!!");
 
@@ -97,5 +112,18 @@ int main()
         }
     }
 
+
+    mcc::impl::MccSerializer<typename t_t::telemetry_data_t> ser;
+
+    std::string str;
+
+    auto err = ser(str, tdata);
+    if (err) {
+        std::cout << "ERR: " << err.message() << "\n";
+    } else {
+        std::cout << "\n\n";
+        std::cout << str << "\n";
+    }
+
     return 0;
 }