@essrt/physics 1.0.0

package/src/constants/index.js

@@ -0,0 +1,30 @@
+/**
+ * The constants context (§2d) — stable import point.
+ *
+ * `generated.js` is written by `tools/constants/generate.mjs` from the JSON
+ * source of truth and is never hand-edited. Consumers import from here so they
+ * do not depend on the generator's output path.
+ *
+ * Injected via `createModel`, never imported by a layer: importing constants
+ * inside a layer is what makes counterfactuals impossible, and that capability
+ * is the one thing DE440 and Laskar cannot offer.
+ *
+ * Validation targets are deliberately absent from DEFAULT_CONSTANTS —
+ * `laplaceLagrangeBounds`, `knownValues`, `ascendingNodesSouamiSouchay`,
+ * `jplEclipticInclinationTrends`, `eigenmodePhasesLaplaceLagrange` — plus
+ * `galaxyMotion`, which is presentation rather than physics.
+ *
+ * They ship as REFERENCE_DATA instead: single-sourced, so nothing duplicates
+ * them as literals, but never injectable. `createModel` refuses these keys
+ * outright, because a counterfactual must not be able to move the goalposts it
+ * is judged by. See CLASSIFICATION in the generator.
+ */
+export { DEFAULT_CONSTANTS, CONSTANTS_HASH, REFERENCE_DATA } from './generated.js';
+
+/**
+ * Fitting-pipeline output, at full double precision (§2j). Kept apart from
+ * DEFAULT_CONSTANTS because the lifecycle differs: these regenerate wholesale
+ * when a fit step runs, and are never hand-edited. COEFFICIENTS_HASH identifies
+ * the fit, CONSTANTS_HASH the parameters — a result is reproducible from both.
+ */
+export { FITTED_COEFFICIENTS, COEFFICIENTS_HASH } from './coefficients.js';

package/src/deltat/cycles.cjs

@@ -0,0 +1,256 @@
+/**
+ * ΔT cycle-correction stack — THE shared implementation (Phase 8.4, slice 2).
+ *
+ * The four anchored lattice-cycle ΔT corrections (Bond 8H/1830, Hallstatt
+ * 8H/1104, Jose5 8H/2989, Jose4 8H/3749 — Jose5/Jose4 are a COUPLED PAIR,
+ * fitted jointly), their implied δLOD twins (the d/dy of each correction:
+ * physical consistency between the corrected ΔT curve and the LOD curve),
+ * and the Core-mantle swing episode (Resonator driver: 2-kick damped
+ * eigenmode T₀ = 8H/685, Q = 1.8, plus one switch-on-compensated drive
+ * tone at the bond−hallstatt difference frequency — the §10g-adjacent
+ * phase-locked construction; docs/104 §6/§8).
+ *
+ * One ±300/400-kyr taper serves the whole family (the browser carried four
+ * per-cycle copies of the same two JSON half-widths plus a fifth
+ * function-local pair in its taper derivative — all value-identical,
+ * dissolved here; the historical "Holocene taper" name survives only in
+ * engine comments).
+ *
+ * MATCHED PAIR: the coefficients were fitted JOINTLY (dt-corrections-fit.js
+ * --joint) with the USNO 86400.0014 / deltaTStart 56.05 anchors — the
+ * 4-cycle+swing δLOD sum at J2000 closes Layer-4 LOD_real onto the USNO
+ * anchor by construction. Coefficients and this evaluation form ship
+ * together; do not simplify the anchored (raw − raw@2000) construction or
+ * the impulse-consistent tone compensation.
+ *
+ * ENGINE-SIDE, by design: the enable flags (browser mutable research
+ * toggles, Node env vars), the per-cycle gated wrappers, the stack sum,
+ * and the coefficient PROVENANCE (browser FIT.DT_STACK/FIT.DT_RESONATOR,
+ * Node the fit-output data JSONs) — all injected.
+ */
+
+'use strict';
+
+/**
+ * @typedef {{ latticeN: number, cosCoeffSeconds: number, sinCoeffSeconds: number }} CycleSpec
+ * @typedef {{ tYear: number, cosSeconds: number, sinSeconds: number }} ResonatorKick
+ * @typedef {{ dn: number, phiLockedRad: number, ampSeconds: number }} ResonatorTone
+ */
+
+/**
+ * @typedef {Object} DeltaTCyclesDeps
+ * @property {number} eightHYears - 8 × the holistic year (J2000)
+ * @property {number} taperFullHalfwidthYears - full strength within |y−2000| ≤ this
+ * @property {number} taperTotalHalfwidthYears - zero beyond
+ * @property {number} tropicalYearSecondsJ2000 - δLOD denominator (variation ≤1e-8 in-window)
+ * @property {Record<string, CycleSpec>} cycles - keyed bond/hallstatt/jose5/jose4
+ * @property {{ t0LatticeN: number, q: number, kicks: ResonatorKick[],
+ *   tones: ResonatorTone[] }} resonator
+ */
+
+/**
+ * Build the cycle-correction evaluators over one engine's constant set.
+ * All evaluators are UNGATED — the engines own their enable flags.
+ * @param {DeltaTCyclesDeps} deps
+ */
+function createDeltaTCycles(deps) {
+  const HW_FULL = deps.taperFullHalfwidthYears;
+  const HW_TOTAL = deps.taperTotalHalfwidthYears;
+  const YEAR_S = deps.tropicalYearSecondsJ2000;
+
+  /** @param {number} year @returns {number} 1 inside, cosine roll-off, 0 beyond */
+  function taperAt(year) {
+    const dy = Math.abs(year - 2000);
+    if (dy <= HW_FULL) return 1.0;
+    if (dy >= HW_TOTAL) return 0.0;
+    const u = (dy - HW_FULL) / (HW_TOTAL - HW_FULL);
+    return 0.5 * (1.0 + Math.cos(Math.PI * u));
+  }
+
+  /** @param {number} year @returns {number} d(taper)/dy */
+  function taperDerivativeAt(year) {
+    const dy = Math.abs(year - 2000);
+    if (dy <= HW_FULL) return 0;
+    if (dy >= HW_TOTAL) return 0;
+    const width = HW_TOTAL - HW_FULL;
+    const u = (dy - HW_FULL) / width;
+    // taper(y) = 0.5·(1 + cos(π·u)); d/dy = −0.5·π·sin(π·u) · (du/dy)
+    // du/dy = (1/width) · sign(y − 2000)
+    const sign = year >= 2000 ? 1 : -1;
+    return -0.5 * Math.PI * Math.sin(Math.PI * u) / width * sign;
+  }
+
+  // Per-cycle derived constants — period = 8H/N, ω = 2π/period, and the
+  // J2000 anchor value (the correction is exactly 0 at year 2000 by
+  // construction: taper·(raw − raw@2000)).
+  /** @type {Record<string, {omega: number, cosC: number, sinC: number, rawAtJ2000: number}>} */
+  const cyc = {};
+  for (const [key, c] of Object.entries(deps.cycles)) {
+    const periodYears = deps.eightHYears / c.latticeN;
+    const omega = 2 * Math.PI / periodYears;
+    cyc[key] = {
+      omega, cosC: c.cosCoeffSeconds, sinC: c.sinCoeffSeconds,
+      rawAtJ2000: c.cosCoeffSeconds * Math.cos(omega * 2000) + c.sinCoeffSeconds * Math.sin(omega * 2000),
+    };
+  }
+
+  /** Anchored cycle ΔT correction, seconds. 0 at 2000 and outside the taper.
+   * @param {string} cycleKey @param {number} year @returns {number} */
+  function cycleDeltaTSecondsAt(cycleKey, year) {
+    const c = cyc[cycleKey];
+    const taper = taperAt(year);
+    if (taper <= 0) return 0;
+    const raw = c.cosC * Math.cos(c.omega * year) + c.sinC * Math.sin(c.omega * year);
+    return taper * (raw - c.rawAtJ2000);
+  }
+
+  /** Implied δLOD of one cycle correction (s to add to LOD_mean):
+   *  δLOD = 86400 · d/dy[correction] / yearS, product rule over taper·(raw−raw₀).
+   * @param {string} cycleKey @param {number} year @returns {number} */
+  function cycleLodSecondsAt(cycleKey, year) {
+    const c = cyc[cycleKey];
+    const taper = taperAt(year);
+    if (taper <= 0) return 0;
+    const raw = c.cosC * Math.cos(c.omega * year) + c.sinC * Math.sin(c.omega * year);
+    const raw_prime = c.omega * (c.sinC * Math.cos(c.omega * year) - c.cosC * Math.sin(c.omega * year));
+    const taper_prime = taperDerivativeAt(year);
+    const dCdy = taper_prime * (raw - c.rawAtJ2000) + taper * raw_prime;
+    return 86400 * dCdy / YEAR_S;
+  }
+
+  // ── Core-mantle swing (Resonator driver) ─────────────────────────────────
+  const R = deps.resonator;
+  const RES_T0_YR = deps.eightHYears / R.t0LatticeN;
+  const RES_W0 = 2 * Math.PI / RES_T0_YR;
+  const RES_LAMBDA = RES_W0 / (2 * R.q);
+  const RES_WD = RES_W0 * Math.sqrt(1 - 1 / (4 * R.q * R.q));
+  const RES_KICKS = R.kicks.map((k) => ({ t: k.tYear, cos_s: k.cosSeconds, sin_s: k.sinSeconds }));
+  const RES_TONES = R.tones.map((t) => ({
+    omega: 2 * Math.PI * t.dn / deps.eightHYears, phi_locked: t.phiLockedRad, amp_s: t.ampSeconds,
+  }));
+
+  // IMPULSE-CONSISTENT episode: kicks are sin-only (displacement-continuous —
+  // ΔT is accumulated angle and must not step); the drive tone's displacement
+  // at the excitation epoch is cancelled by an eigenmode transient (switched-on
+  // drive; slope discontinuities at the kicks ARE the impulses).
+  /** @param {{omega: number, phi_locked: number}} t @returns {number} */
+  function resonatorToneC0(t) {
+    return Math.cos(t.omega * RES_KICKS[0].t - t.phi_locked);
+  }
+
+  /** @param {number} year @returns {number} raw episode displacement, seconds */
+  function resonatorRawSecondsAt(year) {
+    let v = 0;
+    for (const k of RES_KICKS) {
+      const dt = year - k.t;
+      if (dt < 0) continue;
+      const e = Math.exp(-RES_LAMBDA * dt);
+      v += e * (k.cos_s * Math.cos(RES_WD * dt) + k.sin_s * Math.sin(RES_WD * dt));
+    }
+    const dt1 = year - RES_KICKS[0].t;
+    if (dt1 >= 0) {
+      const e1 = Math.exp(-RES_LAMBDA * dt1);
+      for (const t of RES_TONES) {
+        v += e1 * t.amp_s * (Math.cos(t.omega * year - t.phi_locked)
+                             - resonatorToneC0(t) * Math.cos(RES_WD * dt1));
+      }
+    }
+    return v;
+  }
+
+  /** @param {number} year @returns {number} d(raw)/dy */
+  function resonatorRawPrimeAt(year) {
+    let v = 0;
+    for (const k of RES_KICKS) {
+      const dt = year - k.t;
+      if (dt < 0) continue;
+      const e = Math.exp(-RES_LAMBDA * dt);
+      v += e * ((-RES_LAMBDA * k.cos_s + RES_WD * k.sin_s) * Math.cos(RES_WD * dt)
+              + (-RES_LAMBDA * k.sin_s - RES_WD * k.cos_s) * Math.sin(RES_WD * dt));
+    }
+    const dt1 = year - RES_KICKS[0].t;
+    if (dt1 >= 0) {
+      const e1 = Math.exp(-RES_LAMBDA * dt1);
+      for (const t of RES_TONES) {
+        const c0 = resonatorToneC0(t);
+        // d/dy of e1·[cos(ωy−φ) − c0·cos(w_d·dt1)] — product rule
+        v += e1 * t.amp_s * (-RES_LAMBDA * (Math.cos(t.omega * year - t.phi_locked)
+                                            - c0 * Math.cos(RES_WD * dt1))
+                             - t.omega * Math.sin(t.omega * year - t.phi_locked)
+                             + c0 * RES_WD * Math.sin(RES_WD * dt1));
+      }
+    }
+    return v;
+  }
+
+  // Analytic SECOND derivative — the dLOD/dt decomposition needs it: the
+  // resonator's δLOD has a genuine STEP at each kick, and a finite-difference
+  // rate smears it into a window-wide rectangle. Coefficient map applied
+  // twice for the kicks; product rule expansion for the compensated tone.
+  /** @param {number} year @returns {number} d²(raw)/dy² */
+  function resonatorRawSecondAt(year) {
+    let v = 0;
+    for (const k of RES_KICKS) {
+      const dt = year - k.t;
+      if (dt < 0) continue;
+      const e = Math.exp(-RES_LAMBDA * dt);
+      const a1 = -RES_LAMBDA * k.cos_s + RES_WD * k.sin_s;
+      const b1 = -RES_LAMBDA * k.sin_s - RES_WD * k.cos_s;
+      const a2 = -RES_LAMBDA * a1 + RES_WD * b1;
+      const b2 = -RES_LAMBDA * b1 - RES_WD * a1;
+      v += e * (a2 * Math.cos(RES_WD * dt) + b2 * Math.sin(RES_WD * dt));
+    }
+    const dt1 = year - RES_KICKS[0].t;
+    if (dt1 >= 0) {
+      const e1 = Math.exp(-RES_LAMBDA * dt1);
+      for (const t of RES_TONES) {
+        const c0 = resonatorToneC0(t);
+        const A = Math.cos(t.omega * year - t.phi_locked) - c0 * Math.cos(RES_WD * dt1);
+        const A1 = -t.omega * Math.sin(t.omega * year - t.phi_locked)
+                 + c0 * RES_WD * Math.sin(RES_WD * dt1);
+        const A2 = -t.omega * t.omega * Math.cos(t.omega * year - t.phi_locked)
+                 + c0 * RES_WD * RES_WD * Math.cos(RES_WD * dt1);
+        v += t.amp_s * e1 * (RES_LAMBDA * RES_LAMBDA * A - 2 * RES_LAMBDA * A1 + A2);
+      }
+    }
+    return v;
+  }
+
+  const RES_DT_RAW_AT_J2000 = resonatorRawSecondsAt(2000);
+
+  /** @param {number} year @returns {number} anchored swing ΔT correction, s */
+  function swingDeltaTSecondsAt(year) {
+    const taper = taperAt(year);
+    if (taper <= 0) return 0;
+    return taper * (resonatorRawSecondsAt(year) - RES_DT_RAW_AT_J2000);
+  }
+
+  /** @param {number} year @returns {number} implied swing δLOD, s */
+  function swingLodSecondsAt(year) {
+    const taper = taperAt(year);
+    if (taper <= 0) return 0;
+    const dCdy = taperDerivativeAt(year) * (resonatorRawSecondsAt(year) - RES_DT_RAW_AT_J2000)
+               + taper * resonatorRawPrimeAt(year);
+    return 86400 * dCdy / YEAR_S;
+  }
+
+  /** Analytic d(δLOD)/dy — exact in the flat-taper region, central
+   *  difference in the transition (values there are microscopic).
+   * @param {number} year @returns {number} */
+  function swingLodRateAt(year) {
+    const taper = taperAt(year);
+    if (taper <= 0) return 0;
+    if (taper >= 1) {
+      return 86400 * resonatorRawSecondAt(year) / YEAR_S;
+    }
+    return (swingLodSecondsAt(year + 1) - swingLodSecondsAt(year - 1)) / 2;
+  }
+
+  return {
+    taperAt, taperDerivativeAt,
+    cycleDeltaTSecondsAt, cycleLodSecondsAt,
+    swingDeltaTSecondsAt, swingLodSecondsAt, swingLodRateAt,
+  };
+}
+
+module.exports = { createDeltaTCycles };

package/src/deltat/deep-time.cjs

@@ -0,0 +1,266 @@
+/**
+ * Deep-time LOD / ΔT core — THE shared implementation (Phase 8.4, slice 3).
+ *
+ * The angular-momentum-conservation LOD (Layer 1/2), the H(t) identity, the
+ * mass-loss year chain, the Simpson ΔT integrator with the H/5 ecliptic
+ * "missing motion" integrand, the corrected-LOD composite, the Actual-LOD
+ * Fourier ripple, and the dLOD/dt driver decomposition (tidal / GIA /
+ * stack / resonator channels).
+ *
+ * INJECTED, by design:
+ *  - moonDistanceMetresAtAge — the 8.2 moon month-chain (each engine's own
+ *    factory wiring).
+ *  - moiFactorAtAge — the L1-orbital-coupled GIA α(t). The lattice-α pin
+ *    machinery (_withLatticeAlpha) is ENGINE STATE and stays there.
+ *  - siderealYearDaysFourierAt — the IAU-base integrated-phase Fourier
+ *    evaluator (Phase D matched pair). 8.4-1 S-D2: the browser's old Actual
+ *    divided by its epoch-aware f(Y) evaluator instead, double-counting the
+ *    deep-time drift already in mean(t) — 12% wrong at −400 Ma. Both engines
+ *    now inject the ripple-form evaluator.
+ *  - cycleLodSumAt / swingLodAt / swingLodRateAt — the engine-GATED
+ *    cycle-stack sums (flags are engine dispatch).
+ *
+ * The ΔT CACHE and the post-integration correction adds stay engine-side:
+ * both engines key the cache on their flag state (the browser's flags are
+ * runtime-mutable UI toggles), and the corrections are added SEQUENTIALLY
+ * onto the integral — pre-summing them here would change the FP
+ * association, so deltaTRawSecondsAtAge returns the raw integral and each
+ * engine keeps its exact add order.
+ *
+ * Year anchor: every year-of-age conversion here is 2000 − t_Ma·1e6 — the
+ * convention of the ΔT integrand and the Node engine throughout. 8.4-1
+ * S-D3/S-D5: the browser's WithCorrections and decomposition historically
+ * used startmodelYear (2000.5), a half-year phase offset — aligned with
+ * measured fixture re-records.
+ */
+
+'use strict';
+
+/**
+ * @typedef {Object} DeepTimeLodConstants
+ * @property {number} lTotalEmKgm2S - Earth–Moon total angular momentum
+ * @property {number} mMoonAloneKg
+ * @property {number} mEarthAloneKg
+ * @property {number} rEarthMetres
+ * @property {number} gmEmM3PerS2 - GM of the Earth–Moon system
+ * @property {number} eFactorMoon - √(1−e²) factor of the lunar orbit
+ * @property {number} aLockMetres - tidal-lock distance (LOD denominator → 0)
+ * @property {number} aMoonNowMetres - Farhat polynomial anchor
+ * @property {number} alpha1PerMa @property {number} alpha3PerMa3
+ * @property {number} alpha4PerMa4
+ * @property {number} holisticYearJ2000
+ * @property {number} lodNowH13Seconds - the H/13-identity mean LOD at J2000
+ * @property {number} meanSiderealYearJ2000Seconds
+ * @property {number} solarMassLossFracPerYear
+ * @property {number} siderealYearDaysKinematicJ2000 - Actual-LOD numerator
+ */
+
+/**
+ * @typedef {Object} DeepTimeLodDeps
+ * @property {DeepTimeLodConstants} constants
+ * @property {(tMa: number) => number} moonDistanceMetresAtAge
+ * @property {(tMa: number) => number} moiFactorAtAge - GIA α(t)
+ * @property {(year: number) => number} siderealYearDaysFourierAt
+ * @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
+ */
+
+/** @param {DeepTimeLodDeps} deps */
+function createDeepTimeLod(deps) {
+  const K = deps.constants;
+
+  /** Layer 1/2 mean LOD: LOD = 2π·I(t) / (L_total − 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);
+  }
+
+  /** Same LOD with an EXPLICIT α (the browser's "α at climate mean" curve).
+   * @param {number} t_Ma @param {number} alpha @returns {number|null} */
+  function lodSecondsAtAgeWithAlpha(t_Ma, alpha) {
+    const a = deps.moonDistanceMetresAtAge(t_Ma);
+    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);
+  }
+
+  /** @param {number} t_Ma @returns {number|null} */
+  function lodHoursAtAge(t_Ma) {
+    const s = lodSecondsAtAge(t_Ma);
+    return (s === null) ? null : s / 3600;
+  }
+
+  /** H(t) via the H/13 identity: H(t) = H_J2000 · LOD(t)/LOD_J2000.
+   * @param {number} t_Ma @returns {number|null} */
+  function hAtAge(t_Ma) {
+    const LOD_s = lodSecondsAtAge(t_Ma);
+    if (LOD_s === null) return null;
+    return K.holisticYearJ2000 * LOD_s / K.lodNowH13Seconds;
+  }
+
+  /** Sidereal year seconds (Kepler under linear mass loss, dT/T = −2 dM/M).
+   * @param {number} t_Ma @returns {number} */
+  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);
+  }
+
+  /** @param {number} t_Ma @returns {number} tropical = sidereal · (1 − 13/H(t)) */
+  function tropicalYearSecondsAtAge(t_Ma) {
+    const sidSec = siderealYearSecondsAtAge(t_Ma);
+    const Ht = hAtAge(t_Ma);
+    if (Ht === null) return sidSec * (1 - 13 / K.holisticYearJ2000);
+    return sidSec * (1 - 13 / Ht);
+  }
+
+  /** @param {number} t_Ma @returns {number|null} */
+  function tropicalYearDaysAtAge(t_Ma) {
+    const seconds = tropicalYearSecondsAtAge(t_Ma);
+    return seconds === null ? null : seconds / 86400;
+  }
+
+  /** @param {number} t_Ma @returns {number|null} tropical seconds / LOD(t) */
+  function yearInDaysAtAge(t_Ma) {
+    const LOD_s = lodSecondsAtAge(t_Ma);
+    if (LOD_s === null) return null;
+    return tropicalYearSecondsAtAge(t_Ma) / LOD_s;
+  }
+
+  /**
+   * RAW ΔT integral relative to J2000 (0 at t=0 by convention) — Simpson
+   * over the H/5-raw kinematic LOD, WITHOUT the cycle corrections and
+   * WITHOUT a cache. The engines wrap this: flag-keyed cache + their exact
+   * sequential post-integration adds (see the module header).
+   * @param {number} t_Ma @returns {number} seconds (NaN past tidal lock)
+   */
+  function deltaTRawSecondsAtAge(t_Ma) {
+    if (t_Ma === 0) return 0;
+    const absSpan = Math.abs(t_Ma);
+    let n = Math.max(32, Math.ceil(absSpan * 10));
+    if (n > 1024) n = 1024;
+    if (n % 2 === 1) n++;
+    const h = t_Ma / n;
+
+    let sum = 0;
+    for (let i = 0; i <= n; i++) {
+      const tau = i * h;
+      const lodMean = lodSecondsAtAge(tau);
+      if (lodMean === null) return NaN;
+      const yearS = tropicalYearSecondsAtAge(tau);
+      // H/5 ecliptic "missing motion" — the solar day is measured against
+      // the Sun on the ECLIPTIC (precesses at H/5), not the inclination
+      // frame (H/3). Adds ~3.5 ms at J2000 (raw kinematic 86400.003 s); the
+      // fitted cycle stack closes Layer-4 LOD_real onto the USNO anchor.
+      // Non-null: both can only be null when lodSecondsAtAge(tau) is null,
+      // which already returned NaN above — the checker can't see the chain.
+      const H_local = /** @type {number} */ (hAtAge(tau));
+      const mSY_days = /** @type {number} */ (tropicalYearDaysAtAge(tau));
+      const lodH5Raw = lodMean + lodMean / ((H_local / 5) * mSY_days);
+      const integrand = (86400 - lodH5Raw) * yearS * 1e6 / 86400;
+      const w = (i === 0 || i === n) ? 1 : (i % 2 === 1 ? 4 : 2);
+      sum += w * integrand;
+    }
+    return (sum * h) / 3;
+  }
+
+  /** Layer 3/4 LOD: tidal mean + the gated cycle δLOD sum.
+   * @param {number} t_Ma @returns {number|null} */
+  function lodSecondsWithCorrectionsAtAge(t_Ma) {
+    const tidal = lodSecondsAtAge(t_Ma);
+    if (tidal === null) return null;
+    const year = 2000 - t_Ma * 1e6;
+    return tidal + deps.cycleLodSumAt(year);
+  }
+
+  /** ACTUAL LOD: tidal mean × Fourier ripple —
+   *  actual(t) = mean(t) × Y_days_kinematic_J2000 / Y_days_fourier(year).
+   *  Fixed bases (the ripple isolates year-to-year variation; the deep-time
+   *  drift is already in mean(t)). @param {number} t_Ma @returns {number|null} */
+  function lodSecondsActualAtAge(t_Ma) {
+    const mean_t = lodSecondsAtAge(t_Ma);
+    if (mean_t === null) return null;
+    const year_at_t = 2000 - t_Ma * 1e6;
+    const Y_days_fourier = deps.siderealYearDaysFourierAt(year_at_t);
+    return mean_t * K.siderealYearDaysKinematicJ2000 / Y_days_fourier;
+  }
+
+  /**
+   * dLOD/dt driver decomposition, ms/century per channel.
+   * tidal: Moon-recession (Farhat da/dt, LLR-anchored) · gia: α(t) numeric
+   * derivative · stack: 50-yr central difference on the FLAGS-ONLY δLOD sum
+   * (smooth; shortest harmonic 716 yr) · resonator: the ANALYTIC rate (the
+   * episode's δLOD steps at the kicks — a central difference smears them).
+   * @param {number} t_Ma
+   * @returns {{ tidal: number|null, gia: number|null, stack: number|null,
+   *   resonator: number|null, net_L2: number|null, net_L3: number|null,
+   *   net_L4: number|null }}
+   */
+  function dLodDtDecompositionAtAge(t_Ma) {
+    const nullResult = { tidal: null, gia: null, stack: null, resonator: null,
+                         net_L2: null, net_L3: null, net_L4: null };
+    const a = deps.moonDistanceMetresAtAge(t_Ma);
+    if (a === null || a <= 0 || a >= K.aLockMetres) return nullResult;
+    const lod_s = lodSecondsAtAge(t_Ma);
+    if (lod_s === null) return nullResult;
+    const alpha = deps.moiFactorAtAge(t_Ma);
+    const I_E = alpha * K.mEarthAloneKg * K.rEarthMetres * K.rEarthMetres;
+    const year = 2000 - t_Ma * 1e6;
+
+    // Farhat polynomial derivative: da/dyear = −A_now·(α₁ + 3α₃t² + 4α₄t³)/1e6
+    // (t_Ma > 0 = past; forward-time sign flip). At J2000: +3.82 cm/yr (LLR) ✓
+    const da_dt_yr = -K.aMoonNowMetres * (K.alpha1PerMa + 3 * K.alpha3PerMa3 * t_Ma * t_Ma
+                   + 4 * K.alpha4PerMa4 * t_Ma * t_Ma * t_Ma) / 1e6;
+    const SEC_PER_YR = 365.25 * 86400;
+    const da_dt_s = da_dt_yr / SEC_PER_YR;
+
+    // Tidal channel: dL_M/dt = m_M · ½ · √(GM/a) · da/dt · √(1−e²)
+    const dLm_dt = K.mMoonAloneKg * 0.5 * Math.sqrt(K.gmEmM3PerS2 / a) * da_dt_s * K.eFactorMoon;
+    const domega_dt_tidal = -dLm_dt / I_E;
+    const dLod_dt_tidal_s_per_s = -(lod_s * lod_s) / (2 * Math.PI) * domega_dt_tidal;
+    const dLod_dt_tidal_ms_per_cy = dLod_dt_tidal_s_per_s * SEC_PER_YR * 100 * 1000;
+
+    // GIA channel: dLOD/dt = LOD·(dα/dt)/α, α differentiated numerically
+    // (100-yr step — well below any L1 harmonic period).
+    const EPS_MA = 1e-4;
+    const alpha_plus = deps.moiFactorAtAge(t_Ma - EPS_MA);
+    const alpha_minus = deps.moiFactorAtAge(t_Ma + EPS_MA);
+    const dalpha_dyr = (alpha_plus - alpha_minus) / (2 * EPS_MA * 1e6);
+    const dLod_dt_gia_s_per_yr = lod_s * dalpha_dyr / alpha;
+    const dLod_dt_gia_ms_per_cy = dLod_dt_gia_s_per_yr * 100 * 1000;
+
+    // Flags-only stack rate (sum minus the resonator term), 50-yr window.
+    const DYR = 50;
+    const dFlags_dyr = ((deps.cycleLodSumAt(year + DYR) - deps.swingLodAt(year + DYR))
+                      - (deps.cycleLodSumAt(year - DYR) - deps.swingLodAt(year - DYR)))
+                      / (2 * DYR);
+    const dLod_dt_stack_only_ms_per_cy = dFlags_dyr * 100 * 1000;
+    const dLod_dt_resonator_ms_per_cy = deps.swingLodRateAt(year) * 100 * 1000;
+
+    const net_L2 = dLod_dt_tidal_ms_per_cy + dLod_dt_gia_ms_per_cy;
+    const net_L3 = net_L2 + dLod_dt_stack_only_ms_per_cy;
+    const net_L4 = net_L3 + dLod_dt_resonator_ms_per_cy;
+
+    return {
+      tidal: dLod_dt_tidal_ms_per_cy,
+      gia: dLod_dt_gia_ms_per_cy,
+      stack: dLod_dt_stack_only_ms_per_cy,
+      resonator: dLod_dt_resonator_ms_per_cy,
+      net_L2, net_L3, net_L4,
+    };
+  }
+
+  return {
+    lodSecondsAtAge, lodSecondsAtAgeWithAlpha, lodHoursAtAge, hAtAge,
+    siderealYearSecondsAtAge, tropicalYearSecondsAtAge, tropicalYearDaysAtAge,
+    yearInDaysAtAge, deltaTRawSecondsAtAge, lodSecondsWithCorrectionsAtAge,
+    lodSecondsActualAtAge, dLodDtDecompositionAtAge,
+  };
+}
+
+module.exports = { createDeepTimeLod };

package/src/deltat/historical.cjs

@@ -0,0 +1,84 @@
+/**
+ * Historical ΔT — the Espenak/Meeus piecewise polynomial (Phase 8.4,
+ * slice 4; canon-only since 8.4-4c). EXACTLY the published NASA canon
+ * (eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html): every era segment
+ * including the separate 1986–2005 one, and the −20 + 32u² parabola
+ * (with the −0.5628·(2150−y) correction above 2050) outside the
+ * tabulated range — Espenak's own out-of-range guidance, not NaN.
+ *
+ * HISTORY: the browser shipped a simplification until 8.4-4c (1986–2005
+ * merged into the 62.92-branch; NaN outside −1999..3000) with a matching
+ * 62.92 display anchor. Both were replaced by the canon + its 63.86
+ * anchor (astro-reference externalCurveAnchors.deltaTEspenakJ2000Seconds)
+ * in one measured commit — curve and anchor are a matched pair.
+ *
+ * ONE VARIANT REMAINS OUTSIDE (recorded in plan §12g for Phase 9):
+ * tools/fit/sun-longitude-harmonics.js — its ΔT timed the UT→TT
+ * conversion when the SHIPPED sun-harmonic coefficients were fitted, so
+ * it is half of a matched pair and swaps only with a deliberate refit.
+ *
+ * The engines own their anchoring conventions (the browser subtracts its
+ * DELTA_T_ESPENAK_J2000_S display anchor separately).
+ */
+
+'use strict';
+
+/**
+ * Espenak/Meeus ΔT in seconds — the FULL published canon: separate
+ * 1986–2005 segment, and the −20 + 32u² parabola (with the −0.5628
+ * correction above 2050) outside the tabulated range instead of NaN.
+ * @param {number} year - calendar year
+ * @returns {number}
+ */
+function deltaTEspenakMeeusCanonSeconds(year) {
+  let u, t;
+  if (year < -500) {
+    u = (year - 1820) / 100;
+    return -20 + 32 * u * u;
+  } else if (year < 500) {
+    u = year / 100;
+    return 10583.6 - 1014.41 * u + 33.78311 * u ** 2 - 5.952053 * u ** 3 - 0.1798452 * u ** 4
+      + 0.022174192 * u ** 5 + 0.0090316521 * u ** 6;
+  } else if (year < 1600) {
+    u = (year - 1000) / 100;
+    return 1574.2 - 556.01 * u + 71.23472 * u ** 2 + 0.319781 * u ** 3 - 0.8503463 * u ** 4
+      - 0.005050998 * u ** 5 + 0.0083572073 * u ** 6;
+  } else if (year < 1700) {
+    t = year - 1600;
+    return 120 - 0.9808 * t - 0.01532 * t ** 2 + t ** 3 / 7129;
+  } else if (year < 1800) {
+    t = year - 1700;
+    return 8.83 + 0.1603 * t - 0.0059285 * t ** 2 + 0.00013336 * t ** 3 - t ** 4 / 1174000;
+  } else if (year < 1860) {
+    t = year - 1800;
+    return 13.72 - 0.332447 * t + 0.0068612 * t ** 2 + 0.0041116 * t ** 3 - 0.00037436 * t ** 4
+      + 0.0000121272 * t ** 5 - 0.0000001699 * t ** 6 + 0.000000000875 * t ** 7;
+  } else if (year < 1900) {
+    t = year - 1860;
+    return 7.62 + 0.5737 * t - 0.251754 * t ** 2 + 0.01680668 * t ** 3 - 0.0004473624 * t ** 4 + t ** 5 / 233174;
+  } else if (year < 1920) {
+    t = year - 1900;
+    return -2.79 + 1.494119 * t - 0.0598939 * t ** 2 + 0.0061966 * t ** 3 - 0.000197 * t ** 4;
+  } else if (year < 1941) {
+    t = year - 1920;
+    return 21.20 + 0.84493 * t - 0.076100 * t ** 2 + 0.0020936 * t ** 3;
+  } else if (year < 1961) {
+    t = year - 1950;
+    return 29.07 + 0.407 * t - t ** 2 / 233 + t ** 3 / 2547;
+  } else if (year < 1986) {
+    t = year - 1975;
+    return 45.45 + 1.067 * t - t ** 2 / 260 - t ** 3 / 718;
+  } else if (year < 2005) {
+    t = year - 2000;
+    return 63.86 + 0.3345 * t - 0.060374 * t ** 2 + 0.0017275 * t ** 3 + 0.000651814 * t ** 4
+      + 0.00002373599 * t ** 5;
+  } else if (year < 2050) {
+    t = year - 2000;
+    return 62.92 + 0.32217 * t + 0.005589 * t ** 2;
+  } else {
+    u = (year - 1820) / 100;
+    return -20 + 32 * u * u - 0.5628 * (2150 - year);
+  }
+}
+
+module.exports = { deltaTEspenakMeeusCanonSeconds };