@essrt/physics 4.8.0 → 5.0.0

package/src/deltat/deep-time.cjs

@@ -36,6 +36,8 @@
 
 'use strict';
 
+const { createComposedPrecession } = require('../earth/precession-composed.cjs');
+
 /**
  * @typedef {Object} DeepTimeLodConstants
  * @property {number} lTotalEmKgm2S - Earth–Moon total angular momentum
@@ -53,6 +55,8 @@
  * @property {number} meanSiderealYearJ2000Seconds
  * @property {number} solarMassLossFracPerYear
  * @property {number} siderealYearDaysKinematicJ2000 - Actual-LOD numerator
+ * @property {number} precessionSolarShareJ2000 - f_S, the solar fraction of the J2000
+ *   precession torque (derive-params) — the unit H(t) = 13·T_p,composed needs it
  */
 
 /**
@@ -100,14 +104,51 @@ function createDeepTimeLod(deps) {
     return (s === null) ? null : s / 3600;
   }
 
-  /** H(t) via the H/13 identity: H(t) = H_J2000 · LOD(t)/LOD_J2000.
+  /** The FROZEN ERA CLOCK's phase convention: H_era(t) = H_J2000 · LOD(t)/LOD_J2000
+   * (pure spin scaling — the pre-Phase-3 "H/13 identity"). The frozen devices
+   * (the cardinal era clock, the year-length comb family, the ∫dt/H phase
+   * table) were fitted against THIS counter; it ships with their coefficients
+   * as a named device constant (plan 06 D8: two named counters). It is NOT
+   * the unit H(t) below.
    * @param {number} t_Ma @returns {number|null} */
-  function hAtAge(t_Ma) {
+  function eraClockHAtAge(t_Ma) {
     const LOD_s = lodSecondsAtAge(t_Ma);
     if (LOD_s === null) return null;
     return K.holisticYearJ2000 * LOD_s / K.lodNowH13Seconds;
   }
 
+  // The unit H(t) ≡ 13 × the composed lunisolar precession period (plan 06
+  // D6 → Phase 3): ψ̇(t) = [ω(t)/ω₀]·p₀·[f_S + (1 − f_S)(a₀/a_M(t))³], p₀ =
+  // 1,296,000/(H₀/13). ONE formula home: earth/precession-composed, built
+  // here on this factory's own LOD and recession history.
+  const composed = createComposedPrecession({
+    p0ArcsecPerYr: 1296000 / (K.holisticYearJ2000 / 13),
+    solarShare: K.precessionSolarShareJ2000,
+    lodSecondsAtAge,
+    lodJ2000Seconds: K.lodNowH13Seconds,
+    moonDistanceMetresAtAge: deps.moonDistanceMetresAtAge,
+    moonDistanceJ2000Metres: K.aMoonNowMetres,
+    yearToTMa: /** @param {number} year */ (year) => (2000 - year) / 1e6,
+  });
+
+  /** The unit H(t) = 13·T_p,composed(t) — H is 13 lunisolar precession periods
+   * at every epoch (plan 06: H is a UNIT). Written as H_era / [f_S + (1 − f_S)
+   * (a₀/a_M)³] — algebraically 13·1,296,000/ψ̇_composed, spelled in the SAME
+   * operations as layer0's holisticHCore so the layer0 gate holds the twins
+   * bit-identical (13·T_p differs by one ULP). ≡ H_era wherever (a₀/a_M)³ ≈ 1.
+   * @param {number} t_Ma @returns {number|null} */
+  function hAtAge(t_Ma) {
+    const hEra = eraClockHAtAge(t_Ma);
+    const term = composed.torqueTermAtAge(t_Ma);
+    return hEra === null || term === null ? null : hEra / term;
+  }
+
+  /** The composed lunisolar precession rate, ″/yr (= 1,296,000·13/H(t)).
+   * @param {number} t_Ma @returns {number|null} */
+  function lunisolarPrecessionRateArcsecPerYrAtAge(t_Ma) {
+    return composed.composedRateArcsecPerYrAtAge(t_Ma);
+  }
+
   /** Sidereal year seconds (Kepler under linear mass loss, dT/T = −2 dM/M).
    * @param {number} t_Ma @returns {number} */
   function siderealYearSecondsAtAge(t_Ma) {
@@ -145,6 +186,26 @@ function createDeepTimeLod(deps) {
     return tropicalYearSecondsAtAge(t_Ma) / LOD_s;
   }
 
+  // ── The frozen era clock's twins (device tier) ──────────────────────────
+  // The same forms on H_era — the bases the frozen cardinal clock (its drift
+  // integrand and real-LOD convention) and the year-length comb family were
+  // fitted against. Bit-identical to the pre-Phase-3 tropicalYearSecondsAtAge /
+  // yearInDaysAtAge; the physical (unit) forms above are what the model
+  // publishes.
+  /** @param {number} t_Ma @returns {number} */
+  function eraClockTropicalYearSecondsAtAge(t_Ma) {
+    const sidSec = siderealYearSecondsAtAge(t_Ma);
+    const Ht = eraClockHAtAge(t_Ma);
+    if (Ht === null) return sidSec * (1 - 13 / K.holisticYearJ2000);
+    return sidSec * (1 - 13 / Ht);
+  }
+  /** @param {number} t_Ma @returns {number|null} */
+  function eraClockYearInDaysAtAge(t_Ma) {
+    const LOD_s = lodSecondsAtAge(t_Ma);
+    if (LOD_s === null) return null;
+    return eraClockTropicalYearSecondsAtAge(t_Ma) / LOD_s;
+  }
+
   /**
    * RAW ΔT integral relative to J2000 (0 at t=0 by convention) — Simpson
    * over the H/5-raw kinematic LOD, WITHOUT the cycle corrections and
@@ -270,9 +331,15 @@ function createDeepTimeLod(deps) {
 
   return {
     lodSecondsAtAge, lodSecondsAtAgeWithAlpha, lodHoursAtAge, hAtAge,
+    lunisolarPrecessionRateArcsecPerYrAtAge,
+    // the composition's terms (plan 06 Phase 3 S3, the lunisolar surface): (a₀/a_M)³ and f_S + (1 − f_S)(a₀/a_M)³
+    lunarTorqueFactorAtAge: composed.lunarTorqueFactorAtAge,
+    precessionTorqueTermAtAge: composed.torqueTermAtAge,
     siderealYearSecondsAtAge, tropicalYearSecondsAtAge, tropicalYearDaysAtAge,
     yearInDaysAtAge, deltaTRawSecondsAtAge, lodSecondsWithCorrectionsAtAge,
     lodSecondsActualAtAge, dLodDtDecompositionAtAge,
+    // the frozen era clock's named counter and bases (device tier, plan 06 D8)
+    eraClockHAtAge, eraClockTropicalYearSecondsAtAge, eraClockYearInDaysAtAge,
   };
 }
 

package/src/earth/deep-orbital-history.cjs

@@ -191,11 +191,12 @@ function createDeepOrbitalHistory({
   const ALPHA = psiDot / Math.cos(EPS0);
   // D1-revised (plan 02, owner 2026-09-13): when the injecting engine
   // supplies its epoch-aware axial-precession evaluator, α follows the
-  // model's own H(t) recession history — α(t) = ψ̇(t)/cos ε₀ — and the
-  // integrated deep-time obliquity IS the sharpened falsification-leg-1
-  // form (the beat 2π/(ψ̇(t) − |s₃|), p H-scaled, s₃ dynamical). No new
-  // constants: ψ̇(t) comes from the same certified year-length machinery
-  // as the J2000 anchor. Absent the option, α stays constant (the
+  // model's own deep-time rate — α(t) = ψ̇(t)/cos ε₀ — and the integrated
+  // deep-time obliquity IS the sharpened falsification-leg-1 form (the
+  // beat 2π/(ψ̇(t) − |s₃|), ψ̇ the COMPOSED lunisolar rate the injecting
+  // engines build from earth/precession-composed (plan 06 D6), s₃
+  // dynamical). No new constants: ψ̇(t)'s J2000 anchor is the same
+  // certified year-length machinery; only its deep-time scaling is injected. Absent the option, α stays constant (the
   // pre-D1 ±Myr-class behavior, bit-identical).
   const alphaAtGeneral = axialPrecessionYearsAtYearFn
     ? (/** @type {number} */ t) =>

package/src/earth/precession-composed.cjs

@@ -0,0 +1,120 @@
+/**
+ * The composed lunisolar precession rate — ONE home (holisticuniverse plan 06,
+ * D6: the physical ψ̇(t) of falsification leg 1).
+ *
+ * Earth's axial precession rate is the two tiers composed: the spin ω(t) from
+ * the tidal chain (LOD history) carries BOTH torques, and the lunar torque
+ * additionally grows with the recession history as (a₀/a_M(t))³:
+ *
+ *   ψ̇(t) = [ω(t)/ω₀] · p₀ · [ f_S + (1 − f_S) · (a₀/a_M(t))³ ]
+ *
+ * with p₀ the J2000 rate and f_S the solar fraction of the J2000 torque,
+ * derived from the shared constants (two-body point-mass torques with the
+ * (1 − e²)^(−3/2) eccentricity factors and the lunar-inclination factor
+ * 1 − 3/2·sin² i_M; ≈ 0.316, the textbook value). At J2000 every factor is 1.
+ * Plan 06 Phase 3: the unit H(t) IS 13 of these periods at every epoch
+ * (deltat/deep-time.cjs hAtAge builds on this factory), so H(t)/13 and the
+ * composed period are one quantity. The pre-Phase-3 structural clock
+ * 13·1,296,000/H_era(t) (pure ω-scaling, H_era = H₀·LOD/LOD₀) survives only
+ * as the FROZEN ERA CLOCK's named phase convention (eraClockHAtAge) and in
+ * docs/retired-record.md, with its record: it read 70.9 ″/yr against
+ * Lantink et al. 2022's 108.6 ± 8.5 at 2.46 Ga and 65.2 against Meyers &
+ * Malinverno 2018's 85.79 ± 2.72 at 1.4 Ga, where the composed rate reads
+ * 104.5 and 86.5.
+ *
+ * Pure factory: the tidal chain is injected (each runtime's own LOD and
+ * moon-distance evaluators), no artifact reads, no globals.
+ */
+
+'use strict';
+
+const D2R = Math.PI / 180;
+
+/**
+ * Solar fraction of the J2000 precession torque from the shared constants.
+ * @param {{
+ *   gmSunKm3S2: number, auKm: number, earthEccentricity: number,
+ *   gmMoonKm3S2: number, moonDistanceKm: number, moonEccentricity: number, moonInclinationDeg: number,
+ * }} c
+ * @returns {number} f_S in [0, 1]
+ */
+function computeSolarTorqueShare(c) {
+  const sol = (c.gmSunKm3S2 / c.auKm ** 3) * Math.pow(1 - c.earthEccentricity * c.earthEccentricity, -1.5);
+  const lun = (c.gmMoonKm3S2 / c.moonDistanceKm ** 3) * Math.pow(1 - c.moonEccentricity * c.moonEccentricity, -1.5)
+    * (1 - 1.5 * Math.sin(c.moonInclinationDeg * D2R) ** 2);
+  return sol / (sol + lun);
+}
+
+/**
+ * @param {{
+ *   p0ArcsecPerYr: number,
+ *   solarShare: number,
+ *   lodSecondsAtAge: (tMa: number) => (number | null),
+ *   lodJ2000Seconds: number,
+ *   moonDistanceMetresAtAge: (tMa: number) => (number | null),
+ *   moonDistanceJ2000Metres: number,
+ *   yearToTMa: (year: number) => number,
+ * }} deps - p0 = 1,296,000/(H/13) (the model's J2000 rate); lodJ2000Seconds
+ *   the SAME day basis lodSecondsAtAge(0) returns.
+ * @returns {{
+ *   composedRateArcsecPerYrAtAge: (tMa: number) => (number | null),
+ *   composedPeriodYearsAtAge: (tMa: number) => (number | null),
+ *   composedRateArcsecPerYrAtYear: (year: number) => (number | null),
+ *   composedPeriodYearsAtYear: (year: number) => (number | null),
+ *   composedRateRatioAtAge: (tMa: number) => (number | null),
+ *   torqueTermAtAge: (tMa: number) => (number | null),
+ *   lunarTorqueFactorAtAge: (tMa: number) => (number | null),
+ *   solarShare: number,
+ *   p0ArcsecPerYr: number,
+ * }}
+ */
+function createComposedPrecession(deps) {
+  const { p0ArcsecPerYr: p0, solarShare: fS } = deps;
+  /** @param {number} tMa */
+  const lunarTorqueFactorAtAge = (tMa) => {
+    const a = deps.moonDistanceMetresAtAge(tMa);
+    return a === null || !(a > 0) ? null : Math.pow(deps.moonDistanceJ2000Metres / a, 3);
+  };
+  /** The torque term f_S + (1 − f_S)·(a₀/a_M)³ — the factor the unit H(t)
+   * divides the spin-scaled H_era by (deltat/deep-time.cjs; layer0 spells the
+   * SAME operations, the layer0 gate holds them bit-identical).
+   * @param {number} tMa */
+  const torqueTermAtAge = (tMa) => {
+    const lf = lunarTorqueFactorAtAge(tMa);
+    return lf === null ? null : fS + (1 - fS) * lf;
+  };
+  /** @param {number} tMa */
+  const composedRateArcsecPerYrAtAge = (tMa) => {
+    const lod = deps.lodSecondsAtAge(tMa);
+    const term = torqueTermAtAge(tMa);
+    if (lod === null || !(lod > 0) || term === null) return null;
+    return (deps.lodJ2000Seconds / lod) * p0 * term;
+  };
+  /** @param {number} tMa */
+  const composedPeriodYearsAtAge = (tMa) => {
+    const r = composedRateArcsecPerYrAtAge(tMa);
+    return r === null ? null : 1296000 / r;
+  };
+  /** ψ̇(t)/ψ̇₀ — the factor a consumer scales ITS OWN certified J2000
+   * anchor by (the hybrids anchor on the of-date beat 25,771.4 yr, not on
+   * p₀'s 25,793; the ratio is what D6 changes, the anchor stays theirs).
+   * ≡ 1 at J2000; null out of the tidal chain's domain.
+   * @param {number} tMa */
+  const composedRateRatioAtAge = (tMa) => {
+    const r = composedRateArcsecPerYrAtAge(tMa);
+    return r === null ? null : r / p0;
+  };
+  return {
+    composedRateArcsecPerYrAtAge,
+    composedPeriodYearsAtAge,
+    composedRateArcsecPerYrAtYear: (year) => composedRateArcsecPerYrAtAge(deps.yearToTMa(year)),
+    composedPeriodYearsAtYear: (year) => composedPeriodYearsAtAge(deps.yearToTMa(year)),
+    composedRateRatioAtAge,
+    torqueTermAtAge,
+    lunarTorqueFactorAtAge,
+    solarShare: fS,
+    p0ArcsecPerYr: p0,
+  };
+}
+
+module.exports = { computeSolarTorqueShare, createComposedPrecession };

package/src/earth/year-lengths.cjs

@@ -113,4 +113,15 @@ function createYearLengths({ sampleAt, massLossSiderealSecondsAtYearFn, apsidalS
   });
 }
 
-module.exports = { createYearLengths };
+/**
+ * The published of-date window (plan 06 Phase 3 S2): inside |year − 2000| ≤
+ * this span the one-family route is THE published year-length / precession
+ * family (the banked tiers — 100-yr and 1000-yr grids, no unbounded sampler
+ * growth); beyond it the published surfaces return the unit's SECULAR mean
+ * (H(t)/13 for the precession period, the tidal-chain mean year), because the
+ * of-date wobble is unresolved there and the deep sampler grows ~0.1 s per Myr
+ * of span. A displayed rate must name its window — this is the window.
+ */
+const ONE_FAMILY_WINDOW_YEARS = 2000000;
+
+module.exports = { createYearLengths, ONE_FAMILY_WINDOW_YEARS };

package/src/index.js

@@ -138,7 +138,11 @@ export { createDeepOrbitalHistory } from './earth/deep-orbital-history.cjs';
 // D6: the sidereal-year-of-date channel (banked λ̇ ratio × the caller's mass-loss law)
 export { createSiderealYearChannel } from './earth/sidereal-year-channel.cjs';
 // S2: THE ONE of-date year-length family (years + precession beats, SI seconds)
-export { createYearLengths } from './earth/year-lengths.cjs';
+export { createYearLengths, ONE_FAMILY_WINDOW_YEARS } from './earth/year-lengths.cjs';
+// Plan 06 D6: THE ONE home of the composed lunisolar precession rate ψ̇(t)
+// (spin ω(t) × [solar torque + lunar torque on the recession history]) —
+// leg-1's physical rate; the structural H(t)/13 clock is its named diagnostic.
+export { computeSolarTorqueShare, createComposedPrecession } from './earth/precession-composed.cjs';
 export { createPredictivePrecession, calcPlanetPerihelionLongDeg } from './planets/predict.cjs';
 // L10 — the composition front door: one law set, N body records. Thin by
 // design; engines keep their direct call sites (see planets/model.cjs).
@@ -148,7 +152,7 @@ export { createDeltaTCycles } from './deltat/cycles.cjs';
 export { createDeepTimeLod } from './deltat/deep-time.cjs';
 export { createMoonRecessionHistory, createSolarChannelBudget } from './deltat/recession-history.cjs';
 export { deltaTEspenakMeeusCanonSeconds } from './deltat/historical.cjs';
-export { evalClimateL1OrbitalPermil } from './climate/l1-orbital.cjs';
+export { evalClimateL1OrbitalPermil, laggedL1Terms, createAlphaGiaChannel } from './climate/l1-orbital.cjs';
 // Phase 8.5 — eclipse geometry (single-copy: the browser had no Node twin).
 export { createEclipseFinders } from './eclipse/finders.cjs';
 // Phase 8.6 — the published reference curves (external comparison formulas

package/src/layer0/derive-params.js

@@ -9,12 +9,16 @@
  * If the two ever disagree, one of them changed and the other did not — which
  * is the exact drift mode that produced five diverging implementations.
  *
- * Pure function, imports nothing. Lives in physics so the browser and the Node
- * engine can both build Layer 0 from ONE derivation (deep-time.js keeps its
- * own inline copy only until Phase C rewrites it; until then the test is the
- * enforcement).
+ * Pure function; its only import is the torque-share derivation (plan 06
+ * Phase 3: the unit H(t) = 13·T_p,composed needs the solar fraction of the
+ * J2000 precession torque, derived ONCE here from the shared constants).
+ * Lives in physics so the browser and the Node engine can both build Layer 0
+ * from ONE derivation (deep-time.js keeps its own inline copy only until
+ * Phase C rewrites it; until then the test is the enforcement).
  */
 
+import { computeSolarTorqueShare } from '../earth/precession-composed.cjs';
+
 /**
  * @typedef {Object} RawEpochConstants
  * @property {number} solarLuminosityW          IAU 2015 nominal (W)
@@ -35,6 +39,10 @@
  * @property {number} moonDistanceKm
  * @property {number} moonOrbitalEccentricity
  * @property {number} gmEarthMoonSystemKm3S2
+ * @property {number} gmSunKm3S2                 GM☉ (km³/s²) — the solar precession torque
+ * @property {number} astronomicalUnitKm         1 AU (km)
+ * @property {number} earthOrbitalEccentricityJ2000
+ * @property {number} moonEclipticInclinationJ2000Deg
  */
 
 /**
@@ -64,6 +72,14 @@ export const deriveEpochParams = (raw) => {
     + (moonMassKg * Math.sqrt(gmEarthMoonM3S2 * moonDistanceNowM) * moonEccentricityFactor);
   const moonLockDistanceM = (totalAngularMomentumKgM2S / (moonMassKg * Math.sqrt(gmEarthMoonM3S2) * moonEccentricityFactor)) ** 2;
 
+  // The solar fraction of the J2000 precession torque (plan 06 Phase 3): the
+  // unit H(t) ≡ 13·T_p,composed = H_era(t) / [f_S + (1 − f_S)(a₀/a_M(t))³].
+  const precessionSolarShareJ2000 = computeSolarTorqueShare({
+    gmSunKm3S2: raw.gmSunKm3S2, auKm: raw.astronomicalUnitKm, earthEccentricity: raw.earthOrbitalEccentricityJ2000,
+    gmMoonKm3S2: raw.gmMoonAloneKm3S2, moonDistanceKm: raw.moonDistanceKm, moonEccentricity: raw.moonOrbitalEccentricity,
+    moonInclinationDeg: raw.moonEclipticInclinationJ2000Deg,
+  });
+
   return Object.freeze({
     epochYear: 2000,
     alpha1PerMa: raw.alpha1PerMa,
@@ -81,5 +97,6 @@ export const deriveEpochParams = (raw) => {
     lodNowH13Seconds,
     siderealYearJ2000Seconds: raw.meanSiderealYearSeconds,
     solarMassLossFracPerYear,
+    precessionSolarShareJ2000,
   });
 };

package/src/layer0/index.js

@@ -47,6 +47,7 @@
  * @property {number} lodNowH13Seconds
  * @property {number} siderealYearJ2000Seconds
  * @property {number} solarMassLossFracPerYear
+ * @property {number} precessionSolarShareJ2000  f_S, the solar fraction of the J2000 precession torque
  */
 
 /**
@@ -54,10 +55,12 @@
  * @property {(year: number) => number} tMa
  * @property {(year: number) => number} moonDistanceMetres
  * @property {(year: number) => number|null} lodSeconds
- * @property {(year: number) => number|null} holisticH
+ * @property {(year: number) => number|null} holisticH               the UNIT: 13 × the composed lunisolar precession period
  * @property {(year: number) => number} siderealYearSeconds
  * @property {(year: number) => number} tropicalYearSeconds
  * @property {(year: number) => number|null} anomalisticYearSeconds
+ * @property {(year: number) => number|null} eraClockH               the frozen era clock's phase convention H₀·LOD/LOD₀ (device tier)
+ * @property {(year: number) => number} eraClockTropicalYearSeconds  T_sid·(1 − 13/H_era) — the frozen comb family's base
  */
 
 /**
@@ -98,16 +101,35 @@ export const createEpochPrimitives = ({ params: p, alphaAtAgeMa }) => {
   };
 
   /**
-   * The Earth Fundamental Cycle. H scales with LOD — the lattice is defined by
-   * the rotation rate, so a longer day is a longer H.
+   * The frozen era clock's phase convention: H_era(t) = H₀·LOD(t)/LOD₀ —
+   * pure spin scaling. This is the counter the FROZEN devices (the cardinal
+   * era clock, the year-length comb family) were fitted against; it ships
+   * with their coefficients as a named device constant (plan 06 Phase 3,
+   * D8), never as "H(t)".
    * @param {number} t age in Ma
    * @returns {number|null} years
    */
-  const holisticHCore = (t) => {
+  const eraClockHCore = (t) => {
     const lod = lodSecondsCore(t);
     return lod === null ? null : p.holisticYearJ2000 * lod / p.lodNowH13Seconds;
   };
 
+  /**
+   * The unit H(t) ≡ 13 × the composed lunisolar precession period:
+   * H_era(t) / [f_S + (1 − f_S)·(a₀/a_M(t))³] — the spin scaling AND the
+   * lunar torque growing on the recession history (plan 06 D6/Phase 3; the
+   * formula's home is earth/precession-composed, this is its Layer-0 twin,
+   * held bit-identical to deltat/deep-time.cjs by the layer0 gate).
+   * @param {number} t age in Ma
+   * @returns {number|null} years
+   */
+  const holisticHCore = (t) => {
+    const hEra = eraClockHCore(t);
+    if (hEra === null) return null;
+    const lf = Math.pow(p.moonDistanceNowM / moonDistanceMetresCore(t), 3);
+    return hEra / (p.precessionSolarShareJ2000 + (1 - p.precessionSolarShareJ2000) * lf);
+  };
+
   /**
    * Sidereal year. Driver 2 alone — solar mass loss via Kepler, `dT/T = -2 dM/M`
    * under the adiabatic `a*M = const` coupling. Carries NO alpha and NO LOD,
@@ -159,6 +181,13 @@ export const createEpochPrimitives = ({ params: p, alphaAtAgeMa }) => {
     return sid * (H - 13) / H * H / (H - 16);
   };
 
+  /** The frozen comb family's tropical base: T_sid·(1 − 13/H_era). @param {number} t */
+  const eraClockTropicalYearSecondsCore = (t) => {
+    const sid = siderealYearSecondsCore(t);
+    const H = eraClockHCore(t);
+    return H === null ? sid * (1 - 13 / p.holisticYearJ2000) : sid * (1 - 13 / H);
+  };
+
   return Object.freeze({
     tMa,
     moonDistanceMetres: (year) => moonDistanceMetresCore(tMa(year)),
@@ -167,5 +196,7 @@ export const createEpochPrimitives = ({ params: p, alphaAtAgeMa }) => {
     siderealYearSeconds: (year) => siderealYearSecondsCore(tMa(year)),
     tropicalYearSeconds: (year) => tropicalYearSecondsCore(tMa(year)),
     anomalisticYearSeconds: (year) => anomalisticYearSecondsCore(tMa(year)),
+    eraClockH: (year) => eraClockHCore(tMa(year)),
+    eraClockTropicalYearSeconds: (year) => eraClockTropicalYearSecondsCore(tMa(year)),
   });
 };