@essrt/physics 22.1.0 → 23.2.0

package/types/earth/mass-chain.d.cts

@@ -0,0 +1,78 @@
+/**
+ * The mass chain in §9 order: Δa (the Sun's tidal coupling to the Earth–Moon
+ * barycentric wobble, leading order), the corrected Moon distance, Kepler on
+ * the Moon's orbit → G(M_E + M_M), the DE440 split → GM_E and GM_M, Kepler on
+ * Earth's orbit → G(M_☉ + M_E), the subtraction → GM_☉ and M_☉.
+ * @param {{
+ *   moonDistanceKm: number, moonSiderealMonthDays: number, meanSiderealYearDays: number,
+ *   meanLengthOfDaySeconds: number, massRatioEarthMoon: number, currentAUDistanceKm: number,
+ *   gravitationalConstantKm3KgS2: number,
+ * }} c
+ * @returns {{
+ *   meanSiderealYearSeconds: number, moonOrbitalShiftKm: number, moonDistanceCorrectedKm: number,
+ *   gmEarthMoonSystemKm3S2: number, gmEarthAloneKm3S2: number, gmMoonAloneKm3S2: number,
+ *   gmSunPlusEarthKm3S2: number, gmSunKm3S2: number, sunMassKg: number,
+ * }}
+ */
+export function computeMassChainJ2000(c: {
+    moonDistanceKm: number;
+    moonSiderealMonthDays: number;
+    meanSiderealYearDays: number;
+    meanLengthOfDaySeconds: number;
+    massRatioEarthMoon: number;
+    currentAUDistanceKm: number;
+    gravitationalConstantKm3KgS2: number;
+}): {
+    meanSiderealYearSeconds: number;
+    moonOrbitalShiftKm: number;
+    moonDistanceCorrectedKm: number;
+    gmEarthMoonSystemKm3S2: number;
+    gmEarthAloneKm3S2: number;
+    gmMoonAloneKm3S2: number;
+    gmSunPlusEarthKm3S2: number;
+    gmSunKm3S2: number;
+    sunMassKg: number;
+};
+/**
+ * The Moon's J2000 periods on the IAU inputs. The two precession inputs are
+ * equinox-OF-DATE observables (3231.50 d / 6798.38 d; the legacy "ICRF" name
+ * is kept); the star-referenced periods remove the equinox's own precession,
+ * 1/T_E = 1/T_I ∓ 1/T_p (the perigee advances, the node regresses), T_p the
+ * J2000 precession anchor in days. The months follow kinematically.
+ * @param {{
+ *   moonSiderealMonthDays: number, moonApsidalPrecessionDaysInput: number, moonNodalPrecessionDaysInput: number,
+ *   axialPrecessionJ2000Days: number, meanSiderealYearDays: number, meanSolarYearDays: number,
+ * }} c
+ * @returns {{
+ *   moonApsidalPrecessionDaysEarth: number, moonNodalPrecessionDaysEarth: number,
+ *   moonApsidalJ2000Seconds: number, moonNodalJ2000Seconds: number, moonSiderealMonthJ2000Seconds: number,
+ *   moonAnomalisticMonthDays: number, moonNodalMonthDays: number, moonSynodicMonthDays: number, moonTropicalMonthDays: number,
+ *   moonFullMoonCycleEarthDays: number, moonFullMoonCycleICRFDays: number,
+ *   moonApsidalMeetsNodalDays: number, moonLunarLevelingCycleDays: number,
+ *   moonDraconicYearICRFDays: number, moonDraconicYearEarthDays: number,
+ * }}
+ */
+export function computeMoonPeriodsJ2000(c: {
+    moonSiderealMonthDays: number;
+    moonApsidalPrecessionDaysInput: number;
+    moonNodalPrecessionDaysInput: number;
+    axialPrecessionJ2000Days: number;
+    meanSiderealYearDays: number;
+    meanSolarYearDays: number;
+}): {
+    moonApsidalPrecessionDaysEarth: number;
+    moonNodalPrecessionDaysEarth: number;
+    moonApsidalJ2000Seconds: number;
+    moonNodalJ2000Seconds: number;
+    moonSiderealMonthJ2000Seconds: number;
+    moonAnomalisticMonthDays: number;
+    moonNodalMonthDays: number;
+    moonSynodicMonthDays: number;
+    moonTropicalMonthDays: number;
+    moonFullMoonCycleEarthDays: number;
+    moonFullMoonCycleICRFDays: number;
+    moonApsidalMeetsNodalDays: number;
+    moonLunarLevelingCycleDays: number;
+    moonDraconicYearICRFDays: number;
+    moonDraconicYearEarthDays: number;
+};

package/types/earth/mean-obliquity-history.d.cts

@@ -0,0 +1,32 @@
+export type MeanObliquityTable = {
+    /**
+     * - ascending, 0 first, uniform 1-Myr step
+     */
+    ageMa: ReadonlyArray<number>;
+    /**
+     * - the cited mean obliquity column, degrees
+     */
+    obliquityDeg: ReadonlyArray<number>;
+};
+/**
+ * @typedef {Object} MeanObliquityTable
+ * @property {ReadonlyArray<number>} ageMa - ascending, 0 first, uniform 1-Myr step
+ * @property {ReadonlyArray<number>} obliquityDeg - the cited mean obliquity column, degrees
+ */
+/**
+ * @param {{ table: MeanObliquityTable }} deps
+ * @returns {{
+ *   meanObliquityDegAtAge: (tMa: number) => number|null,
+ *   cosRatioAtAge: (tMa: number) => number|null,
+ *   meanObliquityJ2000Deg: number,
+ *   spanMa: number,
+ * }}
+ */
+export function createMeanObliquityHistory(deps: {
+    table: MeanObliquityTable;
+}): {
+    meanObliquityDegAtAge: (tMa: number) => number | null;
+    cosRatioAtAge: (tMa: number) => number | null;
+    meanObliquityJ2000Deg: number;
+    spanMa: number;
+};

package/types/earth/precession-composed.d.cts

@@ -24,14 +24,20 @@ export function computeSolarTorqueShare(c: {
  *   moonDistanceMetresAtAge: (tMa: number) => (number | null),
  *   moonDistanceJ2000Metres: number,
  *   yearToTMa: (year: number) => number,
+ *   meanObliquityCosRatioAtAge?: (tMa: number) => (number | null),
  * }} deps - p0 = the model's derived J2000 rate, 1,296,000/axial0 (S5; a
  *   number or a LAZY getter — the callers' certified year laws read the
  *   deep-time factory this is built inside, so the anchor is resolved on
  *   the first RATE use, never at construction; the torque term needs no
- *   anchor); lodJ2000Seconds the SAME day basis lodSecondsAtAge(0) returns.
+ *   anchor); lodJ2000Seconds the SAME day basis lodSecondsAtAge(0) returns;
+ *   meanObliquityCosRatioAtAge the cited mean obliquity's cos ε̄(t)/cos ε̄(0)
+ *   (OPTIONAL — absent, the rate of date is the constant alone, bit-identical).
  * @returns {{
  *   composedRateArcsecPerYrAtAge: (tMa: number) => (number | null),
  *   composedPeriodYearsAtAge: (tMa: number) => (number | null),
+ *   torqueRateArcsecPerYrAtAge: (tMa: number) => (number | null),
+ *   torquePeriodYearsAtAge: (tMa: number) => (number | null),
+ *   obliquityFactorAtAge: (tMa: number) => (number | null),
  *   composedRateArcsecPerYrAtYear: (year: number) => (number | null),
  *   composedPeriodYearsAtYear: (year: number) => (number | null),
  *   composedRateRatioAtAge: (tMa: number) => (number | null),
@@ -49,9 +55,13 @@ export function createComposedPrecession(deps: {
     moonDistanceMetresAtAge: (tMa: number) => (number | null);
     moonDistanceJ2000Metres: number;
     yearToTMa: (year: number) => number;
+    meanObliquityCosRatioAtAge?: (tMa: number) => (number | null);
 }): {
     composedRateArcsecPerYrAtAge: (tMa: number) => (number | null);
     composedPeriodYearsAtAge: (tMa: number) => (number | null);
+    torqueRateArcsecPerYrAtAge: (tMa: number) => (number | null);
+    torquePeriodYearsAtAge: (tMa: number) => (number | null);
+    obliquityFactorAtAge: (tMa: number) => (number | null);
     composedRateArcsecPerYrAtYear: (year: number) => (number | null);
     composedPeriodYearsAtYear: (year: number) => (number | null);
     composedRateRatioAtAge: (tMa: number) => (number | null);

package/types/index.d.ts

@@ -14,10 +14,12 @@ export { createSecularSeriesOverride } from "./planets/secular-series.cjs";
 export { createDeepEccChannel } from "./moon/deep-ecc-channel.cjs";
 export { createDeepOrbitalHistory } from "./earth/deep-orbital-history.cjs";
 export { createSiderealYearChannel } from "./earth/sidereal-year-channel.cjs";
+export { createMeanObliquityHistory } from "./earth/mean-obliquity-history.cjs";
 export { createPlanetModel } from "./planets/model.cjs";
 export { PLANET_DISPLAY_NAMES } from "./planets/display-names.cjs";
 export { createDeltaTCycles } from "./deltat/cycles.cjs";
 export { createDeepTimeLod } from "./deltat/deep-time.cjs";
+export { createMoonDistanceHistory } from "./deltat/moon-distance-history.cjs";
 export { deltaTEspenakMeeusCanonSeconds } from "./deltat/historical.cjs";
 export { createEclipseFinders } from "./eclipse/finders.cjs";
 export function createModel(constants?: Constants, opts?: {
@@ -57,6 +59,11 @@ import { REFERENCE_DATA } from './constants/index.js';
 import { assembleModel } from './model.js';
 export { GENERATED as DEFAULT_CONSTANTS, CONSTANTS_HASH, MODEL_VERSION, PREPRINT_DOI, REFERENCE_DATA };
 export { FITTED_COEFFICIENTS, COEFFICIENTS_HASH } from "./constants/index.js";
+export { GREGORIAN_START, GREGORIAN_START_JD, calendarToJD, jdToCalendar, jdToDecimalYear, dayFractionToHMS, julianCalendarToJD, jdToJulianCalendar } from "./time/calendar.cjs";
+export { DEG2RAD, RAD2DEG, ARCSEC_PER_TURN, ARCSEC_PER_RAD, wrap360, wrap180, wrap180Closed, wrap2pi, wrapPi } from "./math/angles.cjs";
+export { createDeepTimeChain, MOON_ECC_SENSITIVITY_PERIGEE, MOON_ECC_SENSITIVITY_NODE } from "./deltat/deep-time-chain.js";
+export { computeMassChainJ2000, computeMoonPeriodsJ2000 } from "./earth/mass-chain.cjs";
+export { SECONDS_PER_DAY, DAYS_PER_JULIAN_YEAR, JULIAN_CENTURY_DAYS, SECONDS_PER_JULIAN_YEAR } from "./constants/units.cjs";
 export { computeEarthFrameOfDate, solveWheelAngleForLongitude, computeSceneWorldFrameJ2000, SCENE_EQUINOX_VIEW_AZIMUTH_DEG } from "./earth/frame-of-date.cjs";
 export { derivePlanetGeometry, scaffoldOrbitInputs } from "./planets/geometry.cjs";
 export { buildPlanetChainsFromArtifactData, computePlanetElementsAtYear, computeHeliocentricEclipticFromElements, computePoissonArgRad, computeOsculatingElements, solveKeplerRad, computeApsidalSecularDegPerYr, ANCHOR_EPOCH_YEAR, ANCHOR_EPOCH_JD } from "./planets/keplerian-chain.cjs";
@@ -66,5 +73,5 @@ export { CHAIN_ARTIFACT, CHAIN_ARTIFACT_HASH } from "./planets/chain-artifact.js
 export { DEEP_MODES_ARTIFACT, DEEP_MODES_ARTIFACT_HASH } from "./moon/deep-modes-artifact.cjs";
 export { createYearLengths, computeMeanTropicalYearJ2000Days, ONE_FAMILY_WINDOW_YEARS } from "./earth/year-lengths.cjs";
 export { computeSolarTorqueShare, createComposedPrecession } from "./earth/precession-composed.cjs";
-export { createMoonRecessionHistory, createSolarChannelBudget } from "./deltat/recession-history.cjs";
+export { MOON_DISTANCE_ARTIFACT, MOON_DISTANCE_ARTIFACT_HASH } from "./deltat/moon-distance-artifact.cjs";
 export { evalClimateL1OrbitalPermil, laggedL1Terms, createAlphaGiaChannel } from "./climate/l1-orbital.cjs";

package/types/layer0/derive-params.d.ts

@@ -12,9 +12,10 @@ export type RawEpochConstants = {
      * km/s (fallback 299792458 m/s if falsy)
      */
     speedOfLightKmPerS: number;
+    /**
+     * the LLR recession rate — the cited distance history's J2000 slope
+     */
     alpha1PerMa: number;
-    alpha3PerMa3: number;
-    alpha4PerMa4: number;
     meanSiderealYearSeconds: number;
     /**
      * ω₀: the J2000 day length, SI seconds (the SI day since plan 09)

package/types/layer0/index.d.ts

@@ -1,6 +1,8 @@
-export function createEpochPrimitives({ params: p, alphaAtAgeMa }: {
+export function createEpochPrimitives({ params: p, alphaAtAgeMa, moonDistanceMetresAtAge, meanObliquityCosRatioAtAge }: {
     params: EpochParams;
     alphaAtAgeMa: (tMa: number) => number;
+    moonDistanceMetresAtAge: (tMa: number) => number | null;
+    meanObliquityCosRatioAtAge?: (tMa: number) => number | null;
 }): EpochPrimitives;
 export type EpochParams = {
     /**
@@ -8,11 +10,9 @@ export type EpochParams = {
      */
     epochYear: number;
     /**
-     * Moon recession, LLR-anchored
+     * Moon recession, LLR-anchored (the J2000 slope of the cited history)
      */
     alpha1PerMa: number;
-    alpha3PerMa3: number;
-    alpha4PerMa4: number;
     /**
      * a_Moon at J2000, metres
      */
@@ -47,11 +47,14 @@ export type EpochParams = {
 };
 export type EpochPrimitives = {
     tMa: (year: number) => number;
-    moonDistanceMetres: (year: number) => number;
+    /**
+     * - null beyond the cited history's span
+     */
+    moonDistanceMetres: (year: number) => number | null;
     lodSeconds: (year: number) => number | null;
     siderealYearSeconds: (year: number) => number;
     /**
-     * sidereal less one equinox turn per T_p(t) (the composed precession period)
+     * sidereal less one equinox turn per T_p(t) (the composed precession period on the RATE of date)
      */
     tropicalYearSeconds: (year: number) => number;
 };

package/types/math/angles.d.cts

@@ -0,0 +1,18 @@
+/** π/180 — degrees to radians. */
+export const DEG2RAD: number;
+/** 180/π — radians to degrees. */
+export const RAD2DEG: number;
+/** Arcseconds in a full turn. */
+export const ARCSEC_PER_TURN: 1296000;
+/** Arcseconds per radian, 206264.806…  */
+export const ARCSEC_PER_RAD: number;
+/** @param {number} x degrees @returns {number} the same angle in [0, 360) */
+export function wrap360(x: number): number;
+/** @param {number} x degrees @returns {number} the same angle in [−180, 180) */
+export function wrap180(x: number): number;
+/** @param {number} x degrees @returns {number} the same angle in (−180, 180] */
+export function wrap180Closed(x: number): number;
+/** @param {number} x radians @returns {number} the same angle in [0, 2π) */
+export function wrap2pi(x: number): number;
+/** @param {number} x radians @returns {number} the same angle in [−π, π) */
+export function wrapPi(x: number): number;

package/types/model.d.ts

@@ -1,3 +1,9 @@
+/**
+ * RA-day-offset Fourier amplitudes (ms). KNOWN EXCEPTION carried over from
+ * the reference adapters: these are fit results that live as literals in the
+ * engine too — packaging them into FITTED_COEFFICIENTS is the remaining
+ * §7a-step-1b move; until then this is their single packaged home.
+ */
 /**
  * Assemble the model surfaces from a resolved constants context + fitted
  * coefficients. Internal: `createModel` in index.js composes this with the
@@ -41,7 +47,7 @@ export function assembleModel(C: Readonly<Record<string, any>>, F: Readonly<Reco
         lunarSmallParameter: number;
         moonMassFraction: number;
         solarTidalShiftKm: number;
-        moonDistanceCorrectedKm: any;
+        moonDistanceCorrectedKm: number;
         gmEarthMoonSystemKm3S2: number;
         gmEarthKm3S2: number;
         gmMoonKm3S2: number;
@@ -69,10 +75,18 @@ export function assembleModel(C: Readonly<Record<string, any>>, F: Readonly<Reco
         tropicalYearSecondsAtYear: (year: number) => number;
     }>;
     lunisolar: Readonly<{
-        /** The mean lunisolar precession period T_p(t), years — the composed torque rate's period on the derived J2000 anchor (25,771.4 at J2000). @param {number} year @returns {number} */
+        /** The mean lunisolar precession period T_p(t), years — 1,296,000/the precession RATE of date (25,771.6 at J2000): THE published deep-time clock. @param {number} year @returns {number} */
         meanPeriodYearsAtYear: (year: number) => number;
-        /** The composed rate ψ̇(t) = [ω/ω₀]·p₀·[f_S + (1 − f_S)(a₀/a_M)³], ″/yr (p₀ = 50.2883, derived). @param {number} year @returns {number} */
+        /** THE PRECESSION RATE OF DATE ψ̇(t) = [ω/ω₀]·p₀·[f_S + (1 − f_S)(a₀/a_M)³] × cos ε̄(t)/cos ε̄(0), ″/yr — the constant's scaling on the spin and the lunar torque times the cited mean obliquity's cosine (plan 12 §8 option (a); p₀ = 50.2880, the IAU 2006 input). @param {number} year @returns {number} */
         meanRateArcsecPerYrAtYear: (year: number) => number;
+        /** THE PRECESSION CONSTANT OF DATE as a rate on the J2000 obliquity, ″/yr — the spin and torque scaling alone (the hybrid obliquity integration's integrand: its own ŝ·n̂ carries the cosine). @param {number} year @returns {number} */
+        torqueRateArcsecPerYrAtYear: (year: number) => number;
+        /** 1,296,000/the torque rate, years. @param {number} year @returns {number} */
+        torquePeriodYearsAtYear: (year: number) => number;
+        /** cos ε̄(t)/cos ε̄(0) — the rate of date's obliquity factor on the constant (1 at J2000; 1.0075 at the Devonian, 1.0245 at 2.46 Ga). @param {number} year @returns {number} */
+        precessionObliquityFactorAtYear: (year: number) => number;
+        /** THE CITED MEAN OBLIQUITY OF DATE ε̄(t), degrees — Farhat et al. 2022's own column of the Earth–Moon history (a Myr-scale MEAN: 23.25° at age 0 against the J2000 instant 23.44°; 22.23° Devonian, 19.73° at 2.46 Ga); read as the shape cos ε̄(t)/cos ε̄(0) on the precession rate. NaN beyond the input's span (4,429 Ma); forward of J2000 the J2000 slope is held. @param {number} year @returns {number} */
+        meanObliquityCitedDegAtYear: (year: number) => number;
         /** The of-date period — the one-family beat inside ±2 Myr, the composed mean beyond. @param {number} year @returns {number} */
         ofDatePeriodYearsAtYear: (year: number) => number;
         /** f_S, the solar fraction of the J2000 precession torque. */
@@ -142,6 +156,10 @@ export function assembleModel(C: Readonly<Record<string, any>>, F: Readonly<Reco
     earth: Readonly<{
         perihelionLongitudeDeg: (year: number) => number;
         obliquityDeg: (year: number) => number;
+        /** The hybrid's own domain, [yearFrom, yearTo] — the banked ζ series' span, ±10 Myr about J2000 (plan 12 §8.5: the published surfaces serve `obliquityDeg` inside it only; null without a series, i.e. a bare createModel()). */
+        obliquityHybridDomainYears: [number, number] | null;
+        /** The cited mean obliquity of date ε̄(t) (Farhat et al. 2022's column; plan 12 §8 option (a)), degrees — a Myr-scale mean; NaN beyond 4,429 Ma. @param {number} year @returns {number} */
+        meanObliquityCitedDeg: (year: number) => number;
         eccentricity: (year: number) => number;
         inclinationDeg: (year: number) => number;
         ascendingNodeDeg: (year: number) => number;

package/types/moon/arguments.d.cts

@@ -121,12 +121,7 @@ export function createMoonArguments({ constants, fns }: {
         };
     };
 };
-/**
- * Astronomical JD → decimal year: Julian calendar before 1582-10-15,
- * Gregorian after (Meeus Ch. 7 inverse). The S3-aligned coordinate for the
- * Sun secular deviations. @param {number} jd @returns {number}
- */
-export function jdToDecimalYear(jd: number): number;
+import { jdToDecimalYear } from "../time/calendar.cjs";
 /**
  * @typedef {{Lp: number, D: number, M: number, Mp: number, F: number}} MoonArgsDeg
  */
@@ -137,3 +132,4 @@ export function jdToDecimalYear(jd: number): number;
  *  5c: it was written as the era unit's twelfth, H/12, "lattice-derived";
  *  the value is kept bit-identical and named for what it is). */
 export const SECULAR_COMPLETION_TAPER_YEARS: 27943.083333333332;
+export { jdToDecimalYear };

package/types/moon/month-chain.d.cts

@@ -2,9 +2,6 @@
  * @param {{
  *   constants: {
  *     aMoonNowMetres: number,
- *     alpha1PerMa: number,
- *     alpha3PerMa3: number,
- *     alpha4PerMa4: number,
  *     gmEarthMoonM3PerS2: number,
  *     massRatioEarthMoon: number,
  *     moonSiderealMonthInputDays: number,
@@ -20,7 +17,7 @@
  *     meanSiderealYearSecondsAtAge: (tMa: number) => number,
  *     precessionPeriodYearsAtAge: (tMa: number) => (number | null),
  *     modulation: (tMa: number, s: number) => number,
- *     distanceMetresAtAge?: (tMa: number) => number,
+ *     distanceMetresAtAge: (tMa: number) => number|null,
  *   },
  * }} deps — fns are the ENGINE'S OWN layer-0/1 evaluators and the shared
  *   eccentricity channel's modulation; constants are the engine's derived
@@ -30,16 +27,13 @@
  *   5c — the tropical month's equinox turn, formerly the counter's 13/H(t),
  *   0.086 % slow: the chain's J2000 tropical month sat 5.85 ms above the IAU
  *   input, the 1/T_p form is within 0.1 ms of it).
- *   fns.distanceMetresAtAge, when present, OVERRIDES the internal quartic —
- *   the Driver-1½ regime-aware history (recession-history.cjs); absent, the
- *   internal quartic is the pure twin (bit-identical for t ≤ jointMa).
+ *   fns.distanceMetresAtAge is the engine's CITED distance history
+ *   (deltat/moon-distance-history; plan 12 option A — the internal quartic
+ *   twin this chain carried until then is deleted; null beyond the span).
  */
 export function createMoonMonthChain({ constants, fns }: {
     constants: {
         aMoonNowMetres: number;
-        alpha1PerMa: number;
-        alpha3PerMa3: number;
-        alpha4PerMa4: number;
         gmEarthMoonM3PerS2: number;
         massRatioEarthMoon: number;
         moonSiderealMonthInputDays: number;
@@ -55,11 +49,11 @@ export function createMoonMonthChain({ constants, fns }: {
         meanSiderealYearSecondsAtAge: (tMa: number) => number;
         precessionPeriodYearsAtAge: (tMa: number) => (number | null);
         modulation: (tMa: number, s: number) => number;
-        distanceMetresAtAge?: (tMa: number) => number;
+        distanceMetresAtAge: (tMa: number) => number | null;
     };
 }): {
-    distanceMetresAtAge: (tMa: number) => number;
-    distanceKmAtAge: (tMa: number) => number;
+    distanceMetresAtAge: (tMa: number) => number | null;
+    distanceKmAtAge: (tMa: number) => number | null;
     solarDeltaAKmAtAge: (tMa: number, aApparentKm: number) => number | null;
     distanceCorrectedKmAtAge: (tMa: number) => number | null;
     siderealMonthSecondsAtAge: (tMa: number) => number | null;

package/types/time/calendar.d.cts

@@ -0,0 +1,78 @@
+/** The first Gregorian calendar day, as a calendar date. */
+export const GREGORIAN_START: Readonly<{
+    year: 1582;
+    month: 10;
+    day: 15;
+}>;
+/** The first Gregorian calendar day, as a JD (00:00 UT). */
+export const GREGORIAN_START_JD: 2299160.5;
+/**
+ * Calendar date → Julian Day (Meeus 7.1). The calendar is decided by the
+ * date itself: Julian before 1582-10-15, Gregorian from it on.
+ * @param {number} year astronomical year (0 = 1 BC)
+ * @param {number} month 1–12
+ * @param {number} day 1–31, may carry a fraction
+ * @param {number} [dayFraction=0] added to the day (e.g. hour/24)
+ * @returns {number} JD
+ */
+export function calendarToJD(year: number, month: number, day: number, dayFraction?: number): number;
+/**
+ * Julian Day → calendar date (Meeus ch. 7 inverse). Gregorian for
+ * JD ≥ 2299160.5, Julian before.
+ * @param {number} jd
+ * @returns {{year: number, month: number, day: number, dayFrac: number, calendar: 'Julian'|'Gregorian'}}
+ *   day the integer day of month, dayFrac in [0, 1) the fraction since 00:00
+ */
+export function jdToCalendar(jd: number): {
+    year: number;
+    month: number;
+    day: number;
+    dayFrac: number;
+    calendar: "Julian" | "Gregorian";
+};
+/**
+ * Julian Day → decimal year: the year plus the elapsed fraction of that
+ * calendar year (Julian or Gregorian leap rule as the date's calendar has
+ * it). Jan 1 00:00 → year exactly. The S3-aligned coordinate of the Sun's
+ * secular deviations and the browser's `julianDateToDecimalYear`.
+ * @param {number} jd
+ * @returns {number}
+ */
+export function jdToDecimalYear(jd: number): number;
+/**
+ * The day fraction as hours, minutes and whole seconds (floored, as the
+ * browser's date strings always did).
+ * @param {number} dayFrac in [0, 1)
+ * @returns {{hour: number, minute: number, second: number}}
+ */
+export function dayFractionToHMS(dayFrac: number): {
+    hour: number;
+    minute: number;
+    second: number;
+};
+/**
+ * Proleptic JULIAN calendar date → Julian Day, no reform: the convention the
+ * NASA eclipse canons and the Babylonian/Greek record tables use for every
+ * pre-1582 date, and the browser's eclipse diagnostics apply to their whole
+ * table (so a post-reform Gregorian date in such a table — 1654 Aug 12 —
+ * lands ten days late; the tables name the convention). Same expression
+ * order as the copies it replaces.
+ * @param {number} year astronomical year (0 = 1 BC)
+ * @param {number} month 1–12
+ * @param {number} day 1–31
+ * @param {number} [dayFraction=0] added to the day (e.g. hour/24)
+ * @returns {number} JD
+ */
+export function julianCalendarToJD(year: number, month: number, day: number, dayFraction?: number): number;
+/**
+ * Julian Day → proleptic JULIAN calendar date, no reform (the inverse of
+ * `julianCalendarToJD`; the NASA-convention diagnostics' printer).
+ * @param {number} jd
+ * @returns {{year: number, month: number, day: number, dayFrac: number}}
+ */
+export function jdToJulianCalendar(jd: number): {
+    year: number;
+    month: number;
+    day: number;
+    dayFrac: number;
+};

package/src/deltat/recession-history.cjs

@@ -1,169 +0,0 @@
-/**
- * Regime-aware lunar recession history + the solar angular-momentum
- * channels (Driver 1½) — THE shared implementation.
- *
- * Background (docs/99 §"The ungated mid-Precambrian window", docs/106 §D,
- * and the research record in tools/explore/{farhat-divergence-probe,
- * fit-regime-recession}.js — the hand-shaped regime-aware-recession-study.js
- * was deleted at plan 09 step 7e): Farhat 2022's
- * central result is that lunar recession followed a resonant STAIRCASE —
- * a single smooth quartic anchored at the modern LLR rate, the gated
- * 0–650 Ma era and the Roche crossing cannot follow it through the
- * 1–3.5 Ga window (−8.9σ Joffre, −11.4σ Moodies). This module carries
- * the regime-aware history:
- *
- *   t ≤ jointMa       — the calibrated quartic, BIT-IDENTICAL (the
- *                       Wells/Wu-gated era; its α set is the calibrated
- *                       effective closed-budget pair and is not touched).
- *   jointMa..genesisMa — monotone cubic Hermite (Fritsch–Carlson) through
- *                       the fitted knots, value- AND slope-continuous at
- *                       the joint (analytic polynomial derivative), ending
- *                       at the rigid Roche limit at genesisMa.
- *   t ≥ genesisMa     — clamped at the Roche value (the Moon does not
- *                       exist beyond its genesis; boundary value, not an
- *                       extrapolation).
- *
- * The solar channels (explicit ONLY beyond jointMa — inside the gated era
- * they are absorbed by the α calibration, and applying them there without
- * recalibration measurably breaks Wells; see the study's variant 3):
- *   leak  τ_s = β₀ (a/a₀)⁶ · τ_moon   — ocean solar tide (M²/AU⁶ ratio
- *          scaling of the semidiurnal torque)
- *   pump  τ_t = f_p · (τ_moon + τ_s) inside [pumpStartMa, pumpEndMa] —
- *          the insolation-driven atmospheric thermal tide
- *          (Zahnle–Walker 1987; Bartlett–Stevenson 2016;
- *          Mitchell–Kirscher 2023). The FITTED f_p ≈ 0.45 over a ~300 Myr
- *          window (degenerate with 0.15 × 900 Myr — the data constrain
- *          the INTEGRATED pump, ~2σ preferred over zero, Zhou 2024's
- *          contrary reading honestly noted in the fit record).
- *
- * Fit provenance: tools/explore/fit-regime-recession.js — 11 anchors
- * (Lantink/Joffre 2022 · Weeli Wolli · Zhou 2024 ×3 paired a+LOD ·
- * Meyers–Malinverno 2018 · Nanfen 2023 · Moodies), all ≤1.3σ; genesis
- * pinned at the shipped 4498 Ma Roche crossing (the genesis profile is
- * flat — the data do not constrain it). The knot values ARE the shipped
- * definition (metre-rounded at fit time, not truncated from a more
- * precise source).
- */
-
-'use strict';
-
-/**
- * @typedef {Object} RecessionRegime
- * @property {number} jointMa - regime boundary; quartic below, spline above
- * @property {number[]} knotAgesMa - interior knot ages (ascending)
- * @property {number[]} knotDistancesKm - fitted knot distances
- * @property {number} genesisMa - the Roche-crossing epoch
- * @property {number} rocheLimitKm - the rigid Roche endpoint
- */
-
-/**
- * @param {{
- *   aMoonNowMetres: number,
- *   alpha1PerMa: number, alpha3PerMa3: number, alpha4PerMa4: number,
- *   regime: RecessionRegime,
- * }} deps
- * @returns {{ distanceMetresAtAge: (tMa: number) => number }}
- */
-function createMoonRecessionHistory(deps) {
-  const { aMoonNowMetres: aNow, alpha1PerMa: a1, alpha3PerMa3: a3, alpha4PerMa4: a4 } = deps;
-  const R = deps.regime;
-
-  /** The calibrated quartic (identical expression to every consumer).
-   * @param {number} tMa @returns {number} */
-  const polyM = (tMa) => aNow * (1 + a1 * tMa + a3 * tMa * tMa * tMa + a4 * tMa * tMa * tMa * tMa);
-  /** Analytic slope of the quartic, m/Ma.
-   * @param {number} tMa @returns {number} */
-  const polySlopeM = (tMa) => aNow * (a1 + 3 * a3 * tMa * tMa + 4 * a4 * tMa * tMa * tMa);
-
-  // Knot chain: joint (value+slope from the quartic) → fitted knots → Roche.
-  const ts = [R.jointMa, ...R.knotAgesMa, R.genesisMa];
-  const vs = [polyM(R.jointMa), ...R.knotDistancesKm.map((km) => km * 1000), R.rocheLimitKm * 1000];
-  const n = ts.length;
-  const d = [];
-  for (let i = 0; i < n - 1; i++) d.push((vs[i + 1] - vs[i]) / (ts[i + 1] - ts[i]));
-  const m = new Array(n);
-  m[0] = polySlopeM(R.jointMa);
-  for (let i = 1; i < n - 1; i++) m[i] = (d[i - 1] * d[i] <= 0) ? 0 : (d[i - 1] + d[i]) / 2;
-  m[n - 1] = d[n - 2];
-  // Fritsch–Carlson monotonicity limiter — the history must be monotone
-  // into the past (the Moon only recedes on the mean).
-  for (let i = 0; i < n - 1; i++) {
-    if (d[i] === 0) { m[i] = 0; m[i + 1] = 0; continue; }
-    const a = m[i] / d[i], b = m[i + 1] / d[i];
-    const s = a * a + b * b;
-    if (s > 9) { const tau = 3 / Math.sqrt(s); m[i] = tau * a * d[i]; m[i + 1] = tau * b * d[i]; }
-  }
-
-  /** @param {number} tMa @returns {number} metres */
-  function distanceMetresAtAge(tMa) {
-    if (tMa <= R.jointMa) return polyM(tMa);
-    if (tMa >= R.genesisMa) return R.rocheLimitKm * 1000;
-    let i = 0;
-    while (i < n - 2 && tMa > ts[i + 1]) i++;
-    const h = ts[i + 1] - ts[i], s = (tMa - ts[i]) / h, s2 = s * s, s3 = s2 * s;
-    return (2 * s3 - 3 * s2 + 1) * vs[i] + (s3 - 2 * s2 + s) * h * m[i]
-      + (-2 * s3 + 3 * s2) * vs[i + 1] + (s3 - s2) * h * m[i + 1];
-  }
-
-  return { distanceMetresAtAge };
-}
-
-/**
- * The solar angular-momentum channels: L_EM(t) integrated backward from
- * J2000 with the ocean leak and the thermal-tide pump, explicit only
- * beyond jointMa. Absent this module, every consumer's L_EM is the J2000
- * constant — which remains the exact behaviour for t ≤ jointMa.
- *
- * @param {{
- *   lTotalJ2000KgM2S: number,
- *   mMoonAloneKg: number, gmEmM3PerS2: number, eFactorMoon: number,
- *   beta0: number,
- *   pumpStartMa: number, pumpEndMa: number, pumpFactor: number,
- *   jointMa: number, genesisMa: number,
- *   distanceMetresAtAge: (tMa: number) => number,
- *   stepMa?: number,
- * }} deps
- * @returns {{ lEmAtAgeKgm2S: (tMa: number) => number }}
- */
-function createSolarChannelBudget(deps) {
-  const STEP = deps.stepMa ?? 5;
-  /** @param {number} aM @returns {number} */
-  const lOrb = (aM) => deps.mMoonAloneKg * Math.sqrt(deps.gmEmM3PerS2 * aM) * deps.eFactorMoon;
-  const a0 = deps.distanceMetresAtAge(0);
-
-  /** @type {Float64Array|null} */
-  let table = null;
-  const build = () => {
-    const nSteps = Math.ceil(deps.genesisMa / STEP) + 1;
-    const t = new Float64Array(nSteps);
-    let L = deps.lTotalJ2000KgM2S;
-    for (let i = 0; i < nSteps; i++) {
-      t[i] = L;
-      const tMa = i * STEP;
-      const dLorb = lOrb(deps.distanceMetresAtAge(tMa)) - lOrb(deps.distanceMetresAtAge(tMa + STEP));
-      const mid = tMa + STEP / 2;
-      const leakDt = mid > deps.jointMa ? deps.beta0 * Math.pow(deps.distanceMetresAtAge(tMa) / a0, 6) * dLorb : 0;
-      const pumpDt = (mid > deps.pumpStartMa && mid < deps.pumpEndMa) ? deps.pumpFactor * (dLorb + leakDt) : 0;
-      L = L - (pumpDt - leakDt);
-    }
-    return t;
-  };
-
-  /** @param {number} tMa @returns {number} */
-  function lEmAtAgeKgm2S(tMa) {
-    // The channels are zero below jointMa by construction — return the
-    // constant EXACTLY there (no table interpolation), so the gated era
-    // stays bit-identical to the closed-budget engine (the 1-ULP fixture
-    // gates depend on this).
-    if (tMa <= deps.jointMa) return deps.lTotalJ2000KgM2S;
-    if (table === null) table = build();
-    const x = tMa / STEP;
-    const i = Math.min(Math.floor(x), table.length - 2);
-    const f = Math.min(x - i, 1);
-    return table[i] * (1 - f) + table[i + 1] * f;
-  }
-
-  return { lEmAtAgeKgm2S };
-}
-
-module.exports = { createMoonRecessionHistory, createSolarChannelBudget };