@essrt/physics 1.2.0 → 1.3.1

package/README.md

@@ -53,7 +53,7 @@ The canonical assembly, wired once inside the package:
 import { createModel, DEFAULT_CONSTANTS } from '@essrt/physics';
 
 const model = createModel();
-model.identity.modelVersion;          // 'v10.0' + both content hashes
+model.identity.modelVersion;          // the shipped model identity (e.g. 'v11.0') + both content hashes
 model.epoch.hAtYear(2000 - 380e6);    // 306189 — Devonian H (the Wells 1963 match)
 model.earth.obliquityDeg(2000);       // 23.4393
 model.cardinal.jd(2000, 'SS');        // 2451716.575 — June solstice 2000 (USNO)
@@ -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.2.0",
+  "version": "1.3.1",
   "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} */
@@ -108,7 +113,15 @@ function createDeepTimeLod(deps) {
   function siderealYearSecondsAtAge(t_Ma) {
     if (t_Ma === 0) return K.meanSiderealYearJ2000Seconds;
     const mass_loss_fraction = K.solarMassLossFracPerYear * t_Ma * 1e6;
-    return K.meanSiderealYearJ2000Seconds * (1 - 2 * mass_loss_fraction);
+    // Exact Kepler under the model's mass-history convention (a·M = const,
+    // a(t) = a₀·(1−Δm)): T ∝ M⁻² ⇒ T(t) = T₀·(1−Δm)² — the SAME Driver-2
+    // law the planet chains use (orbit-chain driver2PeriodSecondsAtAge).
+    // The previous (1 − 2Δm) was this law's first-order Taylor — the one
+    // form in the model inconsistent with it, and the entire source of the
+    // day-count invariant's 0.17 ppm residual: with the product form,
+    // H·(days/yr)·(AU₀/AU)² = TOTAL_DAYS_IN_H holds EXACTLY
+    // (tools/explore/deep-time-sensitivity.js §5; docs/99 §near-invariant).
+    return K.meanSiderealYearJ2000Seconds * (1 - mass_loss_fraction) * (1 - mass_loss_fraction);
   }
 
   /** @param {number} t_Ma @returns {number} tropical = sidereal · (1 − 13/H(t)) */

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/layer0/index.js

@@ -118,7 +118,12 @@ export const createEpochPrimitives = ({ params: p, alphaAtAgeMa }) => {
    */
   const siderealYearSecondsCore = (t) => {
     if (t === 0) return p.siderealYearJ2000Seconds;
-    return p.siderealYearJ2000Seconds * (1 - 2 * p.solarMassLossFracPerYear * t * 1e6);
+    // Exact Kepler product form (T ∝ M⁻² under a·M = const, a(t) = a₀·(1−Δm))
+    // — the same Driver-2 law as the planet chains and deltat/deep-time.cjs.
+    // MUST stay the bit-exact twin of siderealYearSecondsAtAge there (the
+    // transparency gate holds the pair at 84/84 round-trip).
+    const dm = p.solarMassLossFracPerYear * t * 1e6;
+    return p.siderealYearJ2000Seconds * (1 - dm) * (1 - dm);
   };
 
   /**

package/src/model.js

@@ -24,6 +24,7 @@ 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';
@@ -158,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;
@@ -222,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) ─────────
@@ -615,6 +644,7 @@ export function assembleModel(C, F) {
       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,
     },
   });
 

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) {