diff --git a/README.md b/README.md
index acb3471..1df3e4b 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # tempoch-cpp
 
-tempoch-cpp is a C++17 library for astronomical time primitives. It provides a header-only C++ API backed by the Rust `tempoch-ffi` engine (via a C FFI), with typed time scales, UTC conversions, and period operations.
+tempoch-cpp is a C++17 library for astronomical time primitives. It provides a header-only C++ API backed by the Rust `tempoch-ffi` engine (via a C FFI), with explicit time scales, explicit encodings, UTC civil conversion, and generic period operations.
 
 [![C++17](https://img.shields.io/badge/C%2B%2B-17-blue.svg)](https://en.cppreference.com/w/cpp/17)
 [![CMake](https://img.shields.io/badge/CMake-3.15%2B-064F8C.svg)](https://cmake.org/)
@@ -8,11 +8,14 @@ tempoch-cpp is a C++17 library for astronomical time primitives. It provides a h
 
 ## Features
 
-- Strongly typed time values such as `JulianDate`, `MJD`, `UTC`, `TT`, `TAI`, `TDB`, `TCG`, `TCB`, `GPS`, `UT`, `JDE`, and `UnixTime`
+- Split scale/format model:
+  `Time<scale::TT>`, `JulianDate<scale::TT>`, `JulianDate<scale::UTC>`,
+  `ModifiedJulianDate<scale::UT1>`, `UnixTime`, and `GpsTime`
 - Civil UTC representation with nanosecond precision via `tempoch::CivilTime`
-- Cross-scale conversion helpers such as `from_utc()`, `to_utc()`, `to_jd()`, and `to_mjd()`
+- Explicit conversion flow:
+  `CivilTime -> Time<scale::UTC> -> Time<scale::TT> -> to<format::JD>()`
+- `TimeContext` for UT1 and historical UTC routes
 - Time arithmetic using `qtty-cpp` duration quantities such as `qtty::Day`, `qtty::Hour`, and `qtty::Minute`
-- `UT::delta_t()` with checked UT1 horizon errors from the Rust FFI
 - `Period<T>` intervals with typed start/end access, intersection, and duration conversion
 - CMake target (`tempoch_cpp`) for straightforward integration
 
@@ -33,7 +36,7 @@ cd tempoch-cpp
 cmake -S . -B build
 cmake --build build --parallel
 ctest --test-dir build --output-on-failure
-./build/time_example
+./build/01_quickstart
 ```
 
 If you cloned without submodules:
@@ -49,22 +52,26 @@ git submodule update --init --recursive
 #include <qtty/qtty.hpp>
 #include <tempoch/tempoch.hpp>
 
-using namespace tempoch;
-
 int main() {
-    UTC utc(2026, 7, 15, 22, 0, 0);
+    using namespace tempoch;
+
+    CivilTime civil{2026, 7, 15, 22, 0, 0};
+    auto utc = Time<scale::UTC>::from_civil(civil);
+    auto tt = utc.to<scale::TT>();
 
-    auto jd = JulianDate::from_utc(utc);
-    auto mjd = MJD::from_jd(jd);
+    auto jd_tt = tt.to<format::JD>();
+    auto jd_utc = utc.to<format::JD>();
+    auto mjd_tt = tt.to<format::MJD>();
 
-    std::cout << "UTC: " << utc << "\n";
-    std::cout << "JD:  " << jd << "\n";
-    std::cout << "MJD: " << mjd << "\n";
+    std::cout << "Civil UTC : " << civil << "\n";
+    std::cout << "JD(TT)    : " << jd_tt << "\n";
+    std::cout << "JD(UTC)   : " << jd_utc << "\n";
+    std::cout << "MJD(TT)   : " << mjd_tt << "\n";
 
-    Period observing_window(MJD(60200.0), MJD(60200.5));
-    std::cout << "Duration: "
-              << observing_window.duration<qtty::Hour>()
-              << "\n";
+    Period<ModifiedJulianDate<scale::TT>> observing_window(
+        mjd_tt,
+        mjd_tt + qtty::Hour(12.0));
+    std::cout << "Duration: " << observing_window.duration<qtty::Hour>() << "\n";
 }
 ```
 
@@ -73,18 +80,26 @@ int main() {
 Time arithmetic uses `qtty-cpp` quantities. Subtracting two times returns a typed duration, and adding or subtracting a quantity shifts the time value.
 
 ```cpp
-auto jd0 = JulianDate::J2000();
+auto jd0 = tempoch::JulianDate<tempoch::scale::TT>::J2000();
 auto jd1 = jd0 + qtty::Hour(12.0);
 auto dt = jd1 - jd0;
 
 std::cout << dt.to<qtty::Hour>() << "\n";
 ```
 
+## Migration Notes
+
+- Old `JulianDate` means `JulianDate<scale::TT>`.
+- Old `MJD` means `ModifiedJulianDate<scale::TT>`.
+- Old `TT` means `Time<scale::TT>`, not a JD-valued wrapper.
+- Old `UTC` civil construction is now `CivilTime` plus `Time<scale::UTC>::from_civil(...)`.
+- Legacy names remain available only through opt-in shim headers such as `tempoch/legacy_time.hpp`.
+
 ## Documentation
 
 - `docs/mainpage.md` (API overview)
-- `examples/time_example.cpp` (basic usage)
-- `examples/timescales.cpp` (all supported scale conversions plus `ΔT`)
+- `examples/01_quickstart.cpp` (civil UTC -> canonical time -> explicit encodings)
+- `examples/02_scales.cpp` (all supported scale conversions)
 - `include/tempoch/tempoch.hpp` (umbrella public header)
 
 ## Integration
diff --git a/docs/mainpage.md b/docs/mainpage.md
index 47ac0a4..5939ffd 100644
--- a/docs/mainpage.md
+++ b/docs/mainpage.md
@@ -3,9 +3,8 @@
 `tempoch-cpp` is a **modern, header-only C++17 library** for astronomical
 time primitives. It wraps the Rust-based
 [`tempoch`](https://github.com/siderust/tempoch) through its C FFI layer
-(`tempoch-ffi`), exposing `UTC`, `JulianDate`, `MJD`, and `Period` as
-idiomatic C++ value types with arithmetic, comparisons, and exception-based
-error reporting — no manual FFI plumbing required.
+(`tempoch-ffi`), exposing the same two-axis model as Rust: physical
+**scale** and external **format** are separate type parameters.
 
 ---
 
@@ -13,10 +12,11 @@ error reporting — no manual FFI plumbing required.
 
 | Feature | Description |
 |---------|-------------|
-| **`UTC`** | Civil date-time struct (year/month/day/hour/min/sec) with nanosecond precision |
-| **`JulianDate`** | Strongly-typed Julian Date with arithmetic and UTC conversion |
-| **`MJD`** | Strongly-typed Modified Julian Date; interchangeable with `JulianDate` |
-| **`Period`** | Inclusive `[start, end]` MJD interval with intersection, duration, and iteration helpers |
+| **`CivilTime`** | Civil UTC date-time struct (year/month/day/hour/min/sec) with nanosecond precision |
+| **`Time<scale::S>`** | Canonical instant on a physical timescale, stored as split J2000 seconds |
+| **`EncodedTime<S, F>`** | Typed external encoding such as `JulianDate<scale::TT>` or `ModifiedJulianDate<scale::UTC>` |
+| **`TimeContext`** | Explicit context for UT1 and historical UTC routes |
+| **`Period<T>`** | Inclusive `[start, end]` interval over any supported time representation |
 | **Exception hierarchy** | All FFI status codes map to typed C++ exceptions |
 | **Header-only** | Drop into any project — no separate compilation step |
 
@@ -26,37 +26,23 @@ error reporting — no manual FFI plumbing required.
 
 ```cpp
 #include <tempoch/tempoch.hpp>
-#include <cstdio>
+#include <iostream>
 
 int main() {
     using namespace tempoch;
 
-    // Construct a UTC civil time
-    UTC utc{2026, 7, 15, 22, 0, 0};
+    CivilTime civil{2026, 7, 15, 22, 0, 0};
+    auto utc = Time<scale::UTC>::from_civil(civil);
+    auto tt = utc.to<scale::TT>();
 
-    // Convert to Julian Date and MJD
-    JulianDate jd  = JulianDate::from_utc(utc);
-    MJD        mjd = MJD::from_jd(jd);
+    auto jd_tt = tt.to<format::JD>();
+    auto jd_utc = utc.to<format::JD>();
+    auto mjd_tt = tt.to<format::MJD>();
 
-    std::printf("JD  = %.6f\n", jd.value());
-    std::printf("MJD = %.6f\n", mjd.value());
-
-    // Create a one-day window and check containment
-    MJD start = mjd;
-    MJD end   = mjd + 1.0;
-    Period night{start, end};
-
-    std::printf("Duration: %.2f days\n", night.duration());
-    std::printf("Contains midpoint: %s\n",
-                night.contains(mjd + 0.5) ? "yes" : "no");
-
-    // Round-trip back to UTC
-    UTC back = jd.to_utc();
-    std::printf("UTC: %04d-%02d-%02d %02d:%02d:%02d\n",
-                back.year, back.month, back.day,
-                back.hour, back.minute, back.second);
-
-    return 0;
+    std::cout << "Civil UTC : " << civil << "\n";
+    std::cout << "JD(TT)    : " << jd_tt << "\n";
+    std::cout << "JD(UTC)   : " << jd_utc << "\n";
+    std::cout << "MJD(TT)   : " << mjd_tt << "\n";
 }
 ```
 
@@ -71,7 +57,7 @@ int main() {
 └──────┬───────┘
        │  header-only (inline)
 ┌──────▼───────┐
-│ tempoch-cpp  │   C++17 value types: UTC, JulianDate, MJD, Period
+│ tempoch-cpp  │   C++17 value types: CivilTime, Time<S>, EncodedTime<S,F>, Period<T>
 │  (headers)   │
 └──────┬───────┘
        │  extern "C" calls
@@ -90,10 +76,18 @@ int main() {
 ## Modules
 
 - `tempoch/tempoch.hpp` — umbrella include for the full public API
-- `tempoch/time.hpp` — `UTC`, `JulianDate`, `MJD` types
+- `tempoch/time.hpp` — `CivilTime`, `Time<scale::S>`, `JulianDate<scale::S>`, `ModifiedJulianDate<scale::S>`
 - `tempoch/period.hpp` — `Period` interval type
 - `tempoch/ffi_core.hpp` — FFI helpers and exception hierarchy
 
+## Migration Notes
+
+- Old `JulianDate` means `JulianDate<scale::TT>`.
+- Old `MJD` means `ModifiedJulianDate<scale::TT>`.
+- Old `TT` means `Time<scale::TT>`.
+- Old `UTC` civil construction is now `CivilTime` plus `Time<scale::UTC>::from_civil(...)`.
+- Legacy names are available only through opt-in compatibility headers.
+
 ---
 
 ## Error Model
@@ -128,7 +122,7 @@ cmake -S . -B build
 cmake --build build --parallel
 ctest --test-dir build --output-on-failure
 
-./build/time_example
+./build/01_quickstart
 ```
 
 ---
diff --git a/examples/01_quickstart.cpp b/examples/01_quickstart.cpp
index 9e50e17..5902a6e 100644
--- a/examples/01_quickstart.cpp
+++ b/examples/01_quickstart.cpp
@@ -4,7 +4,8 @@
 /**
  * @file 01_quickstart.cpp
  * @example 01_quickstart.cpp
- * @brief Quick start: a fixed UTC instant expressed as TT, JD, and MJD.
+ * @brief Quick start: civil UTC promoted to canonical time, then encoded as
+ * JD(TT), JD(UTC), and MJD(TT).
  *
  * Mirrors tempoch example 01_quickstart.rs.  chrono system-time integration
  * is not available through the C FFI, so a fixed reference date is used.
@@ -21,16 +22,20 @@
 int main() {
   using namespace tempoch;
 
-  UTC utc_now{2026, 7, 15, 22, 0, 0};
-  JulianDate jd = JulianDate::from_utc(utc_now);
-  TT tt = jd.to<scales::TT>();
-  MJD mjd = jd.to<scales::MJD>();
+  CivilTime civil{2026, 7, 15, 22, 0, 0};
+  auto utc = Time<scale::UTC>::from_civil(civil);
+  auto tt = utc.to<scale::TT>();
+  auto jd_tt = tt.to<format::JD>();
+  auto jd_utc = utc.to<format::JD>();
+  auto mjd_tt = tt.to<format::MJD>();
 
   std::cout << std::fixed << std::setprecision(9);
-  std::cout << "UTC       : " << utc_now << "\n";
-  std::cout << "TT JD     : " << tt << "\n";
-  std::cout << "JD        : " << jd << "\n";
-  std::cout << "MJD       : " << mjd << "\n";
+  std::cout << "Civil UTC : " << civil << "\n";
+  std::cout << "UTC axis  : " << utc << "\n";
+  std::cout << "TT axis   : " << tt << "\n";
+  std::cout << "JD(TT)    : " << jd_tt << "\n";
+  std::cout << "JD(UTC)   : " << jd_utc << "\n";
+  std::cout << "MJD(TT)   : " << mjd_tt << "\n";
 
   return 0;
 }
diff --git a/examples/02_scales.cpp b/examples/02_scales.cpp
index 1f74638..6c8c73f 100644
--- a/examples/02_scales.cpp
+++ b/examples/02_scales.cpp
@@ -22,27 +22,29 @@
 int main() {
   using namespace tempoch;
 
-  JulianDate jd{constants::j2000_jd_tt()};
-  TT tt = jd.to<scales::TT>();
-  TAI tai = tt.to<scales::TAI>();
-  UTC utc = tt.to_utc();
-  UT ut1 = tt.to<scales::UT>();
-  TDB tdb = tt.to<scales::TDB>();
-  TCG tcg = tt.to<scales::TCG>();
-  TCB tcb = tt.to<scales::TCB>();
+  auto ctx = TimeContext::with_builtin_eop();
+
+  auto jd_tt = JulianDate<scale::TT>::J2000();
+  auto tt = jd_tt.to_time();
+  auto tai = tt.to<scale::TAI>();
+  auto utc = tt.to<scale::UTC>().to_civil();
+  auto ut1 = tt.to_with<scale::UT1>(ctx);
+  auto tdb = tt.to<scale::TDB>();
+  auto tcg = tt.to<scale::TCG>();
+  auto tcb = tt.to<scale::TCB>();
 
   std::cout << std::fixed << std::setprecision(9);
-  std::cout << "TT  JD  : " << tt << "\n";
-  std::cout << "TAI JD  : " << tai << "\n";
-  std::cout << "UT1 JD  : " << ut1 << "\n";
-  std::cout << "TDB JD  : " << tdb << "\n";
-  std::cout << "TCG JD  : " << tcg << "\n";
-  std::cout << "TCB JD  : " << tcb << "\n";
+  std::cout << "TT  JD  : " << tt.to<format::JD>() << "\n";
+  std::cout << "TAI JD  : " << tai.to<format::JD>() << "\n";
+  std::cout << "UT1 JD  : " << ut1.to<format::JD>() << "\n";
+  std::cout << "TDB JD  : " << tdb.to<format::JD>() << "\n";
+  std::cout << "TCG JD  : " << tcg.to<format::JD>() << "\n";
+  std::cout << "TCB JD  : " << tcb.to<format::JD>() << "\n";
   std::cout << "UTC     : " << utc << "\n";
 
   constexpr double SPD = 86'400.0;
-  const double tt_tai = (tt.value() - tai.value()) * SPD;
-  const double tt_ut1 = (tt.value() - ut1.value()) * SPD;
+  const double tt_tai = (tt.to<format::JD>().value() - tai.to<format::JD>().value()) * SPD;
+  const double tt_ut1 = (tt.to<format::JD>().value() - ut1.to<format::JD>().value()) * SPD;
 
   std::cout << std::fixed << std::setprecision(6);
   std::cout << "TT-TAI  : " << tt_tai << " s\n";
diff --git a/examples/03_formats.cpp b/examples/03_formats.cpp
index 1e0534e..cbf8a0e 100644
--- a/examples/03_formats.cpp
+++ b/examples/03_formats.cpp
@@ -24,32 +24,32 @@ static constexpr double UNIX_EPOCH_MJD = 40'587.0;   // 1970-01-01 MJD
 int main() {
   using namespace tempoch;
 
-  // J2000 epoch via direct JD construction.
-  TT j2000_tt{constants::j2000_jd_tt()};
+  // J2000 epoch as canonical TT, then viewed through encodings.
+  auto j2000_tt = JulianDate<scale::TT>::J2000().to_time();
 
   // Sample TT instant: J2000 + 123 456.789 s.
-  TT sample_tt{constants::j2000_jd_tt() + 123'456.789 / 86'400.0};
+  auto sample_tt = j2000_tt + qtty::Second(123'456.789);
 
   // J2000 from JulianDate constructor (mirrors JulianDate::<TT>::try_new(J2000_JD_TT)).
-  JulianDate j2000_from_jd{constants::j2000_jd_tt()};
+  JulianDate<scale::TT> j2000_from_jd{constants::j2000_jd_tt()};
 
   // Unix epoch from JD value.
-  JulianDate unix_epoch_jd{UNIX_EPOCH_JD};
+  JulianDate<scale::TT> unix_epoch_jd{UNIX_EPOCH_JD};
 
   // Half-day after J2000 via JD.
-  JulianDate half_day_jd{constants::j2000_jd_tt() + 0.5};
+  JulianDate<scale::TT> half_day_jd{constants::j2000_jd_tt() + 0.5};
 
   // Unix epoch from MJD value.
-  MJD unix_epoch_mjd{UNIX_EPOCH_MJD};
+  ModifiedJulianDate<scale::TT> unix_epoch_mjd{UNIX_EPOCH_MJD};
 
   // Unix time from seconds (mirrors UnixTime::try_new(Second::new(1_700_000_000.25))).
   UnixTime ux{1'700'000'000.25};
-  UTC utc_from_ux = ux.to_utc();
+  auto utc_from_ux = ux.to_time().to_civil();
 
   std::cout << std::fixed << std::setprecision(9);
-  std::cout << "J2000 TT JD       : " << j2000_tt << "\n";
-  std::cout << "Sample TT JD      : " << sample_tt << "\n";
-  std::cout << "Sample TT MJD     : " << sample_tt.to<scales::MJD>() << "\n";
+  std::cout << "J2000 TT JD       : " << j2000_tt.to<format::JD>() << "\n";
+  std::cout << "Sample TT JD      : " << sample_tt.to<format::JD>() << "\n";
+  std::cout << "Sample TT MJD     : " << sample_tt.to<format::MJD>() << "\n";
   std::cout << "J2000 from JD     : " << j2000_from_jd << "\n";
   std::cout << "Unix epoch JD(TT) : " << unix_epoch_jd << "\n";
   std::cout << "Half-day JD(TT)   : " << half_day_jd << "\n";
diff --git a/examples/04_periods.cpp b/examples/04_periods.cpp
index ff1615c..b6c1e47 100644
--- a/examples/04_periods.cpp
+++ b/examples/04_periods.cpp
@@ -19,22 +19,25 @@
 int main() {
   using namespace tempoch;
 
-  auto mjd = [](double v) { return MJD{v}; };
+  using TTMjd = ModifiedJulianDate<scale::TT>;
+  using TTMjdPeriod = Period<TTMjd>;
 
-  MJDPeriod day{mjd(61'000.0), mjd(61'001.0)};
+  auto mjd = [](double v) { return TTMjd{v}; };
 
-  std::vector<MJDPeriod> a{
+  TTMjdPeriod day{mjd(61'000.0), mjd(61'001.0)};
+
+  std::vector<TTMjdPeriod> a{
       {mjd(61'000.10), mjd(61'000.30)},
       {mjd(61'000.60), mjd(61'000.85)},
   };
-  std::vector<MJDPeriod> b{
+  std::vector<TTMjdPeriod> b{
       {mjd(61'000.00), mjd(61'000.20)},
       {mjd(61'000.70), mjd(61'001.00)},
   };
 
   auto overlaps = intersect_periods(a, b);
   auto gaps = day.complement_of(a);
-  auto merged = normalize_periods<MJD>({a[0], a[1], overlaps[0]});
+  auto merged = normalize_periods<TTMjd>({a[0], a[1], overlaps[0]});
 
   validate_periods(a); // no-throw = valid
 
@@ -43,7 +46,7 @@ int main() {
   std::cout << "merged   : " << merged.size() << "\n";
   std::cout << "contains 61000.5? " << std::boolalpha << a[1].contains(mjd(61'000.5)) << "\n";
 
-  auto joined = day.union_with(MJDPeriod{mjd(60'999.0), mjd(61'001.5)});
+  auto joined = day.union_with(TTMjdPeriod{mjd(60'999.0), mjd(61'001.5)});
   std::cout << "union    : " << joined.size() << " period(s)\n";
 
   return 0;
diff --git a/examples/06_runtime_tables.cpp b/examples/06_runtime_tables.cpp
index 91c03a3..dd17849 100644
--- a/examples/06_runtime_tables.cpp
+++ b/examples/06_runtime_tables.cpp
@@ -22,19 +22,21 @@ int main() {
   using namespace tempoch;
   using namespace tempoch::constants;
 
+  auto ctx = TimeContext::with_builtin_eop();
+
   // ── TT → UT1 (mirrors probe_tt → probe_ut1 in 06_runtime_tables.rs) ────
   // JD TT 2 460 000.25 ≈ 2023-05-15T18:00:00 TT
-  JulianDate probe_tt{2'460'000.25};
-  UT probe_ut1 = probe_tt.to<scales::UT>();
+  JulianDate<scale::TT> probe_tt{2'460'000.25};
+  auto probe_ut1 = probe_tt.to_with<scale::UT1>(ctx);
 
   std::cout << std::fixed << std::setprecision(9);
   std::cout << "probe TT JD  : " << probe_tt << "\n";
-  std::cout << "probe UT1 JD : " << probe_ut1 << "\n";
+  std::cout << "probe UT1 JD : " << probe_ut1.to<format::JD>() << "\n";
 
   // ── Unix timestamp roundtrip ─────────────────────────────────────────────
   UnixTime ux{1'700'000'000.0};
-  UTC utc_from_ux = ux.to_utc();
-  UnixTime back = UnixTime::from_utc(utc_from_ux);
+  auto utc_from_ux = ux.to_time().to_civil();
+  auto back = Time<scale::UTC>::from_civil(utc_from_ux).to<format::Unix>();
 
   std::cout << std::fixed << std::setprecision(3);
   std::cout << "Unix roundtrip: " << back << "\n\n";
@@ -43,8 +45,8 @@ int main() {
   std::cout << std::fixed << std::setprecision(1);
   std::cout << "EOP range    : [" << eop_start_mjd() << ", " << eop_end_mjd() << "] MJD (UTC)\n";
 
-  // Query EOP at the probe epoch (need UTC MJD; approximate TT→UTC via MJD).
-  const double probe_mjd_utc = probe_tt.to<scales::MJD>().value();
+  // Query EOP at the probe epoch in UTC MJD.
+  const double probe_mjd_utc = probe_tt.to<scale::UTC>().to<format::MJD>().value();
   if (auto eop = eop_at(probe_mjd_utc)) {
     std::cout << std::fixed << std::setprecision(6);
     std::cout << "DUT1 at probe: " << eop->ut1_minus_utc << " s\n";
diff --git a/examples/07_conversions.cpp b/examples/07_conversions.cpp
index 5cbcf84..b216440 100644
--- a/examples/07_conversions.cpp
+++ b/examples/07_conversions.cpp
@@ -22,32 +22,34 @@
 int main() {
   using namespace tempoch;
 
+  auto ctx = TimeContext::with_builtin_eop();
+
   // Start from a Unix timestamp (mirrors UnixTime::try_new(1_700_000_000.25)).
   UnixTime ux{1'700'000'000.25};
-  UTC utc = ux.to_utc();
+  auto utc = ux.to_time().to_civil();
 
   // Convert across continuous scales.
-  TAI tai = ux.to<scales::TAI>();
-  TT tt = tai.to<scales::TT>();
-  TDB tdb = tt.to<scales::TDB>();
-  UT ut1 = ux.to<scales::UT>();
+  auto tai = ux.to<scale::TAI>();
+  auto tt = tai.to<scale::TT>();
+  auto tdb = tt.to<scale::TDB>();
+  auto ut1 = ux.to_with<scale::UT1>(ctx);
 
   // GPS bridge.
-  GPS gps = tai.to<scales::GPS>();
-  TAI tai_from_gps = gps.to<scales::TAI>();
+  auto gps = tai.to<format::GPS>();
+  auto tai_from_gps = gps.to<scale::TAI>();
 
   std::cout << std::fixed << std::setprecision(9);
   std::cout << "UTC          : " << utc << "\n";
-  std::cout << "Unix seconds : " << std::fixed << std::setprecision(3) << ux << "\n";
+  std::cout << "Unix seconds : " << std::fixed << std::setprecision(3) << ux.value() << "\n";
   std::cout << std::fixed << std::setprecision(9);
-  std::cout << "TAI JD       : " << tai << "\n";
-  std::cout << "TT JD        : " << tt << "\n";
-  std::cout << "TDB JD       : " << tdb << "\n";
-  std::cout << "UT1 JD       : " << ut1 << "\n";
-  std::cout << "GPS days     : " << gps << "\n"; // days since GPS epoch
+  std::cout << "TAI JD       : " << tai.to<format::JD>() << "\n";
+  std::cout << "TT JD        : " << tt.to<format::JD>() << "\n";
+  std::cout << "TDB JD       : " << tdb.to<format::JD>() << "\n";
+  std::cout << "UT1 JD       : " << ut1.to<format::JD>() << "\n";
+  std::cout << "GPS seconds  : " << gps.value() << "\n";
 
   // GPS → TAI round-trip residual (mirrors the assert in 07_conversions.rs).
-  const double residual = std::abs(tai_from_gps.value() - tai.value()) * 86'400.0;
+  const double residual = std::abs((tai_from_gps - tai).value());
   std::cout << std::scientific;
   std::cout << "GPS→TAI residual: " << residual << " s\n";
   assert(residual < 1e-9);
diff --git a/include/tempoch/civil_time.hpp b/include/tempoch/civil_time.hpp
index 1a9765a..802f492 100644
--- a/include/tempoch/civil_time.hpp
+++ b/include/tempoch/civil_time.hpp
@@ -21,7 +21,8 @@ namespace tempoch {
  *
  * @code
  * tempoch::CivilTime noon(2000, 1, 1, 12, 0, 0);
- * auto jd = tempoch::JulianDate::from_utc(noon);
+ * auto utc = tempoch::Time<tempoch::scale::UTC>::from_civil(noon);
+ * auto jd = utc.to<tempoch::scale::TT>().to<tempoch::format::JD>();
  * @endcode
  */
 struct CivilTime {
diff --git a/include/tempoch/ffi_core.hpp b/include/tempoch/ffi_core.hpp
index 322edc4..1fd614f 100644
--- a/include/tempoch/ffi_core.hpp
+++ b/include/tempoch/ffi_core.hpp
@@ -77,6 +77,22 @@ class InvalidDurationUnitError : public TempochException {
   explicit InvalidDurationUnitError(const std::string &msg) : TempochException(msg) {}
 };
 
+/**
+ * @brief A generic scale/format conversion failed.
+ */
+class ConversionFailedError : public TempochException {
+public:
+  explicit ConversionFailedError(const std::string &msg) : TempochException(msg) {}
+};
+
+/**
+ * @brief The supplied raw format identifier is invalid.
+ */
+class InvalidFormatIdError : public TempochException {
+public:
+  explicit InvalidFormatIdError(const std::string &msg) : TempochException(msg) {}
+};
+
 /**
  * @brief Rust caught a panic before unwinding across the FFI boundary.
  */
@@ -138,6 +154,10 @@ inline void check_status(tempoch_status_t status, const char *operation) {
     throw InvalidScaleIdError(msg + "invalid scale id");
   case TEMPOCH_STATUS_T_INVALID_DURATION_UNIT:
     throw InvalidDurationUnitError(msg + "invalid duration unit");
+  case TEMPOCH_STATUS_T_CONVERSION_FAILED:
+    throw ConversionFailedError(msg + "conversion failed");
+  case TEMPOCH_STATUS_T_INVALID_FORMAT_ID:
+    throw InvalidFormatIdError(msg + "invalid format id");
   case TEMPOCH_STATUS_T_INTERNAL_PANIC:
     throw InternalPanicError(msg + "internal panic");
   case TEMPOCH_STATUS_T_UT1_HORIZON_EXCEEDED:
diff --git a/include/tempoch/legacy_time.hpp b/include/tempoch/legacy_time.hpp
new file mode 100644
index 0000000..0771b22
--- /dev/null
+++ b/include/tempoch/legacy_time.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+/**
+ * @file legacy_time.hpp
+ * @brief Opt-in legacy aliases for pre-redesign tempoch-cpp call sites.
+ *
+ * This header is intentionally not included by `tempoch/tempoch.hpp`.
+ */
+
+#include "time.hpp"
+
+namespace tempoch::legacy {
+
+using UTC [[deprecated("Use tempoch::CivilTime or tempoch::Time<tempoch::scale::UTC>.")]] =
+    CivilTime;
+using JulianDate [[deprecated("Use tempoch::JulianDate<tempoch::scale::TT>.")]] =
+    tempoch::JulianDate<tempoch::scale::TT>;
+using MJD [[deprecated("Use tempoch::ModifiedJulianDate<tempoch::scale::TT>.")]] =
+    tempoch::ModifiedJulianDate<tempoch::scale::TT>;
+using TT [[deprecated("Use tempoch::Time<tempoch::scale::TT>.")]] =
+    tempoch::Time<tempoch::scale::TT>;
+using TAI [[deprecated("Use tempoch::Time<tempoch::scale::TAI>.")]] =
+    tempoch::Time<tempoch::scale::TAI>;
+using TDB [[deprecated("Use tempoch::Time<tempoch::scale::TDB>.")]] =
+    tempoch::Time<tempoch::scale::TDB>;
+using TCG [[deprecated("Use tempoch::Time<tempoch::scale::TCG>.")]] =
+    tempoch::Time<tempoch::scale::TCG>;
+using TCB [[deprecated("Use tempoch::Time<tempoch::scale::TCB>.")]] =
+    tempoch::Time<tempoch::scale::TCB>;
+using UT [[deprecated("Use tempoch::Time<tempoch::scale::UT1>.")]] =
+    tempoch::Time<tempoch::scale::UT1>;
+using JDE [[deprecated("Use tempoch::JulianDate<tempoch::scale::TDB>.")]] =
+    tempoch::JulianDate<tempoch::scale::TDB>;
+using GPS [[deprecated("Use tempoch::GpsTime.")]] = tempoch::GpsTime;
+
+} // namespace tempoch::legacy
diff --git a/include/tempoch/period.hpp b/include/tempoch/period.hpp
index 2af74b0..7311feb 100644
--- a/include/tempoch/period.hpp
+++ b/include/tempoch/period.hpp
@@ -2,16 +2,7 @@
 
 /**
  * @file period.hpp
- * @brief C++ wrapper for time periods, generic over any time type.
- *
- * Wraps the tempoch-ffi Period API with a value-semantic, exception-safe C++
- * 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`).
+ * @brief Generic time periods parameterised by a typed time representation.
  */
 
 #include "qtty/qtty.hpp"
@@ -21,140 +12,76 @@
 
 namespace tempoch {
 
-// ============================================================================
-// 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.
+template <typename S> struct TimeTraits<Time<S>> {
+  static double to_mjd_value(const Time<S> &time) {
+    return time.template to<format::MJD>().value();
+  }
 
-template <> struct TimeTraits<CivilTime> {
-  static double to_mjd_value(const CivilTime &t) {
-    return TimeScaleTraits<scales::MJD>::from_civil(t);
+  static Time<S> from_mjd_value(double mjd) { return ModifiedJulianDate<S>(mjd).to_time(); }
+};
+
+template <typename S, typename F> struct TimeTraits<EncodedTime<S, F>> {
+  static double to_mjd_value(const EncodedTime<S, F> &time) {
+    if constexpr (std::is_same_v<F, format::MJD>) {
+      return time.value();
+    } else {
+      return time.to_time().template to<format::MJD>().value();
+    }
+  }
+
+  static EncodedTime<S, F> from_mjd_value(double mjd) {
+    if constexpr (std::is_same_v<F, format::MJD>) {
+      return EncodedTime<S, F>(mjd);
+    } else {
+      return ModifiedJulianDate<S>(mjd).template to<F>();
+    }
   }
-  static CivilTime from_mjd_value(double m) { return TimeScaleTraits<scales::MJD>::to_civil(m); }
 };
 
-// ============================================================================
-// Period<T>
-// ============================================================================
+template <> struct TimeTraits<CivilTime> {
+  static double to_mjd_value(const CivilTime &time) {
+    return Time<scale::UTC>::from_civil(time).template to<format::MJD>().value();
+  }
 
-/**
- * @brief A time period [start, end] parameterised on a time type @p T.
- *
- * Internally stores start/end as raw MJD days (matching the FFI layer) and
- * converts to/from @p T on demand via `TimeTraits<T>`.
- *
- * @tparam T A time type for which `TimeTraits<T>` is defined:
- *           `MJD` (default), `JulianDate`, or `UTC`.
- *
- * @code
- * // MJD period — must use explicit MJD wrappers to avoid JD/MJD ambiguity
- * tempoch::Period night(tempoch::MJD(60200.0), tempoch::MJD(60200.5));
- *
- * // Julian-Date period
- * auto start = tempoch::JulianDate::from_utc({2026, 1, 1});
- * auto end   = tempoch::JulianDate::from_utc({2026, 6, 1});
- * tempoch::Period jd_run(start, end);
- *
- * // UTC period
- * tempoch::Period utc_run(tempoch::UTC(2026, 1, 1), tempoch::UTC(2026, 6, 1));
- * @endcode
- */
-template <typename T = MJD> class Period {
+  static CivilTime from_mjd_value(double mjd) {
+    return ModifiedJulianDate<scale::UTC>(mjd).to_time().to_civil();
+  }
+};
+
+template <typename T = ModifiedJulianDate<scale::TT>> class Period {
   tempoch_period_mjd_t m_inner;
 
-  /// Private struct-based constructor used by from_c(); skips re-validation.
   explicit Period(const tempoch_period_mjd_t &inner) : m_inner(inner) {}
 
 public:
-  /**
-   * @brief Construct from typed start/end values.
-   *
-   * Raw `double` values are intentionally not accepted to prevent the
-   * JD-vs-MJD ambiguity.  Wrap the value in the appropriate type first:
-   * `MJD(mjd_value)`, `JulianDate(jd_value)`, or a `UTC{…}` struct.
-   *
-   * @param start Inclusive start instant.
-   * @param end   Inclusive end instant.
-   * @throws InvalidPeriodError If @p start is later than @p end.
-   */
   Period(const T &start, const T &end) {
     check_status(tempoch_period_mjd_new(TimeTraits<T>::to_mjd_value(start),
                                         TimeTraits<T>::to_mjd_value(end), &m_inner),
                  "Period::Period");
   }
 
-  /// Construct from the C FFI struct (bypasses public validation; FFI output is
-  /// trusted).
   static Period from_c(const tempoch_period_mjd_t &c) { return Period(c); }
 
-  /// Inclusive period start as a value of type @p T.
   T start() const { return TimeTraits<T>::from_mjd_value(m_inner.start_mjd); }
-
-  /// Inclusive period end as a value of type @p T.
   T end() const { return TimeTraits<T>::from_mjd_value(m_inner.end_mjd); }
 
-  /**
-   * @brief Duration as a qtty time quantity.
-   *
-   * Returns the period length converted to the requested unit.
-   * The raw FFI value (in days) is wrapped as a `qtty::Day` and then
-   * converted via the qtty unit-conversion layer.
-   *
-   * @tparam TargetType A qtty unit tag (e.g., `qtty::DayTag`) or its
-   *         convenience alias (e.g., `qtty::Day`, `qtty::Second`,
-   *         `qtty::Hour`). Defaults to `qtty::DayTag`.
-   * @return The duration as a `qtty::Quantity` in the requested unit.
-   *
-   * @code
-   * tempoch::Period p(tempoch::MJD(60200.0), tempoch::MJD(60201.5)); // 1.5-day
-   * period auto d  = p.duration();                        // qtty::Day    → 1.5
-   * d auto h  = p.duration<qtty::Hour>();            // qtty::Hour   → 36 h
-   * auto s  = p.duration<qtty::SecondTag>();       // qtty::Second → 129600 s
-   * @endcode
-   */
   template <typename TargetType = qtty::DayTag>
   qtty::Quantity<typename qtty::ExtractTag<TargetType>::type> duration() const {
     auto qty = tempoch_period_mjd_duration_qty(m_inner);
     return qtty::Quantity<qtty::DayTag>(qty.value).template to<TargetType>();
   }
 
-  /**
-   * @brief Compute the overlapping interval with another period.
-   * @param other The period to intersect with.
-   * @return The overlap as a `Period<T>`.
-   * @throws NoIntersectionError If the two periods do not overlap.
-   */
   Period intersection(const Period &other) const {
-    tempoch_period_mjd_t out;
+    tempoch_period_mjd_t out{};
     check_status(tempoch_period_mjd_intersection(m_inner, other.m_inner, &out),
                  "Period::intersection");
     return from_c(out);
   }
 
-  /**
-   * @brief Test whether an instant falls within this period.
-   *
-   * Uses a half-open [start, end) convention consistent with the FFI layer.
-   *
-   * @param point The instant to test.
-   * @return `true` when @p point is in `[start(), end())`.
-   */
   bool contains(const T &point) const noexcept {
     return tempoch_period_mjd_contains(m_inner, TimeTraits<T>::to_mjd_value(point));
   }
 
-  /**
-   * @brief Compute the union of this period and @p other.
-   *
-   * If the two periods overlap or touch, the result is a single merged period
-   * (`result.size() == 1`).  If they are disjoint, the result contains both
-   * periods in chronological order (`result.size() == 2`).
-   *
-   * @param other The period to unite with.
-   * @return A `std::vector<Period<T>>` with one or two elements.
-   * @throws InvalidPeriodError If either period is malformed.
-   */
   std::vector<Period<T>> union_with(const Period<T> &other) const {
     tempoch_period_mjd_t buf[2];
     std::size_t count = 0;
@@ -167,23 +94,11 @@ template <typename T = MJD> class Period {
     return result;
   }
 
-  /**
-   * @brief Compute the complement of a period list within this period.
-   *
-   * Returns the gaps inside `*this` that are not covered by any period in
-   * @p others.  @p others must be sorted and non-overlapping.
-   *
-   * @param others Sorted, non-overlapping inner periods (may be empty).
-   * @return The gaps as a `std::vector<Period<T>>`.
-   * @throws InvalidPeriodError        If any period is malformed.
-   * @throws PeriodListUnsortedError    If @p others is not sorted.
-   * @throws PeriodListOverlappingError If @p others has overlapping intervals.
-   */
   std::vector<Period<T>> complement_of(const std::vector<Period<T>> &others) const {
     std::vector<tempoch_period_mjd_t> raw;
     raw.reserve(others.size());
-    for (const auto &p : others)
-      raw.push_back(p.c_inner());
+    for (const auto &period : others)
+      raw.push_back(period.c_inner());
 
     tempoch_period_mjd_t *out_ptr = nullptr;
     std::size_t out_count = 0;
@@ -199,66 +114,32 @@ template <typename T = MJD> class Period {
     return result;
   }
 
-  /// Access the underlying FFI POD value.
-  const tempoch_period_mjd_t &c_inner() const { return m_inner; }
+  const tempoch_period_mjd_t &c_inner() const noexcept { return m_inner; }
 };
 
-// ============================================================================
-// C++17 deduction guides
-// ============================================================================
-
-/// Typed time values → Period<T> (covers MJD, JulianDate, UTC, …).
 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.
-
-// ============================================================================
-// Period list free functions
-// ============================================================================
+using TTMjdPeriod = Period<ModifiedJulianDate<scale::TT>>;
+using UTCPeriod = Period<CivilTime>;
 
-/**
- * @brief Validate that a list of periods is sorted and non-overlapping.
- *
- * @tparam T Time type (e.g. `MJD`, `JulianDate`, `CivilTime`).
- * @param periods The list to check (may be empty).
- * @throws InvalidPeriodError        If any period has start > end.
- * @throws PeriodListUnsortedError    If the list is not sorted.
- * @throws PeriodListOverlappingError If the list has overlapping intervals.
- */
 template <typename T> inline void validate_periods(const std::vector<Period<T>> &periods) {
   std::vector<tempoch_period_mjd_t> raw;
   raw.reserve(periods.size());
-  for (const auto &p : periods)
-    raw.push_back(p.c_inner());
+  for (const auto &period : periods)
+    raw.push_back(period.c_inner());
   check_status(tempoch_period_list_validate(raw.data(), raw.size()), "validate_periods");
 }
 
-/**
- * @brief Intersect two sorted, non-overlapping period lists.
- *
- * @tparam T Time type.
- * @param a First sorted, non-overlapping list.
- * @param b Second sorted, non-overlapping list.
- * @return Sorted intersection of the two lists.
- * @throws InvalidPeriodError, PeriodListUnsortedError, PeriodListOverlappingError
- *         if either input list is invalid.
- */
 template <typename T>
 inline std::vector<Period<T>> intersect_periods(const std::vector<Period<T>> &a,
                                                 const std::vector<Period<T>> &b) {
   std::vector<tempoch_period_mjd_t> ra, rb;
   ra.reserve(a.size());
   rb.reserve(b.size());
-  for (const auto &p : a)
-    ra.push_back(p.c_inner());
-  for (const auto &p : b)
-    rb.push_back(p.c_inner());
+  for (const auto &period : a)
+    ra.push_back(period.c_inner());
+  for (const auto &period : b)
+    rb.push_back(period.c_inner());
 
   tempoch_period_mjd_t *out_ptr = nullptr;
   std::size_t out_count = 0;
@@ -274,28 +155,16 @@ inline std::vector<Period<T>> intersect_periods(const std::vector<Period<T>> &a,
   return result;
 }
 
-/**
- * @brief Merge two period lists, combining overlapping and adjacent intervals.
- *
- * The inputs need not be sorted or non-overlapping; the output is always
- * sorted and non-overlapping.
- *
- * @tparam T Time type.
- * @param a First list.
- * @param b Second list.
- * @return Merged, normalised period list.
- * @throws InvalidPeriodError if any input period is malformed.
- */
 template <typename T>
 inline std::vector<Period<T>> union_periods(const std::vector<Period<T>> &a,
                                             const std::vector<Period<T>> &b) {
   std::vector<tempoch_period_mjd_t> ra, rb;
   ra.reserve(a.size());
   rb.reserve(b.size());
-  for (const auto &p : a)
-    ra.push_back(p.c_inner());
-  for (const auto &p : b)
-    rb.push_back(p.c_inner());
+  for (const auto &period : a)
+    ra.push_back(period.c_inner());
+  for (const auto &period : b)
+    rb.push_back(period.c_inner());
 
   tempoch_period_mjd_t *out_ptr = nullptr;
   std::size_t out_count = 0;
@@ -311,20 +180,12 @@ inline std::vector<Period<T>> union_periods(const std::vector<Period<T>> &a,
   return result;
 }
 
-/**
- * @brief Sort and merge overlapping or adjacent periods in a single list.
- *
- * @tparam T Time type.
- * @param periods The list to normalise (may be unsorted / overlapping).
- * @return Sorted, non-overlapping list.
- * @throws InvalidPeriodError if any period is malformed.
- */
 template <typename T>
 inline std::vector<Period<T>> normalize_periods(const std::vector<Period<T>> &periods) {
   std::vector<tempoch_period_mjd_t> raw;
   raw.reserve(periods.size());
-  for (const auto &p : periods)
-    raw.push_back(p.c_inner());
+  for (const auto &period : periods)
+    raw.push_back(period.c_inner());
 
   tempoch_period_mjd_t *out_ptr = nullptr;
   std::size_t out_count = 0;
@@ -339,13 +200,8 @@ inline std::vector<Period<T>> normalize_periods(const std::vector<Period<T>> &pe
   return result;
 }
 
-// ============================================================================
-// operator<<
-// ============================================================================
-
-/// Stream a Period as [start, end] using T's own operator<<.
-template <typename T> inline std::ostream &operator<<(std::ostream &os, const Period<T> &p) {
-  return os << '[' << p.start() << ", " << p.end() << ']';
+template <typename T> inline std::ostream &operator<<(std::ostream &os, const Period<T> &period) {
+  return os << '[' << period.start() << ", " << period.end() << ']';
 }
 
 } // namespace tempoch
diff --git a/include/tempoch/scales.hpp b/include/tempoch/scales.hpp
index f56a5af..0db4260 100644
--- a/include/tempoch/scales.hpp
+++ b/include/tempoch/scales.hpp
@@ -2,276 +2,130 @@
 
 /**
  * @file scales.hpp
- * @brief Time-scale tag types and traits for the tempoch Time<S> template.
+ * @brief Time-scale and time-format tag types for the tempoch C++ API.
  *
- * Scale tag structs live in `tempoch::scales::` (e.g., `scales::TT`,
- * `scales::JD`).  Convenience type aliases (`TT = Time<scales::TT>` etc.)
- * are provided in `time.hpp`.
- *
- * Mirrors the Rust scale set while keeping the C++ API strongly typed.
- * The C ABI underneath is intentionally simpler: all generic dispatch goes
- * through `double` values plus a raw scale id.
+ * The C++ surface follows the Rust `tempoch` model: physical *scale* and
+ * external *format* are orthogonal type parameters.
  */
 
-#include "civil_time.hpp" // CivilTime struct definition
-#include "ffi_core.hpp"   // tempoch_ffi.h + check_status
-#include <cstdint>
+#include "ffi_core.hpp"
+#include <qtty/qtty.hpp>
+#include <type_traits>
 
 namespace tempoch {
 
-// ============================================================================
-// Scale Tags — in tempoch::scales::
-// ============================================================================
-
-namespace scales {
-
-/// Julian Date (days since −4712‑01‑01T12:00 TT).
-struct JD {};
-
-/// Modified Julian Date (JD − 2 400 000.5).
-struct MJD {};
-
-/// UTC, internally stored as MJD days for arithmetic.
-struct UTC {};
+namespace scale {
 
-/// Terrestrial Time (TT), stored as JD days in TT scale.
 struct TT {};
-
-/// International Atomic Time (TAI), stored as JD days in TAI scale.
 struct TAI {};
-
-/// Barycentric Dynamical Time (TDB), stored as JD days in TDB scale.
+struct UTC {};
+struct UT1 {};
 struct TDB {};
-
-/// Geocentric Coordinate Time (TCG), stored as JD days in TCG scale.
 struct TCG {};
-
-/// Barycentric Coordinate Time (TCB), stored as JD days in TCB scale.
 struct TCB {};
 
-/// GPS Time, stored as JD days in GPS scale.
-struct GPS {};
-
-/// Universal Time (UT1), stored as JD days in UT1 scale.
-struct UT {};
+} // namespace scale
 
-/// Julian Ephemeris Date (JDE ≡ TDB), stored as JD days.
-struct JDE {};
+namespace format {
 
-/// Unix Time (seconds since 1970-01-01T00:00:00 UTC), stored as Unix seconds.
+struct JD {};
+struct MJD {};
+struct J2000s {};
 struct Unix {};
+struct GPS {};
 
-} // namespace scales
-
-// ============================================================================
-// 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.");
-};
-
-namespace detail {
-
-template <typename S> struct ScaleIdOf;
-
-template <> struct ScaleIdOf<scales::JD> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_JD;
-};
-template <> struct ScaleIdOf<scales::MJD> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_MJD;
-};
-// UTC is stored as MJD days in the FFI layer (TempochScaleId::MJD = 1).
-// tempoch_time_from_utc/to_utc with scale_id=1 perform the UTC↔civil
-// conversion. This aliasing is intentional: UTC and MJD share the same
-// underlying numeric representation in the C ABI.
-template <> struct ScaleIdOf<scales::UTC> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_MJD;
-};
-template <> struct ScaleIdOf<scales::TDB> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_TDB;
-};
-template <> struct ScaleIdOf<scales::TT> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_TT;
-};
-template <> struct ScaleIdOf<scales::TAI> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_TAI;
-};
-template <> struct ScaleIdOf<scales::TCG> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_TCG;
-};
-template <> struct ScaleIdOf<scales::TCB> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_TCB;
-};
-template <> struct ScaleIdOf<scales::GPS> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_GPS;
-};
-template <> struct ScaleIdOf<scales::UT> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_UT;
-};
-template <> struct ScaleIdOf<scales::JDE> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_JDE;
-};
-template <> struct ScaleIdOf<scales::Unix> {
-  static constexpr int32_t value = TEMPOCH_SCALE_ID_T_UNIX_TIME;
-};
-
-template <typename S> inline constexpr int32_t scale_id_v = ScaleIdOf<S>::value;
-
-inline double time_from_utc(const CivilTime &ct, int32_t scale_id, const char *operation) {
-  double out = 0.0;
-  auto raw = ct.to_c();
-  check_status(tempoch_time_from_utc(raw, scale_id, &out), operation);
-  return out;
-}
-
-inline CivilTime time_to_utc(double value, int32_t scale_id, const char *operation) {
-  tempoch_utc_t out{};
-  check_status(tempoch_time_to_utc(value, scale_id, &out), operation);
-  return CivilTime::from_c(out);
-}
-
-inline double time_add_days(double value, int32_t scale_id, double delta, const char *operation) {
-  double out = 0.0;
-  check_status(tempoch_time_add_days(value, scale_id, delta, &out), operation);
-  return out;
-}
-
-inline double time_difference_days(double lhs, double rhs, int32_t scale_id,
-                                   const char *operation) {
-  double out = 0.0;
-  check_status(tempoch_time_difference_days(lhs, rhs, scale_id, &out), operation);
-  return out;
-}
-
-inline qtty_quantity_t time_difference_qty(double lhs, double rhs, int32_t scale_id,
-                                           const char *operation) {
-  qtty_quantity_t out{0.0, UNIT_ID_DAY};
-  check_status(tempoch_time_difference_qty(lhs, rhs, scale_id, &out), operation);
-  return out;
-}
-
-inline void time_add_qty(double value, int32_t scale_id, qtty_quantity_t duration, double &out,
-                         const char *operation) {
-  check_status(tempoch_time_add_qty(value, scale_id, duration, &out), operation);
-}
-
-template <typename S> struct GenericScaleTraits {
-  static double from_civil(const CivilTime &ct) {
-    return time_from_utc(ct, scale_id_v<S>, "tempoch_time_from_utc");
-  }
-
-  static CivilTime to_civil(double value) {
-    return time_to_utc(value, scale_id_v<S>, "tempoch_time_to_utc");
-  }
-
-  static double add_days(double value, double delta) {
-    return time_add_days(value, scale_id_v<S>, delta, "tempoch_time_add_days");
-  }
-
-  static double difference(double a, double b) {
-    return time_difference_days(a, b, scale_id_v<S>, "tempoch_time_difference_days");
-  }
-
-  static qtty_quantity_t difference_qty(double a, double b) {
-    return time_difference_qty(a, b, scale_id_v<S>, "tempoch_time_difference_qty");
-  }
+} // namespace format
 
-  static void add_qty(double value, qtty_quantity_t duration, double &out) {
-    time_add_qty(value, scale_id_v<S>, duration, out, "tempoch_time_add_qty");
-  }
-};
+template <typename T> struct is_scale : std::false_type {};
+template <> struct is_scale<scale::TT> : std::true_type {};
+template <> struct is_scale<scale::TAI> : std::true_type {};
+template <> struct is_scale<scale::UTC> : std::true_type {};
+template <> struct is_scale<scale::UT1> : std::true_type {};
+template <> struct is_scale<scale::TDB> : std::true_type {};
+template <> struct is_scale<scale::TCG> : std::true_type {};
+template <> struct is_scale<scale::TCB> : std::true_type {};
 
-} // namespace detail
+template <typename T> inline constexpr bool is_scale_v = is_scale<T>::value;
 
-template <> struct TimeScaleTraits<scales::JD> : detail::GenericScaleTraits<scales::JD> {
-  static constexpr const char *label() { return "JD"; }
+template <typename T> struct is_format : std::false_type {};
+template <> struct is_format<format::JD> : std::true_type {};
+template <> struct is_format<format::MJD> : std::true_type {};
+template <> struct is_format<format::J2000s> : std::true_type {};
+template <> struct is_format<format::Unix> : std::true_type {};
+template <> struct is_format<format::GPS> : std::true_type {};
 
-  static double j2000() { return tempoch_jd_j2000(); }
+template <typename T> inline constexpr bool is_format_v = is_format<T>::value;
 
-  static double julian_centuries(double jd) { return tempoch_jd_julian_centuries(jd); }
+template <typename S> struct ScaleTraits;
 
-  static qtty_quantity_t julian_centuries_qty(double jd) {
-    return tempoch_jd_julian_centuries_qty(jd);
-  }
+template <> struct ScaleTraits<scale::TT> {
+  static constexpr tempoch_scale_tag_t ffi_tag = TEMPOCH_SCALE_TAG_T_TT;
+  static constexpr const char *name() { return "TT"; }
 };
 
-template <> struct TimeScaleTraits<scales::MJD> : detail::GenericScaleTraits<scales::MJD> {
-  static constexpr const char *label() { return "MJD"; }
+template <> struct ScaleTraits<scale::TAI> {
+  static constexpr tempoch_scale_tag_t ffi_tag = TEMPOCH_SCALE_TAG_T_TAI;
+  static constexpr const char *name() { return "TAI"; }
 };
 
-template <> struct TimeScaleTraits<scales::UTC> : detail::GenericScaleTraits<scales::UTC> {
-  static constexpr const char *label() { return "UTC"; }
+template <> struct ScaleTraits<scale::UTC> {
+  static constexpr tempoch_scale_tag_t ffi_tag = TEMPOCH_SCALE_TAG_T_UTC;
+  static constexpr const char *name() { return "UTC"; }
 };
 
-template <> struct TimeScaleTraits<scales::TT> : detail::GenericScaleTraits<scales::TT> {
-  static constexpr const char *label() { return "TT"; }
+template <> struct ScaleTraits<scale::UT1> {
+  static constexpr tempoch_scale_tag_t ffi_tag = TEMPOCH_SCALE_TAG_T_UT1;
+  static constexpr const char *name() { return "UT1"; }
 };
 
-template <> struct TimeScaleTraits<scales::TAI> : detail::GenericScaleTraits<scales::TAI> {
-  static constexpr const char *label() { return "TAI"; }
+template <> struct ScaleTraits<scale::TDB> {
+  static constexpr tempoch_scale_tag_t ffi_tag = TEMPOCH_SCALE_TAG_T_TDB;
+  static constexpr const char *name() { return "TDB"; }
 };
 
-template <> struct TimeScaleTraits<scales::TDB> : detail::GenericScaleTraits<scales::TDB> {
-  static constexpr const char *label() { return "TDB"; }
+template <> struct ScaleTraits<scale::TCG> {
+  static constexpr tempoch_scale_tag_t ffi_tag = TEMPOCH_SCALE_TAG_T_TCG;
+  static constexpr const char *name() { return "TCG"; }
 };
 
-template <> struct TimeScaleTraits<scales::TCG> : detail::GenericScaleTraits<scales::TCG> {
-  static constexpr const char *label() { return "TCG"; }
+template <> struct ScaleTraits<scale::TCB> {
+  static constexpr tempoch_scale_tag_t ffi_tag = TEMPOCH_SCALE_TAG_T_TCB;
+  static constexpr const char *name() { return "TCB"; }
 };
 
-template <> struct TimeScaleTraits<scales::TCB> : detail::GenericScaleTraits<scales::TCB> {
-  static constexpr const char *label() { return "TCB"; }
-};
+template <typename F> struct FormatTraits;
 
-template <> struct TimeScaleTraits<scales::GPS> : detail::GenericScaleTraits<scales::GPS> {
-  static constexpr const char *label() { return "GPS"; }
+template <> struct FormatTraits<format::JD> {
+  using quantity_type = qtty::Day;
+  static constexpr tempoch_format_tag_t ffi_tag = TEMPOCH_FORMAT_TAG_T_JD;
+  static constexpr const char *name() { return "JD"; }
 };
 
-template <> struct TimeScaleTraits<scales::UT> : detail::GenericScaleTraits<scales::UT> {
-  static constexpr const char *label() { return "UT1"; }
+template <> struct FormatTraits<format::MJD> {
+  using quantity_type = qtty::Day;
+  static constexpr tempoch_format_tag_t ffi_tag = TEMPOCH_FORMAT_TAG_T_MJD;
+  static constexpr const char *name() { return "MJD"; }
 };
 
-template <> struct TimeScaleTraits<scales::JDE> : detail::GenericScaleTraits<scales::JDE> {
-  static constexpr const char *label() { return "JDE"; }
+template <> struct FormatTraits<format::J2000s> {
+  using quantity_type = qtty::Second;
+  static constexpr tempoch_format_tag_t ffi_tag = TEMPOCH_FORMAT_TAG_T_J2000_SECONDS;
+  static constexpr const char *name() { return "J2000s"; }
 };
 
-template <> struct TimeScaleTraits<scales::Unix> : detail::GenericScaleTraits<scales::Unix> {
-  static constexpr const char *label() { return "Unix"; }
+template <> struct FormatTraits<format::Unix> {
+  using quantity_type = qtty::Second;
+  static constexpr tempoch_format_tag_t ffi_tag = TEMPOCH_FORMAT_TAG_T_UNIX;
+  static constexpr const char *name() { return "Unix"; }
 };
 
-// ============================================================================
-// TimeConvertTraits — cross-scale conversion
-// ============================================================================
-
-/**
- * @brief Primary template — routes any A→B conversion through JD.
- *
- * All cross-scale conversion goes through the generic `tempoch_time_convert`
- * ABI entrypoint and compile-time scale-id mapping.
- */
-template <typename From, typename To> struct TimeConvertTraits {
-  static double convert(double src) {
-    double out = 0.0;
-    check_status(tempoch_time_convert(src, detail::scale_id_v<From>, detail::scale_id_v<To>, &out),
-                 "tempoch_time_convert");
-    return out;
-  }
+template <> struct FormatTraits<format::GPS> {
+  using quantity_type = qtty::Second;
+  static constexpr tempoch_format_tag_t ffi_tag = TEMPOCH_FORMAT_TAG_T_GPS;
+  static constexpr const char *name() { return "GPS"; }
 };
 
-/// Identity conversion — zero cost.
-template <typename S> struct TimeConvertTraits<S, S> {
-  static double convert(double v) { return v; }
-};
+template <typename S> inline constexpr tempoch_scale_tag_t scale_tag_v = ScaleTraits<S>::ffi_tag;
+template <typename F> inline constexpr tempoch_format_tag_t format_tag_v = FormatTraits<F>::ffi_tag;
 
 } // namespace tempoch
diff --git a/include/tempoch/tempoch.hpp b/include/tempoch/tempoch.hpp
index b41822c..877c504 100644
--- a/include/tempoch/tempoch.hpp
+++ b/include/tempoch/tempoch.hpp
@@ -6,12 +6,12 @@
  *
  * Include this single header to get the full tempoch C++ API:
  *
- *   - `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] with list operations
+ *   - `tempoch::Time<S>`         — split-storage instant on scale `S`
+ *   - `tempoch::JulianDate<S>`   — JD encoding on scale `S`
+ *   - `tempoch::ModifiedJulianDate<S>`
+ *   - `tempoch::CivilTime`       — civil UTC calendar label
+ *   - `tempoch::TimeContext`     — explicit UT1 / historical UTC context
+ *   - `tempoch::Period<T>`       — time period [start, end] with list operations
  *   - `tempoch::EopValues`     — IERS Earth Orientation Parameter values
  *   - `tempoch::eop_at()`      — interpolate EOP at a UTC MJD
  *   - `tempoch::eop_covers()`  — check EOP data availability
@@ -20,8 +20,10 @@
  * @code
  * #include <tempoch/tempoch.hpp>
  *
- * auto jd  = tempoch::JulianDate::from_utc({2026, 7, 15, 22, 0, 0});
- * auto mjd = jd.to<tempoch::MJDScale>();   // cross-scale conversion
+ * auto utc = tempoch::Time<tempoch::scale::UTC>::from_civil({2026, 7, 15, 22, 0, 0});
+ * auto tt  = utc.to<tempoch::scale::TT>();
+ * auto jd  = tt.to<tempoch::format::JD>();
+ * auto mjd = tt.to<tempoch::format::MJD>();
  *
  * if (auto eop = tempoch::eop_at(mjd.value()))
  *     std::cout << "DUT1 = " << eop->ut1_minus_utc << " s\n";
diff --git a/include/tempoch/time.hpp b/include/tempoch/time.hpp
index e1532de..3d8da41 100644
--- a/include/tempoch/time.hpp
+++ b/include/tempoch/time.hpp
@@ -2,59 +2,18 @@
 
 /**
  * @file time.hpp
- * @brief Public type aliases for tempoch time types.
- *
- * 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:
- *
- *   - `tempoch::JulianDate`  = `Time<scales::JD>`
- *   - `tempoch::MJD`         = `Time<scales::MJD>`
- *   - `tempoch::UTC`         = `CivilTime` (civil date-time breakdown)
- *   - `tempoch::CivilTime`   (canonical name for the civil struct)
+ * @brief Public aliases for tempoch time encodings.
  */
 
 #include "time_base.hpp"
 
 namespace tempoch {
 
-/// Julian Date — days since −4712-01-01T12:00 TT.
-using JulianDate = Time<scales::JD>;
+template <typename S> using JulianDate = EncodedTime<S, format::JD>;
+template <typename S> using ModifiedJulianDate = EncodedTime<S, format::MJD>;
+template <typename S> using J2000Seconds = EncodedTime<S, format::J2000s>;
 
-/// Modified Julian Date — JD − 2 400 000.5.
-using MJD = Time<scales::MJD>;
-
-/// Barycentric Dynamical Time.
-using TDB = Time<scales::TDB>;
-
-/// Terrestrial Time.
-using TT = Time<scales::TT>;
-
-/// International Atomic Time.
-using TAI = Time<scales::TAI>;
-
-/// Geocentric Coordinate Time.
-using TCG = Time<scales::TCG>;
-
-/// Barycentric Coordinate Time.
-using TCB = Time<scales::TCB>;
-
-/// GPS Time.
-using GPS = Time<scales::GPS>;
-
-/// Universal Time (UT1).
-using UT = Time<scales::UT>;
-
-/// Alias — mirrors Rust's `UniversalTime`.
-using UniversalTime = Time<scales::UT>;
-
-/// Julian Ephemeris Date (≡ TDB expressed as JD).
-using JDE = Time<scales::JDE>;
-
-/// Unix (POSIX) time — seconds since 1970-01-01T00:00:00 UTC.
-using UnixTime = Time<scales::Unix>;
-
-// `UTC` and `CivilTime` are already declared in time_base.hpp:
-//   using UTC = CivilTime;
+using UnixTime = EncodedTime<scale::UTC, format::Unix>;
+using GpsTime = EncodedTime<scale::TAI, format::GPS>;
 
 } // namespace tempoch
diff --git a/include/tempoch/time_base.hpp b/include/tempoch/time_base.hpp
index 3603b2e..6a7d6ab 100644
--- a/include/tempoch/time_base.hpp
+++ b/include/tempoch/time_base.hpp
@@ -2,243 +2,384 @@
 
 /**
  * @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` in the scale's native scalar representation
- *     (days for astronomical scales, seconds for Unix time) with compile-time
- *     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.
+ * @brief Core `Time<S>`, `EncodedTime<S, F>`, and `TimeContext` types.
  */
 
 #include "civil_time.hpp"
-#include "qtty/qtty.hpp"
+#include "ffi_core.hpp"
 #include "scales.hpp"
-#include <iomanip>
+#include <cmath>
+#include <memory>
+#include <optional>
 #include <ostream>
 #include <type_traits>
+#include <utility>
 
 namespace tempoch {
 
+template <typename S> class Time;
+template <typename S, typename F> class EncodedTime;
+template <typename T> struct TimeTraits;
+
+namespace detail {
+
+struct ContextDeleter {
+  void operator()(tempoch_context_t *ptr) const noexcept { tempoch_context_free(ptr); }
+};
+
+inline std::shared_ptr<tempoch_context_t> make_default_context() {
+  tempoch_context_t *raw = nullptr;
+  check_status(tempoch_context_create_default(&raw), "tempoch_context_create_default");
+  return std::shared_ptr<tempoch_context_t>(raw, ContextDeleter{});
+}
+
+inline std::shared_ptr<tempoch_context_t> make_builtin_eop_context() {
+  tempoch_context_t *raw = nullptr;
+  check_status(tempoch_context_create_with_builtin_eop(&raw),
+               "tempoch_context_create_with_builtin_eop");
+  return std::shared_ptr<tempoch_context_t>(raw, ContextDeleter{});
+}
+
+inline std::shared_ptr<tempoch_context_t>
+make_pre_definition_context(const tempoch_context_t *parent) {
+  tempoch_context_t *raw = nullptr;
+  check_status(tempoch_context_allow_pre_definition_utc(parent, &raw),
+               "tempoch_context_allow_pre_definition_utc");
+  return std::shared_ptr<tempoch_context_t>(raw, ContextDeleter{});
+}
+
+inline tempoch_time_t make_time(double hi_seconds, double lo_seconds) {
+  tempoch_time_t out{};
+  check_status(tempoch_time_new(hi_seconds, lo_seconds, &out), "tempoch_time_new");
+  return out;
+}
+
+template <typename From, typename To>
+inline tempoch_time_t scale_convert(const tempoch_time_t &value, const tempoch_context_t *ctx) {
+  tempoch_time_t out{};
+  check_status(tempoch_time_scale_convert(value, static_cast<int32_t>(scale_tag_v<From>),
+                                          static_cast<int32_t>(scale_tag_v<To>), ctx, &out),
+               "tempoch_time_scale_convert");
+  return out;
+}
+
+template <typename S, typename F>
+inline double encode_time(const tempoch_time_t &value, const tempoch_context_t *ctx) {
+  double out = 0.0;
+  check_status(tempoch_time_to_format(value, static_cast<int32_t>(scale_tag_v<S>),
+                                      static_cast<int32_t>(format_tag_v<F>), ctx, &out),
+               "tempoch_time_to_format");
+  return out;
+}
+
+template <typename S, typename F>
+inline tempoch_time_t decode_time(double raw, const tempoch_context_t *ctx) {
+  tempoch_time_t out{};
+  check_status(tempoch_time_from_format(raw, static_cast<int32_t>(scale_tag_v<S>),
+                                        static_cast<int32_t>(format_tag_v<F>), ctx, &out),
+               "tempoch_time_from_format");
+  return out;
+}
+
+inline tempoch_time_t time_from_civil(const CivilTime &civil, const tempoch_context_t *ctx) {
+  tempoch_time_t out{};
+  check_status(tempoch_time_from_civil(civil.to_c(), ctx, &out), "tempoch_time_from_civil");
+  return out;
+}
+
+inline CivilTime time_to_civil(const tempoch_time_t &value, const tempoch_context_t *ctx) {
+  tempoch_utc_t out{};
+  check_status(tempoch_time_to_civil(value, ctx, &out), "tempoch_time_to_civil");
+  return CivilTime::from_c(out);
+}
+
+template <typename Q> inline tempoch_time_t add_seconds(const tempoch_time_t &value, const Q &qty) {
+  tempoch_time_t out{};
+  qtty_quantity_t raw{qty.value(), qtty::UnitTraits<typename Q::unit_tag>::unit_id()};
+  check_status(tempoch_time_add_seconds(value, raw, &out), "tempoch_time_add_seconds");
+  return out;
+}
+
+inline qtty::Second difference_seconds(const tempoch_time_t &lhs, const tempoch_time_t &rhs) {
+  double out = 0.0;
+  check_status(tempoch_time_difference_seconds(lhs, rhs, &out), "tempoch_time_difference_seconds");
+  return qtty::Second(out);
+}
+
+template <typename F> inline typename FormatTraits<F>::quantity_type quantity_from_raw(double raw) {
+  return typename FormatTraits<F>::quantity_type(raw);
+}
+
+template <typename F> inline void ensure_finite_encoded(double raw, const char *operation) {
+  if (!std::isfinite(raw))
+    throw ConversionFailedError(std::string(operation) + " failed: non-finite raw value");
+}
+
+} // namespace detail
+
 /**
- * @brief A point in time on scale @p S, stored as a raw native scalar.
- *
- * 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::scales::JD>;
- * auto jd = JulianDate::from_utc({2026, 7, 15, 22, 0, 0});
- * auto mjd = jd.to<tempoch::scales::MJD>();
- * @endcode
+ * @brief Immutable conversion context for UT1 and historical UTC routes.
+ */
+class TimeContext {
+  std::shared_ptr<tempoch_context_t> handle_;
+
+  explicit TimeContext(std::shared_ptr<tempoch_context_t> handle) : handle_(std::move(handle)) {}
+
+public:
+  TimeContext() : handle_(detail::make_default_context()) {}
+
+  static TimeContext with_builtin_eop() { return TimeContext(detail::make_builtin_eop_context()); }
+
+  TimeContext allow_pre_definition_utc() const {
+    return TimeContext(detail::make_pre_definition_context(handle_.get()));
+  }
+
+  const tempoch_context_t *get() const noexcept { return handle_.get(); }
+};
+
+/**
+ * @brief A point in time on scale @p S, stored as a split J2000-second pair.
  */
 template <typename S> class Time {
-  double m_days;
+  static_assert(is_scale_v<S>, "Time<S> requires a valid tempoch::scale tag");
+
+  tempoch_time_t raw_;
+
+  explicit Time(const tempoch_time_t &raw) : raw_(raw) {}
+
+  template <typename> friend class Time;
+  template <typename, typename> friend class EncodedTime;
 
 public:
   using scale_type = S;
 
-  // ── Constructors ──────────────────────────────────────────────────────
-
-  /// Construct from a raw value in this scale's native representation.
-  constexpr explicit Time(double value) : m_days(value) {}
-
-  /// Default-construct to zero in the scale's native representation.
-  constexpr Time() : m_days(0.0) {}
-
-  // Rule of Five (trivial — all defaulted)
-  Time(const Time &) = default;
-  Time(Time &&) noexcept = default;
-  Time &operator=(const Time &) = default;
-  Time &operator=(Time &&) noexcept = default;
-  ~Time() = default;
+  Time() : raw_(detail::make_time(0.0, 0.0)) {}
+
+  static Time from_split_seconds(qtty::Second hi, qtty::Second lo = qtty::Second(0.0)) {
+    return Time(detail::make_time(hi.value(), lo.value()));
+  }
+
+  static Time from_raw_j2000_seconds(qtty::Second seconds) { return from_split_seconds(seconds); }
 
-  // ── Factory: from civil time ──────────────────────────────────────────
+  std::pair<qtty::Second, qtty::Second> split_seconds() const noexcept {
+    return {qtty::Second(raw_.hi_seconds), qtty::Second(raw_.lo_seconds)};
+  }
 
-  /**
-   * @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)); }
+  qtty::Second total_seconds() const noexcept {
+    return qtty::Second(raw_.hi_seconds + raw_.lo_seconds);
+  }
 
-  // ── Accessors ─────────────────────────────────────────────────────────
+  const tempoch_time_t &c_inner() const noexcept { return raw_; }
 
-  /// Raw value in this scale's native representation.
-  constexpr double value() const noexcept { return m_days; }
+  static constexpr const char *label() { return ScaleTraits<S>::name(); }
 
-  /// Human-readable label for the scale (e.g. "JD", "MJD", "UTC").
-  static constexpr const char *label() { return TimeScaleTraits<S>::label(); }
+  template <typename U = S, std::enable_if_t<std::is_same_v<U, scale::UTC>, int> = 0>
+  static Time from_civil(const CivilTime &civil) {
+    return Time(detail::time_from_civil(civil, nullptr));
+  }
 
-  // ── Civil-time conversion ─────────────────────────────────────────────
+  template <typename U = S, std::enable_if_t<std::is_same_v<U, scale::UTC>, int> = 0>
+  static Time from_civil(const CivilTime &civil, const TimeContext &ctx) {
+    return Time(detail::time_from_civil(civil, ctx.get()));
+  }
 
-  /// Convert to a UTC civil-time breakdown.
-  CivilTime to_utc() const { return TimeScaleTraits<S>::to_civil(m_days); }
+  template <typename U = S, std::enable_if_t<std::is_same_v<U, scale::UTC>, int> = 0>
+  CivilTime to_civil() const {
+    return detail::time_to_civil(raw_, nullptr);
+  }
 
-  // ── Cross-scale conversion ────────────────────────────────────────────
+  template <typename U = S, std::enable_if_t<std::is_same_v<U, scale::UTC>, int> = 0>
+  CivilTime to_civil(const TimeContext &ctx) const {
+    return detail::time_to_civil(raw_, ctx.get());
+  }
 
-  /**
-   * @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));
+  template <typename TargetScale,
+            std::enable_if_t<is_scale_v<TargetScale> && !std::is_same_v<S, scale::UT1> &&
+                                 !std::is_same_v<TargetScale, scale::UT1>,
+                             int> = 0>
+  Time<TargetScale> to() const {
+    return Time<TargetScale>(detail::scale_convert<S, TargetScale>(raw_, nullptr));
   }
 
-  // ── Arithmetic ────────────────────────────────────────────────────────
+  template <typename TargetScale,
+            std::enable_if_t<is_scale_v<TargetScale> && (std::is_same_v<S, scale::UT1> ||
+                                                         std::is_same_v<TargetScale, scale::UT1>),
+                             int> = 0>
+  Time<TargetScale> to() const = delete;
+
+  template <typename TargetScale, std::enable_if_t<is_scale_v<TargetScale>, int> = 0>
+  Time<TargetScale> to_with(const TimeContext &ctx) const {
+    return Time<TargetScale>(detail::scale_convert<S, TargetScale>(raw_, ctx.get()));
+  }
 
-  /**
-   * @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 {
-    qtty_quantity_t qty{delta.value(), qtty::UnitTraits<Q>::unit_id()};
-    double result;
-    TimeScaleTraits<S>::add_qty(m_days, qty, result);
-    return Time(result);
+  template <typename TargetFormat, std::enable_if_t<is_format_v<TargetFormat>, int> = 0>
+  EncodedTime<S, TargetFormat> to() const {
+    return EncodedTime<S, TargetFormat>(detail::quantity_from_raw<TargetFormat>(
+        detail::encode_time<S, TargetFormat>(raw_, nullptr)));
   }
 
-  /**
-   * @brief Retreat by a typed time quantity.
-   */
-  template <typename Q> Time operator-(const qtty::Quantity<Q> &delta) const {
-    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);
+  template <typename TargetFormat, std::enable_if_t<is_format_v<TargetFormat>, int> = 0>
+  EncodedTime<S, TargetFormat> to_with(const TimeContext &ctx) const {
+    return EncodedTime<S, TargetFormat>(detail::quantity_from_raw<TargetFormat>(
+        detail::encode_time<S, TargetFormat>(raw_, ctx.get())));
   }
 
-  /**
-   * @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 {
-    auto qty = TimeScaleTraits<S>::difference_qty(m_days, other.m_days);
-    return qtty::Day(qty.value);
+  template <typename TargetScale, std::enable_if_t<is_scale_v<TargetScale>, int> = 0>
+  std::optional<Time<TargetScale>> try_to() const {
+    try {
+      return to_with<TargetScale>(TimeContext());
+    } catch (const std::exception &) {
+      return std::nullopt;
+    }
   }
 
-  // ── Comparisons ───────────────────────────────────────────────────────
+  template <typename TargetFormat, std::enable_if_t<is_format_v<TargetFormat>, int> = 0>
+  std::optional<EncodedTime<S, TargetFormat>> try_to() const {
+    try {
+      return to_with<TargetFormat>(TimeContext());
+    } catch (const std::exception &) {
+      return std::nullopt;
+    }
+  }
 
-  bool operator==(const Time &o) const noexcept { return m_days == o.m_days; }
-  bool operator!=(const Time &o) const noexcept { return m_days != o.m_days; }
-  bool operator<(const Time &o) const noexcept { return m_days < o.m_days; }
-  bool operator<=(const Time &o) const noexcept { return m_days <= o.m_days; }
-  bool operator>(const Time &o) const noexcept { return m_days > o.m_days; }
-  bool operator>=(const Time &o) const noexcept { return m_days >= o.m_days; }
+  template <typename Q> Time operator+(const Q &delta) const {
+    return Time(detail::add_seconds(raw_, delta));
+  }
 
-  // ── JD-only extras (SFINAE-guarded) ───────────────────────────────────
+  template <typename Q> Time operator-(const Q &delta) const { return *this + Q(-delta.value()); }
 
-  /// J2000.0 epoch (JD 2 451 545.0).  Only available for `Time<scales::JD>`.
-  template <typename U = S> static std::enable_if_t<std::is_same_v<U, scales::JD>, Time> J2000() {
-    return Time(TimeScaleTraits<scales::JD>::j2000());
+  qtty::Second operator-(const Time &other) const {
+    return detail::difference_seconds(raw_, other.raw_);
   }
 
-  /// Julian centuries since J2000.  Only available for `Time<scales::JD>`.
-  template <typename U = S>
-  std::enable_if_t<std::is_same_v<U, scales::JD>, double> julian_centuries() const {
-    return TimeScaleTraits<scales::JD>::julian_centuries(m_days);
+  bool operator==(const Time &other) const noexcept {
+    return raw_.hi_seconds == other.raw_.hi_seconds && raw_.lo_seconds == other.raw_.lo_seconds;
   }
 
-  /// Julian centuries since J2000 as a typed quantity.
-  /// Only for `Time<scales::JD>`.
-  template <typename U = S>
-  std::enable_if_t<std::is_same_v<U, scales::JD>, qtty::JulianCentury>
-  julian_centuries_qty() const {
-    auto qty = TimeScaleTraits<scales::JD>::julian_centuries_qty(m_days);
-    return qtty::JulianCentury(qty.value);
+  bool operator!=(const Time &other) const noexcept { return !(*this == other); }
+
+  bool operator<(const Time &other) const noexcept {
+    return raw_.hi_seconds < other.raw_.hi_seconds ||
+           (raw_.hi_seconds == other.raw_.hi_seconds && raw_.lo_seconds < other.raw_.lo_seconds);
   }
 
-  // ── JD ↔ MJD convenience (preserves old API surface) ──────────────────
+  bool operator<=(const Time &other) const noexcept { return !(other < *this); }
+  bool operator>(const Time &other) const noexcept { return other < *this; }
+  bool operator>=(const Time &other) const noexcept { return !(*this < other); }
+};
+
+template <typename S> inline std::ostream &operator<<(std::ostream &os, const Time<S> &time) {
+  return os << Time<S>::label() << " " << time.total_seconds().value() << " s";
+}
+
+/**
+ * @brief A typed external encoding of a time instant on scale @p S.
+ */
+template <typename S, typename F> class EncodedTime {
+  static_assert(is_scale_v<S>, "EncodedTime<S, F> requires a valid tempoch::scale tag");
+  static_assert(is_format_v<F>, "EncodedTime<S, F> requires a valid tempoch::format tag");
+
+public:
+  using scale_type = S;
+  using format_type = F;
+  using quantity_type = typename FormatTraits<F>::quantity_type;
 
-  /// Convert to MJD double.  Only available for `Time<scales::JD>`.
-  template <typename U = S> std::enable_if_t<std::is_same_v<U, scales::JD>, double> to_mjd() const {
-    return TimeConvertTraits<scales::JD, scales::MJD>::convert(m_days);
+private:
+  quantity_type raw_;
+
+public:
+  EncodedTime() : raw_(0.0) {}
+
+  explicit EncodedTime(quantity_type raw) : raw_(raw) {
+    detail::ensure_finite_encoded<F>(raw_.value(), "EncodedTime::EncodedTime");
   }
 
-  /// Create from a JulianDate.  Only available for `Time<scales::MJD>`.
-  template <typename U = S>
-  static std::enable_if_t<std::is_same_v<U, scales::MJD>, Time>
-  from_jd(const Time<scales::JD> &jd) {
-    return Time(TimeConvertTraits<scales::JD, scales::MJD>::convert(jd.value()));
+  explicit EncodedTime(double value) : EncodedTime(quantity_type(value)) {}
+
+  static std::optional<EncodedTime> try_new(quantity_type raw) {
+    if (!std::isfinite(raw.value()))
+      return std::nullopt;
+    return EncodedTime(raw);
   }
 
-  /// Convert to JulianDate.  Only available for `Time<scales::MJD>`.
-  template <typename U = S>
-  std::enable_if_t<std::is_same_v<U, scales::MJD>, Time<scales::JD>> to_jd() const {
-    return Time<scales::JD>(TimeConvertTraits<scales::MJD, scales::JD>::convert(m_days));
-  }
+  static EncodedTime from_raw_unchecked(quantity_type raw) { return EncodedTime(raw); }
 
-  // ── UT-only extras (SFINAE-guarded) ───────────────────────────────────
+  quantity_type raw() const noexcept { return raw_; }
+  quantity_type quantity() const noexcept { return raw_; }
+  double value() const noexcept { return raw_.value(); }
 
-  /// ΔT = TT − UT1 in seconds.  Only available for `Time<scales::UT>`.
-  template <typename U = S>
-  std::enable_if_t<std::is_same_v<U, scales::UT>, qtty::Second> delta_t() const {
-    double jd = TimeConvertTraits<scales::UT, scales::JD>::convert(m_days);
-    double seconds = 0.0;
-    check_status(tempoch_delta_t_seconds_checked(jd, &seconds), "tempoch_delta_t_seconds_checked");
-    return qtty::Second(seconds);
+  template <typename U = F, std::enable_if_t<std::is_same_v<U, format::JD>, int> = 0>
+  static EncodedTime J2000() {
+    return EncodedTime(tempoch_const_j2000_jd_tt());
   }
-};
 
-// ============================================================================
-// operator<<  —  streams "<label>:<value>"
-// ============================================================================
+  Time<S> to_time() const { return Time<S>(detail::decode_time<S, F>(raw_.value(), nullptr)); }
 
-template <typename S> inline std::ostream &operator<<(std::ostream &os, const Time<S> &t) {
-  return os << t.value();
-}
+  Time<S> to_time_with(const TimeContext &ctx) const {
+    return Time<S>(detail::decode_time<S, F>(raw_.value(), ctx.get()));
+  }
 
-// ============================================================================
-// TimeTraits<Time<S>>  —  connects Time<S> to Period<T>
-// ============================================================================
+  template <typename TargetScale, std::enable_if_t<is_scale_v<TargetScale>, int> = 0>
+  auto to() const -> decltype(this->to_time().template to<TargetScale>()) {
+    return to_time().template to<TargetScale>();
+  }
 
-// Forward declaration — full Period template lives in period.hpp.
-template <typename T> struct TimeTraits;
+  template <typename TargetScale, std::enable_if_t<is_scale_v<TargetScale>, int> = 0>
+  Time<TargetScale> to_with(const TimeContext &ctx) const {
+    return to_time_with(ctx).template to_with<TargetScale>(ctx);
+  }
+
+  template <typename TargetFormat, std::enable_if_t<is_format_v<TargetFormat>, int> = 0>
+  EncodedTime<S, TargetFormat> to() const {
+    return to_time().template to<TargetFormat>();
+  }
 
-/// 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, scales::MJD> || std::is_same_v<S, scales::UTC>) {
-      return t.value();
-    } else {
-      return t.template to<scales::MJD>().value();
+  template <typename TargetFormat, std::enable_if_t<is_format_v<TargetFormat>, int> = 0>
+  EncodedTime<S, TargetFormat> to_with(const TimeContext &ctx) const {
+    return to_time_with(ctx).template to_with<TargetFormat>(ctx);
+  }
+
+  template <typename TargetScale, std::enable_if_t<is_scale_v<TargetScale>, int> = 0>
+  std::optional<Time<TargetScale>> try_to() const {
+    try {
+      return to_with<TargetScale>(TimeContext());
+    } catch (const std::exception &) {
+      return std::nullopt;
     }
   }
 
-  static Time<S> from_mjd_value(double mjd) {
-    if constexpr (std::is_same_v<S, scales::MJD> || std::is_same_v<S, scales::UTC>) {
-      return Time<S>(mjd);
-    } else {
-      return Time<scales::MJD>(mjd).template to<S>();
+  template <typename TargetFormat, std::enable_if_t<is_format_v<TargetFormat>, int> = 0>
+  std::optional<EncodedTime<S, TargetFormat>> try_to() const {
+    try {
+      return to_with<TargetFormat>(TimeContext());
+    } catch (const std::exception &) {
+      return std::nullopt;
     }
   }
-};
 
-// ============================================================================
-// Backward-compatible alias
-// ============================================================================
+  template <typename Q> EncodedTime operator+(const Q &delta) const {
+    return (to_time() + delta).template to<F>();
+  }
+
+  template <typename Q> EncodedTime operator-(const Q &delta) const {
+    return (to_time() - delta).template to<F>();
+  }
 
-/// Old name kept for source compatibility.
-using UTC = CivilTime;
+  quantity_type operator-(const EncodedTime &other) const {
+    return (to_time() - other.to_time()).template to<quantity_type>();
+  }
+
+  bool operator==(const EncodedTime &other) const noexcept { return raw_ == other.raw_; }
+  bool operator!=(const EncodedTime &other) const noexcept { return raw_ != other.raw_; }
+  bool operator<(const EncodedTime &other) const noexcept { return raw_ < other.raw_; }
+  bool operator<=(const EncodedTime &other) const noexcept { return raw_ <= other.raw_; }
+  bool operator>(const EncodedTime &other) const noexcept { return raw_ > other.raw_; }
+  bool operator>=(const EncodedTime &other) const noexcept { return raw_ >= other.raw_; }
+};
+
+template <typename S, typename F>
+inline std::ostream &operator<<(std::ostream &os, const EncodedTime<S, F> &time) {
+  return os << time.value();
+}
 
 } // namespace tempoch
diff --git a/qtty-cpp b/qtty-cpp
index 8fba41b..594f41c 160000
--- a/qtty-cpp
+++ b/qtty-cpp
@@ -1 +1 @@
-Subproject commit 8fba41b4e3e19da31ed3e2461d35929b8cfd0789
+Subproject commit 594f41ce2269c6a446efa0be0ac83b31a95f177c
diff --git a/tempoch b/tempoch
index dfd2abf..39abd9b 160000
--- a/tempoch
+++ b/tempoch
@@ -1 +1 @@
-Subproject commit dfd2abf5d30176f24b0fb4dc4bff63177c3274d9
+Subproject commit 39abd9bd7a9163227bbb06517d03b9d74d43c1ab
diff --git a/tests/test_period.cpp b/tests/test_period.cpp
index 0affeb9..44a6ee4 100644
--- a/tests/test_period.cpp
+++ b/tests/test_period.cpp
@@ -1,75 +1,34 @@
 #include <gtest/gtest.h>
-#include <qtty/qtty.hpp>
 #include <tempoch/tempoch.hpp>
 
 using namespace tempoch;
 
-// ============================================================================
-// Period
-// ============================================================================
+TEST(Period, GenericMjdTtDuration) {
+  using MjdTt = ModifiedJulianDate<scale::TT>;
 
-TEST(Period, Duration) {
-  Period p(MJD(60200.0), MJD(60201.0));
-  EXPECT_NEAR(p.duration().value(), 1.0, 1e-10);
+  Period<MjdTt> period(MjdTt(60200.0), MjdTt(60201.5));
+  EXPECT_NEAR(period.duration().value(), 1.5, 1e-12);
+  EXPECT_NEAR(period.duration<qtty::Hour>().value(), 36.0, 1e-9);
 }
 
-TEST(Period, DurationInSeconds) {
-  Period p(MJD(60200.0), MJD(60201.0)); // 1 day
-  EXPECT_NEAR(p.duration<qtty::Second>().value(), 86400.0, 1e-6);
-}
-
-TEST(Period, DurationInHours) {
-  Period p(MJD(60200.0), MJD(60201.0)); // 1 day = 24 hours
-  EXPECT_NEAR(p.duration<qtty::Hour>().value(), 24.0, 1e-10);
-}
+TEST(Period, IntersectionPreservesType) {
+  using MjdTt = ModifiedJulianDate<scale::TT>;
 
-TEST(Period, StartEnd) {
-  Period p(MJD(60200.0), MJD(60201.0));
-  EXPECT_NEAR(p.start().value(), 60200.0, 1e-10);
-  EXPECT_NEAR(p.end().value(), 60201.0, 1e-10);
-}
+  Period<MjdTt> a(MjdTt(60200.0), MjdTt(60202.0));
+  Period<MjdTt> b(MjdTt(60201.0), MjdTt(60203.0));
+  auto overlap = a.intersection(b);
 
-TEST(Period, FromMJD) {
-  MJD s(60200.0);
-  MJD e(60201.0);
-  Period p(s, e);
-  EXPECT_NEAR(p.duration().value(), 1.0, 1e-10);
+  EXPECT_NEAR(overlap.start().value(), 60201.0, 1e-12);
+  EXPECT_NEAR(overlap.end().value(), 60202.0, 1e-12);
 }
 
-TEST(Period, Intersection) {
-  Period a(MJD(60200.0), MJD(60202.0));
-  Period b(MJD(60201.0), MJD(60203.0));
-  auto c = a.intersection(b);
-  EXPECT_NEAR(c.start().value(), 60201.0, 1e-10);
-  EXPECT_NEAR(c.end().value(), 60202.0, 1e-10);
-}
-
-TEST(Period, NoIntersectionThrows) {
-  Period a(MJD(60200.0), MJD(60201.0));
-  Period b(MJD(60202.0), MJD(60203.0));
-  EXPECT_THROW(a.intersection(b), NoIntersectionError);
-}
-
-TEST(Period, InvalidThrows) {
-  EXPECT_THROW((Period(MJD(60203.0), MJD(60200.0))), InvalidPeriodError);
-}
-
-TEST(Period, CInner) {
-  Period p(MJD(60200.0), MJD(60201.0));
-  auto c = p.c_inner();
-  EXPECT_NEAR(c.start_mjd, 60200.0, 1e-10);
-  EXPECT_NEAR(c.end_mjd, 60201.0, 1e-10);
-}
-
-TEST(Period, FromC) {
-  tempoch_period_mjd_t c{60200.0, 60201.0};
-  auto p = Period<MJD>::from_c(c);
-  EXPECT_NEAR(p.start().value(), 60200.0, 1e-10);
-  EXPECT_NEAR(p.duration().value(), 1.0, 1e-10);
-}
+TEST(Period, CivilPeriodsUseUtcMjdRoundtrip) {
+  Period<CivilTime> period(CivilTime(2026, 1, 1, 0, 0, 0), CivilTime(2026, 1, 2, 0, 0, 0));
+  auto start = period.start();
+  auto end = period.end();
 
-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);
+  EXPECT_EQ(start.year, 2026);
+  EXPECT_EQ(start.month, 1);
+  EXPECT_EQ(start.day, 1);
+  EXPECT_EQ(end.day, 2);
 }
diff --git a/tests/test_time.cpp b/tests/test_time.cpp
index 2f01d2a..fbb9d85 100644
--- a/tests/test_time.cpp
+++ b/tests/test_time.cpp
@@ -1,193 +1,84 @@
 #include <gtest/gtest.h>
 #include <tempoch/tempoch.hpp>
 
-using namespace tempoch;
-
-// ============================================================================
-// JulianDate
-// ============================================================================
-
-TEST(Time, JulianDateJ2000) {
-  auto jd = JulianDate::J2000();
-  EXPECT_DOUBLE_EQ(jd.value(), 2451545.0);
-}
-
-TEST(Time, JulianDateFromUtc) {
-  auto jd = JulianDate::from_utc({2000, 1, 1, 12, 0, 0});
-  EXPECT_NEAR(jd.value(), 2451545.0, 0.001);
-}
-
-TEST(Time, JulianDateRoundtripUtc) {
-  UTC original(2026, 7, 15, 22, 0, 0);
-  auto jd = JulianDate::from_utc(original);
-  auto utc = jd.to_utc();
-  EXPECT_EQ(utc.year, 2026);
-  EXPECT_EQ(utc.month, 7);
-  EXPECT_EQ(utc.day, 15);
-  EXPECT_NEAR(utc.hour, 22, 1);
-}
-
-TEST(Time, JulianDateArithmetic) {
-  auto jd1 = JulianDate(2451545.0);
-  auto jd2 = jd1 + qtty::Day(365.25);
-  EXPECT_NEAR((jd2 - jd1).value(), 365.25, 1e-10);
-}
-
-TEST(Time, JulianCenturies) {
-  auto jd = JulianDate::J2000();
-  EXPECT_NEAR(jd.julian_centuries(), 0.0, 1e-10);
-}
-
-TEST(Time, JulianDateComparisons) {
-  auto a = JulianDate(2451545.0);
-  auto b = JulianDate(2451546.0);
-  EXPECT_TRUE(a < b);
-  EXPECT_TRUE(b > a);
-  EXPECT_TRUE(a <= b);
-  EXPECT_TRUE(a == JulianDate(2451545.0));
-  EXPECT_TRUE(a != b);
-}
-
-// ============================================================================
-// MJD
-// ============================================================================
+#include <type_traits>
 
-TEST(Time, MjdFromJd) {
-  auto jd = JulianDate::J2000();
-  auto mjd = MJD::from_jd(jd);
-  EXPECT_NEAR(mjd.value(), jd.to_mjd(), 1e-10);
-}
-
-TEST(Time, MjdRoundtrip) {
-  auto mjd1 = MJD(60200.0);
-  auto jd = mjd1.to_jd();
-  auto mjd2 = MJD::from_jd(jd);
-  EXPECT_NEAR(mjd1.value(), mjd2.value(), 1e-10);
-}
-
-TEST(Time, MjdFromUtc) {
-  auto mjd = MJD::from_utc({2026, 7, 15, 12, 0, 0});
-  auto utc = mjd.to_utc();
-  EXPECT_EQ(utc.year, 2026);
-  EXPECT_EQ(utc.month, 7);
-  EXPECT_EQ(utc.day, 15);
-}
-
-TEST(Time, MjdArithmetic) {
-  auto mjd1 = MJD(60200.0);
-  auto mjd2 = mjd1 + qtty::Day(1.5);
-  EXPECT_NEAR((mjd2 - mjd1).value(), 1.5, 1e-10);
-}
+using namespace tempoch;
 
-TEST(Time, MjdComparisons) {
-  auto a = MJD(60200.0);
-  auto b = MJD(60201.0);
-  EXPECT_TRUE(a < b);
-  EXPECT_TRUE(b > a);
-  EXPECT_TRUE(a <= a);
-  EXPECT_TRUE(a >= a);
-  EXPECT_TRUE(a == MJD(60200.0));
-  EXPECT_TRUE(a != b);
-}
+TEST(Time, SplitRoundtripThroughFormats) {
+  auto tt = Time<scale::TT>::from_split_seconds(qtty::Second(123456.0), qtty::Second(0.125));
 
-// ============================================================================
-// UTC
-// ============================================================================
+  auto jd = tt.to<format::JD>();
+  auto mjd = tt.to<format::MJD>();
+  auto j2000 = tt.to<format::J2000s>();
 
-TEST(Time, UtcDefaults) {
-  UTC utc;
-  EXPECT_EQ(utc.year, 2000);
-  EXPECT_EQ(utc.month, 1);
-  EXPECT_EQ(utc.day, 1);
-  EXPECT_EQ(utc.hour, 12);
-}
+  auto jd_back = jd.to_time();
+  auto mjd_back = mjd.to_time();
+  auto j2000_back = j2000.to_time();
 
-TEST(Time, UtcToCRoundtrip) {
-  UTC utc(2026, 3, 14, 9, 26, 53, 589);
-  auto c = utc.to_c();
-  auto utc2 = UTC::from_c(c);
-  EXPECT_EQ(utc2.year, 2026);
-  EXPECT_EQ(utc2.month, 3);
-  EXPECT_EQ(utc2.day, 14);
-  EXPECT_EQ(utc2.hour, 9);
-  EXPECT_EQ(utc2.minute, 26);
-  EXPECT_EQ(utc2.second, 53);
-  EXPECT_EQ(utc2.nanosecond, 589u);
+  EXPECT_NEAR((jd_back - tt).value(), 0.0, 2e-5);
+  EXPECT_NEAR((mjd_back - tt).value(), 0.0, 5e-7);
+  EXPECT_NEAR((j2000_back - tt).value(), 0.0, 1e-12);
 }
 
-// ============================================================================
-// Typed-quantity (_qty) methods
-// ============================================================================
+TEST(Time, UnixAndGpsRemainSecondFormats) {
+  auto utc = Time<scale::UTC>::from_civil({1970, 1, 1, 0, 0, 0});
+  auto unix = utc.to<format::Unix>();
+  EXPECT_NEAR(unix.value(), 9.43e-06, 1e-9);
 
-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);
-}
+  auto unix_back = unix.to_time().to_civil();
+  EXPECT_EQ(unix_back.year, 1970);
+  EXPECT_EQ(unix_back.month, 1);
+  EXPECT_EQ(unix_back.day, 1);
 
-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);
+  auto tai = utc.to<scale::TAI>();
+  auto gps = tai.to<format::GPS>();
+  auto gps_back = gps.to_time();
+  EXPECT_NEAR((gps_back - tai).value(), 0.0, 1e-9);
 }
 
-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, JulianDateTypesAreDistinct) {
+  static_assert(!std::is_same_v<JulianDate<scale::TT>, JulianDate<scale::UT1>>);
+  static_assert(!std::is_same_v<JulianDate<scale::TT>, JulianDate<scale::UTC>>);
+  static_assert(!std::is_same_v<ModifiedJulianDate<scale::TT>, ModifiedJulianDate<scale::UT1>>);
 }
 
-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, CivilUtcRoundtrip) {
+  CivilTime original(2026, 7, 15, 22, 0, 0);
+  auto utc = Time<scale::UTC>::from_civil(original);
+  auto roundtrip = utc.to_civil();
 
-TEST(Time, SubtractQuantityHours) {
-  auto jd1 = JulianDate(2451546.0);
-  auto jd2 = jd1 - qtty::Hour(12.0);
-  EXPECT_NEAR(jd2.value(), 2451545.5, 1e-10);
+  EXPECT_EQ(roundtrip.year, 2026);
+  EXPECT_EQ(roundtrip.month, 7);
+  EXPECT_EQ(roundtrip.day, 15);
+  EXPECT_EQ(roundtrip.hour, 22);
+  EXPECT_EQ(roundtrip.minute, 0);
+  EXPECT_EQ(roundtrip.second, 0);
 }
 
-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);
-}
+TEST(Time, PreDefinitionUtcRequiresOptIn) {
+  CivilTime pre_definition(1900, 1, 1, 0, 0, 0);
+  EXPECT_THROW(Time<scale::UTC>::from_civil(pre_definition), ConversionFailedError);
 
-TEST(Time, UnixTimeEpochIsZeroSeconds) {
-  auto unix = UnixTime::from_utc({1970, 1, 1, 0, 0, 0});
-  EXPECT_NEAR(unix.value(), 0.0, 1e-9);
-
-  auto utc = unix.to_utc();
-  EXPECT_EQ(utc.year, 1970);
-  EXPECT_EQ(utc.month, 1);
-  EXPECT_EQ(utc.day, 1);
-  EXPECT_EQ(utc.hour, 0);
-  EXPECT_EQ(utc.minute, 0);
-  EXPECT_EQ(utc.second, 0);
+  auto ctx = TimeContext().allow_pre_definition_utc();
+  EXPECT_NO_THROW({
+    auto utc = Time<scale::UTC>::from_civil(pre_definition, ctx);
+    auto civil = utc.to_civil(ctx);
+    EXPECT_EQ(civil.year, 1900);
+  });
 }
 
-TEST(Time, UnixTimeRoundtripThroughJd) {
-  auto unix = UnixTime::from_utc({2000, 1, 1, 12, 0, 0});
-  auto jd = unix.to<scales::JD>();
-  auto back = jd.to<scales::Unix>();
-  EXPECT_NEAR(back.value(), unix.value(), 1e-5);
+TEST(Time, Ut1HorizonErrorsSurfaceThroughContextBackedConversion) {
+  auto far_future = JulianDate<scale::TT>(2'500'000.0).to_time();
+  auto ctx = TimeContext::with_builtin_eop();
+  EXPECT_THROW((far_future.to_with<scale::UT1>(ctx)), Ut1HorizonExceededError);
 }
 
-TEST(Time, CheckStatusMapsUt1HorizonError) {
-  EXPECT_THROW(check_status(TEMPOCH_STATUS_T_UT1_HORIZON_EXCEEDED, "test"),
-               Ut1HorizonExceededError);
-}
+TEST(Time, ArithmeticIsAffineAndSecondBased) {
+  auto tt = Time<scale::TT>::from_raw_j2000_seconds(qtty::Second(10.0));
+  auto later = tt + qtty::Hour(1.0);
+  auto diff = later - tt;
 
-TEST(Time, UtDeltaTThrowsPastCompiledHorizon) {
-  UT far_future(2500000.0);
-  EXPECT_THROW(far_future.delta_t(), Ut1HorizonExceededError);
+  EXPECT_NEAR(diff.to<qtty::Second>().value(), 3600.0, 1e-9);
+  EXPECT_NEAR(tt.split_seconds().first.value(), 10.0, 1e-12);
 }