@essrt/physics 22.0.1 → 23.0.0

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

@@ -500,6 +500,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 +516,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 +539,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 +573,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 +588,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/index.js

@@ -167,7 +167,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,

package/src/layer0/index.js

@@ -32,9 +32,7 @@
 /**
  * @typedef {Object} EpochParams
  * @property {number} epochYear                  year at t_Ma = 0 (2000, NOT startmodelYear)
- * @property {number} alpha1PerMa                Moon recession, LLR-anchored
- * @property {number} alpha3PerMa3
- * @property {number} alpha4PerMa4
+ * @property {number} alpha1PerMa                Moon recession, LLR-anchored (the J2000 slope of the cited history)
  * @property {number} moonDistanceNowM           a_Moon at J2000, metres
  * @property {number} moonLockDistanceM          tidal-lock asymptote, metres
  * @property {number} totalAngularMomentumKgM2S  L_tot of the Earth-Moon system
@@ -53,17 +51,21 @@
 /**
  * @typedef {Object} EpochPrimitives
  * @property {(year: number) => number} tMa
- * @property {(year: number) => number} moonDistanceMetres
+ * @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)
  */
 
 /**
- * @param {{params: EpochParams, alphaAtAgeMa: (tMa: number) => number}} deps
+ * @param {{params: EpochParams, alphaAtAgeMa: (tMa: number) => number,
+ *   moonDistanceMetresAtAge: (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).
  * @returns {EpochPrimitives}
  */
-export const createEpochPrimitives = ({ params: p, alphaAtAgeMa }) => {
+export const createEpochPrimitives = ({ params: p, alphaAtAgeMa, moonDistanceMetresAtAge }) => {
   /**
    * Years before the epoch, in Ma. The ONE place this conversion lives.
    * @param {number} year
@@ -72,24 +74,21 @@ export const createEpochPrimitives = ({ params: p, alphaAtAgeMa }) => {
   const tMa = (year) => (p.epochYear - year) / 1e6;
 
   /**
-   * Moon semi-major axis. Cubic in t_Ma: alpha1 is LLR-anchored, alpha3/alpha4
-   * are the Farhat 2022 deep-time fit.
+   * Moon distance at age t — the cited history (null beyond its span).
    * @param {number} t age in Ma
-   * @returns {number} metres
+   * @returns {number|null} metres
    */
-  const moonDistanceMetresCore = (t) =>
-    p.moonDistanceNowM
-      * (1 + p.alpha1PerMa * t + p.alpha3PerMa3 * t * t * t + p.alpha4PerMa4 * t * t * t * t);
+  const moonDistanceMetresCore = (t) => moonDistanceMetresAtAge(t);
 
   /**
    * Length of day from angular-momentum conservation: as the Moon recedes it
    * takes orbital angular momentum and Earth's spin slows to compensate.
    * @param {number} t age in Ma
-   * @returns {number|null} seconds; null past the tidal-lock asymptote
+   * @returns {number|null} seconds; null past the tidal-lock asymptote or the history's span
    */
   const lodSecondsCore = (t) => {
     const a = moonDistanceMetresCore(t);
-    if (a <= 0 || a >= p.moonLockDistanceM) return null;
+    if (a === null || a <= 0 || a >= p.moonLockDistanceM) return null;
     const iEarth = alphaAtAgeMa(t) * p.earthMassKg * p.earthRadiusM * p.earthRadiusM;
     return (2 * Math.PI * iEarth)
       / (p.totalAngularMomentumKgM2S

package/src/model.js

@@ -28,7 +28,8 @@ import { createPlanetSpinChannelFromArtifacts, computeObliquityJ2000Deg } from '
 import { PLANET_DISPLAY_NAMES } from './planets/display-names.cjs';
 import { createDeltaTCycles } from './deltat/cycles.cjs';
 import { createDeepTimeLod } from './deltat/deep-time.cjs';
-import { createMoonRecessionHistory, createSolarChannelBudget } from './deltat/recession-history.cjs';
+import { createMoonDistanceHistory } from './deltat/moon-distance-history.cjs';
+import { MOON_DISTANCE_ARTIFACT } from './deltat/moon-distance-artifact.cjs';
 import { evalClimateL1OrbitalPermil, createAlphaGiaChannel } from './climate/l1-orbital.cjs';
 import { createDeepEccChannel } from './moon/deep-ecc-channel.cjs';
 import { DEEP_MODES_ARTIFACT } from './moon/deep-modes-artifact.cjs';
@@ -197,8 +198,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     solarWindKgPerS: C.physicalConstants.solarWindMassLossKgPerS,
     speedOfLightKmPerS: C.physicalConstants.speedOfLight,
     alpha1PerMa: C.deepTime.alpha1PerMa,
-    alpha3PerMa3: C.deepTime.alpha3PerMa3,
-    alpha4PerMa4: C.deepTime.alpha4PerMa4,
     meanSiderealYearSeconds,
     lodJ2000Seconds: meanLengthOfDay,   // plan 09: ω₀ = the SI day (was the H/13 kinematic day)
     sunMassKg: M_SUN,
@@ -219,38 +218,22 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     axialPrecessionJ2000Years: certifiedAxialPrecessionJ2000Years(),
   });
 
-  // ── Driver 1½: regime-aware recession history + the solar channels ────────
-  // The quartic stays bit-identical ≤ jointMa (the Wells/Wu-gated era);
-  // beyond, the fitted staircase spline to the Roche crossing, and the
-  // ocean-leak/thermal-pump channels make L_EM time-dependent.
-  const REGIME = C.deepTime.recessionRegime;
-  const recession = createMoonRecessionHistory({
+  // ── The Earth–Moon distance history — a CITED PHYSICAL INPUT (plan 12, option A)
+  // Farhat et al. 2022 (the AstroGeo22 ephemeris, embedded VERBATIM by the
+  // constants generator) read as the ratio a(t)/a(0) on the model's own J2000
+  // anchor, the J2000 slope the LLR observation α₁; null beyond its span. LOD
+  // follows by angular-momentum conservation with the J2000 L_EM constant —
+  // the former quartic, regime spline and solar-channel budget are deleted.
+  const recession = createMoonDistanceHistory({
+    table: MOON_DISTANCE_ARTIFACT,
     aMoonNowMetres: EPOCH_PARAMS.moonDistanceNowM,
     alpha1PerMa: EPOCH_PARAMS.alpha1PerMa,
-    alpha3PerMa3: EPOCH_PARAMS.alpha3PerMa3,
-    alpha4PerMa4: EPOCH_PARAMS.alpha4PerMa4,
-    regime: {
-      jointMa: REGIME.jointMa,
-      knotAgesMa: REGIME.knotAgesMa,
-      knotDistancesKm: REGIME.knotDistancesKm,
-      genesisMa: REGIME.genesisMa,
-      rocheLimitKm: REGIME.rocheLimitKm,
-    },
   });
   const moonDistanceMetresAtAge = recession.distanceMetresAtAge;
-  const solarBudget = createSolarChannelBudget({
-    lTotalJ2000KgM2S: EPOCH_PARAMS.totalAngularMomentumKgM2S,
-    mMoonAloneKg: EPOCH_PARAMS.moonMassKg,
-    gmEmM3PerS2: EPOCH_PARAMS.gmEarthMoonM3S2,
-    eFactorMoon: EPOCH_PARAMS.moonEccentricityFactor,
-    beta0: REGIME.solarOceanLeakBeta0,
-    pumpStartMa: REGIME.thermalPumpStartMa,
-    pumpEndMa: REGIME.thermalPumpEndMa,
-    pumpFactor: REGIME.thermalPumpFactor,
-    jointMa: REGIME.jointMa,
-    genesisMa: REGIME.genesisMa,
-    distanceMetresAtAge: moonDistanceMetresAtAge,
-  });
+  /** The published surfaces' km reading — NaN beyond the cited history's span (the API's
+   *  validity span lies inside it; the deep charts stop where the input stops).
+   *  @param {number} year @returns {number} */
+  const moonDistanceKmAtYearOrNaN = (year) => { const m = moonDistanceMetresAtAge(yearToTMa(year)); return m === null ? NaN : m / 1000; };
 
   const DT = F.DT_STACK;
   const RES = F.DT_RESONATOR;
@@ -343,8 +326,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       aLockMetres: EPOCH_PARAMS.moonLockDistanceM,
       aMoonNowMetres: EPOCH_PARAMS.moonDistanceNowM,
       alpha1PerMa: EPOCH_PARAMS.alpha1PerMa,
-      alpha3PerMa3: EPOCH_PARAMS.alpha3PerMa3,
-      alpha4PerMa4: EPOCH_PARAMS.alpha4PerMa4,
       lodNowH13Seconds: EPOCH_PARAMS.lodNowH13Seconds,
       meanSiderealYearJ2000Seconds: meanSiderealYearSeconds,
       solarMassLossFracPerYear: EPOCH_PARAMS.solarMassLossFracPerYear,
@@ -361,7 +342,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     cycleLodSumAt: dtCycleLodCorrectionSum,
     swingLodAt: (year) => dtCycles.swingLodSecondsAt(year),
     swingLodRateAt: (year) => dtCycles.swingLodRateAt(year),
-    lEmAtAgeKgm2S: solarBudget.lEmAtAgeKgm2S,
+    // plan 12 option A: L_EM is the J2000 constant (conservation; no channels);
+    // the LOD-rate decomposition's tidal term reads the history's analytic slope.
+    moonDistanceSlopeMetresPerMaAtAge: recession.slopeMetresPerMaAtAge,
   });
 
   // (Plan 09 step 7a: the integrated ∫dt/H_era phase table and its counter
@@ -588,19 +571,23 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     // and the year-length rates (±0.5-yr central differences through the
     // grid) then returned grid-segment averages instead of local rates
     // (anomalistic of date +2.63 s / +19 s, visit-order dependent).
-    const samplers = /** @type {Map<number|'deep', any>} */ (new Map());
-    let deepRangeYr = 0;
+    const samplers = /** @type {Map<number, any>} */ (new Map());
     const gridStep = (/** @type {number} */ n) => (n <= 50000 ? 100 : n <= 2000000 ? 1000 : 5000);
-    const tierSpan = (/** @type {number} */ n) => (n <= 50000 ? 50000 : n <= 2000000 ? 2000000 : Math.ceil(n * 1.25 / 5000) * 5000);
+    const tierSpan = (/** @type {number} */ n) => (n <= 50000 ? 50000 : 2000000);
     const sampleAt = (/** @type {number} */ year) => {
       const t = year - 2000, need = Math.max(20000, Math.abs(t) * 1.25);
-      const span = tierSpan(need);
-      const key = span > 2000000 ? /** @type {'deep'} */ ('deep') : span;
-      if (!samplers.has(key) || (key === 'deep' && span > deepRangeYr)) {
-        if (key === 'deep') deepRangeYr = span;
-        samplers.set(key, hist.build(span, -span, gridStep(span)));
+      if (need > 2000000) {
+        // The deep tier (5000-yr grid): walked in the queried DIRECTION only,
+        // to two nodes past the query, and EXTENDED by the factory's shared
+        // walk when a deeper epoch arrives (plan 13 A1). It was built to
+        // ±1.25·|t| in both directions and rebuilt from J2000 on every deeper
+        // probe — bit-identical values, 4× the RK4 steps of one walk.
+        const span = Math.ceil((Math.abs(t) + 2 * 5000) / 5000) * 5000;
+        return hist.build(t < 0 ? -span : span, 0, 5000).at(t);
       }
-      return samplers.get(key).at(t);
+      const span = tierSpan(need);
+      if (!samplers.has(span)) samplers.set(span, hist.build(span, -span, gridStep(span)));
+      return samplers.get(span).at(t);
     };
     // The anomalistic year rides THIS movement's own apsidal line (the
     // scene's perihelion) — the factory owns the construction; the planet
@@ -686,8 +673,9 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   const moonSiderealMonthDaysAt = (year) => {
     const tMa = yearToTMa(year);
     const lod = deepLod.lodSecondsAtAge(tMa);
-    if (lod === null) return NaN;
-    const aAppKm = moonDistanceMetresAtAge(tMa) / 1000;
+    const aAppM = moonDistanceMetresAtAge(tMa);
+    if (lod === null || aAppM === null) return NaN;
+    const aAppKm = aAppM / 1000;
     const sidYrDays = deepLod.siderealYearSecondsAtAge(tMa) / lod;
     const deltaA = aAppKm * (1 / (MASS_RATIO_EARTH_MOON + 1)) * (moonSiderealMonthInput / sidYrDays);
     const aCorrM = (aAppKm + deltaA) * 1000;
@@ -973,9 +961,6 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
   const moonChain = createMoonMonthChain({
     constants: {
       aMoonNowMetres: EPOCH_PARAMS.moonDistanceNowM,
-      alpha1PerMa: EPOCH_PARAMS.alpha1PerMa,
-      alpha3PerMa3: EPOCH_PARAMS.alpha3PerMa3,
-      alpha4PerMa4: EPOCH_PARAMS.alpha4PerMa4,
       gmEarthMoonM3PerS2: EPOCH_PARAMS.gmEarthMoonM3S2,
       massRatioEarthMoon: MASS_RATIO_EARTH_MOON,
       moonSiderealMonthInputDays: moonSiderealMonthInput,
@@ -1516,6 +1501,34 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       jdFromYear,
       siTropicalYearDays,
     }),
+    // The Moon-Kepler mass chain — the J2000 derivation docs 24 / the website's
+    // "mass from the Moon" page narrate, published from the one place that
+    // computes it (physics 22.1.0; the pages used to carry its numbers as
+    // hand-typed literals): Kepler III on the Moon's orbit with the
+    // solar-tidal shift Δa = a·μ·m (μ the Moon's mass fraction, m the lunar
+    // small parameter T_M/T_sidereal-year), the Earth/Moon split on the
+    // DE440 mass ratio, and GM_Sun from Earth's heliocentric orbit minus
+    // GM_Earth. Every value is the J2000 snapshot the rest of the model runs
+    // on; the of-date Moon distance is the recession history (epoch.*).
+    massChain: Object.freeze({
+      moonDistanceKm,
+      moonSiderealMonthDays: moonSiderealMonth,
+      siderealYearDays: meanSiderealYearDays,
+      dayLengthSeconds: meanLengthOfDay,
+      massRatioEarthMoon: MASS_RATIO_EARTH_MOON,
+      lunarSmallParameter: moonSiderealMonth / meanSiderealYearDays,
+      moonMassFraction: 1 / (MASS_RATIO_EARTH_MOON + 1),
+      solarTidalShiftKm: moonOrbitalShift,
+      moonDistanceCorrectedKm: moonDistanceCorrected,
+      gmEarthMoonSystemKm3S2: GM_EARTH_MOON_SYSTEM,
+      gmEarthKm3S2: GM_EARTH_ALONE,
+      gmMoonKm3S2: GM_MOON_ALONE,
+      gmSunPlusEarthKm3S2: GM_SUN_PLUS_EARTH,
+      gmSunKm3S2: GM_SUN,
+      sunMassKg: M_SUN,
+      earthMassKg: GM_EARTH_ALONE / G_CONSTANT,
+      gravitationalConstantKm3KgS2: G_CONSTANT,
+    }),
     // Plan 09: the ONE certified Sun's mean elements of date — the lunar
     // arguments of every runtime build their Sun from these two (the Node
     // scene twin and the browser read them here; the "model timeline" Sun on
@@ -1540,7 +1553,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       // + the calibrated ΔT cycle stack. 86,400.001780 s at J2000.
       lodRealSecondsAtYear: /** @param {number} year @returns {number} */ (year) => lodRealSeconds(year),
       alphaAtYear: /** @param {number} year @returns {number} */ (year) => earthMoiFactorAtAge(yearToTMa(year)),
-      moonDistanceKmAtYear: /** @param {number} year @returns {number} */ (year) => moonDistanceMetresAtAge(yearToTMa(year)) / 1000,
+      moonDistanceKmAtYear: /** @param {number} year @returns {number} */ (year) => moonDistanceKmAtYearOrNaN(year),
       // D6: OF-DATE — mass-loss law / the banked planetary λ̇ ratio
       // (identical at J2000 where the ratio ≡ 1 by construction)
       siderealYearSecondsAtYear: /** @param {number} year @returns {number} */ (year) => yearLengthsM.siderealYearSecondsAtYear(year),
@@ -1718,7 +1731,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
     // the single surface the panel, charts, API and website consume.
     yearLengths: yearLengthsM,
     moon: Object.freeze({
-      distanceKmAtYear: /** @param {number} year @returns {number} */ (year) => moonDistanceMetresAtAge(yearToTMa(year)) / 1000,
+      distanceKmAtYear: /** @param {number} year @returns {number} */ (year) => moonDistanceKmAtYearOrNaN(year),
       siderealMonthDaysAtYear: moonSiderealMonthDaysAt,
       synodicMonthDays: moonSynodicMonthDays,
       // The apparent-position chain (truncated Meeus Ch. 47 series on
@@ -1752,7 +1765,7 @@ export function assembleModel(C, F, laws = {}, secularSeriesArtifact = /** @type
       // construction sites (tools/verify/eclipse-audit.js, the browser
       // _eclipse twins) spread the SAME assembly into their own
       // createEclipseFinders call instead of triplicating it (the
-      // three-runtimes rule — cf. recession-history):
+      // three-runtimes rule — cf. moon-distance-history):
       frameworkSunDeps: Object.freeze({
         sunMeanLongitudeJ2000Deg: sunL0Deg,
         tropicalRateDegPerCy: sunTropicalRateDegPerCy,

package/src/moon/month-chain.cjs

@@ -49,9 +49,6 @@
  * @param {{
  *   constants: {
  *     aMoonNowMetres: number,
- *     alpha1PerMa: number,
- *     alpha3PerMa3: number,
- *     alpha4PerMa4: number,
  *     gmEarthMoonM3PerS2: number,
  *     massRatioEarthMoon: number,
  *     moonSiderealMonthInputDays: number,
@@ -67,7 +64,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
@@ -77,32 +74,27 @@
  *   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).
  */
 function createMoonMonthChain({ constants, fns }) {
   const {
-    aMoonNowMetres, alpha1PerMa, alpha3PerMa3, alpha4PerMa4,
+    aMoonNowMetres,
     gmEarthMoonM3PerS2, massRatioEarthMoon, moonSiderealMonthInputDays,
     meanSiderealYearJ2000Seconds,
     moonApsidalJ2000Seconds, moonNodalJ2000Seconds,
     moonSiderealMonthJ2000Seconds,
     sPerigee, sNode,
   } = constants;
-  const { meanLodSecondsAtAge, meanSiderealYearSecondsAtAge, precessionPeriodYearsAtAge, modulation } = fns;
+  const { meanLodSecondsAtAge, meanSiderealYearSecondsAtAge, precessionPeriodYearsAtAge, modulation, distanceMetresAtAge } = fns;
+  if (typeof distanceMetresAtAge !== 'function') throw new Error('month-chain: fns.distanceMetresAtAge (the cited distance history) is required');
+  void aMoonNowMetres;
 
-  /** Farhat α₁/α₃/α₄ polynomial — Earth–Moon distance in metres at age t_Ma.
-   *  @param {number} tMa @returns {number} */
-  function quarticMetresAtAge(tMa) {
-    const t = tMa;
-    return aMoonNowMetres * (1 + alpha1PerMa * t + alpha3PerMa3 * t * t * t + alpha4PerMa4 * t * t * t * t);
-  }
-  const distanceMetresAtAge = fns.distanceMetresAtAge ?? quarticMetresAtAge;
-
-  /** @param {number} tMa @returns {number} */
+  /** @param {number} tMa @returns {number|null} */
   function distanceKmAtAge(tMa) {
-    return distanceMetresAtAge(tMa) / 1000;
+    const m = distanceMetresAtAge(tMa);
+    return m === null ? null : m / 1000;
   }
 
   /** Solar Δa correction (km) for the Moon's apparent semi-major axis
@@ -120,6 +112,7 @@ function createMoonMonthChain({ constants, fns }) {
    *  @param {number} tMa @returns {number | null} */
   function distanceCorrectedKmAtAge(tMa) {
     const aApp = distanceKmAtAge(tMa);
+    if (aApp === null) return null;
     const dA = solarDeltaAKmAtAge(tMa, aApp);
     return (dA === null) ? null : aApp + dA;
   }