@essrt/physics 23.0.0 → 23.2.0

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)]);

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

package/src/layer0/index.js

@@ -54,18 +54,21 @@
  * @property {(year: number) => number|null} moonDistanceMetres - null beyond the cited history's span
  * @property {(year: number) => number|null} lodSeconds
  * @property {(year: number) => number} siderealYearSeconds
- * @property {(year: number) => number} tropicalYearSeconds      sidereal less one equinox turn per T_p(t) (the composed precession period)
+ * @property {(year: number) => number} tropicalYearSeconds      sidereal less one equinox turn per T_p(t) (the composed precession period on the RATE of date)
  */
 
 /**
  * @param {{params: EpochParams, alphaAtAgeMa: (tMa: number) => number,
- *   moonDistanceMetresAtAge: (tMa: number) => number|null}} deps —
+ *   moonDistanceMetresAtAge: (tMa: number) => number|null,
+ *   meanObliquityCosRatioAtAge?: (tMa: number) => number|null}} deps —
  *   moonDistanceMetresAtAge is the engine's cited distance history
  *   (deltat/moon-distance-history: Farhat et al. 2022 as a shape on the
- *   J2000 anchor; plan 12 option A — the layer0 quartic twin is deleted).
+ *   J2000 anchor; plan 12 option A — the layer0 quartic twin is deleted);
+ *   meanObliquityCosRatioAtAge the cited mean obliquity's cos ε̄(t)/cos ε̄(0)
+ *   (earth/mean-obliquity-history, plan 12 §8 option (a)) — OPTIONAL, absent → 1.
  * @returns {EpochPrimitives}
  */
-export const createEpochPrimitives = ({ params: p, alphaAtAgeMa, moonDistanceMetresAtAge }) => {
+export const createEpochPrimitives = ({ params: p, alphaAtAgeMa, moonDistanceMetresAtAge, meanObliquityCosRatioAtAge }) => {
   /**
    * Years before the epoch, in Ma. The ONE place this conversion lives.
    * @param {number} year
@@ -80,6 +83,14 @@ export const createEpochPrimitives = ({ params: p, alphaAtAgeMa, moonDistanceMet
    */
   const moonDistanceMetresCore = (t) => moonDistanceMetresAtAge(t);
 
+  /**
+   * cos ε̄(t)/cos ε̄(0) of the cited mean obliquity — the precession RATE's
+   * factor on the constant (plan 12 §8); 1 when no history is injected.
+   * @param {number} t age in Ma
+   * @returns {number|null}
+   */
+  const meanObliquityCosRatioCore = (t) => (meanObliquityCosRatioAtAge ? meanObliquityCosRatioAtAge(t) : 1);
+
   /**
    * Length of day from angular-momentum conservation: as the Moon recedes it
    * takes orbital angular momentum and Earth's spin slows to compensate.
@@ -122,7 +133,9 @@ export const createEpochPrimitives = ({ params: p, alphaAtAgeMa, moonDistanceMet
    * Tropical year of date — the sidereal year less the equinox's own motion
    * over one year: one turn per the composed lunisolar precession period
    * T_p(t), i.e. 1/T_trop = 1/T_sid + ψ̇(t)/(1,296,000″ · Julian-year s) with
-   * ψ̇(t) = [ω₀/ω(t)]⁻¹… spelled as (LOD₀/LOD(t))·p₀·[f_S + (1 − f_S)(a₀/a_M)³].
+   * ψ̇(t) the RATE of date, spelled as (LOD₀/LOD(t))·p₀·[f_S + (1 − f_S)(a₀/a_M)³]
+   * × cos ε̄(t)/cos ε̄(0) — the cited mean obliquity's factor (plan 12 §8 option (a);
+   * injected, 1 when absent).
    * Plan 09 step 5d: it was the unit's calendar convention sid·(1 − 13/H(t))
    * (plan 06 D2 kept it as a named device), 0.086 % slow on the equinox term
    * — 1.0 s of year at J2000, integrated by the deep JD↔year calendar. The
@@ -142,7 +155,8 @@ export const createEpochPrimitives = ({ params: p, alphaAtAgeMa, moonDistanceMet
     const lf = (a === null || !(a > 0)) ? null : Math.pow(p.moonDistanceNowM / a, 3);
     const term = lf === null ? null : p.precessionSolarShareJ2000 + (1 - p.precessionSolarShareJ2000) * lf;
     const p0 = p.precessionRateJ2000ArcsecPerYr;
-    const rate = (lod === null || !(lod > 0) || term === null) ? p0 : (p.lodNowH13Seconds / lod) * p0 * term;
+    const f = meanObliquityCosRatioCore(t);
+    const rate = (lod === null || !(lod > 0) || term === null || f === null) ? p0 : (p.lodNowH13Seconds / lod) * p0 * term * f;
     return 1 / (1 / sid + rate / (1296000 * 365.25 * 86400));
   };
 

package/src/math/angles.cjs

@@ -0,0 +1,38 @@
+/**
+ * Angles — ONE home for the degree ↔ radian constants and the wraps
+ * (holisticuniverse plan 13 B1). Before B1 the browser carried 27 local
+ * `D2R`-style constants and twelve local wrap helpers in three ±180 forms;
+ * the package itself a dozen private `D2R`s.
+ *
+ * The two ±180 forms in use differ only AT the boundary: `wrap180` maps
+ * +180 to −180 (the half-open [−180, 180) the longitude-difference sites
+ * use), `wrap180Closed` keeps +180 (the (−180, 180] of the residual
+ * printers). A site keeps the form it had — B1 moves the formula, never
+ * the convention.
+ *
+ * Pure, no model dependencies.
+ */
+
+'use strict';
+
+/** π/180 — degrees to radians. */
+const DEG2RAD = Math.PI / 180;
+/** 180/π — radians to degrees. */
+const RAD2DEG = 180 / Math.PI;
+/** Arcseconds in a full turn. */
+const ARCSEC_PER_TURN = 1296000;
+/** Arcseconds per radian, 206264.806…  */
+const ARCSEC_PER_RAD = (180 / Math.PI) * 3600;
+
+/** @param {number} x degrees @returns {number} the same angle in [0, 360) */
+const wrap360 = (x) => ((x % 360) + 360) % 360;
+/** @param {number} x degrees @returns {number} the same angle in [−180, 180) */
+const wrap180 = (x) => ((x + 540) % 360 + 360) % 360 - 180;
+/** @param {number} x degrees @returns {number} the same angle in (−180, 180] */
+const wrap180Closed = (x) => { const w = ((x % 360) + 360) % 360; return w > 180 ? w - 360 : w; };
+/** @param {number} x radians @returns {number} the same angle in [0, 2π) */
+const wrap2pi = (x) => { const tau = 2 * Math.PI; return ((x % tau) + tau) % tau; };
+/** @param {number} x radians @returns {number} the same angle in [−π, π) */
+const wrapPi = (x) => { const tau = 2 * Math.PI; return ((x + Math.PI) % tau + tau) % tau - Math.PI; };
+
+module.exports = { DEG2RAD, RAD2DEG, ARCSEC_PER_TURN, ARCSEC_PER_RAD, wrap360, wrap180, wrap180Closed, wrap2pi, wrapPi };