@essrt/physics 22.1.0 → 23.2.0

package/src/deltat/moon-distance-history.cjs

@@ -0,0 +1,115 @@
+/**
+ * The Earth–Moon distance history — a CITED PHYSICAL INPUT, read as a shape
+ * on the model's own J2000 anchor (plan 12, option A).
+ *
+ * WHY AN INPUT. Everything downstream of a(t) is derived here by our own
+ * equations: the day length by angular-momentum conservation (deep-time.cjs),
+ * the composed lunisolar precession and the clock T_p(t)
+ * (earth/precession-composed.cjs), the month chain (moon/month-chain.cjs).
+ * a(t) itself cannot be derived without an ocean-tide dissipation history —
+ * the continental configuration and the resonance crossings that decide how
+ * fast the Moon recedes in each era — and the model has no physics for it.
+ * With constant dissipation at today's rate the Moon sits at the Roche limit
+ * 1.5 Gyr ago, three billion years too late for its age. The published
+ * solution that computes that history from a modelled ocean is Farhat,
+ * Auclair-Desrotour, Boué & Laskar 2022 (A&A 665, L1), distributed as the
+ * AstroGeo22 ephemeris; it is the input, as the planetary masses are DE440's
+ * and p₀ is IAU 2006's. Before plan 12 the history was a quartic whose two
+ * higher coefficients were least-squares fitted to that same curve (0.5 h of
+ * day off at 1 Ga) and, beyond 1 Ga, a spline through knots fitted to the
+ * rock record — a fit to the data the falsification leg then tested.
+ *
+ * WHAT IS READ. The table's distance column as the RATIO r(t) = a(t)/a(0):
+ * Farhat's a is the Keplerian semi-major axis (383,598 km at J2000); the
+ * model's anchor is the observed mean distance (384,399 km). The history
+ * enters as a(t) = a₀ · r(t), so J2000 stays the observation and the shape is
+ * Farhat's.
+ *
+ * INTERPOLATION. Monotone cubic Hermite (Fritsch–Carlson) between the 1-Myr
+ * samples — C1, so the LOD-rate decomposition's tidal term (the slope) is
+ * smooth. The J2000 END-SLOPE is the OBSERVED LLR recession rate, the α₁
+ * input (3.820 cm/yr; Farhat's own first sample reads 3.833, his fit to the
+ * same observation): the boundary condition is the measurement, so the ΔT
+ * era's tidal term does not move with the input.
+ *
+ * DOMAIN. Forward of J2000 (t < 0) the LLR rate is held constant — the
+ * charts' labelled extrapolation (the input has no future). Beyond the
+ * table's last sample (4,429 Ma — the lunar age is the input's end) the
+ * history REFUSES: null, never an extrapolation. The former "Roche crossing
+ * at 4.498 Ga, a self-validation" was the spline's pinned endpoint, not a
+ * derivation, and is withdrawn.
+ */
+
+'use strict';
+
+/**
+ * @typedef {Object} MoonDistanceTable
+ * @property {ReadonlyArray<number>} ageMa - ascending, 0 first, uniform 1-Myr step
+ * @property {ReadonlyArray<number>} aEarthRadii - the distance column (any consistent unit; only ratios are read)
+ */
+
+/**
+ * @param {{ table: MoonDistanceTable, aMoonNowMetres: number, alpha1PerMa: number }} deps
+ *   aMoonNowMetres — the model's J2000 anchor (the observed mean distance);
+ *   alpha1PerMa — the LLR rate as a fraction of a₀ per Ma (negative into the past: a shrinks).
+ * @returns {{
+ *   distanceMetresAtAge: (tMa: number) => number|null,
+ *   slopeMetresPerMaAtAge: (tMa: number) => number|null,
+ *   ratioAtAge: (tMa: number) => number|null,
+ *   spanMa: number,
+ * }}
+ */
+function createMoonDistanceHistory(deps) {
+  const { table, aMoonNowMetres: aNow, alpha1PerMa: a1 } = deps;
+  const ages = table.ageMa, aRE = table.aEarthRadii;
+  const n = ages.length;
+  if (!(n >= 2) || aRE.length !== n || ages[0] !== 0) throw new Error('moon-distance-history: the table must start at age 0 with ≥ 2 samples');
+  const step = ages[1] - ages[0];
+  for (let i = 1; i < n; i++) {
+    if (ages[i] - ages[i - 1] !== step) throw new Error(`moon-distance-history: non-uniform age step at index ${i}`);
+    if (aRE[i] > aRE[i - 1]) throw new Error(`moon-distance-history: the distance must be monotone into the past (index ${i})`);
+  }
+  const spanMa = ages[n - 1];
+  // The ratio table and its Fritsch–Carlson tangents (ratio per Ma).
+  const r = new Float64Array(n);
+  for (let i = 0; i < n; i++) r[i] = aRE[i] / aRE[0];
+  const d = new Float64Array(n - 1);
+  for (let i = 0; i < n - 1; i++) d[i] = (r[i + 1] - r[i]) / step;
+  const m = new Float64Array(n);
+  m[0] = a1;                                  // the LLR observation, in ratio/Ma
+  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];
+  for (let i = 0; i < n - 1; i++) {             // monotonicity limiter (Fritsch–Carlson)
+    if (d[i] === 0) { m[i] = 0; m[i + 1] = 0; continue; }
+    const al = m[i] / d[i], be = m[i + 1] / d[i];
+    const s = al * al + be * be;
+    if (s > 9) { const tau = 3 / Math.sqrt(s); m[i] = tau * al * d[i]; m[i + 1] = tau * be * d[i]; }
+  }
+
+  /** @param {number} tMa @returns {number|null} the ratio a(t)/a₀ */
+  function ratioAtAge(tMa) {
+    if (tMa <= 0) return 1 + a1 * tMa;        // forward: the LLR rate held constant (labelled extrapolation)
+    if (tMa > spanMa) return null;            // beyond the input: refused
+    const i = Math.min(Math.floor(tMa / step), n - 2);
+    const h = step, s = (tMa - ages[i]) / h, s2 = s * s, s3 = s2 * s;
+    return (2 * s3 - 3 * s2 + 1) * r[i] + (s3 - 2 * s2 + s) * h * m[i]
+      + (-2 * s3 + 3 * s2) * r[i + 1] + (s3 - s2) * h * m[i + 1];
+  }
+  /** @param {number} tMa @returns {number|null} d(ratio)/dt, per Ma */
+  function ratioSlopePerMaAtAge(tMa) {
+    if (tMa <= 0) return a1;
+    if (tMa > spanMa) return null;
+    const i = Math.min(Math.floor(tMa / step), n - 2);
+    const h = step, s = (tMa - ages[i]) / h, s2 = s * s;
+    return ((6 * s2 - 6 * s) * r[i] + (3 * s2 - 4 * s + 1) * h * m[i]
+      + (-6 * s2 + 6 * s) * r[i + 1] + (3 * s2 - 2 * s) * h * m[i + 1]) / h;
+  }
+  return {
+    distanceMetresAtAge: (tMa) => { const q = ratioAtAge(tMa); return q === null ? null : aNow * q; },
+    slopeMetresPerMaAtAge: (tMa) => { const q = ratioSlopePerMaAtAge(tMa); return q === null ? null : aNow * q; },
+    ratioAtAge,
+    spanMa,
+  };
+}
+
+module.exports = { createMoonDistanceHistory };

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

@@ -57,9 +57,11 @@
  *   measured at the 500-yr artifact cadence: 0.16″/0.18″ rms vs IAU-2006
  *   over 1900–2100/1600–2400 vs the era tier's 0.31″/0.63″, and 0.0396°
  *   vs La2004 over −200 kyr vs the deep tier's 0.069° — the C-1 verdict,
- *   plan 02) and zetaModes serves only as the TAIL beyond the span (the
- *   seam at the span edge is the extraction residual, far outside every
- *   certified window). solarTorqueShareJ2000 and
+ *   plan 02) and zetaModes serves only as the TAIL beyond the span, joined
+ *   to the series at each edge so n̂ is continuous there (plan 12 §8.3 — the
+ *   J2000-point anchor left a 1.6° step at −10 Myr that kicked the hybrid's
+ *   mean obliquity +0.9° for the whole tail; far outside every certified window).
+ *   solarTorqueShareJ2000 and
  *   dynamicalEllipticityRatioAtYearFn: THE PRECESSION OF DATE — the two
  *   factors on the precession constant (see alphaAtGeneral below); absent,
  *   the constant is the secular law alone, bit-identical.
@@ -73,19 +75,22 @@ function createDeepOrbitalHistory({
 }) {
   const D2R = Math.PI / 180, R2D = 180 / Math.PI;
 
+  const mkRawSum = (
+    /** @type {ReadonlyArray<{omegaRadPerYr: number, re: number, im: number}>} */ modes,
+  ) => (/** @type {number} */ t) => {
+    let re = 0, im = 0;
+    for (const m of modes) {
+      const c = Math.cos(m.omegaRadPerYr * t), s = Math.sin(m.omegaRadPerYr * t);
+      re += m.re * c - m.im * s;
+      im += m.re * s + m.im * c;
+    }
+    return [re, im];
+  };
   const mkAnchored = (
     /** @type {ReadonlyArray<{omegaRadPerYr: number, re: number, im: number}>} */ modes,
     /** @type {[number, number]} */ anchor,
   ) => {
-    const sum = (/** @type {number} */ t) => {
-      let re = 0, im = 0;
-      for (const m of modes) {
-        const c = Math.cos(m.omegaRadPerYr * t), s = Math.sin(m.omegaRadPerYr * t);
-        re += m.re * c - m.im * s;
-        im += m.re * s + m.im * c;
-      }
-      return [re, im];
-    };
+    const sum = mkRawSum(modes);
     const s0 = sum(0), R = [anchor[0] - s0[0], anchor[1] - s0[1]];
     return (/** @type {number} */ t) => { const [x, y] = sum(t); return [x + R[0], y + R[1]]; };
   };
@@ -161,9 +166,33 @@ function createDeepOrbitalHistory({
     const nS = sq.length, tEndYr = t0Yr + (nS - 1) * stepYr;
     const li = mkSeriesCubic(t0Yr, stepYr, nS);
     const R = [zetaAnchor[0] - li(sq, 0), zetaAnchor[1] - li(sp, 0)];
-    zetaAt = (/** @type {number} */ t) => (t >= t0Yr && t <= tEndYr)
-      ? [li(sq, t) + R[0], li(sp, t) + R[1]]
-      : zetaModeSum(t);
+    // THE TAIL JOINS THE SERIES AT EACH SEAM (plan 12 §8.3, measured 2026-10).
+    // The mode-sum tail anchored to the J2000 POINT reached the span edges
+    // 1.61° (past) / 0.74° (future) away from the series — its ~70-kyr phases
+    // drift over 10 Myr (the extraction residual) and its J2000 anchor misses
+    // the series' mean plane by 0.506° — and the hybrid's mean obliquity
+    // STEPPED +0.90° / +0.30° there and stayed stepped (24.17° over ±1 Myr at
+    // −20 Myr against 23.3° inside the span; the API served it to ±500 Myr).
+    // Three anchors measured: J2000 point (above), the series' MEAN plane
+    // (n̂ step 1.12°/0.54°, ε step +0.74°/+0.57°), and the SEAM POINT per side
+    // — the tail's constant chosen so n̂ is continuous at the edge it continues
+    // (ε step +0.09°/+0.13°, the tail's mean 23.31–23.36° over ±100 Myr). The
+    // pole follows n̂ adiabatically (ds/dt = α(ŝ·n̂)(ŝ×n̂) conserves ŝ·n̂ for a
+    // slowly moving n̂), so a DISCONTINUITY in n̂ is what kicks ε, not the
+    // tail's mean plane: continuity wins. Inside the span nothing changes
+    // (bit-identical); beyond it the hybrid carries the Quaternary mean on the
+    // tail — NO tidal evolution of the mean (the cited mean obliquity of date
+    // is model.earth.meanObliquityCitedDeg).
+    const rawSum = mkRawSum(zetaModes);
+    const e0 = rawSum(t0Yr), e1 = rawSum(tEndYr);
+    const RPast = [li(sq, t0Yr) + R[0] - e0[0], li(sp, t0Yr) + R[1] - e0[1]];
+    const RFuture = [li(sq, tEndYr) + R[0] - e1[0], li(sp, tEndYr) + R[1] - e1[1]];
+    zetaAt = (/** @type {number} */ t) => {
+      if (t >= t0Yr && t <= tEndYr) return [li(sq, t) + R[0], li(sp, t) + R[1]];
+      const [x, y] = rawSum(t);
+      const Rt = t < t0Yr ? RPast : RFuture;
+      return [x + Rt[0], y + Rt[1]];
+    };
   }
   const zAnchor = /** @type {[number, number]} */ (
     [anchorE * Math.cos(anchorPeriEclipticDeg * D2R), anchorE * Math.sin(anchorPeriEclipticDeg * D2R)]);
@@ -500,6 +529,8 @@ function createDeepOrbitalHistory({
     };
   }
 
+  /** The factory's walks, one per step size — see build(). @type {Map<number, { grid: Map<number, any>, frontier: Record<number, { s: number[], t: number }> }>} */
+  const walks = new Map();
   /**
    * Integrate once over [min(t0,t1,0), max(t0,t1,0)] and return a sampler
    * on a stepYr grid (linear interpolation; angles interpolated on the
@@ -514,7 +545,18 @@ function createDeepOrbitalHistory({
     if (Math.max(Math.abs(tMin), Math.abs(tMax)) > 50000 && stepYr % 250 !== 0) {
       throw new Error(`deep-orbital-history: builds beyond ±50 kyr need stepYr % 250 === 0 (got ${stepYr})`);
     }
-    const grid = new Map();
+    // ONE WALK PER STEP SIZE, EXTENDED, NEVER RESTARTED (plan 13 A1, measured):
+    // every caller's tier routing asked for `build(span, -span, step)` and
+    // rebuilt from J2000 whenever a deeper epoch arrived, so the four deep
+    // fixture anchors (380…2460 Ma) walked ~49 million RK4 steps — 14 of the
+    // chain's 17 minutes — and the API's first read at −498 Myr would walk
+    // ~5 million. The walk is a pure function of t from the fixed J2000 state
+    // S0, so continuing a stored walk from its last (s, t) yields the SAME
+    // step sequence as a fresh walk to the farther end: bit-identical nodes
+    // (the sampler-order-purity gate pins this). The grid and the two
+    // direction frontiers live on the factory, keyed by stepYr; a returned
+    // sampler reads the shared grid, which only ever gains nodes.
+    let w = walks.get(stepYr);
     const S0 = S0A;
     // D1-revised adaptive stepping: 5-yr RK4 near the era (the certified-
     // precision zone), 250-yr beyond ±50 kyr — still 103 steps per
@@ -526,8 +568,16 @@ function createDeepOrbitalHistory({
     // 250-aligned; switching one fine-step later would leave the coarse walk
     // permanently off-grid — measured: every key beyond ±50 kyr missing).
     const hStepAt = (/** @type {number} */ t) => (Math.abs(t) < 50000 ? 5 : 250);
+    if (!w) {
+      w = { grid: new Map(), frontier: { [-1]: { s: S0, t: 0 }, [1]: { s: S0, t: 0 } } };
+      walks.set(stepYr, w);
+    }
+    const grid = w.grid;
     for (const dir of [-1, +1]) {
-      let s = S0, t = 0;
+      const end = dir < 0 ? tMin : tMax;
+      const front = w.frontier[dir];
+      if (dir < 0 ? end >= front.t : end <= front.t) continue;   // already walked this far
+      let s = front.s, t = front.t;
       // Each stored node also carries the equinox-node RATE (deg/yr) from a
       // ±2.5-yr central difference on the integrator's own state — the C1
       // (Hermite) interpolation input. Linear interpolation of the node
@@ -552,8 +602,7 @@ function createDeepOrbitalHistory({
         smp.periOfDateRateDegPerYr = (((lp.peri - lm.peri + 540) % 360) - 180) / (2 * hR);
         grid.set(key, smp);
       };
-      storeWithRate(0, s, 0);
-      const end = dir < 0 ? tMin : tMax;
+      if (t === 0 && !grid.has(0)) storeWithRate(0, s, 0);
       while (dir < 0 ? t > end : t < end) {
         const H_STEP = hStepAt(t);
         s = rk4(s, t, dir * H_STEP);
@@ -568,6 +617,7 @@ function createDeepOrbitalHistory({
         // zone boundary is itself 250-aligned, so the walk stays on-grid).
         if (Math.abs(t - Math.round(t / stepYr) * stepYr) < 1e-6) storeWithRate(Math.round(t / stepYr) * stepYr, s, t);
       }
+      w.frontier[dir] = { s, t };
     }
     return {
       /** @param {number} tYr */

package/src/earth/mass-chain.cjs

@@ -0,0 +1,95 @@
+/**
+ * The J2000 mass chain and the Moon's J2000 periods — ONE home (holisticuniverse
+ * plan 13 B3). Before B3 the mass chain (Moon Kepler → GM_EM → the Earth/Moon
+ * split → the Sun) was computed in three places (model.js, tools/lib/
+ * constants.js, src/script.js), and the Moon's derived periods in three more.
+ *
+ * Every expression here is the twins' expression in the twins' operation
+ * order (floating point is not associative; the goldens pin the values).
+ */
+
+'use strict';
+
+/**
+ * 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,
+ * }}
+ */
+function computeMassChainJ2000(c) {
+  const meanSiderealYearSeconds = c.meanSiderealYearDays * 86400;
+  const moonOrbitalShiftKm = c.moonDistanceKm * (1 / (c.massRatioEarthMoon + 1)) * (c.moonSiderealMonthDays / c.meanSiderealYearDays);
+  const moonDistanceCorrectedKm = c.moonDistanceKm + moonOrbitalShiftKm;
+  const gmEarthMoonSystemKm3S2 = (4 * Math.PI * Math.PI * Math.pow(moonDistanceCorrectedKm, 3))
+    / Math.pow(c.moonSiderealMonthDays * c.meanLengthOfDaySeconds, 2);
+  const gmEarthAloneKm3S2 = gmEarthMoonSystemKm3S2 * (c.massRatioEarthMoon / (c.massRatioEarthMoon + 1));
+  const gmMoonAloneKm3S2 = gmEarthMoonSystemKm3S2 / (c.massRatioEarthMoon + 1);
+  const gmSunPlusEarthKm3S2 = (4 * Math.PI * Math.PI * Math.pow(c.currentAUDistanceKm, 3))
+    / Math.pow(meanSiderealYearSeconds, 2);
+  const gmSunKm3S2 = gmSunPlusEarthKm3S2 - gmEarthAloneKm3S2;
+  const sunMassKg = gmSunKm3S2 / c.gravitationalConstantKm3KgS2;
+  return { meanSiderealYearSeconds, moonOrbitalShiftKm, moonDistanceCorrectedKm, gmEarthMoonSystemKm3S2, gmEarthAloneKm3S2, gmMoonAloneKm3S2, gmSunPlusEarthKm3S2, gmSunKm3S2, sunMassKg };
+}
+
+/**
+ * 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,
+ * }}
+ */
+function computeMoonPeriodsJ2000(c) {
+  const T = c.axialPrecessionJ2000Days;
+  const M = c.moonSiderealMonthDays;
+  // the days forms (tools/lib/constants.js §7, src/script.js)
+  const moonApsidalPrecessionDaysEarth = 1 / (1 / c.moonApsidalPrecessionDaysInput - 1 / T);
+  const moonNodalPrecessionDaysEarth = 1 / (1 / c.moonNodalPrecessionDaysInput + 1 / T);
+  const moonAnomalisticMonthDays = 1 / (1 / M - 1 / moonApsidalPrecessionDaysEarth);
+  const moonNodalMonthDays = 1 / (1 / M + 1 / moonNodalPrecessionDaysEarth);
+  const moonSynodicMonthDays = M * c.meanSiderealYearDays / (c.meanSiderealYearDays - M);
+  const moonTropicalMonthDays = 1 / (1 / M + 1 / T);
+  const moonFullMoonCycleEarthDays = (moonSynodicMonthDays / (moonSynodicMonthDays - moonAnomalisticMonthDays)) * moonAnomalisticMonthDays;
+  const moonFullMoonCycleICRFDays = 1 / (1 / moonFullMoonCycleEarthDays + 1 / T);
+  const moonApsidalMeetsNodalDays = (moonNodalMonthDays / (moonAnomalisticMonthDays - moonNodalMonthDays)) * moonAnomalisticMonthDays;
+  const moonLunarLevelingCycleDays = (moonNodalPrecessionDaysEarth / (moonNodalPrecessionDaysEarth - moonApsidalPrecessionDaysEarth) * (moonApsidalPrecessionDaysEarth / c.meanSolarYearDays)) * c.meanSolarYearDays;
+  const moonDraconicYearICRFDays = 1 / ((1 / c.meanSolarYearDays) + (1 / moonNodalPrecessionDaysEarth));
+  const moonDraconicYearEarthDays = 1 / (1 / moonDraconicYearICRFDays - 1 / T);
+  // the seconds forms the deep-time chain anchors on (model.js / tools/lib/deep-time.js — the same
+  // relation written on the seconds, so the J2000 anchors of the month chain are bit-identical)
+  const moonApsidalOfDateJ2000Seconds = c.moonApsidalPrecessionDaysInput * 86400;
+  const moonNodalOfDateJ2000Seconds = c.moonNodalPrecessionDaysInput * 86400;
+  const moonApsidalJ2000Seconds = 1 / (1 / moonApsidalOfDateJ2000Seconds - 1 / (T * 86400));
+  const moonNodalJ2000Seconds = 1 / (1 / moonNodalOfDateJ2000Seconds + 1 / (T * 86400));
+  const moonSiderealMonthJ2000Seconds = M * 86400;
+  return {
+    moonApsidalPrecessionDaysEarth, moonNodalPrecessionDaysEarth,
+    moonApsidalJ2000Seconds, moonNodalJ2000Seconds, moonSiderealMonthJ2000Seconds,
+    moonAnomalisticMonthDays, moonNodalMonthDays, moonSynodicMonthDays, moonTropicalMonthDays,
+    moonFullMoonCycleEarthDays, moonFullMoonCycleICRFDays, moonApsidalMeetsNodalDays, moonLunarLevelingCycleDays,
+    moonDraconicYearICRFDays, moonDraconicYearEarthDays,
+  };
+}
+
+module.exports = { computeMassChainJ2000, computeMoonPeriodsJ2000 };

package/src/earth/mean-obliquity-history.cjs

@@ -0,0 +1,94 @@
+/**
+ * The mean obliquity of date ε̄(t) — the SECOND column the model reads from the
+ * cited Earth–Moon history (plan 12 §8, option (a)): Farhat, Auclair-Desrotour,
+ * Boué & Laskar 2022's own mean obliquity, carried in
+ * data/astrogeo22-earth-moon.json beside the distance.
+ *
+ * WHY AN INPUT. The composed lunisolar law (earth/precession-composed.cjs)
+ * scales the precession CONSTANT of date — α(t)/α₀ on the spin history and the
+ * lunar torque's (a₀/a_M)³. The precession RATE is α(t)·cos ε̄(t), and the chain
+ * had held cos ε̄ at its J2000 value at every epoch — a purity freeze without
+ * its twin. Standard theory since Goldreich 1966 (Touma & Wisdom 1994; Farhat
+ * et al. 2022) has the mean obliquity lower in the deep past, evolved by the
+ * lunar tidal torque through the Laplace-plane transition — the same
+ * ocean-dissipation physics option A declined to model for the distance. The
+ * published solution that computes ε̄(t) alongside a(t) is the input, as the
+ * distance is. Measured (plan 12 §8.1): the factor cos ε̄(t)/cos ε̄(0) closes
+ * the composed rate to Farhat's own precession column from −2.0 % to +0.4 % at
+ * 2.46 Ga and moves every paleo precession referee toward its source.
+ *
+ * WHAT IS READ. The column's cosine RATIO cos ε̄(t)/cos ε̄(0) — the SHAPE, as
+ * the distance is read as a(t)/a(0). The column's own value is published as the
+ * cited mean: 23.2545° at age 0, a Myr-scale MEAN of a secular solution, not
+ * the J2000 instant 23.4393° the hybrid obliquity integration starts from.
+ *
+ * INTERPOLATION. Cubic Hermite with central-difference tangents between the
+ * 1-Myr samples (one-sided at the ends) — C1. The column is monotone (measured:
+ * no sign change of its first difference across the 4,429 samples), so no
+ * limiter is needed. Forward of J2000 (t < 0) the column's J2000 one-sided
+ * slope is held — a labelled extrapolation, as the distance holds the LLR rate
+ * (the input has no future). Beyond the table's last sample the history
+ * REFUSES: null, never an extrapolation.
+ *
+ * HISTORICAL ERA. The slope at J2000 is −0.00264°/Myr: the factor is
+ * 1 − 2.0e-7 at 10 kyr and 1 − 2.0e-6 at 100 kyr — the ΔT era is untouched at
+ * the 1e-7 class; the deep-time clock T_p(t) shortens 0.75 % at the Devonian
+ * and 2.5 % at 2.46 Ga.
+ */
+
+'use strict';
+
+const D2R = Math.PI / 180;
+
+/**
+ * @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,
+ * }}
+ */
+function createMeanObliquityHistory(deps) {
+  const ages = deps.table.ageMa, eps = deps.table.obliquityDeg;
+  const n = ages ? ages.length : 0;
+  if (!(n >= 2) || !eps || eps.length !== n || ages[0] !== 0) {
+    throw new Error('mean-obliquity-history: the table must start at age 0 with ≥ 2 obliquity samples (a stale moon-distance embed lacks the obliquity column — regenerate the constants)');
+  }
+  const step = ages[1] - ages[0];
+  for (let i = 1; i < n; i++) {
+    if (ages[i] - ages[i - 1] !== step) throw new Error(`mean-obliquity-history: non-uniform age step at index ${i}`);
+  }
+  const spanMa = ages[n - 1];
+  // Central-difference tangents, deg per Ma (one-sided at the ends).
+  const m = new Float64Array(n);
+  m[0] = (eps[1] - eps[0]) / step;
+  for (let i = 1; i < n - 1; i++) m[i] = (eps[i + 1] - eps[i - 1]) / (2 * step);
+  m[n - 1] = (eps[n - 1] - eps[n - 2]) / step;
+  const cos0 = Math.cos(eps[0] * D2R);
+
+  /** @param {number} tMa @returns {number|null} the cited mean obliquity, degrees */
+  function meanObliquityDegAtAge(tMa) {
+    if (tMa <= 0) return eps[0] + m[0] * tMa;   // forward: the J2000 slope held (labelled extrapolation)
+    if (tMa > spanMa) return null;              // beyond the input: refused
+    const i = Math.min(Math.floor(tMa / step), n - 2);
+    const h = step, s = (tMa - ages[i]) / h, s2 = s * s, s3 = s2 * s;
+    return (2 * s3 - 3 * s2 + 1) * eps[i] + (s3 - 2 * s2 + s) * h * m[i]
+      + (-2 * s3 + 3 * s2) * eps[i + 1] + (s3 - s2) * h * m[i + 1];
+  }
+  /** cos ε̄(t)/cos ε̄(0) — the factor the precession RATE of date carries on the precession constant. ≡ 1 at J2000.
+   * @param {number} tMa @returns {number|null} */
+  function cosRatioAtAge(tMa) {
+    const e = meanObliquityDegAtAge(tMa);
+    return e === null ? null : Math.cos(e * D2R) / cos0;
+  }
+  return { meanObliquityDegAtAge, cosRatioAtAge, meanObliquityJ2000Deg: eps[0], spanMa };
+}
+
+module.exports = { createMeanObliquityHistory };

package/src/earth/precession-composed.cjs

@@ -13,6 +13,20 @@
  * (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.
  *
+ * THE RATE OF DATE vs THE CONSTANT (plan 12 §8, option (a)): the law above
+ * scales the precession CONSTANT α(t) ∝ ω(t)·[torque term] — the rate at the
+ * J2000 obliquity. The precession RATE is α(t)·cos ε̄(t), so the published
+ * rate carries one more factor, the cited mean obliquity's cos ε̄(t)/cos ε̄(0)
+ * (earth/mean-obliquity-history.cjs — Farhat 2022's own column, the second
+ * column read from the distance history; the chain had held cos ε̄ at J2000
+ * at every epoch). torqueRate… is the constant's scaling — what the hybrid
+ * obliquity integration takes, since its own ŝ·n̂ carries the cosine;
+ * composedRate… is the rate of date — T_p(t), the obliquity beat, the tropical
+ * year of date, the paleo referees' precession constant k. Both ≡ p₀ at J2000;
+ * the factor is 1 − 2e-7 at 10 kyr and 1.0245 at 2.46 Ga (the composed rate
+ * 106.6 → 109.2 ″/yr against Lantink 2022's 108.6 ± 8.5; Farhat's own
+ * precession column on the same table: 108.8).
+ *
  * THE ANCHOR p₀ (plan 06 S5 — one J2000 precession reading): p₀ is the
  * model's DERIVED J2000 rate, 1,296,000/axial0 with axial0 the certified
  * year-length laws' beat at 2000 (sid/(sid − trop) = 25,771.4 yr = 50.2883
@@ -64,14 +78,20 @@ 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),
@@ -107,14 +127,37 @@ function createComposedPrecession(deps) {
     const lf = lunarTorqueFactorAtAge(tMa);
     return lf === null ? null : fS + (1 - fS) * lf;
   };
-  /** @param {number} tMa */
-  const composedRateArcsecPerYrAtAge = (tMa) => {
+  /** cos ε̄(t)/cos ε̄(0) from the cited mean obliquity — 1 when no history is
+   * injected (the constant alone, bit-identical). @param {number} tMa @returns {number|null} */
+  const cosRatio = deps.meanObliquityCosRatioAtAge;
+  /** @type {(tMa: number) => number|null} */
+  const obliquityFactorAtAge = cosRatio ? (tMa) => cosRatio(tMa) : () => 1;
+  /** THE PRECESSION CONSTANT OF DATE as a rate on the J2000 obliquity, ″/yr —
+   * [ω(t)/ω₀]·p₀·[f_S + (1 − f_S)(a₀/a_M)³] = α(t)·cos ε̄₀. The hybrid
+   * obliquity integration takes THIS: ds/dt = α(ŝ·n̂)(ŝ×n̂) carries its own cosine.
+   * @param {number} tMa */
+  const torqueRateArcsecPerYrAtAge = (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 torquePeriodYearsAtAge = (tMa) => {
+    const r = torqueRateArcsecPerYrAtAge(tMa);
+    return r === null ? null : 1296000 / r;
+  };
+  /** THE PRECESSION RATE OF DATE ψ̇(t), ″/yr — the constant × cos ε̄(t)/cos ε̄(0):
+   * the published rate (T_p(t) = 1,296,000/ψ̇, the obliquity beat, the tropical
+   * year of date, the paleo referees' precession constant k).
+   * @param {number} tMa */
+  const composedRateArcsecPerYrAtAge = (tMa) => {
+    const r = torqueRateArcsecPerYrAtAge(tMa);
+    if (r === null) return null;
+    const f = obliquityFactorAtAge(tMa);
+    return f === null ? null : r * f;
+  };
+  /** @param {number} tMa */
   const composedPeriodYearsAtAge = (tMa) => {
     const r = composedRateArcsecPerYrAtAge(tMa);
     return r === null ? null : 1296000 / r;
@@ -134,6 +177,9 @@ function createComposedPrecession(deps) {
     composedRateArcsecPerYrAtYear: (year) => composedRateArcsecPerYrAtAge(deps.yearToTMa(year)),
     composedPeriodYearsAtYear: (year) => composedPeriodYearsAtAge(deps.yearToTMa(year)),
     composedRateRatioAtAge,
+    torqueRateArcsecPerYrAtAge,
+    torquePeriodYearsAtAge,
+    obliquityFactorAtAge,
     torqueTermAtAge,
     lunarTorqueFactorAtAge,
     solarShare: fS,

package/src/index.js

@@ -106,6 +106,20 @@ export { createDerivedViews } from './layer1/index.js';
 // file via the exports-map subpath; re-exported here so bundled ESM
 // consumers need only the package root.
 export { createDeepCalendar } from './phase/deep-calendar.cjs';
+// Plan 13 B1: the civil calendar ↔ JD (Meeus ch. 7 with the 1582-10-15
+// reform) and the angle constants/wraps — ONE home; the browser's eighteen
+// calendar copies and 27 local D2R constants import these.
+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';
+// Plan 13 B2: THE deep-time chain assembly — the GIA α channel, the Layer-0
+// bundle, the cited Moon-distance history, the ΔT cycle stack, |s₃|, the
+// LOD/ΔT core, the lunar month chain and the mean*AtAge family, assembled
+// ONCE from the generated constants; the Node twin and the browser destructure it.
+export { createDeepTimeChain, MOON_ECC_SENSITIVITY_PERIGEE, MOON_ECC_SENSITIVITY_NODE } from './deltat/deep-time-chain.js';
+// Plan 13 B3: the J2000 mass chain and the Moon's J2000 periods (one home for
+// three copies each) and the unit constants.
+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';
 // D4b: the one-source cardinal structure — the EoC layer (year lengths,
 // crossing offsets, the e(t)-proportional spread) on the movement's own
 // e(t)/ϖ(t). Absolute dates deliberately excluded (per-renderer mean chain).
@@ -156,6 +170,9 @@ export { createYearLengths, computeMeanTropicalYearJ2000Days, ONE_FAMILY_WINDOW_
 // (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';
+// Plan 12 §8 option (a): the cited mean obliquity of date — the second column read from the
+// Earth–Moon history; the precession RATE of date carries its cos ε̄(t)/cos ε̄(0) on the constant.
+export { createMeanObliquityHistory } from './earth/mean-obliquity-history.cjs';
 // (planets/predict.cjs — the planet predictive-precession feature basis — was
 // retired at plan 06 R8 with PREDICT_COEFFS_PHYSICAL.)
 // L10 — the composition front door: one law set, N body records. Thin by
@@ -167,7 +184,12 @@ export { PLANET_DISPLAY_NAMES } from './planets/display-names.cjs';
 // Phase 8.4 — the climate/ΔT machinery, extracted layer by layer.
 export { createDeltaTCycles } from './deltat/cycles.cjs';
 export { createDeepTimeLod } from './deltat/deep-time.cjs';
-export { createMoonRecessionHistory, createSolarChannelBudget } from './deltat/recession-history.cjs';
+// plan 12 (option A): the Earth–Moon distance history is a CITED PHYSICAL
+// INPUT (Farhat et al. 2022, the AstroGeo22 ephemeris) read as a shape on the
+// model's J2000 anchor; the fitted quartic, the rock-fitted regime spline and
+// the solar-channel budget are deleted.
+export { createMoonDistanceHistory } from './deltat/moon-distance-history.cjs';
+export { MOON_DISTANCE_ARTIFACT, MOON_DISTANCE_ARTIFACT_HASH } from './deltat/moon-distance-artifact.cjs';
 export { deltaTEspenakMeeusCanonSeconds } from './deltat/historical.cjs';
 export { evalClimateL1OrbitalPermil, laggedL1Terms, createAlphaGiaChannel } from './climate/l1-orbital.cjs';
 // Phase 8.5 — eclipse geometry (single-copy: the browser had no Node twin).

package/src/layer0/derive-params.js

@@ -24,9 +24,7 @@ import { computeSolarTorqueShare } from '../earth/precession-composed.cjs';
  * @property {number} solarLuminosityW          IAU 2015 nominal (W)
  * @property {number} solarWindKgPerS           Ulysses/ACE/Wind
  * @property {number} speedOfLightKmPerS        km/s (fallback 299792458 m/s if falsy)
- * @property {number} alpha1PerMa
- * @property {number} alpha3PerMa3
- * @property {number} alpha4PerMa4
+ * @property {number} alpha1PerMa                 the LLR recession rate — the cited distance history's J2000 slope
  * @property {number} meanSiderealYearSeconds
  * @property {number} lodJ2000Seconds              ω₀: the J2000 day length, SI seconds (the SI day since plan 09)
  * @property {number} sunMassKg                 M_SUN
@@ -85,8 +83,6 @@ export const deriveEpochParams = (raw) => {
   return Object.freeze({
     epochYear: 2000,
     alpha1PerMa: raw.alpha1PerMa,
-    alpha3PerMa3: raw.alpha3PerMa3,
-    alpha4PerMa4: raw.alpha4PerMa4,
     moonDistanceNowM,
     moonLockDistanceM,
     totalAngularMomentumKgM2S,