siderust-js 0.1.0

package/tempoch-js/tempoch/README.md

@@ -0,0 +1,76 @@
+# tempoch
+
+[![Crates.io](https://img.shields.io/crates/v/tempoch.svg)](https://crates.io/crates/tempoch)
+[![Docs](https://docs.rs/tempoch/badge.svg)](https://docs.rs/tempoch)
+[![Code Quality](https://github.com/Siderust/tempoch/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/Siderust/tempoch/actions/workflows/ci.yml)
+
+Typed astronomical time primitives for Rust.
+
+`tempoch` provides:
+
+- Generic `Time<S>` instants parameterized by time-scale markers (`JD`, `MJD`, `TT`, `UT`, `TAI`, `GPS`, `UnixTime`, ...).
+- Built-in UTC conversion through `chrono`.
+- Automatic `ΔT = TT - UT` handling for the `UT` scale.
+- Generic intervals with `Interval<T>` and scale-aware alias `Period<S>`.
+- Utility operations like period intersection and complement.
+
+## Installation
+
+```toml
+[dependencies]
+tempoch = "0.3"
+```
+
+## Quick Start
+
+```rust
+use chrono::Utc;
+use tempoch::{JulianDate, MJD, Time};
+
+let now_jd = JulianDate::from_utc(Utc::now());
+let now_mjd: Time<MJD> = now_jd.to::<MJD>();
+
+println!("JD(TT): {now_jd}");
+println!("MJD(TT): {now_mjd}");
+```
+
+## Period Operations
+
+```rust
+use tempoch::{complement_within, intersect_periods, ModifiedJulianDate, Period};
+
+let outer = Period::new(ModifiedJulianDate::new(0.0), ModifiedJulianDate::new(10.0));
+let a = vec![
+    Period::new(ModifiedJulianDate::new(1.0), ModifiedJulianDate::new(4.0)),
+    Period::new(ModifiedJulianDate::new(6.0), ModifiedJulianDate::new(9.0)),
+];
+let b = vec![
+    Period::new(ModifiedJulianDate::new(2.0), ModifiedJulianDate::new(3.0)),
+    Period::new(ModifiedJulianDate::new(7.0), ModifiedJulianDate::new(8.0)),
+];
+
+let overlap = intersect_periods(&a, &b);
+let gaps = complement_within(outer, &a);
+
+assert_eq!(overlap.len(), 2);
+assert_eq!(gaps.len(), 3);
+```
+
+## Examples
+
+- `cargo run --example quickstart`
+- `cargo run --example periods`
+
+## Tests and Coverage
+
+```bash
+cargo test --all-targets
+cargo test --doc
+cargo +nightly llvm-cov --workspace --all-features --doctests --summary-only
+```
+
+Coverage is gated in CI at **>= 90% line coverage**.
+
+## License
+
+AGPL-3.0-only

package/tempoch-js/tempoch/tempoch/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "tempoch"
+version = "0.3.0"
+edition = "2021"
+authors = ["VPRamon <vallespuigramon@gmail.com>"]
+description = "Astronomical time primitives: typed time scales, Julian dates, UTC conversion, and interval operations."
+license = "AGPL-3.0-only"
+readme = "../README.md"
+repository = "https://github.com/Siderust/tempoch"
+keywords = ["astronomy", "time", "julian-date", "ephemeris", "science"]
+categories = ["science", "date-and-time"]
+
+[lib]
+name = "tempoch"
+path = "src/lib.rs"
+
+[features]
+default = []
+serde = ["tempoch-core/serde"]
+
+[dependencies]
+tempoch-core = { path = "../tempoch-core", version = "0.3.0" }
+
+[dev-dependencies]
+chrono = "0.4.44"
+qtty = "0.4.0"
+serde_json = "1.0"

package/tempoch-js/tempoch/tempoch/examples/periods.rs

@@ -0,0 +1,45 @@
+use chrono::{DateTime, Utc};
+use tempoch::{
+    complement_within, intersect_periods, Interval, ModifiedJulianDate, Period, UtcPeriod,
+};
+
+fn main() {
+    let day = Period::new(
+        ModifiedJulianDate::new(61_000.0),
+        ModifiedJulianDate::new(61_001.0),
+    );
+    let windows = vec![
+        Period::new(
+            ModifiedJulianDate::new(61_000.10),
+            ModifiedJulianDate::new(61_000.30),
+        ),
+        Period::new(
+            ModifiedJulianDate::new(61_000.60),
+            ModifiedJulianDate::new(61_000.85),
+        ),
+    ];
+
+    let gaps = complement_within(day, &windows);
+    println!("Visible windows: {}", windows.len());
+    println!("Gaps: {}", gaps.len());
+
+    let constraints = vec![
+        Period::new(
+            ModifiedJulianDate::new(61_000.00),
+            ModifiedJulianDate::new(61_000.20),
+        ),
+        Period::new(
+            ModifiedJulianDate::new(61_000.70),
+            ModifiedJulianDate::new(61_001.00),
+        ),
+    ];
+    let intersection = intersect_periods(&windows, &constraints);
+    println!("Intersection windows: {}", intersection.len());
+
+    let utc_day: UtcPeriod = day.to::<DateTime<Utc>>().unwrap();
+    let roundtrip: Interval<ModifiedJulianDate> = utc_day.to::<ModifiedJulianDate>();
+    println!(
+        "Roundtrip drift (days): {:.3e}",
+        (roundtrip.start.value() - day.start.value()).abs()
+    );
+}

package/tempoch-js/tempoch/tempoch/examples/quickstart.rs

@@ -0,0 +1,13 @@
+use chrono::Utc;
+use tempoch::{JulianDate, Time, MJD, UT};
+
+fn main() {
+    let now_jd = JulianDate::from_utc(Utc::now());
+    let now_mjd: Time<MJD> = now_jd.to::<MJD>();
+    let now_ut: Time<UT> = now_jd.to::<UT>();
+
+    println!("JD(TT): {now_jd}");
+    println!("MJD(TT): {now_mjd}");
+    println!("UT: {now_ut}");
+    println!("ΔT: {}", now_ut.delta_t());
+}

package/tempoch-js/tempoch/tempoch/src/lib.rs

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (C) 2026 Vallés Puig, Ramon
+
+//! Time Module
+//!
+//! This crate is a façade over `tempoch-core` and re-exports its public API.
+//!
+//! # Core types
+//!
+//! - [`Time<S>`] — generic instant parameterised by a [`TimeScale`] marker.
+//! - [`TimeScale`] — trait that defines a time scale (epoch offset + conversions).
+//! - [`JulianDate`] — type alias for `Time<JD>`.
+//! - [`JulianEphemerisDay`] — type alias for `Time<JDE>`.
+//! - [`ModifiedJulianDate`] — type alias for `Time<MJD>`.
+//! - [`Period<S>`] — a time interval parameterised by a [`TimeScale`] marker.
+//! - [`Interval<T>`] — a generic interval over any [`TimeInstant`].
+//! - [`TimeInstant`] — trait for points in time usable with [`Interval`].
+//!
+//! # Time scales
+//!
+//! The following markers implement [`TimeScale`]:
+//!
+//! | Marker | Scale |
+//! |--------|-------|
+//! | [`JD`] | Julian Date |
+//! | [`JDE`] | Julian Ephemeris Day |
+//! | [`MJD`] | Modified Julian Date |
+//! | [`TDB`] | Barycentric Dynamical Time |
+//! | [`TT`] | Terrestrial Time |
+//! | [`TAI`] | International Atomic Time |
+//! | [`TCG`] | Geocentric Coordinate Time |
+//! | [`TCB`] | Barycentric Coordinate Time |
+//! | [`GPS`] | GPS Time |
+//! | [`UnixTime`] | Unix / POSIX time |
+//! | [`UT`] | Universal Time (Earth rotation) |
+//!
+//! # ΔT (Delta T)
+//!
+//! The difference **ΔT = TT − UT** is applied automatically by the
+//! [`UT`] time scale.  Use `Time::<UT>::new(jd_ut)` for UT-based values,
+//! or construct any scale via `from_utc()` which routes through `UT` internally.
+//! The raw ΔT value (in seconds) is available via [`Time::<UT>::delta_t()`](Time::delta_t).
+
+pub use tempoch_core::{
+    complement_within, intersect_periods, normalize_periods, tai_minus_utc, validate_period_list,
+    ConversionError, Interval, InvalidIntervalError, JulianDate, JulianEphemerisDay,
+    ModifiedJulianDate, NonFiniteTimeError, Period, PeriodListError, Time, TimeInstant, TimeScale,
+    UniversalTime, UnixTime, UtcPeriod, GPS, JD, JDE, MJD, TAI, TCB, TCG, TDB, TT, UT,
+};

package/tempoch-js/tempoch/tempoch/tests/integration.rs

@@ -0,0 +1,57 @@
+use chrono::DateTime;
+use qtty::{Day, Days, Seconds};
+use tempoch::{complement_within, intersect_periods, JulianDate, ModifiedJulianDate, Period, UT};
+
+#[test]
+fn utc_roundtrip_j2000_is_stable() {
+    let datetime = DateTime::from_timestamp(946_728_000, 0).unwrap();
+    let jd = JulianDate::from_utc(datetime);
+    let back = jd.to_utc().expect("to_utc");
+    let delta_ns = back.timestamp_nanos_opt().unwrap() - datetime.timestamp_nanos_opt().unwrap();
+    assert!(delta_ns.abs() < 1_000);
+}
+
+#[test]
+fn ut_applies_delta_t_near_j2000() {
+    let ut = tempoch::Time::<UT>::new(2_451_545.0);
+    let jd: JulianDate = ut.to::<tempoch::JD>();
+    let offset = (jd.quantity() - ut.quantity()).to::<Day>();
+    let offset_s = offset.to::<qtty::Second>();
+    assert!((offset_s - Seconds::new(63.83)).abs() < Seconds::new(1.0));
+}
+
+#[test]
+fn period_set_ops_match_expected_intervals() {
+    let outer = Period::new(ModifiedJulianDate::new(0.0), ModifiedJulianDate::new(10.0));
+    let a = vec![
+        Period::new(ModifiedJulianDate::new(1.0), ModifiedJulianDate::new(3.0)),
+        Period::new(ModifiedJulianDate::new(5.0), ModifiedJulianDate::new(9.0)),
+    ];
+    let b = vec![
+        Period::new(ModifiedJulianDate::new(2.0), ModifiedJulianDate::new(4.0)),
+        Period::new(ModifiedJulianDate::new(7.0), ModifiedJulianDate::new(8.0)),
+    ];
+
+    let below_b = complement_within(outer, &b);
+    let between = intersect_periods(&a, &below_b);
+
+    assert_eq!(between.len(), 3);
+    assert_eq!(between[0].start.quantity(), Days::new(1.0));
+    assert_eq!(between[0].end.quantity(), Days::new(2.0));
+    assert_eq!(between[1].start.quantity(), Days::new(5.0));
+    assert_eq!(between[1].end.quantity(), Days::new(7.0));
+    assert_eq!(between[2].start.quantity(), Days::new(8.0));
+    assert_eq!(between[2].end.quantity(), Days::new(9.0));
+}
+
+#[cfg(feature = "serde")]
+#[test]
+fn serde_period_mjd_uses_legacy_field_names() {
+    let period = Period::new(
+        ModifiedJulianDate::new(59_000.25),
+        ModifiedJulianDate::new(59_000.75),
+    );
+    let json = serde_json::to_string(&period).unwrap();
+    assert!(json.contains("start_mjd"));
+    assert!(json.contains("end_mjd"));
+}

package/tempoch-js/tempoch/tempoch-core/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "tempoch-core"
+version = "0.3.0"
+edition = "2021"
+authors = ["VPRamon <vallespuigramon@gmail.com>"]
+description = "Core astronomical time primitives for tempoch."
+license = "AGPL-3.0-only"
+repository = "https://github.com/Siderust/tempoch"
+
+[features]
+default = []
+serde = ["dep:serde"]
+
+[lib]
+name = "tempoch_core"
+path = "src/lib.rs"
+
+[dependencies]
+chrono = "0.4.43"
+qtty = "0.4.0"
+serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
+
+[dev-dependencies]
+serde_json = "1.0"

package/tempoch-js/tempoch/tempoch-core/src/delta_t.rs

@@ -0,0 +1,345 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (C) 2026 Vallés Puig, Ramon
+
+//! # ΔT (Delta T) — UT↔TT Correction Layer
+//!
+//! This module implements a piecewise model for **ΔT = TT − UT** combining:
+//!
+//! * **Pre-1620**: Stephenson & Houlden (1986) quadratic approximations.
+//! * **1620–1992**: Biennial interpolation table (Meeus ch. 9).
+//! * **1992–2025**: Annual observed ΔT values from IERS/USNO (Bulletin A).
+//! * **Post-2025**: Linear extrapolation at the current observed rate
+//!   (~+0.1 s/yr), far more accurate than the Meeus quadratic formula
+//!   which diverges to ~120 s by 2020. The IERS-observed value for 2025
+//!   is ~69.36 s.
+//!
+//! ## Integration with Time Scales
+//!
+//! The correction is applied **automatically** by the [`UT`](super::UT) time
+//! scale marker.  When you convert from `Time<UT>` to any TT-based scale
+//! (`.to::<JD>()`, `.to::<MJD>()`, etc.), `UT::to_jd_tt` adds ΔT.
+//! The inverse (`UT::from_jd_tt`) uses a three-iteration fixed-point solver.
+//!
+//! [`Time::from_utc`](super::Time::from_utc) creates a `Time<UT>` internally
+//! and then converts to the target scale, so external callers get the ΔT
+//! correction without calling any function from this module.
+//!
+//! ## Quick Example
+//! ```rust
+//! # use tempoch_core as tempoch;
+//! use tempoch::{UT, JD, Time};
+//!
+//! // UT-based Julian Day -> JD(TT) with ΔT applied
+//! let ut = Time::<UT>::new(2_451_545.0);
+//! let jd_tt = ut.to::<JD>();
+//! println!("JD(TT) = {jd_tt}");
+//!
+//! // Query the raw ΔT value
+//! let dt = ut.delta_t();
+//! println!("ΔT = {dt}");
+//! ```
+//!
+//! ## Scientific References
+//! * Stephenson & Houlden (1986): *Atlas of Historical Eclipse Maps*.
+//! * Morrison & Stephenson (2004): "Historical values of the Earth's clock error".
+//! * IERS Conventions (2020): official ΔT data tables.
+//! * IERS Bulletin A (2025): observed ΔT values.
+//!
+//! ## Valid Time Range
+//! The algorithm is valid from ancient times through approximately 2035, with
+//! typical uncertainties ≤ ±2 s before 1800 CE, ≤ ±0.5 s since 1900, and
+//! ≤ ±0.1 s for 2000–2025 (observed data).
+
+use super::instant::Time;
+use super::scales::UT;
+use super::JulianDate;
+use qtty::{Days, Seconds, Simplify};
+
+/// Total number of tabulated terms (biennial 1620–1992).
+const TERMS: usize = 187;
+
+/// Biennial ΔT table from 1620 to 1992 (in seconds), compiled by J. Meeus.
+#[rustfmt::skip]
+const DELTA_T: [Seconds; TERMS] = qtty::qtty_vec!(
+    Seconds;
+    124.0,115.0,106.0, 98.0, 91.0, 85.0, 79.0, 74.0, 70.0, 65.0,
+     62.0, 58.0, 55.0, 53.0, 50.0, 48.0, 46.0, 44.0, 42.0, 40.0,
+     37.0, 35.0, 33.0, 31.0, 28.0, 26.0, 24.0, 22.0, 20.0, 18.0,
+     16.0, 14.0, 13.0, 12.0, 11.0, 10.0,  9.0,  9.0,  9.0,  9.0,
+      9.0,  9.0,  9.0,  9.0, 10.0, 10.0, 10.0, 10.0, 10.0, 11.0,
+     11.0, 11.0, 11.0, 11.0, 11.0, 11.0, 12.0, 12.0, 12.0, 12.0,
+     12.0, 12.0, 13.0, 13.0, 13.0, 13.0, 14.0, 14.0, 14.0, 15.0,
+     15.0, 15.0, 15.0, 16.0, 16.0, 16.0, 16.0, 16.0, 17.0, 17.0,
+     17.0, 17.0, 17.0, 17.0, 17.0, 17.0, 16.0, 16.0, 15.0, 14.0,
+     13.7, 13.1, 12.7, 12.5, 12.5, 12.5, 12.5, 12.5, 12.5, 12.3,
+     12.0, 11.4, 10.6,  9.6,  8.6,  7.5,  6.6,  6.0,  5.7,  5.6,
+      5.7,  5.9,  6.2,  6.5,  6.8,  7.1,  7.3,  7.5,  7.7,  7.8,
+      7.9,  7.5,  6.4,  5.4,  2.9,  1.6, -1.0, -2.7, -3.6, -4.7,
+     -5.4, -5.2, -5.5, -5.6, -5.8, -5.9, -6.2, -6.4, -6.1, -4.7,
+     -2.7,  0.0,  2.6,  5.4,  7.7, 10.5, 13.4, 16.0, 18.2, 20.2,
+     21.2, 22.4, 23.5, 23.9, 24.3, 24.0, 23.9, 23.9, 23.7, 24.0,
+     24.3, 25.3, 26.2, 27.3, 28.2, 29.1, 30.0, 30.7, 31.4, 32.2,
+     33.1, 34.0, 35.0, 36.5, 38.3, 40.2, 42.2, 44.5, 46.5, 48.5,
+     50.5, 52.2, 53.8, 54.9, 55.8, 56.9, 58.3,
+);
+
+// ------------------------------------------------------------------------------------
+// Annual observed ΔT table 1992–2025 (IERS/USNO Bulletin A)
+// ------------------------------------------------------------------------------------
+
+/// Annual ΔT values (seconds) from IERS/USNO observations, 1992.0–2025.0.
+/// Index 0 = year 1992, index 33 = year 2025.
+/// Source: IERS Bulletin A, USNO finals2000A data.
+const OBSERVED_TERMS: usize = 34;
+const OBSERVED_START_YEAR: f64 = 1992.0;
+
+#[rustfmt::skip]
+const OBSERVED_DT: [Seconds; OBSERVED_TERMS] = qtty::qtty_vec!(
+    Seconds;
+    // 1992  1993   1994   1995   1996   1997   1998   1999
+    58.31, 59.12, 59.98, 60.78, 61.63, 62.30, 62.97, 63.47,
+    // 2000  2001   2002   2003   2004   2005   2006   2007
+    63.83, 64.09, 64.30, 64.47, 64.57, 64.69, 64.85, 65.15,
+    // 2008  2009   2010   2011   2012   2013   2014   2015
+    65.46, 65.78, 66.07, 66.32, 66.60, 66.91, 67.28, 67.64,
+    // 2016  2017   2018   2019   2020   2021   2022   2023
+    68.10, 68.59, 68.97, 69.22, 69.36, 69.36, 69.29, 69.18,
+    // 2024  2025
+    69.09, 69.36,
+);
+
+/// The year after the last observed data point. Beyond this we extrapolate.
+const OBSERVED_END_YEAR: f64 = OBSERVED_START_YEAR + OBSERVED_TERMS as f64;
+
+/// Last observed ΔT rate (seconds/year). Computed from the last 5 years of
+/// observed data. The rate has been nearly flat 2019–2025 (~+0.02 s/yr).
+const EXTRAPOLATION_RATE: f64 = 0.02;
+
+// ------------------------------------------------------------------------------------
+// ΔT Approximation Sections by Time Interval
+// ------------------------------------------------------------------------------------
+
+/// **Years < 948 CE**
+/// Quadratic formula from Stephenson & Houlden (1986).
+#[inline]
+fn delta_t_ancient(jd: JulianDate) -> Seconds {
+    const DT_A0_S: Seconds = Seconds::new(1_830.0);
+    const DT_A1_S: Seconds = Seconds::new(-405.0);
+    const DT_A2_S: Seconds = Seconds::new(46.5);
+    const JD_EPOCH_948_UT: JulianDate = JulianDate::new(2_067_314.5);
+    let c = days_ratio(jd - JD_EPOCH_948_UT, JulianDate::JULIAN_CENTURY);
+    DT_A0_S + DT_A1_S * c + DT_A2_S * c * c
+}
+
+/// **Years 948–1600 CE**
+/// Second polynomial from Stephenson & Houlden (1986).
+#[inline]
+fn delta_t_medieval(jd: JulianDate) -> Seconds {
+    const JD_EPOCH_1850_UT: JulianDate = JulianDate::new(2_396_758.5);
+    const DT_A2_S: Seconds = Seconds::new(22.5);
+
+    let c = days_ratio(jd - JD_EPOCH_1850_UT, JulianDate::JULIAN_CENTURY);
+    DT_A2_S * c * c
+}
+
+/// **Years 1600–1992**
+/// Bicubic interpolation from the biennial `DELTA_T` table.
+#[inline]
+fn delta_t_table(jd: JulianDate) -> Seconds {
+    const JD_TABLE_START_1620: JulianDate = JulianDate::new(2_312_752.5);
+    const BIENNIAL_STEP_D: Days = Days::new(730.5);
+
+    let mut i = days_ratio(jd - JD_TABLE_START_1620, BIENNIAL_STEP_D) as usize;
+    if i > TERMS - 3 {
+        i = TERMS - 3;
+    }
+    let a: Seconds = DELTA_T[i + 1] - DELTA_T[i];
+    let b: Seconds = DELTA_T[i + 2] - DELTA_T[i + 1];
+    let c: Seconds = a - b;
+    let n = days_ratio(
+        jd - (JD_TABLE_START_1620 + BIENNIAL_STEP_D * i as f64),
+        BIENNIAL_STEP_D,
+    );
+    DELTA_T[i + 1] + n / 2.0 * (a + b + n * c)
+}
+
+/// **Years 1992–2026**
+/// Linear interpolation from annual IERS/USNO observed ΔT values.
+#[inline]
+fn delta_t_observed(jd: JulianDate) -> Seconds {
+    // Convert JD to fractional year
+    let year = 2000.0 + (jd - JulianDate::J2000).value() / 365.25;
+    let idx_f = year - OBSERVED_START_YEAR;
+    let idx = idx_f as usize;
+
+    if idx + 1 >= OBSERVED_TERMS {
+        // At the very end of the table, return the last value
+        return OBSERVED_DT[OBSERVED_TERMS - 1];
+    }
+
+    // Linear interpolation between annual values
+    let frac = idx_f - idx as f64;
+    OBSERVED_DT[idx] + frac * (OBSERVED_DT[idx + 1] - OBSERVED_DT[idx])
+}
+
+/// **Years > 2026**
+/// Linear extrapolation from the last observed value at the current rate.
+///
+/// The observed ΔT trend 2019–2025 is nearly flat (~+0.02 s/yr), which is
+/// far more accurate than the Meeus quadratic that predicted ~121 s for 2020
+/// vs the observed ~69.36 s.
+#[inline]
+fn delta_t_extrapolated(jd: JulianDate) -> Seconds {
+    let year = 2000.0 + (jd - JulianDate::J2000).value() / 365.25;
+    let dt_last = OBSERVED_DT[OBSERVED_TERMS - 1];
+    let years_past = year - OBSERVED_END_YEAR;
+    dt_last + Seconds::new(EXTRAPOLATION_RATE * years_past)
+}
+
+#[inline]
+fn days_ratio(num: Days, den: Days) -> f64 {
+    (num / den).simplify().value()
+}
+
+/// JD boundary: start of year 1992.0
+const JD_1992: JulianDate = JulianDate::new(2_448_622.5);
+
+/// JD boundary: start of year 2026.0
+const JD_2026: JulianDate = JulianDate::new(2_461_041.5);
+
+/// Returns **ΔT** in seconds for a Julian Day on the **UT** axis.
+#[inline]
+pub(crate) fn delta_t_seconds_from_ut(jd_ut: JulianDate) -> Seconds {
+    match jd_ut {
+        jd if jd < JulianDate::new(2_067_314.5) => delta_t_ancient(jd),
+        jd if jd < JulianDate::new(2_305_447.5) => delta_t_medieval(jd),
+        jd if jd < JD_1992 => delta_t_table(jd),
+        jd if jd < JD_2026 => delta_t_observed(jd),
+        _ => delta_t_extrapolated(jd_ut),
+    }
+}
+
+// ── Time<UT> convenience method ───────────────────────────────────────────
+
+impl Time<UT> {
+    /// Returns **ΔT = TT − UT** in seconds for this UT epoch.
+    ///
+    /// This is a convenience accessor; the same correction is applied
+    /// automatically when converting to any TT-based scale (`.to::<JD>()`).
+    #[inline]
+    pub fn delta_t(&self) -> Seconds {
+        delta_t_seconds_from_ut(JulianDate::from_days(self.quantity()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use qtty::{Day, Days};
+
+    #[test]
+    fn delta_t_ancient_sample() {
+        let dt = delta_t_seconds_from_ut(JulianDate::new(2_000_000.0));
+        assert!((dt - Seconds::new(2_734.342_214_024_879_5)).abs() < Seconds::new(1e-6));
+    }
+
+    #[test]
+    fn delta_t_medieval_sample() {
+        let dt = delta_t_seconds_from_ut(JulianDate::new(2_100_000.0));
+        assert!((dt - Seconds::new(1_485.280_240_204_242_3)).abs() < Seconds::new(1e-6));
+    }
+
+    #[test]
+    fn delta_t_table_sample() {
+        let dt = delta_t_seconds_from_ut(JulianDate::new(2_312_752.5));
+        assert!((dt - Seconds::new(115.0)).abs() < Seconds::new(1e-6));
+    }
+
+    #[test]
+    fn delta_t_table_upper_clip() {
+        let dt = delta_t_table(JulianDate::new(2_449_356.0));
+        assert!((dt - Seconds::new(59.3)).abs() < Seconds::new(1e-6));
+    }
+
+    #[test]
+    fn delta_t_2000() {
+        // IERS observed value: 63.83 s
+        let dt = delta_t_seconds_from_ut(JulianDate::J2000);
+        assert!(
+            (dt - Seconds::new(63.83)).abs() < Seconds::new(0.1),
+            "ΔT at J2000 = {dt}, expected 63.83 s"
+        );
+    }
+
+    #[test]
+    fn delta_t_2010() {
+        // IERS observed value for 2010.0: ~66.07 s
+        // JD 2455197.5 ≈ 2010-01-01
+        let dt = delta_t_seconds_from_ut(JulianDate::new(2_455_197.5));
+        assert!(
+            (dt - Seconds::new(66.07)).abs() < Seconds::new(0.5),
+            "ΔT at 2010. = {dt}, expected ~66.07 s"
+        );
+    }
+
+    #[test]
+    fn delta_t_2020() {
+        // IERS observed value for 2020.0: ~69.36 s
+        // The old Meeus extrapolation gave ~121 s here — way off.
+        // JD for 2020-01-01 ≈ 2458849.5
+        let dt = delta_t_seconds_from_ut(JulianDate::new(2_458_849.5));
+        assert!(
+            (dt - Seconds::new(69.36)).abs() < Seconds::new(0.5),
+            "ΔT at 2020.0 = {dt}, expected ~69.36 s"
+        );
+    }
+
+    #[test]
+    fn delta_t_2025() {
+        // IERS observed value for 2025.0: ~69.36 s
+        // JD for 2025-01-01 ≈ 2460676.5
+        let dt = delta_t_seconds_from_ut(JulianDate::new(2_460_676.5));
+        assert!(
+            (dt - Seconds::new(69.36)).abs() < Seconds::new(0.5),
+            "ΔT at 2025.0 = {dt}, expected ~69.36 s"
+        );
+    }
+
+    #[test]
+    fn delta_t_extrapolated_near_future() {
+        // Beyond 2026, linear extrapolation at ~0.02 s/yr
+        // At 2030.0 (4 yr past end), ΔT ≈ 69.36 + 0.02*4 ≈ 69.44
+        let jd_2030 = JulianDate::new(2_462_502.5);
+        let dt = delta_t_seconds_from_ut(jd_2030);
+        assert!(
+            (dt - Seconds::new(69.44)).abs() < Seconds::new(1.0),
+            "ΔT at 2030. = {dt}, expected ~69.44 s"
+        );
+        // Must NOT be the old ~135+ s value
+        assert!(dt < Seconds::new(75.0), "ΔT at 2030 is too large: {dt}");
+    }
+
+    #[test]
+    fn ut_scale_applies_delta_t() {
+        let ut = Time::<UT>::new(2_451_545.0);
+        let jd_tt = ut.to::<crate::JD>();
+        let offset = jd_tt - JulianDate::new(2_451_545.0);
+        let expected = delta_t_seconds_from_ut(JulianDate::new(2_451_545.0)).to::<Day>();
+        assert!((offset - expected).abs() < Days::new(1e-9));
+    }
+
+    #[test]
+    fn ut_scale_roundtrip() {
+        let jd_tt = JulianDate::new(2_451_545.0);
+        let ut: Time<UT> = jd_tt.to::<UT>();
+        let back: JulianDate = ut.to::<crate::JD>();
+        assert!((back - jd_tt).abs() < Days::new(1e-12));
+    }
+
+    #[test]
+    fn delta_t_convenience_method() {
+        let ut = Time::<UT>::new(2_451_545.0);
+        let dt = ut.delta_t();
+        assert!((dt - Seconds::new(63.83)).abs() < Seconds::new(0.5));
+    }
+}