@essrt/physics 1.1.0 → 1.3.0

package/README.md

@@ -75,8 +75,13 @@ with their own formula), `identity` (version + hashes + citation DOI), `epoch`
 (H, LOD, α, ΔT, deep-time quantities at any year ±500 Myr), `earth`
 (obliquity, eccentricity, inclination, perihelion), `lengths` (year and
 day lengths), `cardinal` (solstice/equinox JD, RA, year length), `moon`
-(distance, sidereal month). Validation targets are refused as inputs —
-a counterfactual cannot move the goalposts it is judged by.
+(distance and months at epoch, plus the apparent-position chain on the
+JD(UT) axis — ecliptic longitude, latitude and distance from the shared
+Meeus series over framework-native arguments), `eclipse` (geocentric
+solar/lunar eclipse search over a JD window, greatest-eclipse convention),
+`climate` (the L1 orbital-forcing formula) and `planets` (the Fibonacci-law
+records and orientation at epoch). Validation targets are refused as
+inputs — a counterfactual cannot move the goalposts it is judged by.
 
 ## Underneath: a parts library
 
@@ -88,7 +93,9 @@ browser. For custom wiring (different α channel, subset assembly), use
 the factories directly: the reference adapter is `tools/lib/` in the
 [public repository](https://github.com/dvansonsbeek/3d) — the hosted
 simulator and the project's verification gates run on it. A service
-surface (API/MCP) over `createModel()` is on the project roadmap.
+surface over `createModel()` lives in the same repository
+(`packages/api`, an OpenAPI 3.1 handler with zero runtime dependencies)
+— build-only until the hosting decision.
 
 ## Provenance
 

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@essrt/physics",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "ESSRT (Expanding Solar System Resonance Theory) physics core \u2014 pure, injectable-constants, no I/O, no globals, no DOM. The complete model incl. fitted coefficients; every published version immutably ships one recorded model identity.",
   "essrt": {
-    "modelVersion": "v10.0",
+    "modelVersion": "v11.0",
     "_note": "The model identity this package version ships (IP-unified-architecture \u00a710: package semver tracks the API axis; the model version + CONSTANTS_HASH/COEFFICIENTS_HASH in src/constants/ carry the scientific identity). The version-pinning gate enforces this pairing against public/input/model-version.json."
   },
   "type": "module",
@@ -49,6 +49,7 @@
     "./deltat/cycles": "./src/deltat/cycles.cjs",
     "./deltat/deep-time": "./src/deltat/deep-time.cjs",
     "./deltat/historical": "./src/deltat/historical.cjs",
+    "./deltat/recession-history": "./src/deltat/recession-history.cjs",
     "./climate/l1-orbital": "./src/climate/l1-orbital.cjs",
     "./eclipse/finders": "./src/eclipse/finders.cjs",
     "./reference/published-curves": "./src/reference/published-curves.cjs",

package/src/constants/generated.d.ts

@@ -2,14 +2,14 @@
 // Gives the TypeScript website full type safety at the boundary (§2g) while
 // packages/physics stays JavaScript.
 
-export declare const CONSTANTS_HASH: "d36050ef216d137f";
+export declare const CONSTANTS_HASH: "471a3f440b88cd86";
 
 export declare const MODEL_VERSION: string;
 
 export declare const PREPRINT_DOI: string;
 
 export declare const DEFAULT_CONSTANTS: {
-  readonly hash: "d36050ef216d137f";
+  readonly hash: "471a3f440b88cd86";
   readonly additionalBodies: {
     "pluto": {
       "name": string;
@@ -137,6 +137,17 @@ export declare const DEFAULT_CONSTANTS: {
     "alphaClimateScalePerMille": number;
     "dtStackTaperFullHalfwidthYr": number;
     "dtStackTaperTotalHalfwidthYr": number;
+    "recessionRegime": {
+      "jointMa": number;
+      "knotAgesMa": number[];
+      "knotDistancesKm": number[];
+      "genesisMa": number;
+      "rocheLimitKm": number;
+      "solarOceanLeakBeta0": number;
+      "thermalPumpStartMa": number;
+      "thermalPumpEndMa": number;
+      "thermalPumpFactor": number;
+    };
   };
   readonly earth: {
     "earthtiltMean": number;

package/src/constants/generated.js

@@ -32,17 +32,17 @@
  * carry it so a counterfactual is reproducible (§2d).
  * @type {string}
  */
-export const CONSTANTS_HASH = "d36050ef216d137f";
+export const CONSTANTS_HASH = "471a3f440b88cd86";
 
 /** Model version label — single source: public/input/model-version.json (§10 two-axis scheme). */
-export const MODEL_VERSION = "v10.0";
+export const MODEL_VERSION = "v11.0";
 
 /** Canonical preprint DOI — single source: public/input/model-version.json. */
 export const PREPRINT_DOI = "10.21203/rs.3.rs-8758810/v4";
 
 /** @type {Readonly<Record<string, unknown>>} */
 export const DEFAULT_CONSTANTS = Object.freeze({
-  hash: "d36050ef216d137f",
+  hash: "471a3f440b88cd86",
   additionalBodies: {
     "pluto": {
       "name": "Pluto",
@@ -181,7 +181,30 @@ export const DEFAULT_CONSTANTS = Object.freeze({
     "alpha4PerMa4": 1.3619800519e-16,
     "alphaClimateScalePerMille": -3.93e-7,
     "dtStackTaperFullHalfwidthYr": 300000,
-    "dtStackTaperTotalHalfwidthYr": 400000
+    "dtStackTaperTotalHalfwidthYr": 400000,
+    "recessionRegime": {
+      "jointMa": 1000,
+      "knotAgesMa": [
+        1400,
+        1900,
+        2450,
+        3200,
+        3900
+      ],
+      "knotDistancesKm": [
+        337531.908,
+        322949.311,
+        322533.193,
+        296189.703,
+        275119.896
+      ],
+      "genesisMa": 4498,
+      "rocheLimitKm": 9439.643,
+      "solarOceanLeakBeta0": 0.2,
+      "thermalPumpStartMa": 1000,
+      "thermalPumpEndMa": 1307,
+      "thermalPumpFactor": 0.454
+    }
   },
   earth: {
     "earthtiltMean": 23.413527499101747,

package/src/deltat/deep-time.cjs

@@ -64,19 +64,24 @@
  * @property {(year: number) => number} cycleLodSumAt - gated δLOD sum (incl. swing)
  * @property {(year: number) => number} swingLodAt - gated swing δLOD alone
  * @property {(year: number) => number} swingLodRateAt - gated analytic swing rate
+ * @property {(tMa: number) => number} [lEmAtAgeKgm2S] - OPTIONAL time-dependent
+ *   Earth-Moon angular momentum (the Driver-1½ solar channels,
+ *   recession-history.cjs). Absent → the J2000 constant, which the budget
+ *   module equals exactly for t ≤ jointMa — the pure-twin convention.
  */
 
 /** @param {DeepTimeLodDeps} deps */
 function createDeepTimeLod(deps) {
   const K = deps.constants;
+  const lEmAt = deps.lEmAtAgeKgm2S ?? (() => K.lTotalEmKgm2S);
 
-  /** Layer 1/2 mean LOD: LOD = 2π·I(t) / (L_total − L_moon(t)).
+  /** Layer 1/2 mean LOD: LOD = 2π·I(t) / (L_EM(t) − L_moon(t)).
    * @param {number} t_Ma @returns {number|null} seconds, null past tidal lock */
   function lodSecondsAtAge(t_Ma) {
     const a = deps.moonDistanceMetresAtAge(t_Ma);
     if (a <= 0 || a >= K.aLockMetres) return null;
     return (2 * Math.PI * (deps.moiFactorAtAge(t_Ma) * K.mEarthAloneKg * K.rEarthMetres * K.rEarthMetres)) /
-           (K.lTotalEmKgm2S - K.mMoonAloneKg * Math.sqrt(K.gmEmM3PerS2 * a) * K.eFactorMoon);
+           (lEmAt(t_Ma) - K.mMoonAloneKg * Math.sqrt(K.gmEmM3PerS2 * a) * K.eFactorMoon);
   }
 
   /** Same LOD with an EXPLICIT α (the browser's "α at climate mean" curve).
@@ -86,7 +91,7 @@ function createDeepTimeLod(deps) {
     if (a <= 0 || a >= K.aLockMetres) return null;
     const iEarth = alpha * K.mEarthAloneKg * K.rEarthMetres * K.rEarthMetres;
     return (2 * Math.PI * iEarth) /
-           (K.lTotalEmKgm2S - K.mMoonAloneKg * Math.sqrt(K.gmEmM3PerS2 * a) * K.eFactorMoon);
+           (lEmAt(t_Ma) - K.mMoonAloneKg * Math.sqrt(K.gmEmM3PerS2 * a) * K.eFactorMoon);
   }
 
   /** @param {number} t_Ma @returns {number|null} */

package/src/deltat/recession-history.cjs

@@ -0,0 +1,168 @@
+/**
+ * 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,
+ * regime-aware-recession-study,fit-regime-recession}.js): 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 };

package/src/index.js

@@ -125,6 +125,7 @@ export { createPlanetModel } from './planets/model.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';
 export { deltaTEspenakMeeusCanonSeconds } from './deltat/historical.cjs';
 export { evalClimateL1OrbitalPermil } from './climate/l1-orbital.cjs';
 // Phase 8.5 — eclipse geometry (single-copy: the browser had no Node twin).

package/src/model.js

@@ -18,11 +18,21 @@
  * which itself mirrors tools/lib/constants.js §9.
  */
 import { deriveEpochParams } from './layer0/derive-params.js';
+import * as FL from './planets/fibonacci-laws.cjs';
+import * as planetOrientation from './planets/orientation.cjs';
 import { createPhaseMachinery } from './phase/index.cjs';
 import { createCardinalModel } from './cardinal/index.cjs';
 import { createDeltaTCycles } from './deltat/cycles.cjs';
 import { createDeepTimeLod } from './deltat/deep-time.cjs';
+import { createMoonRecessionHistory, createSolarChannelBudget } from './deltat/recession-history.cjs';
 import { evalClimateL1OrbitalPermil } from './climate/l1-orbital.cjs';
+import { createMoonEccChannel } from './moon/ecc-channel.cjs';
+import { createMoonMonthChain } from './moon/month-chain.cjs';
+import { createChainCycleIntegrator } from './chain-cycles/index.cjs';
+import { createMoonArguments, jdToDecimalYear } from './moon/arguments.cjs';
+import { createMoonSeries } from './moon/series.cjs';
+import { createEclipseFinders } from './eclipse/finders.cjs';
+import { driver2PeriodSecondsAtAge } from './planets/orbit-chain.cjs';
 
 /**
  * RA-day-offset Fourier amplitudes (ms). KNOWN EXCEPTION carried over from
@@ -34,6 +44,17 @@ const RA_DAY_OFFSET_MEAN_MS = -14.194;
 const RA_DAY_OFFSET_ECC_MS = -5.64;
 const RA_DAY_OFFSET_OBLIQ_MS = -1.684;
 
+/**
+ * Moon-channel eccentricity sensitivities (perigee/node), the [g/g₀]^s
+ * exponents of the factored deep-time law. Same known-exception class as the
+ * RA offsets above: single source src/script.js _FW_MOON, mirrored as
+ * literals in tools/lib/deep-time.js (_ECOMP_S_W/_ECOMP_S_N). Both are
+ * Meeus-effective — S_N moved 1.0 → 1.018 with the v4 frame-attribution
+ * batch.
+ */
+const MOON_ECC_SENSITIVITY_PERIGEE = 2.407;
+const MOON_ECC_SENSITIVITY_NODE = 1.018;
+
 /**
  * Assemble the model surfaces from a resolved constants context + fitted
  * coefficients. Internal: `createModel` in index.js composes this with the
@@ -138,11 +159,38 @@ export function assembleModel(C, F) {
     gmEarthMoonSystemKm3S2: GM_EARTH_MOON_SYSTEM,
   });
 
-  /** Farhat polynomial on the t_Ma axis. @param {number} tMa @returns {number} */
-  const moonDistanceMetresAtAge = (tMa) => EPOCH_PARAMS.moonDistanceNowM
-    * (1 + EPOCH_PARAMS.alpha1PerMa * tMa
-      + EPOCH_PARAMS.alpha3PerMa3 * tMa * tMa * tMa
-      + EPOCH_PARAMS.alpha4PerMa4 * tMa * tMa * tMa * tMa);
+  // ── 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({
+    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,
+  });
 
   const DT = F.DT_STACK;
   const RES = F.DT_RESONATOR;
@@ -202,6 +250,7 @@ export function assembleModel(C, F) {
     cycleLodSumAt: dtCycleLodCorrectionSum,
     swingLodAt: (year) => dtCycles.swingLodSecondsAt(year),
     swingLodRateAt: (year) => dtCycles.swingLodRateAt(year),
+    lEmAtAgeKgm2S: solarBudget.lEmAtAgeKgm2S,
   });
 
   // ── Integrated ∫1/H(t)dt phase (R2 α-pin honoured while building) ─────────
@@ -399,6 +448,128 @@ export function assembleModel(C, F) {
   /** @param {number} year @returns {number} */
   const deltaTSeconds = (year) => C.earthOrbital.deltaTStart + meanDeltaTSecondsAtAge(yearToTMa(year));
 
+  // ── Planets: Fibonacci-law derivation chain + orientation ─────────────────
+  const PLANET_KEYS = ['mercury', 'venus', 'mars', 'jupiter', 'saturn', 'uranus', 'neptune'];
+  const massEarthAlone = GM_EARTH_ALONE / G_CONSTANT;
+  /** @type {Record<string, number>} */
+  const massFraction = {};
+  for (const k of PLANET_KEYS) massFraction[k] = 1 / C.physicalConstants.massRatioDE440[k];
+  massFraction.earth = massEarthAlone / M_SUN;
+
+  const PSI = FL.computePsiConstant({
+    earthInvPlaneInclinationAmplitude: earthInclAmplitude,
+    massEarthAlone,
+    massSun: M_SUN,
+  });
+  const eccentricityAmplitudeK = FL.computeKConstant({
+    eccentricityAmplitude,
+    massEarthAlone,
+    massSun: M_SUN,
+    earthTiltMeanDeg: earthtiltMean,
+  });
+  const systemResetN = C.foundational.systemResetN;
+  const t2000 = 2000 - (balancedYear - systemResetN * H);
+  const balancedJD = startmodelJD - meanSolarYearDays * (startModelYearWithCorrection - balancedYear);
+
+  /** @param {[number, number]|null} frac @returns {number|null} */
+  const fractionToYears = (frac) => (frac === null ? null : (H * frac[0]) / frac[1]);
+
+  /** @type {Record<string, Record<string, any>>} */
+  const PLANET_RECORDS = {};
+  for (const k of PLANET_KEYS) {
+    const mp = C.planets[k];
+    const ar = C.planetOrbitalElements[k];
+    const ecl = /** @type {number} */ (fractionToYears(mp.perihelionEclipticFraction));
+    const axial = /** @type {number} */ (fractionToYears(mp.axialPrecessionFraction));
+    const obliquityCycle = fractionToYears(mp.obliquityCycleFraction)
+      ?? Math.abs(1 / (1 / ecl - 1 / (H / 13)));
+    const wobble = FL.computeWobblePeriodYears(ecl, axial, H);
+    const il = FL.computeInclinationLaw({
+      fibonacciD: mp.fibonacciD,
+      massFrac: massFraction[k],
+      invPlaneInclinationJ2000: ar.invPlaneInclinationJ2000,
+      longitudePerihelion: ar.longitudePerihelion,
+      inclinationCycleAnchor: mp.inclinationCycleAnchor,
+      antiPhase: mp.antiPhase || false,
+    }, PSI);
+    const obliquityMean = FL.computeObliquityMeanSnapshot({
+      axialTiltJ2000: ar.axialTiltJ2000,
+      invPlaneInclinationAmplitude: il.amplitude,
+      perihelionEclipticYears: ecl,
+    }, obliquityCycle, { H, t2000 });
+    const el = FL.computeEccentricityLaw({
+      fibonacciD: mp.fibonacciD,
+      massFrac: massFraction[k],
+      solarYearInput: ar.solarYearInput,
+      orbitalEccentricityJ2000: ar.orbitalEccentricityJ2000,
+      antiPhase: mp.antiPhase || false,
+    }, {
+      kConstant: eccentricityAmplitudeK,
+      obliquityMeanDeg: obliquityMean,
+      wobblePeriodYears: wobble,
+      t2000,
+      meanSolarYearDays,
+    });
+    PLANET_RECORDS[k] = Object.freeze({
+      name: mp.name,
+      perihelionEclipticYears: ecl,
+      longitudePerihelion: ar.longitudePerihelion,
+      ascendingNodeCyclesIn8H: mp.ascendingNodeCyclesIn8H,
+      ascendingNodePeriod: -(8 * H) / mp.ascendingNodeCyclesIn8H,
+      axialPrecessionYears: axial,
+      obliquityCycle,
+      wobblePeriod: wobble,
+      fibonacciD: mp.fibonacciD,
+      antiPhase: mp.antiPhase || false,
+      ascendingNodeInvPlane: mp.ascendingNodeInvPlane,
+      inclinationCycleAnchor: mp.inclinationCycleAnchor,
+      invPlaneInclinationJ2000: ar.invPlaneInclinationJ2000,
+      invPlaneInclinationAmplitude: il.amplitude,
+      invPlaneInclinationMean: il.mean,
+      obliquityMean,
+      orbitalEccentricityJ2000: ar.orbitalEccentricityJ2000,
+      orbitalEccentricityAmplitude: el.amplitude,
+      orbitalEccentricityBase: el.base,
+      eccentricityPhaseJ2000: el.phaseJ2000,
+      solarYearInput: ar.solarYearInput,
+      axialTiltJ2000: ar.axialTiltJ2000,
+    });
+  }
+
+  /** Perihelion longitude (linear lattice rate). @param {string} k @param {number} year @returns {number} */
+  const planetPerihelionDeg = (k, year) => {
+    const p = PLANET_RECORDS[k];
+    return (((p.longitudePerihelion + (360.0 * (year - 2000)) / p.perihelionEclipticYears) % 360) + 360) % 360;
+  };
+  /** Ascending node on the invariable plane. @param {string} k @param {number} year @returns {number} */
+  const planetAscNodeDeg = (k, year) => {
+    const p = PLANET_RECORDS[k];
+    return planetOrientation.ascendingNodeInvPlaneLinearAt({
+      ascendingNodeInvPlane: p.ascendingNodeInvPlane,
+      ascendingNodePeriod: p.ascendingNodePeriod,
+      perihelionEclipticYears: p.perihelionEclipticYears,
+    }, year);
+  };
+  /** Invariable-plane inclination (signed ICRF rate, scene year→JD axis). @param {string} k @param {number} year @returns {number} */
+  const planetInclinationDeg = (k, year) => {
+    const p = PLANET_RECORDS[k];
+    const jd = startmodelJD + (year - startmodelYear) * meanSolarYearDays;
+    const yearsSinceBalanced = (jd - balancedJD) / meanSolarYearDays;
+    return planetOrientation.invPlaneInclinationAt({
+      isEarth: false,
+      invPlaneInclinationJ2000: p.invPlaneInclinationJ2000,
+      invPlaneInclinationMean: p.invPlaneInclinationMean,
+      invPlaneInclinationAmplitude: p.invPlaneInclinationAmplitude,
+      inclinationCycleAnchor: p.inclinationCycleAnchor,
+      longitudePerihelion: p.longitudePerihelion,
+      perihelionEclipticYears: p.perihelionEclipticYears,
+      antiPhase: p.antiPhase,
+    }, yearsSinceBalanced, {
+      H,
+      yearsFromBalancedToJ2000: (startmodelJD - balancedJD) / meanSolarYearDays,
+    });
+  };
+
   // ── Time axis: exact JD ↔ model-year conversion ───────────────────────────
   // The model's `year` inputs live on the SI axis (the axis the fits were
   // anchored on — tools/lib `_jdToSIyear`): linear in SI 86400-s days from the
@@ -412,6 +583,236 @@ export function assembleModel(C, F) {
   /** JD(TT) at a model year (SI axis). @param {number} year @returns {number} */
   const jdFromYear = (year) => startmodelJD + (year - startModelYearWithCorrection) * siTropicalYearDays;
 
+  // ── Lunar theory: the shared-chain assembly (§7a slice-2b) ────────────────
+  // Wiring mirrors the engine call sites exactly — tools/lib/deep-time.js
+  // (ecc channel, month chain, J2000 precession anchors),
+  // tools/lib/scene-graph.js (chain-cycles, arguments, series) and
+  // tools/verify/eclipse-audit.js (finders). Deep-time and framework-native
+  // are hardwired ON here: they are the shipped defaults; the A/B env
+  // toggles (SG_DEEP_TIME/MOON_ARGS_PURE_MEEUS) stay an engine concern.
+  const j2000JD = 2451545.0;
+  const julianCenturyDays = 36525;
+
+  // J2000 Moon precession anchors (Option C+ — of-date observational anchors
+  // in the legacy-'ICRF'-named inputs; the E values are star-referenced ∓13)
+  const nApsidalIJ2000 = Math.round((8 * totalDaysInH) / C.moonReference.moonApsidalPrecessionDaysInputICRF) / 8;
+  const nNodalIJ2000 = Math.round((8 * totalDaysInH) / C.moonReference.moonNodalPrecessionDaysInputICRF) / 8;
+  const nApsidalEJ2000 = nApsidalIJ2000 - 13;
+  const nNodalEJ2000 = nNodalIJ2000 + 13;
+  const moonApsidalJ2000Seconds = (totalDaysInH / nApsidalEJ2000) * meanLengthOfDay;
+  const moonNodalJ2000Seconds = (totalDaysInH / nNodalEJ2000) * meanLengthOfDay;
+  const moonSiderealMonthJ2000Seconds = moonSiderealMonth * meanLengthOfDay;
+
+  // 8H-lattice derived months (constants.js §Moon derived months)
+  const nSid = Math.round((8 * totalDaysInH) / moonSiderealMonthInput) / 8;
+  const moonTropicalMonthDays = totalDaysInH / (nSid + 13);
+  const moonAnomalisticMonthDays = totalDaysInH / (nSid - nApsidalEJ2000);
+  const moonSynodicMonthDays = totalDaysInH / (nSid + 13 - H);
+
+  // The framework H/3 eccentricity line (the Moon channel's view of the
+  // wobble movement — NOT the H/16 orbital eccentricity above)
+  const moonEcc = createMoonEccChannel({
+    cyclesBetween,
+    eccentricityBase,
+    perihelionLongitudeJ2000Deg: C.earthOrbital.earthPerihelionLongitudeJ2000,
+    inclinationCycleAnchorDeg: C.earthOrbital.earthInclinationCycleAnchor,
+  });
+
+  // Layer-2 month/precession chain (Brouwer-Clemence m² scaling × the
+  // e_E-line modulation)
+  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,
+      holisticYearJ2000: H,
+      meanSiderealYearJ2000Seconds: meanSiderealYearSeconds,
+      nApsidalOfDateJ2000: nApsidalIJ2000,
+      nNodalOfDateJ2000: nNodalIJ2000,
+      moonApsidalJ2000Seconds,
+      moonNodalJ2000Seconds,
+      moonSiderealMonthJ2000Seconds,
+      sPerigee: MOON_ECC_SENSITIVITY_PERIGEE,
+      sNode: MOON_ECC_SENSITIVITY_NODE,
+    },
+    fns: {
+      meanLodSecondsAtAge: /** @param {number} tMa */ (tMa) => deepLod.lodSecondsAtAge(tMa),
+      meanSiderealYearSecondsAtAge: /** @param {number} tMa */ (tMa) => deepLod.siderealYearSecondsAtAge(tMa),
+      meanHAtAge: /** @param {number} tMa */ (tMa) => deepLod.hAtAge(tMa),
+      modulation: /** @param {number} tMa @param {number} s */ (tMa, s) => moonEcc.modulation(tMa, s),
+      distanceMetresAtAge: moonDistanceMetresAtAge,
+    },
+  });
+
+  // Chain-cycle integrator. S5/S12 conventions: age anchor = startmodelYear
+  // (the scene's t_Ma convention), grid anchor C(2000) = 0 — grid anchor ≠
+  // age anchor, deliberately. One stable period fn per chain so the shared
+  // Float64Array tables key correctly and persist.
+  const chainCycles = createChainCycleIntegrator({
+    ageAnchorYear: startmodelYear,
+    tropicalYearSecondsAtAge: /** @param {number} tMa */ (tMa) => deepLod.tropicalYearSecondsAtAge(tMa),
+    tropicalYearJ2000Seconds: meanTropicalYearJ2000Seconds,
+    isDeepTime: () => true,
+  });
+  /** @param {number} tMa @returns {number|null} */
+  const nodalMonthPeriodFn = (tMa) => moonChain.nodalMonthSecondsAtAge(tMa);
+  /** @param {number} tMa @returns {number|null} */
+  const tropicalMonthPeriodFn = (tMa) => moonChain.tropicalMonthSecondsAtAge(tMa);
+  /** @param {number} tMa @returns {number|null} */
+  const anomalisticMonthPeriodFn = (tMa) => moonChain.anomalisticMonthSecondsAtAge(tMa);
+  const jupiterT0Seconds = C.planetOrbitalElements.jupiter.solarYearInput * 86400;
+  /** @param {number} tMa @returns {number} */
+  const jupiterPeriodFn = (tMa) => driver2PeriodSecondsAtAge(tMa, jupiterT0Seconds, EPOCH_PARAMS.solarMassLossFracPerYear);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcDraconic = (a, b) => chainCycles.cyclesBetween(nodalMonthPeriodFn, a, b);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcTropical = (a, b) => chainCycles.cyclesBetween(tropicalMonthPeriodFn, a, b);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcAnomalistic = (a, b) => chainCycles.cyclesBetween(anomalisticMonthPeriodFn, a, b);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcJupiter = (a, b) => chainCycles.cyclesBetween(jupiterPeriodFn, a, b);
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcApsidalOfDate = (a, b) => {
+    const t = mcTropical(a, b), n = mcAnomalistic(a, b);
+    return (t === null || n === null) ? null : t - n;
+  };
+  /** @param {number} a @param {number} b @returns {number|null} */
+  const mcNodalOfDate = (a, b) => {
+    const dr = mcDraconic(a, b), t = mcTropical(a, b);
+    return (dr === null || t === null) ? null : dr - t;
+  };
+
+  // Snapshot-phase obliquity — the engine's computeObliquityEarth convention
+  // for the lunar chain (linear H-lattice phase; orbital-engine.js). NOT the
+  // integrated-phase display obliquity above — the chain was certified
+  // against this form.
+  /** @param {number} year @returns {number} */
+  const obliquitySnapshotDeg = (year) => {
+    const t = year - balancedYear;
+    let obliq = solsticeObliquityMean;
+    for (const [div, sinC, cosC] of F.SOLSTICE_OBLIQUITY_HARMONICS) {
+      const ph = (2 * Math.PI * t) / (H / div);
+      obliq += sinC * Math.sin(ph) + cosC * Math.cos(ph);
+    }
+    return obliq;
+  };
+
+  // The argument skeleton (the _FW_MOON bundle; Sun secular deviations on
+  // the CALENDAR year coordinate — S3)
+  const moonArgs = createMoonArguments({
+    constants: {
+      j2000JD,
+      julianCenturyDays,
+      holisticYearJ2000: H,
+      balancedYearJ2000: balancedYear,
+      meanSolarYearDays,
+      meanAnomalisticYearDays,
+      tropicalYearHarmonics: F.TROPICAL_YEAR_HARMONICS,
+      anomalisticYearHarmonics: F.ANOMALISTIC_YEAR_HARMONICS,
+      eccentricityJ2000: C.earthOrbital.earthEccentricityJ2000,
+      eccentricityDotJ2000: C.earthOrbital.earthEccentricityDotJ2000,
+      eccentricityDotDotJ2000: C.earthOrbital.earthEccentricityDotDotJ2000,
+      elpEarthFigureJ2ArcsecPerCy2: C.moonMeeus.elpW1T2Decomposition_arcsecPerCy2.earthFigureJ2,
+      elpGeneralPrecessionPA_T2ArcsecPerCy2: C.moonMeeus.elpW1T2Decomposition_arcsecPerCy2.generalPrecessionPA_T2_Lieske1976,
+      eccE0: moonEcc.e0,
+    },
+    fns: {
+      eccAt: /** @param {number} tYr */ (tYr) => moonEcc.eccAt(tYr),
+      channelIntegral: /** @param {number} T @param {number} s */ (T, s) => moonEcc.channelIntegral(T, s),
+      computeObliquityEarth: obliquitySnapshotDeg,
+      jdToSIyear: yearFromJD,
+      tropicalOrbitsBetween: mcTropical,
+      apsidalOfDateCyclesBetween: mcApsidalOfDate,
+      nodalOfDateCyclesBetween: mcNodalOfDate,
+      cyclesBetween,
+      isDeepTime: () => true,
+      isFrameworkNative: () => true,
+    },
+  });
+
+  // UT→TT on the CALENDAR decimal-year coordinate (script.js Phase 9.16 —
+  // a linear-year approximation here once cost ~5–6 s of ΔT and ~1e-3° of
+  // Moon longitude at the Babylonian epochs)
+  /** @param {number} jd @returns {number} */
+  const jdTTFromUT = (jd) => {
+    const tMa = (startmodelYear - jdToDecimalYear(jd)) / 1e6;
+    const dT = meanDeltaTSecondsAtAge(tMa);
+    return Number.isFinite(dT) ? jd + dT / 86400 : jd;
+  };
+  // ΔT at a JD on the CALENDAR-year axis (mirrors deep-time frameworkDeltaT;
+  // NOT deltaTSeconds above, which adds the deltaTStart anchor)
+  /** @param {number} jd @returns {number} */
+  const frameworkDeltaTSecondsAtJD = (jd) => {
+    const decYear = startmodelYear + (jd - startmodelJD) / meanSolarYearDays;
+    const dT = meanDeltaTSecondsAtAge((startmodelYear - decYear) / 1e6);
+    return Number.isFinite(dT) ? dT : 0;
+  };
+
+  // Bounded Meeus E-factor from the H/3 line (framework-native branch only;
+  // the pure-Meeus polynomial A/B branch stays engine-local)
+  /** @param {number} dDays @returns {number} */
+  const fwEFactor = (dDays) => moonEcc.eFactorAt(dDays / C.foundational.inputmeanlengthsolaryearindays);
+
+  // D2 derived additional-argument rates (deg/cy, J2000 8H-lattice months;
+  // record: tools/explore/derive-a1a2a3.js)
+  const fwA2RateDegPerCy = 2 * ((360 * 36525) / moonTropicalMonthDays)
+    - (360 * 36525) / moonAnomalisticMonthDays
+    - 2 * ((360 * 36525) / C.planetOrbitalElements.jupiter.solarYearInput);
+  const fwA3RateDegPerCy = (360 * 36525) / moonSiderealMonth;
+
+  // Meeus Ch. 47 truncated series (framework-native arguments + E-factor)
+  const moonSeries = createMoonSeries({
+    constants: {
+      moonL: F.MEEUS_LONGITUDE_TERMS,
+      moonB: F.MEEUS_LATITUDE_TERMS,
+      j2000JD,
+      julianCenturyDays,
+      moonMeeusLpCorrectionDeg: C.moon.moonMeeusLpCorrection,
+      fwA2RateDegPerCy,
+      fwA3RateDegPerCy,
+    },
+    fns: {
+      argsAt: /** @param {number} jdTT */ (jdTT) => moonArgs.argsAt(jdTT),
+      eFactorForD: fwEFactor,
+      eFactorAtJdTT: /** @param {number} jdTT */ (jdTT) => fwEFactor(jdTT - j2000JD),
+      getMoonDistanceKm: () => moonDistanceKm,
+      getEccentricityBase: () => C.moonReference.moonOrbitalEccentricityBase,
+      deltaTSeconds: /** @param {number} jd */ (jd) => (jdTTFromUT(jd) - jd) * 86400,
+      jdToSIyear: yearFromJD,
+      tropicalOrbitsBetween: mcTropical,
+      apsidalOfDateCyclesBetween: mcApsidalOfDate,
+      cyclesBetween,
+      jupiterOrbitsBetween: mcJupiter,
+      isDeepTime: () => true,
+      isFrameworkNative: () => true,
+    },
+  });
+
+  // Eclipse finders — wired like the engine probe (tools/verify/
+  // eclipse-audit.js). The finder axis is JD(UT): the series wrapper applies
+  // UT→TT internally. Ground-track/umbra paths deliberately absent: the
+  // scene-umbra projection navigates the Tychosium-derived scaffold, which
+  // never enters this package (§2h).
+  const eclipseFinders = createEclipseFinders({
+    moonLonDegAt: /** @param {number} jd */ (jd) => moonSeries.truncatedLonDeg(jd),
+    moonBetaDegAt: /** @param {number} jd */ (jd) => moonSeries.truncatedBetaDeg(jd),
+    moonDistanceKmAt: /** @param {number} jd */ (jd) => moonSeries.truncatedDistanceKm(jd),
+    deltaTSecondsAt: frameworkDeltaTSecondsAtJD,
+    getSynodicMonthDays: () => moonSynodicMonthDays,
+    getSunDistanceKm: () => currentAUDistance,
+    constants: {
+      rEarthMetres: (C.bodyDiametersKm.earth / 2) * 1000,
+      moonDiameterKm: C.bodyDiametersKm.moon,
+      sunDiameterKm: C.bodyDiametersKm.sun,
+      j2000JD,
+      julianCenturyDays,
+    },
+  });
+
   // ── The assembled surface ─────────────────────────────────────────────────
   return Object.freeze({
     time: Object.freeze({
@@ -458,6 +859,28 @@ export function assembleModel(C, F) {
     moon: Object.freeze({
       distanceKmAtYear: /** @param {number} year @returns {number} */ (year) => moonDistanceMetresAtAge(yearToTMa(year)) / 1000,
       siderealMonthDaysAtYear: moonSiderealMonthDaysAt,
+      synodicMonthDays: moonSynodicMonthDays,
+      // The apparent-position chain (truncated Meeus Ch. 47 series on
+      // framework-native arguments). JD(UT) axis — UT→TT applied internally.
+      lonDegAtJD: /** @param {number} jd @returns {number} */ (jd) => moonSeries.truncatedLonDeg(jd),
+      betaDegAtJD: /** @param {number} jd @returns {number} */ (jd) => moonSeries.truncatedBetaDeg(jd),
+      distanceKmAtJD: /** @param {number} jd @returns {number} */ (jd) => moonSeries.truncatedDistanceKm(jd),
+    }),
+    eclipse: Object.freeze({
+      sunLonDegAtJD: /** @param {number} jd @returns {number} */ (jd) => eclipseFinders.sunLonDegAt(jd),
+      findLunarInRange: /** @param {number} jdStart @param {number} jdEnd */ (jdStart, jdEnd) => eclipseFinders.findLunarEclipsesInRange(jdStart, jdEnd),
+      findSolarInRange: /** @param {number} jdStart @param {number} jdEnd */ (jdStart, jdEnd) => eclipseFinders.findSolarEclipsesInRange(jdStart, jdEnd),
+      deltaTSecondsAtJD: frameworkDeltaTSecondsAtJD,
+    }),
+    climate: Object.freeze({
+      l1OrbitalPermil: evalClimateL1,
+    }),
+    planets: Object.freeze({
+      keys: Object.freeze([...PLANET_KEYS]),
+      record: /** @param {string} k @returns {Record<string, any>|undefined} */ (k) => PLANET_RECORDS[k],
+      perihelionLongitudeDeg: planetPerihelionDeg,
+      ascendingNodeInvPlaneDeg: planetAscNodeDeg,
+      invPlaneInclinationDeg: planetInclinationDeg,
     }),
   });
 }

package/src/moon/month-chain.cjs

@@ -67,10 +67,14 @@
  *     meanSiderealYearSecondsAtAge: (tMa: number) => number,
  *     meanHAtAge: (tMa: number) => (number | null),
  *     modulation: (tMa: number, s: number) => number,
+ *     distanceMetresAtAge?: (tMa: number) => number,
  *   },
  * }} deps — fns are the ENGINE'S OWN layer-0/1 evaluators and the shared
  *   eccentricity channel's modulation; constants are the engine's derived
  *   J2000 anchors (both engines derive them from the same JSON).
+ *   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).
  */
 function createMoonMonthChain({ constants, fns }) {
   const {
@@ -85,10 +89,11 @@ function createMoonMonthChain({ constants, fns }) {
 
   /** Farhat α₁/α₃/α₄ polynomial — Earth–Moon distance in metres at age t_Ma.
    *  @param {number} tMa @returns {number} */
-  function distanceMetresAtAge(tMa) {
+  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} */
   function distanceKmAtAge(tMa) {