From e20e886fbc092276ba8c5945f1fee2f6915e313f Mon Sep 17 00:00:00 2001
From: VPRamon <ramon.valles-puig@cta-consortium.org>
Date: Tue, 24 Feb 2026 01:33:17 +0100
Subject: [PATCH 1/5] feat: implement Time<S> class template and CivilTime
 struct; update time-related headers and tests

---
 include/tempoch/period.hpp    |  44 ++---
 include/tempoch/scales.hpp    | 168 ++++++++++++++++++
 include/tempoch/tempoch.hpp   |  20 ++-
 include/tempoch/time.hpp      | 242 ++-----------------------
 include/tempoch/time_base.hpp | 326 ++++++++++++++++++++++++++++++++++
 tests/test_time.cpp           |   8 +-
 6 files changed, 543 insertions(+), 265 deletions(-)
 create mode 100644 include/tempoch/scales.hpp
 create mode 100644 include/tempoch/time_base.hpp

diff --git a/include/tempoch/period.hpp b/include/tempoch/period.hpp
index 65ab3ef..8cfb85d 100644
--- a/include/tempoch/period.hpp
+++ b/include/tempoch/period.hpp
@@ -8,6 +8,10 @@
  * class template `Period<T>`.  The underlying storage is always
  * `tempoch_period_mjd_t`; `TimeTraits<T>` handles conversion to/from the raw
  * MJD doubles.
+ *
+ * `TimeTraits` specialisations for every `Time<S>` are provided automatically
+ * by `time_base.hpp`.  A manual `CivilTime` specialisation is kept here for
+ * `Period<CivilTime>` (i.e. `UTCPeriod`).
  */
 
 #include "qtty/qtty.hpp"
@@ -18,32 +22,18 @@
 namespace tempoch {
 
 // ============================================================================
-// TimeTraits — connect each time type to the MJD-based FFI layer
+// TimeTraits — CivilTime specialisation
 // ============================================================================
+// TimeTraits<Time<S>> for all scale-based types is already defined in
+// time_base.hpp.  We only need the CivilTime-specific one here.
 
-/**
- * @brief Conversion traits between a time type @p T and raw MJD doubles.
- *
- * Specialise this struct to make `Period<T>` work for a custom time type.
- * Each specialisation must provide:
- *   - `static double to_mjd_value(const T&)`
- *   - `static T      from_mjd_value(double)`
- */
-template <typename T> struct TimeTraits;
-
-template <> struct TimeTraits<MJD> {
-  static double to_mjd_value(const MJD &t) { return t.value(); }
-  static MJD from_mjd_value(double m) { return MJD(m); }
-};
-
-template <> struct TimeTraits<JulianDate> {
-  static double to_mjd_value(const JulianDate &t) { return t.to_mjd(); }
-  static JulianDate from_mjd_value(double m) { return MJD(m).to_jd(); }
-};
-
-template <> struct TimeTraits<UTC> {
-  static double to_mjd_value(const UTC &t) { return MJD::from_utc(t).value(); }
-  static UTC from_mjd_value(double m) { return MJD(m).to_utc(); }
+template <> struct TimeTraits<CivilTime> {
+  static double to_mjd_value(const CivilTime &t) {
+    return TimeScaleTraits<MJDScale>::from_civil(t);
+  }
+  static CivilTime from_mjd_value(double m) {
+    return TimeScaleTraits<MJDScale>::to_civil(m);
+  }
 };
 
 // ============================================================================
@@ -160,9 +150,9 @@ template <typename T> Period(T, T) -> Period<T>;
 // Convenience type aliases
 // ============================================================================
 
-using MJDPeriod = Period<MJD>; ///< Period expressed in Modified Julian Date.
-using JDPeriod = Period<JulianDate>; ///< Period expressed in Julian Date.
-using UTCPeriod = Period<UTC>;       ///< Period expressed in UTC civil time.
+using MJDPeriod = Period<MJD>;          ///< Period expressed in Modified Julian Date.
+using JDPeriod  = Period<JulianDate>;   ///< Period expressed in Julian Date.
+using UTCPeriod = Period<CivilTime>;    ///< Period expressed in UTC civil time.
 
 // ============================================================================
 // operator<<
diff --git a/include/tempoch/scales.hpp b/include/tempoch/scales.hpp
new file mode 100644
index 0000000..36b52c1
--- /dev/null
+++ b/include/tempoch/scales.hpp
@@ -0,0 +1,168 @@
+#pragma once
+
+/**
+ * @file scales.hpp
+ * @brief Time-scale tag types and traits for the tempoch Time<S> template.
+ *
+ * Mirrors the Rust `tempoch_core::scales` module.  Each tag is an empty struct
+ * that selects the FFI functions used by `Time<S>`.
+ *
+ * Adding a new scale requires:
+ *  1. Define a tag struct (e.g. `struct TTScale {};`).
+ *  2. Specialise `TimeScaleTraits<TTScale>` with the FFI calls.
+ *  3. Specialise `TimeConvertTraits<A,B>` for each supported conversion pair.
+ */
+
+#include "ffi_core.hpp"  // tempoch_ffi.h + check_status
+
+namespace tempoch {
+
+// Forward declaration — defined in time_base.hpp.
+struct CivilTime;
+
+// ============================================================================
+// Scale Tags
+// ============================================================================
+
+/// Julian Date (days since −4712‑01‑01T12:00 TT).
+struct JDScale {};
+
+/// Modified Julian Date (JD − 2 400 000.5).
+struct MJDScale {};
+
+/// UTC, internally stored as MJD days for arithmetic.
+struct UTCScale {};
+
+// Stubs for future FFI-backed scales — uncomment and specialise traits once
+// the FFI exposes the conversion functions.
+// struct TTScale  {};   // Terrestrial Time
+// struct TAIScale {};   // International Atomic Time
+// struct TDBScale {};   // Barycentric Dynamical Time
+// struct TCGScale {};   // Geocentric Coordinate Time
+// struct TCBScale {};   // Barycentric Coordinate Time
+// struct GPSScale {};   // GPS Time
+// struct UTScale  {};   // Universal Time (UT1)
+
+// ============================================================================
+// TimeScaleTraits — per-scale FFI dispatch
+// ============================================================================
+
+/**
+ * @brief Primary template — must be specialised for every supported scale.
+ *
+ * Required static members:
+ *   - `const char* label()`
+ *   - `double from_utc(const CivilTime&)` — civil time → raw days
+ *   - `CivilTime to_utc(double days)` — raw days → civil time
+ *   - `double add_days(double days, double delta)`
+ *   - `double difference(double a, double b)` — a − b in days
+ */
+template <typename S> struct TimeScaleTraits {
+  static_assert(sizeof(S) == 0,
+                "TimeScaleTraits<S> must be specialised for this scale.");
+};
+
+// ── JDScale ─────────────────────────────────────────────────────────────────
+
+template <> struct TimeScaleTraits<JDScale> {
+  static constexpr const char *label() { return "JD"; }
+
+  static double from_civil(const CivilTime &ct);
+  static CivilTime to_civil(double jd);
+
+  static double add_days(double jd, double delta) {
+    return tempoch_jd_add_days(jd, delta);
+  }
+
+  static double difference(double a, double b) {
+    return tempoch_jd_difference(a, b);
+  }
+
+  /// J2000.0 epoch constant (JD 2 451 545.0).
+  static double j2000() { return tempoch_jd_j2000(); }
+
+  /// Julian centuries elapsed since J2000.
+  static double julian_centuries(double jd) {
+    return tempoch_jd_julian_centuries(jd);
+  }
+};
+
+// ── MJDScale ────────────────────────────────────────────────────────────────
+
+template <> struct TimeScaleTraits<MJDScale> {
+  static constexpr const char *label() { return "MJD"; }
+
+  static double from_civil(const CivilTime &ct);
+  static CivilTime to_civil(double mjd);
+
+  static double add_days(double mjd, double delta) {
+    return tempoch_mjd_add_days(mjd, delta);
+  }
+
+  static double difference(double a, double b) {
+    return tempoch_mjd_difference(a, b);
+  }
+};
+
+// ── UTCScale (internally stored as MJD) ─────────────────────────────────────
+
+template <> struct TimeScaleTraits<UTCScale> {
+  static constexpr const char *label() { return "UTC"; }
+
+  static double from_civil(const CivilTime &ct);
+  static CivilTime to_civil(double mjd);
+
+  static double add_days(double mjd, double delta) {
+    return tempoch_mjd_add_days(mjd, delta);
+  }
+
+  static double difference(double a, double b) {
+    return tempoch_mjd_difference(a, b);
+  }
+};
+
+// ============================================================================
+// TimeConvertTraits — cross-scale conversion
+// ============================================================================
+
+/**
+ * @brief Primary template — specialise for each supported A→B pair.
+ *
+ * Required: `static double convert(double src_days)`.
+ */
+template <typename From, typename To> struct TimeConvertTraits {
+  static_assert(sizeof(From) == 0,
+                "TimeConvertTraits<From,To> is not specialised for this pair.");
+};
+
+// ── JD ↔ MJD ────────────────────────────────────────────────────────────────
+
+template <> struct TimeConvertTraits<JDScale, MJDScale> {
+  static double convert(double jd) { return tempoch_jd_to_mjd(jd); }
+};
+
+template <> struct TimeConvertTraits<MJDScale, JDScale> {
+  static double convert(double mjd) { return tempoch_mjd_to_jd(mjd); }
+};
+
+// ── JD ↔ UTC (UTC stored as MJD internally) ────────────────────────────────
+
+template <> struct TimeConvertTraits<JDScale, UTCScale> {
+  static double convert(double jd) { return tempoch_jd_to_mjd(jd); }
+};
+
+template <> struct TimeConvertTraits<UTCScale, JDScale> {
+  static double convert(double mjd) { return tempoch_mjd_to_jd(mjd); }
+};
+
+// ── MJD ↔ UTC (identity — both stored as MJD) ──────────────────────────────
+
+template <> struct TimeConvertTraits<MJDScale, UTCScale> {
+  static double convert(double mjd) { return mjd; }
+};
+
+template <> struct TimeConvertTraits<UTCScale, MJDScale> {
+  static double convert(double mjd) { return mjd; }
+};
+
+} // namespace tempoch
diff --git a/include/tempoch/tempoch.hpp b/include/tempoch/tempoch.hpp
index 84ea18b..50f8292 100644
--- a/include/tempoch/tempoch.hpp
+++ b/include/tempoch/tempoch.hpp
@@ -5,20 +5,24 @@
  * @brief Umbrella header for the tempoch C++ wrapper library.
  *
  * Include this single header to get the full tempoch C++ API:
- * - `tempoch::UTC` — UTC date-time breakdown
- * - `tempoch::JulianDate` — Julian Date wrapper
- * - `tempoch::MJD` — Modified Julian Date wrapper
- * - `tempoch::Period` — Time period [start, end] in MJD
+ *
+ *   - `tempoch::Time<S>` — generic time-point template (core)
+ *   - `tempoch::JulianDate` = `Time<JDScale>`
+ *   - `tempoch::MJD`        = `Time<MJDScale>`
+ *   - `tempoch::CivilTime`  — UTC civil date-time breakdown
+ *   - `tempoch::UTC`        — alias for `CivilTime`
+ *   - `tempoch::Period<T>`  — time period [start, end]
  *
  * @code
  * #include <tempoch/tempoch.hpp>
  *
- * auto jd = tempoch::JulianDate::from_utc({2026, 7, 15, 22, 0, 0});
- * auto mjd = tempoch::MJD::from_jd(jd);
- * tempoch::Period night(60200.0, 60200.5);
+ * auto jd  = tempoch::JulianDate::from_utc({2026, 7, 15, 22, 0, 0});
+ * auto mjd = jd.to<tempoch::MJDScale>();   // cross-scale conversion
  * @endcode
  */
 
 #include "ffi_core.hpp"
-#include "period.hpp"
+#include "scales.hpp"
+#include "time_base.hpp"
 #include "time.hpp"
+#include "period.hpp"
diff --git a/include/tempoch/time.hpp b/include/tempoch/time.hpp
index e92ff26..d99cad3 100644
--- a/include/tempoch/time.hpp
+++ b/include/tempoch/time.hpp
@@ -2,239 +2,29 @@
 
 /**
  * @file time.hpp
- * @brief C++ wrappers for Julian Date, Modified Julian Date, and UTC.
+ * @brief Public type aliases for tempoch time types.
  *
- * Wraps the tempoch-ffi C layer with value-semantic, exception-safe C++ types.
- */
-
-#include "ffi_core.hpp"
-#include <iomanip>
-#include <ostream>
-
-namespace tempoch {
-
-// ============================================================================
-// UTC
-// ============================================================================
-
-/**
- * @brief UTC date-time breakdown.
- *
- * A simple value type mirroring the C `tempoch_utc_t` struct.
- *
- * @code
- * tempoch::UTC noon(2000, 1, 1, 12, 0, 0);
- * auto jd = tempoch::JulianDate::from_utc(noon);
- * @endcode
- */
-struct UTC {
-  /// Gregorian year (astronomical year numbering).
-  int32_t year;
-  /// Month in range [1, 12].
-  uint8_t month;
-  /// Day of month in range [1, 31].
-  uint8_t day;
-  /// Hour in range [0, 23].
-  uint8_t hour;
-  /// Minute in range [0, 59].
-  uint8_t minute;
-  /// Second in range [0, 60], leap second aware.
-  uint8_t second;
-  /// Nanosecond component in range [0, 999,999,999].
-  uint32_t nanosecond;
-
-  /// Default constructor: J2000 epoch noon-like civil representation.
-  UTC()
-      : year(2000), month(1), day(1), hour(12), minute(0), second(0),
-        nanosecond(0) {}
-
-  /**
-   * @brief Construct from civil UTC components.
-   * @param y Year.
-   * @param mo Month [1, 12].
-   * @param d Day [1, 31].
-   * @param h Hour [0, 23].
-   * @param mi Minute [0, 59].
-   * @param s Second [0, 60].
-   * @param ns Nanoseconds [0, 999,999,999].
-   */
-  UTC(int32_t y, uint8_t mo, uint8_t d, uint8_t h = 0, uint8_t mi = 0,
-      uint8_t s = 0, uint32_t ns = 0)
-      : year(y), month(mo), day(d), hour(h), minute(mi), second(s),
-        nanosecond(ns) {}
-
-  /// Convert to the C FFI struct.
-  tempoch_utc_t to_c() const {
-    return {year, month, day, hour, minute, second, nanosecond};
-  }
-
-  /// Create from the C FFI struct.
-  static UTC from_c(const tempoch_utc_t &c) {
-    return UTC(c.year, c.month, c.day, c.hour, c.minute, c.second,
-               c.nanosecond);
-  }
-};
-
-// ============================================================================
-// JulianDate
-// ============================================================================
-
-/**
- * @brief Julian Date wrapper (value type).
- *
- * Wraps a raw `double` Julian Date value and provides conversions to/from UTC,
- * MJD, and arithmetic operations.
- *
- * @code
- * auto jd = tempoch::JulianDate::J2000();           // 2451545.0
- * auto utc = jd.to_utc();
- * auto jd2 = jd + 365.25;                           // add one Julian year
- * double centuries = jd.julian_centuries();           // since J2000
- * @endcode
- */
-class JulianDate {
-  double m_value;
-
-public:
-  constexpr explicit JulianDate(double v) : m_value(v) {}
-
-  /// J2000.0 epoch (2451545.0).
-  static JulianDate J2000() { return JulianDate(tempoch_jd_j2000()); }
-
-  /// Create from a UTC date-time.
-  static JulianDate from_utc(const UTC &utc) {
-    double jd;
-    auto c = utc.to_c();
-    check_status(tempoch_jd_from_utc(c, &jd), "JulianDate::from_utc");
-    return JulianDate(jd);
-  }
-
-  /// Raw value.
-  constexpr double value() const { return m_value; }
-
-  /// Convert to MJD.
-  double to_mjd() const { return tempoch_jd_to_mjd(m_value); }
-
-  /// Convert to UTC.
-  UTC to_utc() const {
-    tempoch_utc_t out;
-    check_status(tempoch_jd_to_utc(m_value, &out), "JulianDate::to_utc");
-    return UTC::from_c(out);
-  }
-
-  /// Difference in days (this – other).
-  double operator-(const JulianDate &other) const {
-    return tempoch_jd_difference(m_value, other.m_value);
-  }
-
-  /// Add days.
-  JulianDate operator+(double days) const {
-    return JulianDate(tempoch_jd_add_days(m_value, days));
-  }
-
-  /// Julian centuries since J2000.
-  double julian_centuries() const {
-    return tempoch_jd_julian_centuries(m_value);
-  }
-
-  bool operator==(const JulianDate &o) const { return m_value == o.m_value; }
-  bool operator!=(const JulianDate &o) const { return m_value != o.m_value; }
-  bool operator<(const JulianDate &o) const { return m_value < o.m_value; }
-  bool operator<=(const JulianDate &o) const { return m_value <= o.m_value; }
-  bool operator>(const JulianDate &o) const { return m_value > o.m_value; }
-  bool operator>=(const JulianDate &o) const { return m_value >= o.m_value; }
-};
-
-/// Stream a JulianDate as its raw double value.
-inline std::ostream &operator<<(std::ostream &os, const JulianDate &jd) {
-  return os << jd.value();
-}
-
-// ============================================================================
-// MJD (Modified Julian Date)
-// ============================================================================
-
-/**
- * @brief Modified Julian Date wrapper (value type).
- *
- * Wraps a raw `double` MJD value and provides conversions to/from UTC, JD,
- * and arithmetic operations.
+ * All implementation lives in `time_base.hpp` (the `Time<S>` class template)
+ * and `scales.hpp` (scale tags and traits).  This header provides the
+ * backward-compatible names that the rest of the codebase expects:
  *
- * @code
- * auto mjd = tempoch::MJD::from_utc({2026, 7, 15});
- * auto jd  = mjd.to_jd();
- * auto mjd2 = mjd + 1.0;   // next day
- * @endcode
+ *   - `tempoch::JulianDate`  = `Time<JDScale>`
+ *   - `tempoch::MJD`         = `Time<MJDScale>`
+ *   - `tempoch::UTC`         = `CivilTime` (civil date-time breakdown)
+ *   - `tempoch::CivilTime`   (canonical name for the civil struct)
  */
-class MJD {
-  double m_value;
-
-public:
-  constexpr MJD() : m_value(0.0) {}
-  constexpr explicit MJD(double v) : m_value(v) {}
-
-  /// Create from a UTC date-time.
-  static MJD from_utc(const UTC &utc) {
-    double mjd;
-    auto c = utc.to_c();
-    check_status(tempoch_mjd_from_utc(c, &mjd), "MJD::from_utc");
-    return MJD(mjd);
-  }
 
-  /// Create from a Julian Date.
-  static MJD from_jd(const JulianDate &jd) {
-    return MJD(tempoch_jd_to_mjd(jd.value()));
-  }
+#include "time_base.hpp"
 
-  /// Raw value.
-  constexpr double value() const { return m_value; }
-
-  /// Convert to JD.
-  JulianDate to_jd() const { return JulianDate(tempoch_mjd_to_jd(m_value)); }
-
-  /// Convert to UTC.
-  UTC to_utc() const {
-    tempoch_utc_t out;
-    check_status(tempoch_mjd_to_utc(m_value, &out), "MJD::to_utc");
-    return UTC::from_c(out);
-  }
-
-  /// Difference in days (this – other).
-  double operator-(const MJD &other) const {
-    return tempoch_mjd_difference(m_value, other.m_value);
-  }
-
-  /// Add days.
-  MJD operator+(double days) const {
-    return MJD(tempoch_mjd_add_days(m_value, days));
-  }
+namespace tempoch {
 
-  bool operator==(const MJD &o) const { return m_value == o.m_value; }
-  bool operator!=(const MJD &o) const { return m_value != o.m_value; }
-  bool operator<(const MJD &o) const { return m_value < o.m_value; }
-  bool operator<=(const MJD &o) const { return m_value <= o.m_value; }
-  bool operator>(const MJD &o) const { return m_value > o.m_value; }
-  bool operator>=(const MJD &o) const { return m_value >= o.m_value; }
-};
+/// Julian Date — days since −4712-01-01T12:00 TT.
+using JulianDate = Time<JDScale>;
 
-/// Stream a MJD as its raw double value.
-inline std::ostream &operator<<(std::ostream &os, const MJD &mjd) {
-  return os << mjd.value();
-}
+/// Modified Julian Date — JD − 2 400 000.5.
+using MJD = Time<MJDScale>;
 
-/// Stream a UTC date-time as YYYY-MM-DD HH:MM:SS[.nnnnnnnnn].
-inline std::ostream &operator<<(std::ostream &os, const UTC &u) {
-  const char prev_fill = os.fill();
-  os << u.year << '-' << std::setfill('0') << std::setw(2)
-     << static_cast<int>(u.month) << '-' << std::setw(2)
-     << static_cast<int>(u.day) << ' ' << std::setw(2)
-     << static_cast<int>(u.hour) << ':' << std::setw(2)
-     << static_cast<int>(u.minute) << ':' << std::setw(2)
-     << static_cast<int>(u.second);
-  if (u.nanosecond != 0)
-    os << '.' << std::setw(9) << u.nanosecond;
-  os.fill(prev_fill);
-  return os;
-}
+// `UTC` and `CivilTime` are already declared in time_base.hpp:
+//   using UTC = CivilTime;
 
 } // namespace tempoch
diff --git a/include/tempoch/time_base.hpp b/include/tempoch/time_base.hpp
new file mode 100644
index 0000000..17aafd2
--- /dev/null
+++ b/include/tempoch/time_base.hpp
@@ -0,0 +1,326 @@
+#pragma once
+
+/**
+ * @file time_base.hpp
+ * @brief Core `Time<S>` class template and `CivilTime` struct.
+ *
+ * Mirrors the Rust `tempoch_core::instant::Time<S: TimeScale>` design:
+ *   - A single `double` (days in the scale's epoch) with compile-time scale
+ *     dispatch via `TimeScaleTraits<S>`.
+ *   - Cross-scale `.to<T>()` via `TimeConvertTraits<S,T>`.
+ *   - `CivilTime` replaces the old `UTC` aggregate struct.
+ *   - JD-specific extras (`J2000()`, `julian_centuries()`) are enabled only
+ *     for `Time<JDScale>` via SFINAE.
+ */
+
+#include "scales.hpp"
+#include "qtty/qtty.hpp"
+#include <iomanip>
+#include <ostream>
+#include <type_traits>
+
+namespace tempoch {
+
+// ============================================================================
+// CivilTime (civil UTC breakdown — formerly the `UTC` struct)
+// ============================================================================
+
+/**
+ * @brief UTC date-time breakdown.
+ *
+ * A simple value type mirroring the C `tempoch_utc_t` struct.
+ *
+ * @code
+ * tempoch::CivilTime noon(2000, 1, 1, 12, 0, 0);
+ * auto jd = tempoch::JulianDate::from_utc(noon);
+ * @endcode
+ */
+struct CivilTime {
+  int32_t year;       ///< Gregorian year (astronomical year numbering).
+  uint8_t month;      ///< Month [1, 12].
+  uint8_t day;        ///< Day of month [1, 31].
+  uint8_t hour;       ///< Hour [0, 23].
+  uint8_t minute;     ///< Minute [0, 59].
+  uint8_t second;     ///< Second [0, 60] (leap-second aware).
+  uint32_t nanosecond; ///< Nanosecond [0, 999 999 999].
+
+  /// Default constructor: J2000 epoch noon-like civil representation.
+  CivilTime()
+      : year(2000), month(1), day(1), hour(12), minute(0), second(0),
+        nanosecond(0) {}
+
+  /**
+   * @brief Construct from civil UTC components.
+   */
+  CivilTime(int32_t y, uint8_t mo, uint8_t d, uint8_t h = 0, uint8_t mi = 0,
+            uint8_t s = 0, uint32_t ns = 0)
+      : year(y), month(mo), day(d), hour(h), minute(mi), second(s),
+        nanosecond(ns) {}
+
+  /// Convert to the C FFI struct.
+  tempoch_utc_t to_c() const {
+    return {year, month, day, hour, minute, second, nanosecond};
+  }
+
+  /// Create from the C FFI struct.
+  static CivilTime from_c(const tempoch_utc_t &c) {
+    return CivilTime(c.year, c.month, c.day, c.hour, c.minute, c.second,
+                     c.nanosecond);
+  }
+};
+
+/// Stream CivilTime as YYYY-MM-DD HH:MM:SS[.nnnnnnnnn].
+inline std::ostream &operator<<(std::ostream &os, const CivilTime &u) {
+  const char prev = os.fill();
+  os << u.year << '-' << std::setfill('0') << std::setw(2)
+     << static_cast<int>(u.month) << '-' << std::setw(2)
+     << static_cast<int>(u.day) << ' ' << std::setw(2)
+     << static_cast<int>(u.hour) << ':' << std::setw(2)
+     << static_cast<int>(u.minute) << ':' << std::setw(2)
+     << static_cast<int>(u.second);
+  if (u.nanosecond != 0)
+    os << '.' << std::setw(9) << u.nanosecond;
+  os.fill(prev);
+  return os;
+}
+
+// ============================================================================
+// TimeScaleTraits deferred implementations (need CivilTime to be complete)
+// ============================================================================
+
+inline double TimeScaleTraits<JDScale>::from_civil(const CivilTime &ct) {
+  double jd;
+  auto c = ct.to_c();
+  check_status(tempoch_jd_from_utc(c, &jd), "Time<JD>::from_utc");
+  return jd;
+}
+
+inline CivilTime TimeScaleTraits<JDScale>::to_civil(double jd) {
+  tempoch_utc_t out;
+  check_status(tempoch_jd_to_utc(jd, &out), "Time<JD>::to_utc");
+  return CivilTime::from_c(out);
+}
+
+inline double TimeScaleTraits<MJDScale>::from_civil(const CivilTime &ct) {
+  double mjd;
+  auto c = ct.to_c();
+  check_status(tempoch_mjd_from_utc(c, &mjd), "Time<MJD>::from_utc");
+  return mjd;
+}
+
+inline CivilTime TimeScaleTraits<MJDScale>::to_civil(double mjd) {
+  tempoch_utc_t out;
+  check_status(tempoch_mjd_to_utc(mjd, &out), "Time<MJD>::to_utc");
+  return CivilTime::from_c(out);
+}
+
+// UTCScale delegates to MJDScale (same internal representation).
+inline double TimeScaleTraits<UTCScale>::from_civil(const CivilTime &ct) {
+  return TimeScaleTraits<MJDScale>::from_civil(ct);
+}
+
+inline CivilTime TimeScaleTraits<UTCScale>::to_civil(double mjd) {
+  return TimeScaleTraits<MJDScale>::to_civil(mjd);
+}
+
+// ============================================================================
+// Time<S> — the core template
+// ============================================================================
+
+/**
+ * @brief A point in time on scale @p S, stored as a raw `double` (days).
+ *
+ * Mirrors `tempoch_core::instant::Time<S: TimeScale>`.  Most operations are
+ * dispatched through `TimeScaleTraits<S>`, keeping this class small and
+ * reusable across all scales.
+ *
+ * @tparam S A scale tag for which `TimeScaleTraits<S>` is specialised.
+ *
+ * @code
+ * using JulianDate = tempoch::Time<tempoch::JDScale>;
+ * auto jd = JulianDate::from_utc({2026, 7, 15, 22, 0, 0});
+ * auto mjd = jd.to<tempoch::MJDScale>();
+ * @endcode
+ */
+template <typename S> class Time {
+  double m_days;
+
+public:
+  using scale_type = S;
+
+  // ── Constructors ──────────────────────────────────────────────────────
+
+  /// Construct from a raw day count in this scale.
+  constexpr explicit Time(double days) : m_days(days) {}
+
+  /// Default-construct to zero (MJD epoch).
+  constexpr Time() : m_days(0.0) {}
+
+  // ── Factory: from civil time ──────────────────────────────────────────
+
+  /**
+   * @brief Create from a UTC civil-time breakdown.
+   *
+   * Accepts brace-initialised `CivilTime`, e.g.:
+   * @code
+   * auto jd = JulianDate::from_utc({2026, 7, 15, 22, 0, 0});
+   * @endcode
+   */
+  static Time from_utc(const CivilTime &ct) {
+    return Time(TimeScaleTraits<S>::from_civil(ct));
+  }
+
+  // ── Accessors ─────────────────────────────────────────────────────────
+
+  /// Raw value in this scale's day-count.
+  constexpr double value() const { return m_days; }
+
+  /// Human-readable label for the scale (e.g. "JD", "MJD", "UTC").
+  static constexpr const char *label() { return TimeScaleTraits<S>::label(); }
+
+  // ── Civil-time conversion ─────────────────────────────────────────────
+
+  /// Convert to a UTC civil-time breakdown.
+  CivilTime to_utc() const { return TimeScaleTraits<S>::to_civil(m_days); }
+
+  // ── Cross-scale conversion ────────────────────────────────────────────
+
+  /**
+   * @brief Convert to another time scale.
+   * @tparam T Target scale tag (e.g. `MJDScale`).
+   */
+  template <typename T> Time<T> to() const {
+    return Time<T>(TimeConvertTraits<S, T>::convert(m_days));
+  }
+
+  // ── Arithmetic ────────────────────────────────────────────────────────
+
+  /**
+   * @brief Advance by a typed time quantity.
+   *
+   * Accepts any qtty time unit; the value is converted to days internally.
+   * @code
+   * auto t2 = jd  + qtty::Day(365.25);
+   * auto t3 = mjd + qtty::Hour(12.0);
+   * auto t4 = mjd + 30.0_min;            // using qtty::literals
+   * @endcode
+   */
+  template <typename Q>
+  Time operator+(const qtty::Quantity<Q> &delta) const {
+    return Time(TimeScaleTraits<S>::add_days(
+        m_days, delta.template to<qtty::DayTag>().value()));
+  }
+
+  /**
+   * @brief Retreat by a typed time quantity.
+   */
+  template <typename Q>
+  Time operator-(const qtty::Quantity<Q> &delta) const {
+    return Time(TimeScaleTraits<S>::add_days(
+        m_days, -delta.template to<qtty::DayTag>().value()));
+  }
+
+  /**
+   * @brief Elapsed duration between two instants, returned as `qtty::Day`.
+   *
+   * Convert to other units with `.to<qtty::Hour>()` etc.
+   * @code
+   * qtty::Day  d = t2 - t1;
+   * qtty::Hour h = (t2 - t1).to<qtty::Hour>();
+   * @endcode
+   */
+  qtty::Day operator-(const Time &other) const {
+    return qtty::Day(TimeScaleTraits<S>::difference(m_days, other.m_days));
+  }
+
+  // ── Comparisons ───────────────────────────────────────────────────────
+
+  bool operator==(const Time &o) const { return m_days == o.m_days; }
+  bool operator!=(const Time &o) const { return m_days != o.m_days; }
+  bool operator<(const Time &o) const { return m_days < o.m_days; }
+  bool operator<=(const Time &o) const { return m_days <= o.m_days; }
+  bool operator>(const Time &o) const { return m_days > o.m_days; }
+  bool operator>=(const Time &o) const { return m_days >= o.m_days; }
+
+  // ── JD-only extras (SFINAE-guarded) ───────────────────────────────────
+
+  /// J2000.0 epoch (JD 2 451 545.0).  Only available for `Time<JDScale>`.
+  template <typename U = S>
+  static std::enable_if_t<std::is_same_v<U, JDScale>, Time> J2000() {
+    return Time(TimeScaleTraits<JDScale>::j2000());
+  }
+
+  /// Julian centuries since J2000.  Only available for `Time<JDScale>`.
+  template <typename U = S>
+  std::enable_if_t<std::is_same_v<U, JDScale>, double>
+  julian_centuries() const {
+    return TimeScaleTraits<JDScale>::julian_centuries(m_days);
+  }
+
+  // ── JD ↔ MJD convenience (preserves old API surface) ──────────────────
+
+  /// Convert to MJD double.  Only available for `Time<JDScale>`.
+  template <typename U = S>
+  std::enable_if_t<std::is_same_v<U, JDScale>, double> to_mjd() const {
+    return TimeConvertTraits<JDScale, MJDScale>::convert(m_days);
+  }
+
+  /// Create from a JulianDate.  Only available for `Time<MJDScale>`.
+  template <typename U = S>
+  static std::enable_if_t<std::is_same_v<U, MJDScale>, Time>
+  from_jd(const Time<JDScale> &jd) {
+    return Time(TimeConvertTraits<JDScale, MJDScale>::convert(jd.value()));
+  }
+
+  /// Convert to JulianDate.  Only available for `Time<MJDScale>`.
+  template <typename U = S>
+  std::enable_if_t<std::is_same_v<U, MJDScale>, Time<JDScale>>
+  to_jd() const {
+    return Time<JDScale>(
+        TimeConvertTraits<MJDScale, JDScale>::convert(m_days));
+  }
+};
+
+// ============================================================================
+// operator<<  —  streams "<label>:<value>"
+// ============================================================================
+
+template <typename S>
+inline std::ostream &operator<<(std::ostream &os, const Time<S> &t) {
+  return os << t.value();
+}
+
+// ============================================================================
+// TimeTraits<Time<S>>  —  connects Time<S> to Period<T>
+// ============================================================================
+
+// Forward declaration — full Period template lives in period.hpp.
+template <typename T> struct TimeTraits;
+
+/// Generic TimeTraits for any Time<S>.  Converts via MJD internally.
+template <typename S> struct TimeTraits<Time<S>> {
+  static double to_mjd_value(const Time<S> &t) {
+    if constexpr (std::is_same_v<S, MJDScale> || std::is_same_v<S, UTCScale>) {
+      return t.value();
+    } else {
+      return t.template to<MJDScale>().value();
+    }
+  }
+
+  static Time<S> from_mjd_value(double mjd) {
+    if constexpr (std::is_same_v<S, MJDScale> || std::is_same_v<S, UTCScale>) {
+      return Time<S>(mjd);
+    } else {
+      return Time<MJDScale>(mjd).template to<S>();
+    }
+  }
+};
+
+// ============================================================================
+// Backward-compatible alias
+// ============================================================================
+
+/// Old name kept for source compatibility.
+using UTC = CivilTime;
+
+} // namespace tempoch
diff --git a/tests/test_time.cpp b/tests/test_time.cpp
index 24b3971..44c50b1 100644
--- a/tests/test_time.cpp
+++ b/tests/test_time.cpp
@@ -29,8 +29,8 @@ TEST(Time, JulianDateRoundtripUtc) {
 
 TEST(Time, JulianDateArithmetic) {
   auto jd1 = JulianDate(2451545.0);
-  auto jd2 = jd1 + 365.25;
-  EXPECT_NEAR(jd2 - jd1, 365.25, 1e-10);
+  auto jd2 = jd1 + qtty::Day(365.25);
+  EXPECT_NEAR((jd2 - jd1).value(), 365.25, 1e-10);
 }
 
 TEST(Time, JulianCenturies) {
@@ -75,8 +75,8 @@ TEST(Time, MjdFromUtc) {
 
 TEST(Time, MjdArithmetic) {
   auto mjd1 = MJD(60200.0);
-  auto mjd2 = mjd1 + 1.5;
-  EXPECT_NEAR(mjd2 - mjd1, 1.5, 1e-10);
+  auto mjd2 = mjd1 + qtty::Day(1.5);
+  EXPECT_NEAR((mjd2 - mjd1).value(), 1.5, 1e-10);
 }
 
 TEST(Time, MjdComparisons) {

From 517b0d418dc32c821667ecbe3c275a518b8c3450 Mon Sep 17 00:00:00 2001
From: VPRamon <ramon.valles-puig@cta-consortium.org>
Date: Tue, 24 Feb 2026 02:07:51 +0100
Subject: [PATCH 2/5] style: format code for consistency in period, scales, and
 time_base headers

---
 include/tempoch/period.hpp    |  6 +++---
 include/tempoch/scales.hpp    |  2 +-
 include/tempoch/tempoch.hpp   |  4 ++--
 include/tempoch/time_base.hpp | 26 +++++++++++---------------
 4 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/include/tempoch/period.hpp b/include/tempoch/period.hpp
index 8cfb85d..de3d468 100644
--- a/include/tempoch/period.hpp
+++ b/include/tempoch/period.hpp
@@ -150,9 +150,9 @@ template <typename T> Period(T, T) -> Period<T>;
 // Convenience type aliases
 // ============================================================================
 
-using MJDPeriod = Period<MJD>;          ///< Period expressed in Modified Julian Date.
-using JDPeriod  = Period<JulianDate>;   ///< Period expressed in Julian Date.
-using UTCPeriod = Period<CivilTime>;    ///< Period expressed in UTC civil time.
+using MJDPeriod = Period<MJD>; ///< Period expressed in Modified Julian Date.
+using JDPeriod = Period<JulianDate>; ///< Period expressed in Julian Date.
+using UTCPeriod = Period<CivilTime>; ///< Period expressed in UTC civil time.
 
 // ============================================================================
 // operator<<
diff --git a/include/tempoch/scales.hpp b/include/tempoch/scales.hpp
index 36b52c1..db7a937 100644
--- a/include/tempoch/scales.hpp
+++ b/include/tempoch/scales.hpp
@@ -13,7 +13,7 @@
  *  3. Specialise `TimeConvertTraits<A,B>` for each supported conversion pair.
  */
 
-#include "ffi_core.hpp"  // tempoch_ffi.h + check_status
+#include "ffi_core.hpp" // tempoch_ffi.h + check_status
 
 namespace tempoch {
 
diff --git a/include/tempoch/tempoch.hpp b/include/tempoch/tempoch.hpp
index 50f8292..af085cf 100644
--- a/include/tempoch/tempoch.hpp
+++ b/include/tempoch/tempoch.hpp
@@ -22,7 +22,7 @@
  */
 
 #include "ffi_core.hpp"
+#include "period.hpp"
 #include "scales.hpp"
-#include "time_base.hpp"
 #include "time.hpp"
-#include "period.hpp"
+#include "time_base.hpp"
diff --git a/include/tempoch/time_base.hpp b/include/tempoch/time_base.hpp
index 17aafd2..53869c1 100644
--- a/include/tempoch/time_base.hpp
+++ b/include/tempoch/time_base.hpp
@@ -13,8 +13,8 @@
  *     for `Time<JDScale>` via SFINAE.
  */
 
-#include "scales.hpp"
 #include "qtty/qtty.hpp"
+#include "scales.hpp"
 #include <iomanip>
 #include <ostream>
 #include <type_traits>
@@ -36,12 +36,12 @@ namespace tempoch {
  * @endcode
  */
 struct CivilTime {
-  int32_t year;       ///< Gregorian year (astronomical year numbering).
-  uint8_t month;      ///< Month [1, 12].
-  uint8_t day;        ///< Day of month [1, 31].
-  uint8_t hour;       ///< Hour [0, 23].
-  uint8_t minute;     ///< Minute [0, 59].
-  uint8_t second;     ///< Second [0, 60] (leap-second aware).
+  int32_t year;        ///< Gregorian year (astronomical year numbering).
+  uint8_t month;       ///< Month [1, 12].
+  uint8_t day;         ///< Day of month [1, 31].
+  uint8_t hour;        ///< Hour [0, 23].
+  uint8_t minute;      ///< Minute [0, 59].
+  uint8_t second;      ///< Second [0, 60] (leap-second aware).
   uint32_t nanosecond; ///< Nanosecond [0, 999 999 999].
 
   /// Default constructor: J2000 epoch noon-like civil representation.
@@ -205,8 +205,7 @@ template <typename S> class Time {
    * auto t4 = mjd + 30.0_min;            // using qtty::literals
    * @endcode
    */
-  template <typename Q>
-  Time operator+(const qtty::Quantity<Q> &delta) const {
+  template <typename Q> Time operator+(const qtty::Quantity<Q> &delta) const {
     return Time(TimeScaleTraits<S>::add_days(
         m_days, delta.template to<qtty::DayTag>().value()));
   }
@@ -214,8 +213,7 @@ template <typename S> class Time {
   /**
    * @brief Retreat by a typed time quantity.
    */
-  template <typename Q>
-  Time operator-(const qtty::Quantity<Q> &delta) const {
+  template <typename Q> Time operator-(const qtty::Quantity<Q> &delta) const {
     return Time(TimeScaleTraits<S>::add_days(
         m_days, -delta.template to<qtty::DayTag>().value()));
   }
@@ -274,10 +272,8 @@ template <typename S> class Time {
 
   /// Convert to JulianDate.  Only available for `Time<MJDScale>`.
   template <typename U = S>
-  std::enable_if_t<std::is_same_v<U, MJDScale>, Time<JDScale>>
-  to_jd() const {
-    return Time<JDScale>(
-        TimeConvertTraits<MJDScale, JDScale>::convert(m_days));
+  std::enable_if_t<std::is_same_v<U, MJDScale>, Time<JDScale>> to_jd() const {
+    return Time<JDScale>(TimeConvertTraits<MJDScale, JDScale>::convert(m_days));
   }
 };
 

From 20abf8a0729358c8c29a75434ae29eb7030ea1f5 Mon Sep 17 00:00:00 2001
From: VPRamon <ramon.valles-puig@cta-consortium.org>
Date: Tue, 24 Feb 2026 18:58:39 +0100
Subject: [PATCH 3/5] feat: enhance time-related functionality with typed
 quantity methods and arithmetic operations

---
 include/tempoch/period.hpp    |  4 +--
 include/tempoch/scales.hpp    | 35 ++++++++++++++++++++++++++
 include/tempoch/time_base.hpp | 23 +++++++++++++----
 tests/test_period.cpp         |  6 +++++
 tests/test_time.cpp           | 47 +++++++++++++++++++++++++++++++++++
 5 files changed, 108 insertions(+), 7 deletions(-)

diff --git a/include/tempoch/period.hpp b/include/tempoch/period.hpp
index de3d468..f2591a9 100644
--- a/include/tempoch/period.hpp
+++ b/include/tempoch/period.hpp
@@ -118,8 +118,8 @@ template <typename T = MJD> class Period {
    */
   template <typename TargetType = qtty::DayTag>
   qtty::Quantity<typename qtty::ExtractTag<TargetType>::type> duration() const {
-    double days = tempoch_period_mjd_duration_days(m_inner);
-    return qtty::Quantity<qtty::DayTag>(days).template to<TargetType>();
+    auto qty = tempoch_period_mjd_duration_qty(m_inner);
+    return qtty::Quantity<qtty::DayTag>(qty.value).template to<TargetType>();
   }
 
   /**
diff --git a/include/tempoch/scales.hpp b/include/tempoch/scales.hpp
index db7a937..4d1e67a 100644
--- a/include/tempoch/scales.hpp
+++ b/include/tempoch/scales.hpp
@@ -78,6 +78,16 @@ template <> struct TimeScaleTraits<JDScale> {
     return tempoch_jd_difference(a, b);
   }
 
+  /// Difference as a typed `qtty_quantity_t` (Day unit).
+  static qtty_quantity_t difference_qty(double a, double b) {
+    return tempoch_jd_difference_qty(a, b);
+  }
+
+  /// Add a typed duration quantity and write result to @p out.
+  static void add_qty(double jd, qtty_quantity_t duration, double &out) {
+    check_status(tempoch_jd_add_qty(jd, duration, &out), "Time<JD>::add_qty");
+  }
+
   /// J2000.0 epoch constant (JD 2 451 545.0).
   static double j2000() { return tempoch_jd_j2000(); }
 
@@ -85,6 +95,11 @@ template <> struct TimeScaleTraits<JDScale> {
   static double julian_centuries(double jd) {
     return tempoch_jd_julian_centuries(jd);
   }
+
+  /// Julian centuries since J2000 as a typed `qtty_quantity_t` (JulianCentury unit).
+  static qtty_quantity_t julian_centuries_qty(double jd) {
+    return tempoch_jd_julian_centuries_qty(jd);
+  }
 };
 
 // ── MJDScale ────────────────────────────────────────────────────────────────
@@ -102,6 +117,16 @@ template <> struct TimeScaleTraits<MJDScale> {
   static double difference(double a, double b) {
     return tempoch_mjd_difference(a, b);
   }
+
+  /// Difference as a typed `qtty_quantity_t` (Day unit).
+  static qtty_quantity_t difference_qty(double a, double b) {
+    return tempoch_mjd_difference_qty(a, b);
+  }
+
+  /// Add a typed duration quantity and write result to @p out.
+  static void add_qty(double mjd, qtty_quantity_t duration, double &out) {
+    check_status(tempoch_mjd_add_qty(mjd, duration, &out), "Time<MJD>::add_qty");
+  }
 };
 
 // ── UTCScale (internally stored as MJD) ─────────────────────────────────────
@@ -119,6 +144,16 @@ template <> struct TimeScaleTraits<UTCScale> {
   static double difference(double a, double b) {
     return tempoch_mjd_difference(a, b);
   }
+
+  /// Difference as a typed `qtty_quantity_t` (Day unit).
+  static qtty_quantity_t difference_qty(double a, double b) {
+    return TimeScaleTraits<MJDScale>::difference_qty(a, b);
+  }
+
+  /// Add a typed duration quantity and write result to @p out.
+  static void add_qty(double mjd, qtty_quantity_t duration, double &out) {
+    TimeScaleTraits<MJDScale>::add_qty(mjd, duration, out);
+  }
 };
 
 // ============================================================================
diff --git a/include/tempoch/time_base.hpp b/include/tempoch/time_base.hpp
index 53869c1..c0aec13 100644
--- a/include/tempoch/time_base.hpp
+++ b/include/tempoch/time_base.hpp
@@ -206,16 +206,20 @@ template <typename S> class Time {
    * @endcode
    */
   template <typename Q> Time operator+(const qtty::Quantity<Q> &delta) const {
-    return Time(TimeScaleTraits<S>::add_days(
-        m_days, delta.template to<qtty::DayTag>().value()));
+    qtty_quantity_t qty{delta.value(), qtty::UnitTraits<Q>::unit_id()};
+    double result;
+    TimeScaleTraits<S>::add_qty(m_days, qty, result);
+    return Time(result);
   }
 
   /**
    * @brief Retreat by a typed time quantity.
    */
   template <typename Q> Time operator-(const qtty::Quantity<Q> &delta) const {
-    return Time(TimeScaleTraits<S>::add_days(
-        m_days, -delta.template to<qtty::DayTag>().value()));
+    qtty_quantity_t neg_qty{-delta.value(), qtty::UnitTraits<Q>::unit_id()};
+    double result;
+    TimeScaleTraits<S>::add_qty(m_days, neg_qty, result);
+    return Time(result);
   }
 
   /**
@@ -228,7 +232,8 @@ template <typename S> class Time {
    * @endcode
    */
   qtty::Day operator-(const Time &other) const {
-    return qtty::Day(TimeScaleTraits<S>::difference(m_days, other.m_days));
+    auto qty = TimeScaleTraits<S>::difference_qty(m_days, other.m_days);
+    return qtty::Day(qty.value);
   }
 
   // ── Comparisons ───────────────────────────────────────────────────────
@@ -255,6 +260,14 @@ template <typename S> class Time {
     return TimeScaleTraits<JDScale>::julian_centuries(m_days);
   }
 
+  /// Julian centuries since J2000 as a typed quantity.  Only for `Time<JDScale>`.
+  template <typename U = S>
+  std::enable_if_t<std::is_same_v<U, JDScale>, qtty::JulianCentury>
+  julian_centuries_qty() const {
+    auto qty = TimeScaleTraits<JDScale>::julian_centuries_qty(m_days);
+    return qtty::JulianCentury(qty.value);
+  }
+
   // ── JD ↔ MJD convenience (preserves old API surface) ──────────────────
 
   /// Convert to MJD double.  Only available for `Time<JDScale>`.
diff --git a/tests/test_period.cpp b/tests/test_period.cpp
index dd9ed11..0affeb9 100644
--- a/tests/test_period.cpp
+++ b/tests/test_period.cpp
@@ -67,3 +67,9 @@ TEST(Period, FromC) {
   EXPECT_NEAR(p.start().value(), 60200.0, 1e-10);
   EXPECT_NEAR(p.duration().value(), 1.0, 1e-10);
 }
+
+TEST(Period, DurationInMinutes) {
+  Period p(MJD(60200.0), MJD(60200.5)); // 0.5 day = 720 minutes
+  auto min = p.duration<qtty::Minute>();
+  EXPECT_NEAR(min.value(), 720.0, 1e-6);
+}
diff --git a/tests/test_time.cpp b/tests/test_time.cpp
index 44c50b1..af5e70d 100644
--- a/tests/test_time.cpp
+++ b/tests/test_time.cpp
@@ -114,3 +114,50 @@ TEST(Time, UtcToCRoundtrip) {
   EXPECT_EQ(utc2.second, 53);
   EXPECT_EQ(utc2.nanosecond, 589u);
 }
+
+// ============================================================================
+// Typed-quantity (_qty) methods
+// ============================================================================
+
+TEST(Time, JulianCenturiesQty) {
+  auto jd = JulianDate::J2000();
+  auto jc = jd.julian_centuries_qty();
+  EXPECT_NEAR(jc.value(), 0.0, 1e-10);
+  // Verify it's actually a JulianCentury quantity with correct unit_id
+  EXPECT_EQ(jc.unit_id(), UNIT_ID_JULIAN_CENTURY);
+}
+
+TEST(Time, JulianCenturiesQtyNonZero) {
+  // 36525 days ≈ 1 Julian century
+  auto jd = JulianDate(2451545.0 + 36525.0);
+  auto jc = jd.julian_centuries_qty();
+  EXPECT_NEAR(jc.value(), 1.0, 1e-10);
+}
+
+TEST(Time, ArithmeticWithHours) {
+  // Test that operator+ works with non-Day time quantities via add_qty
+  auto jd1 = JulianDate(2451545.0);
+  auto jd2 = jd1 + qtty::Hour(24.0);
+  EXPECT_NEAR((jd2 - jd1).value(), 1.0, 1e-10); // 24 hours = 1 day
+}
+
+TEST(Time, ArithmeticWithMinutes) {
+  auto mjd1 = MJD(60200.0);
+  auto mjd2 = mjd1 + qtty::Minute(1440.0);
+  EXPECT_NEAR((mjd2 - mjd1).value(), 1.0, 1e-10); // 1440 minutes = 1 day
+}
+
+TEST(Time, SubtractQuantityHours) {
+  auto jd1 = JulianDate(2451546.0);
+  auto jd2 = jd1 - qtty::Hour(12.0);
+  EXPECT_NEAR(jd2.value(), 2451545.5, 1e-10);
+}
+
+TEST(Time, DifferenceConvertible) {
+  // operator- returns qtty::Day which supports .to<>() conversion
+  auto jd1 = JulianDate(2451545.0);
+  auto jd2 = JulianDate(2451546.0);
+  auto diff = jd2 - jd1; // qtty::Day
+  auto hours = diff.to<qtty::Hour>();
+  EXPECT_NEAR(hours.value(), 24.0, 1e-10);
+}

From 36b259aa6849967ce97b2173e06c43f58149ce8b Mon Sep 17 00:00:00 2001
From: VPRamon <ramon.valles-puig@cta-consortium.org>
Date: Tue, 24 Feb 2026 19:51:48 +0100
Subject: [PATCH 4/5] chore: update subproject commits for qtty-cpp and tempoch

---
 qtty-cpp | 2 +-
 tempoch  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/qtty-cpp b/qtty-cpp
index 0dea35c..3592144 160000
--- a/qtty-cpp
+++ b/qtty-cpp
@@ -1 +1 @@
-Subproject commit 0dea35c5e671fb2275609e250179b7ee9c31f3b3
+Subproject commit 359214460a656adf052a25236cd38b8d95d3fc86
diff --git a/tempoch b/tempoch
index 3efa54b..e33d63e 160000
--- a/tempoch
+++ b/tempoch
@@ -1 +1 @@
-Subproject commit 3efa54b7c0cba271c3d7c97a10795bf1e8fb07a9
+Subproject commit e33d63e3e20aba0342559561a4945b074385b651

From b5a3bb6c2ce989f9798d7f60facfb97b2ea4f9c5 Mon Sep 17 00:00:00 2001
From: VPRamon <ramon.valles-puig@cta-consortium.org>
Date: Tue, 24 Feb 2026 21:35:22 +0100
Subject: [PATCH 5/5] style: improve code formatting in scales.hpp and
 time_base.hpp for clarity chore: update subproject commits for qtty-cpp and
 tempoch

---
 include/tempoch/scales.hpp    | 6 ++++--
 include/tempoch/time_base.hpp | 3 ++-
 qtty-cpp                      | 2 +-
 tempoch                       | 2 +-
 4 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/include/tempoch/scales.hpp b/include/tempoch/scales.hpp
index 4d1e67a..f88e0d1 100644
--- a/include/tempoch/scales.hpp
+++ b/include/tempoch/scales.hpp
@@ -96,7 +96,8 @@ template <> struct TimeScaleTraits<JDScale> {
     return tempoch_jd_julian_centuries(jd);
   }
 
-  /// Julian centuries since J2000 as a typed `qtty_quantity_t` (JulianCentury unit).
+  /// Julian centuries since J2000 as a typed `qtty_quantity_t`
+  /// (JulianCentury unit).
   static qtty_quantity_t julian_centuries_qty(double jd) {
     return tempoch_jd_julian_centuries_qty(jd);
   }
@@ -125,7 +126,8 @@ template <> struct TimeScaleTraits<MJDScale> {
 
   /// Add a typed duration quantity and write result to @p out.
   static void add_qty(double mjd, qtty_quantity_t duration, double &out) {
-    check_status(tempoch_mjd_add_qty(mjd, duration, &out), "Time<MJD>::add_qty");
+    check_status(tempoch_mjd_add_qty(mjd, duration, &out),
+                 "Time<MJD>::add_qty");
   }
 };
 
diff --git a/include/tempoch/time_base.hpp b/include/tempoch/time_base.hpp
index c0aec13..3c6820f 100644
--- a/include/tempoch/time_base.hpp
+++ b/include/tempoch/time_base.hpp
@@ -260,7 +260,8 @@ template <typename S> class Time {
     return TimeScaleTraits<JDScale>::julian_centuries(m_days);
   }
 
-  /// Julian centuries since J2000 as a typed quantity.  Only for `Time<JDScale>`.
+  /// Julian centuries since J2000 as a typed quantity.
+  /// Only for `Time<JDScale>`.
   template <typename U = S>
   std::enable_if_t<std::is_same_v<U, JDScale>, qtty::JulianCentury>
   julian_centuries_qty() const {
diff --git a/qtty-cpp b/qtty-cpp
index 3592144..3612a8f 160000
--- a/qtty-cpp
+++ b/qtty-cpp
@@ -1 +1 @@
-Subproject commit 359214460a656adf052a25236cd38b8d95d3fc86
+Subproject commit 3612a8ff03f7290ea7fe53df897f10aa5716582f
diff --git a/tempoch b/tempoch
index e33d63e..e04bb31 160000
--- a/tempoch
+++ b/tempoch
@@ -1 +1 @@
-Subproject commit e33d63e3e20aba0342559561a4945b074385b651
+Subproject commit e04bb319f422b993891169546ef7cc6c6414dc94