@essrt/physics 25.0.1 → 26.0.1

package/src/moon/arguments.cjs

@@ -20,8 +20,12 @@
  *    with p the IAU general precession.
  *
  * Construction (docs/66 §1, abridged): linear rates are observational J2000
- * anchors; perigee/node ride the PHASE-AWARE e_E channel integral (s_ϖ
- * 2.407 / s_Ω 1.018, Meeus-effective); Lp's planetary T² remainder rides
+ * anchors; perigee/node ride the PHASE-AWARE e_E channel integral on the
+ * PHYSICAL sensitivities (s_ϖ 2.479 / s_Ω 0.867 — derived from the
+ * Meeus-effective 2.407 / 1.018 by removing the frame's T²;
+ * moon/ecc-sensitivities.cjs, the ONE home) plus the model's own precession
+ * of date, pFix, the ONE frame term every of-date longitude carries (plan 23
+ * — so M′ and F are frame-free at every epoch); Lp's planetary T² remainder rides
  * the bounded e_E² carrier + the obliquity-line carrier (K_PL derived
  * lazily from the closed v4 budget — zero new constants); D and M are
  * identity-composed (D ≡ Lp − L_sun, M ≡ L_sun − ϖ_sun) on the injected
@@ -37,6 +41,8 @@
 // reform). ONE home — time/calendar.cjs; re-exported here for the readers
 // that import it from the arguments module.
 const { jdToDecimalYear } = require('../time/calendar.cjs');
+// The Meeus Ch. 47 argument rates — ONE home (plan 23; the sensitivities' derivation reads the same set).
+const { MEEUS_ARGUMENT_RATES_DEG_PER_CY } = require('./ecc-sensitivities.cjs');
 
 /**
  * @typedef {{Lp: number, D: number, M: number, Mp: number, F: number}} MoonArgsDeg
@@ -59,6 +65,7 @@ const SECULAR_COMPLETION_TAPER_YEARS = 27943.083333333332;
  *     elpEarthFigureJ2ArcsecPerCy2: number,
  *     elpGeneralPrecessionPA_T2ArcsecPerCy2: number,
  *     eccE0: number,
+ *     moonEccSensitivities: ReturnType<typeof import('./ecc-sensitivities.cjs').deriveMoonEccSensitivities>,
  *   },
  *   fns: {
  *     eccAt: (tYr: number) => number,
@@ -94,8 +101,9 @@ function createMoonArguments({ constants, fns }) {
     j2000JD, julianCenturyDays,
     eccentricityJ2000, eccentricityDotJ2000, eccentricityDotDotJ2000,
     elpEarthFigureJ2ArcsecPerCy2, elpGeneralPrecessionPA_T2ArcsecPerCy2,
-    eccE0,
+    eccE0, moonEccSensitivities,
   } = constants;
+  if (!moonEccSensitivities) throw new Error('moon/arguments: constants.moonEccSensitivities is required (the deep-time chain\'s derived pair — plan 23)');
   const {
     eccAt, channelIntegral, computeObliquityEarth, jdToSIyear,
     sunMeanLonDegAtJdTT, sunPerihelionLonDegAtJdTT,
@@ -108,17 +116,26 @@ function createMoonArguments({ constants, fns }) {
   const bundle = (() => {
     const LP0 = 218.3164477, D0 = 297.8501921, M0 = 357.5291092,
           MP0 = 134.9633964, F0 = 93.2720950;
-    const LPR = 481267.88123421, DR = 445267.1114034, MR = 35999.0502909,
-          MPR = 477198.8675055, FR = 483202.0175233;
+    const { Lp: LPR, D: DR, M: MR, Mp: MPR, F: FR } = MEEUS_ARGUMENT_RATES_DEG_PER_CY;   // ONE home (plan 23)
     const WDOT = LPR - MPR;   // perigee ϖ̇ of-date (+4069.0137) = ϖ̇_ICRF + p
     const NDOT = LPR - FR;    // node   Ω̇ of-date (−1934.1363) = Ω̇_ICRF + p
     // e_E channel Taylor CHECKS (documented J2000 reference values — the live
     // path is the phase-aware channelIntegral; T2_*/T3_* are NOT consumed):
     const E0 = eccentricityJ2000, EDOT0 = eccentricityDotJ2000;
     const KAPPA = 3 * E0 * EDOT0 / (1 - E0 * E0);
-    // v4 frame attribution: FRAME-EFFECTIVE exponents (physical pair after
-    // removing the IAU ṗ_A frame term: s_ϖ 2.479 / s_Ω 0.867).
-    const S_W = 2.407, S_N = 1.018;
+    // The sensitivities (plan 23; moon/ecc-sensitivities.cjs, the ONE home). The
+    // Meeus-EFFECTIVE pair S_W/S_N reproduces Meeus's of-date T² exactly — the
+    // documented check below. The live channel runs the PHYSICAL pair
+    // S_W_PHYS/S_N_PHYS (the frame's T² removed; the three-body lab's pure-gravity
+    // values) on the ICRF rates W_ICRF/N_ICRF, and the frame rides separately:
+    // the Meeus polynomial p₀·T + T2F·T² in the snapshot branch (so its T² is
+    // Meeus-exact as before), the model's own precession of date (pFix) in the
+    // deep branch — ONE frame term on L′, ϖ and Ω alike.
+    const SENS = moonEccSensitivities;
+    const S_W = SENS.perigeeEffective, S_N = SENS.nodeEffective;
+    const S_W_PHYS = SENS.perigeePhysical, S_N_PHYS = SENS.nodePhysical;
+    const W_ICRF = SENS.perigeeRateIcrfDegPerCy, N_ICRF = SENS.nodeRateIcrfDegPerCy;
+    const P0 = SENS.generalPrecessionDegPerCy, T2F = SENS.frameT2DegPerCy2;
     const T2_W = S_W * WDOT * KAPPA / 2;   // −0.010318 °/cy² (Meeus ϖ −0.010320)
     const T2_N = S_N * NDOT * KAPPA / 2;   // +0.0020752 °/cy² (Meeus Ω +0.0020753)
     const EDDOT0 = eccentricityDotDotJ2000;
@@ -130,7 +147,7 @@ function createMoonArguments({ constants, fns }) {
     const T2_LP_TIDAL = (-25.86 / 3600) / 2;
     const T2_LP_PLANETARY = -0.0015786 - T2_LP_TIDAL;   // +7.247″/cy²
     const T2_LP = T2_LP_TIDAL + T2_LP_PLANETARY;
-    return { LP0, D0, M0, MP0, F0, LPR, DR, MR, WDOT, NDOT, T2_W, T2_N, T3_W, T3_N, T2_LP, T2_LP_TIDAL, S_W, S_N };
+    return { LP0, D0, M0, MP0, F0, LPR, DR, MR, WDOT, NDOT, T2_W, T2_N, T3_W, T3_N, T2_LP, T2_LP_TIDAL, S_W, S_N, S_W_PHYS, S_N_PHYS, W_ICRF, N_ICRF, P0, T2F };
   })();
 
   // ── Bounded Lp carriers (K_PL / C_OBL derived lazily — zero new constants)
@@ -146,59 +163,63 @@ function createMoonArguments({ constants, fns }) {
     return kPl;
   }
   // ── Deep-time carrier tables ────────────────────────────────────────────────
-  // In the era (|T| ≤ CARRIER_DENSE_CY = 250 kyr) each carrier is the Simpson
-  // sum below, untouched — the certified numbers. Beyond, the integral
-  // continues from the dense edge on a cumulative table of CARRIER_CELL_CY
-  // cells (1 kyr; per-cell 3-point Simpson, a 3-point Simpson over the
-  // partial last cell), grown in CARRIER_CHUNK cells in the direction asked
-  // for. The former form re-integrated the whole span from J2000 on EVERY
-  // call with N ∝ |T| nodes — 77 evaluations of the e channel at 300 kyr,
-  // 2,500 at 10 Myr, per lunar argument set and frame — the deep-time
-  // playback cost the owner measured (the loop's JS at 190 ms a frame).
-  const CARRIER_DENSE_CY = 2500, CARRIER_CELL_CY = 10, CARRIER_CHUNK = 2500;
+  // Every carrier is ∫₀ᵀ f dt on ONE cumulative table per direction: fine
+  // cells of CARRIER_FINE_CY (100 yr) to ±CARRIER_FINE_RANGE_CY (250 kyr),
+  // grown in CARRIER_FINE_CHUNK cells (10 kyr — an in-window call never
+  // samples deeper than it must), then CARRIER_CELL_CY cells (1 kyr) grown in
+  // CARRIER_CHUNK (the former deep tier, unchanged); per-cell 3-point Simpson
+  // and a 3-point Simpson over the partial last cell. Continuous in value AND
+  // in rate: the per-cell error is fixed by the cell, so nothing jumps when T
+  // grows. (Plan 23 follow-up, measured on the Node Regression panel: the
+  // in-era form was one Simpson from J2000 to T whose node count stepped every
+  // 2 kyr (obliquity) / 8 kyr (planetary), so the accumulated error jumped
+  // there — 0.3–6″ on the obliquity carrier at 20–250 kyr, 10–15″ on the
+  // planetary one at ±6/22 kyr — invisible on L′'s rate, a notch of 0.5 d on
+  // the node period once the remainder rode Ω. The earlier form that
+  // re-integrated the whole span on every call cost the deep-time playback
+  // 190 ms a frame — the owner's measurement behind the tables.)
+  const CARRIER_FINE_CY = 1, CARRIER_FINE_RANGE_CY = 2500, CARRIER_FINE_CHUNK = 100;
+  const CARRIER_CELL_CY = 10, CARRIER_CHUNK = 2500;
   /** @param {(t: number) => number} f the SCALED integrand per century
-   *  @param {(T: number) => number} dense the in-era Simpson (its value at ±CARRIER_DENSE_CY seeds the table)
-   *  @returns {(T: number) => number} */
-  function makeDeepCarrier(f, dense) {
-    /** @type {{ fwd: number[] | null, bwd: number[] | null }} */
+   *  @returns {(T: number) => number} ∫₀ᵀ f dt, T in Julian centuries (signed) */
+  function makeDeepCarrier(f) {
+    /** @type {{ fwd: {fine: number[], coarse: number[] | null} | null, bwd: {fine: number[], coarse: number[] | null} | null }} */
     const sides = { fwd: null, bwd: null };
+    const NF = CARRIER_FINE_RANGE_CY / CARRIER_FINE_CY;
+    /** The signed cell integral from t0 (nearer J2000) to t1. @param {number} t0 @param {number} t1 */
+    const cell = (t0, t1) => (f(t0) + 4 * f((t0 + t1) / 2) + f(t1)) * ((t1 - t0) / 6);
+    /** @param {{fine: number[]}} s @param {number} dir @param {number} upTo grow the fine table to this many cells */
+    const growFine = (s, dir, upTo) => {
+      for (let i = s.fine.length; i <= upTo; i++) s.fine.push(s.fine[i - 1] + cell(dir * (i - 1) * CARRIER_FINE_CY, dir * i * CARRIER_FINE_CY));
+    };
     return (T) => {
-      if (Math.abs(T) <= CARRIER_DENSE_CY) return dense(T);
-      const dir = T > 0 ? 1 : -1;
-      let cum = dir === 1 ? sides.fwd : sides.bwd;
-      if (!cum) { cum = [dense(dir * CARRIER_DENSE_CY)]; if (dir === 1) sides.fwd = cum; else sides.bwd = cum; }
-      const dist = Math.abs(T) - CARRIER_DENSE_CY;
+      if (T === 0) return 0;
+      const dir = T > 0 ? 1 : -1, a = Math.abs(T);
+      let s = dir === 1 ? sides.fwd : sides.bwd;
+      if (!s) { s = { fine: [0], coarse: null }; if (dir === 1) sides.fwd = s; else sides.bwd = s; }
+      if (a <= CARRIER_FINE_RANGE_CY) {
+        const k = Math.floor(a / CARRIER_FINE_CY);
+        if (s.fine.length < k + 2) growFine(s, dir, Math.min(NF, Math.ceil((k + 1) / CARRIER_FINE_CHUNK) * CARRIER_FINE_CHUNK));
+        return s.fine[k] + cell(dir * k * CARRIER_FINE_CY, T);
+      }
+      if (!s.coarse) { growFine(s, dir, NF); s.coarse = [s.fine[NF]]; }
+      const dist = a - CARRIER_FINE_RANGE_CY;
       const k = Math.floor(dist / CARRIER_CELL_CY);
-      let target = cum.length;
+      let target = s.coarse.length;
       while (target < k + 2) target += CARRIER_CHUNK;
-      for (let i = cum.length; i < target; i++) {
-        const t0 = dir * (CARRIER_DENSE_CY + (i - 1) * CARRIER_CELL_CY), t1 = t0 + dir * CARRIER_CELL_CY;
-        cum.push(cum[i - 1] + dir * (f(t0) + 4 * f((t0 + t1) / 2) + f(t1)) * (CARRIER_CELL_CY / 6));
+      for (let i = s.coarse.length; i < target; i++) {
+        const t0 = dir * (CARRIER_FINE_RANGE_CY + (i - 1) * CARRIER_CELL_CY);
+        s.coarse.push(s.coarse[i - 1] + cell(t0, t0 + dir * CARRIER_CELL_CY));
       }
-      const ta = dir * (CARRIER_DENSE_CY + k * CARRIER_CELL_CY);
-      const hp = T - ta;
-      return cum[k] + (f(ta) + 4 * f(ta + hp / 2) + f(T)) * (hp / 6);
+      return s.coarse[k] + cell(dir * (CARRIER_FINE_RANGE_CY + k * CARRIER_CELL_CY), T);
     };
   }
 
-  /** The planetary carrier's SCALED integrand, k_PL · (e² − e0²), per century. @param {number} t */
+  /** The planetary carrier's SCALED integrand, k_PL · (e² − e0²), per century
+   *  (e0 the channel's anchor CONST — not eccAt(0), which under integrated
+   *  phase carries the R3 drift correction, the 8.2-2 convention). @param {number} t */
   const planetaryIntegrand = (t) => { const e = eccAt(t * 100); return kPlValue() * (e * e - eccE0 * eccE0); };
-  /** @param {number} T @returns {number} */
-  function planetaryCarrierDense(T) {
-    if (T === 0) return 0;
-    const k = kPlValue();
-    // The channel's e0 anchor CONST — not eccAt(0), which under integrated
-    // phase carries the R3 drift correction (the 8.2-2 convention).
-    const e0sq = eccE0 * eccE0;
-    /** @param {number} t */
-    const f = (t) => { const e = eccAt(t * 100); return e * e - e0sq; };
-    const N = Math.max(2, 2 * Math.ceil(Math.abs(T) * 100 / 8000));
-    const h = T / N;
-    let sum = f(0) + f(T);
-    for (let i = 1; i < N; i++) sum += f(i * h) * (i % 2 ? 4 : 2);
-    return k * sum * h / 3;
-  }
-  const planetaryCarrier = makeDeepCarrier(planetaryIntegrand, planetaryCarrierDense);
+  const planetaryCarrier = makeDeepCarrier(planetaryIntegrand);
 
   /** @type {{eps0: number, C: number} | null} */
   let obl = null;
@@ -221,19 +242,24 @@ function createMoonArguments({ constants, fns }) {
   }
   /** The obliquity carrier's SCALED integrand, C · (ε − ε0), per century. @param {number} t */
   const obliquityIntegrand = (t) => { const O = oblInit(); return O.C * (computeObliquityEarth(2000 + t * 100) - O.eps0); };
-  /** @param {number} T @returns {number} */
-  function obliquityCarrierDense(T) {
+  const obliquityCarrier = makeDeepCarrier(obliquityIntegrand);
+
+  /** The frame share's REMAINDER for ϖ and Ω (plan 23). The physical exponents gave
+   *  up the frame's T² the Meeus-effective pair carried (T2F, Lieske's); pFix
+   *  supplies the model's own in-window acceleration (ṗΔ_eff/2, self-measured);
+   *  the difference rides the obliquity carrier's integrand, exactly as L′'s
+   *  figure+frame part does — so every of-date longitude's T² stays Meeus-exact
+   *  and ONE frame term (pFix + this remainder) rides L′, ϖ and Ω alike. Bounded
+   *  (the obliquity cycle), ~0.1° at most. Without the (d′) pair (pdSlope 0) the
+   *  whole Lieske share rides here and pFix is 0 — the same frame, one carrier.
+   *  @param {number} T @returns {number} */
+  function frameRemainder(T) {
     if (T === 0) return 0;
-    const O = oblInit();
-    /** @param {number} t */
-    const f = (t) => computeObliquityEarth(2000 + t * 100) - O.eps0;
-    const N = Math.max(2, 2 * Math.ceil(Math.abs(T) * 100 / 2000));
-    const h = T / N;
-    let sum = f(0) + f(T);
-    for (let i = 1; i < N; i++) sum += f(i * h) * (i % 2 ? 4 : 2);
-    return O.C * sum * h / 3;
+    const pdHalf = rateCompInit().pdSlopeDegPerCy2 / 2;
+    const t2Obl = (elpEarthFigureJ2ArcsecPerCy2 + elpGeneralPrecessionPA_T2ArcsecPerCy2) / 3600 - pdHalf;   // L′'s carrier normalization (oblInit)
+    const t2Rem = bundle.T2F - pdHalf;
+    return t2Obl === 0 ? 0 : obliquityCarrier(T) * (t2Rem / t2Obl);
   }
-  const obliquityCarrier = makeDeepCarrier(obliquityIntegrand, obliquityCarrierDense);
 
   // ── Secular-ë completion carrier (ṅ campaign, plan §12i item 0 (c)) ──────
   // The certified snapshot's Lp T³/T⁴ tail is DERIVED physics (v4 D3,
@@ -273,24 +299,20 @@ function createMoonArguments({ constants, fns }) {
       const d2Ch = (e2(10) - 2 * e2(0) + e2(-10)) / 100;
       secComp = { dd2: d2Sec - d2Ch, d3Sec, Tq: SECULAR_COMPLETION_TAPER_YEARS / 100 };
     }
-    const S = secComp;
-    /** @param {number} t */
-    const f = (t) => {
-      const q = Math.abs(t) / S.Tq;
-      if (q >= 1) return 0;
-      const env = Math.cos(Math.PI / 2 * q) ** 2;
-      return (0.5 * S.dd2 * t * t + S.d3Sec * t * t * t / 6) * env;
-    };
-    // Beyond the era the envelope has long closed (|t| ≥ Tq ≈ 279 cy → 0): the
-    // integral is the constant to ±Tq, so integrate exactly that span instead of
-    // N ∝ |T| nodes of zeros (in-era calls untouched).
-    if (Math.abs(T) > CARRIER_DENSE_CY) T = Math.sign(T) * S.Tq;
-    const N = Math.max(2, 2 * Math.ceil(Math.abs(T) * 100 / 2000));
-    const h = T / N;
-    let sum = f(0) + f(T);
-    for (let i = 1; i < N; i++) sum += f(i * h) * (i % 2 ? 4 : 2);
-    return kPlValue() * sum * h / 3;
+    // Beyond the taper the envelope has closed (|t| ≥ Tq ≈ 279 cy → 0): the
+    // integral is the constant to ±Tq, so the table is read at ±Tq there.
+    const Tq = secComp.Tq;
+    return secCarrier(Math.abs(T) > Tq ? Math.sign(T) * Tq : T);
   }
+  /** The completion's SCALED integrand, k_PL · the tapered curvature difference, per century. @param {number} t */
+  const secIntegrand = (t) => {
+    const S = /** @type {{dd2: number, d3Sec: number, Tq: number}} */ (secComp);
+    const q = Math.abs(t) / S.Tq;
+    if (q >= 1) return 0;
+    const env = Math.cos(Math.PI / 2 * q) ** 2;
+    return kPlValue() * (0.5 * S.dd2 * t * t + S.d3Sec * t * t * t / 6) * env;
+  };
+  const secCarrier = makeDeepCarrier(secIntegrand);
 
   // ── Deep-time branch: always-chains (Stage B) ────────────────────────────
   /** @type {number | null} */
@@ -446,18 +468,22 @@ function createMoonArguments({ constants, fns }) {
     if (Ntrop === null || Naps === null || Nnod === null) return null;   // tidal-lock guard
     const Tj = (jd - j2000JD) / julianCenturyDays;
     const dy = y - argsY0;
-    // pFix rides Lp ONLY: the obliquity carrier's PA reduction compensates
-    // its ṗΔ·T²/2 there, keeping total Lp T² certified. The apsidal/nodal
-    // chains' own curvature is ALREADY certified-consistent (v4 checks;
-    // pre-(d′) isolation −0.20/+0.13″/cy²), so ϖ/Ω take only the tapered
-    // rate anchors — which self-measure and absorb their Δp rate share.
-    // Deep time: Mp/F inherit Lp's bounded pFix oscillation uncancelled
-    // (physically p-free args; bounded, display-class — documented).
-    const pF = rateCompInit().pFix(dy);
+    // ONE equinox for the three of-date longitudes (plan 23): pFix = ∫(p_dyn − p_kin),
+    // the model's own precession of date beyond the chains' kinematic mean, rides
+    // L′, ϖ AND Ω alike, so the frame-free arguments M′ = L′ − ϖ and F = L′ − Ω
+    // cancel it exactly at every epoch. The apsidal/nodal chains run the PHYSICAL
+    // exponents (the frame's T² is no longer frozen inside them); the Lieske share
+    // they gave up minus pFix's in-window T² rides the obliquity carrier as
+    // frameRemainder, as L′'s figure+frame part does, so ϖ and Ω stay Meeus-exact
+    // in T²; the tapered rate anchors self-measure. (Before plan 23 pFix rode L′ only while the chains
+    // carried the frame share in the Meeus-effective exponents: in the window the
+    // two agreed to 0.006″/cy², beyond it M′ and F inherited the whole wobble —
+    // measured 2.5° at ±10 kyr, 39° at −1 Myr.)
+    const pF = rateCompInit().pFix(dy), fr = frameRemainder(Tj);
     const Lp = A.LP0 + 360 * Ntrop + planetaryCarrier(Tj) + obliquityCarrier(Tj)
       + lpSecularCompletion(Tj) + pF;
-    const w = (A.LP0 - A.MP0) + 360 * Naps;                      // perigee ϖ (of-date, advance)
-    const om = (A.LP0 - A.F0) - 360 * Nnod;                      // node Ω (of-date, regression)
+    const w = (A.LP0 - A.MP0) + 360 * Naps + pF + fr;            // perigee ϖ (of-date, advance)
+    const om = (A.LP0 - A.F0) - 360 * Nnod + pF + fr;            // node Ω (of-date, regression)
     const Lsun = sunMeanLonDegAtJdTT(jd);          // the certified Sun's mean longitude (unwrapped)
     const ws = sunPerihelionLonDegAtJdTT(jd) + 180;   // the Sun's perihelion = Earth's mean ϖ of date + 180° (wrapped; M wraps)
     void A;
@@ -503,8 +529,13 @@ function createMoonArguments({ constants, fns }) {
     const Tc = Math.max(-100, Math.min(100, T));
     const Tc2 = Tc * Tc, Tc3 = Tc2 * Tc, Tc4 = Tc3 * Tc;
     const Lp = A.LP0 + A.LPR * T + A.T2_LP * Tc2 + Tc3 / 538841 - Tc4 / 65194000;
-    const w = (A.LP0 - A.MP0) + A.WDOT * (T + channelIntegral(T, A.S_W));   // perigee ϖ (of-date)
-    const om = (A.LP0 - A.F0) + A.NDOT * (T + channelIntegral(T, A.S_N));   // node Ω (of-date)
+    // Perigee and node (of-date), plan 23: the ICRF rate on the PHYSICAL channel
+    // exponent plus the Meeus polynomial's frame, p₀·T + T2F·T² (clamped with the
+    // other tails) — the T² is Meeus-exact as before, the frame share no longer
+    // rides the eccentricity channel's wiggle. The deep branch carries the model's
+    // own precession of date (pFix) in its place.
+    const w = (A.LP0 - A.MP0) + A.W_ICRF * (T + channelIntegral(T, A.S_W_PHYS)) + A.P0 * T + A.T2F * Tc2;   // perigee ϖ (of-date)
+    const om = (A.LP0 - A.F0) + A.N_ICRF * (T + channelIntegral(T, A.S_N_PHYS)) + A.P0 * T + A.T2F * Tc2;   // node Ω (of-date)
     const Lsun = sunMeanLonDegAtJdTT(jdTT);               // the certified Sun's mean longitude of date
     const ws = sunPerihelionLonDegAtJdTT(jdTT) + 180;     // the Sun's perihelion of date
     return {
@@ -520,12 +551,13 @@ function createMoonArguments({ constants, fns }) {
     const T2 = T * T, T3 = T2 * T, T4 = T3 * T;
     /** @param {number} x */
     const wrap = (x) => ((x % 360) + 360) % 360;
+    const R = MEEUS_ARGUMENT_RATES_DEG_PER_CY;   // the rates' ONE home (plan 23)
     return {
-      Lp: wrap(218.3164477 + 481267.88123421 * T - 0.0015786 * T2 + T3 / 538841 - T4 / 65194000),
-      D:  wrap(297.8501921 + 445267.1114034 * T - 0.0018819 * T2 + T3 / 545868 - T4 / 113065000),
-      M:  wrap(357.5291092 +  35999.0502909 * T - 0.0001536 * T2 + T3 / 24490000),
-      Mp: wrap(134.9633964 + 477198.8675055 * T + 0.0087414 * T2 + T3 / 69699 - T4 / 14712000),
-      F:  wrap( 93.2720950 + 483202.0175233 * T - 0.0036539 * T2 - T3 / 3526000 + T4 / 863310000),
+      Lp: wrap(218.3164477 + R.Lp * T - 0.0015786 * T2 + T3 / 538841 - T4 / 65194000),
+      D:  wrap(297.8501921 + R.D * T - 0.0018819 * T2 + T3 / 545868 - T4 / 113065000),
+      M:  wrap(357.5291092 + R.M * T - 0.0001536 * T2 + T3 / 24490000),
+      Mp: wrap(134.9633964 + R.Mp * T + 0.0087414 * T2 + T3 / 69699 - T4 / 14712000),
+      F:  wrap( 93.2720950 + R.F * T - 0.0036539 * T2 - T3 / 3526000 + T4 / 863310000),
     };
   }
 

package/src/moon/deep-ecc-channel.cjs

@@ -12,30 +12,24 @@
  * — the constant remainder pins the unresolved short/ultra-long content at
  * the JPL J2000 seed anchor, so e(J2000) is exact by construction.
  *
- * DOMAIN (decision (ii), proper physics — no mixed device): the ENTIRE
- * lunar chain reads THIS channel — eccAt (the Δe² argument terms),
- * channelIntegral (perigee/node of-date rates), modulation (the
- * month/precession chain and its integrated cycle counts), eFactorAt (the
- * Meeus E-factor). The Sun/clock machinery (eclipse Sun equation of
- * centre, besselian Sun distance, cardinal braid) stays on the H/3 law
- * (moon/ecc-channel.cjs) — a CERTIFICATION split, not a physics one: the
- * two e's agree within 4.2e-5 wherever the domains overlap, and the H/3
- * line keeps its E18 role as the epoch-local tangent inside the fitted
- * clock stack.
+ * DOMAIN (decision (ii)): the ENTIRE lunar chain reads THIS channel — eccAt
+ * (the Δe² argument terms), channelIntegral (perigee/node of-date rates),
+ * modulation (the month/precession chain and its integrated cycle counts),
+ * eFactorAt (the Meeus E-factor). Earth's eccentricity of date is the
+ * N-body series on every other path as well (plan 21: one e-vector of date
+ * on every surface).
  *
- * MEASURED at adoption (banked in the plan record): vs the H/3 law the
- * attractor-mean modulation shifts are +2,526 ppm (perigee channel,
- * s = 2.407) and +1,067 ppm (node, s = 1.018) — month/LOD shifts of
- * ~10–25 ppm class, all 41 paleo anchors in bands; the ancient eclipse
- * stack's cycle counts shift (χ² IMPROVES — recorded with its
- * explanation: this e is La2004-corroborated in-era, 3× closer than the
- * H/3 line; theory-corroborated, never tuned). Beyond ~5 Myr the table is
- * spectrum-class (phases decohere) — the quasi-periodic ATTRACTOR (mean e
- * and the 405-kyr-class beat structure) is the claim, never a pointwise
- * ephemeris.
+ * MEASURED at adoption (banked in the plan record): the attractor-mean
+ * modulation shifts were +2,526 ppm (perigee channel) and +1,067 ppm (node)
+ * against the single-line law it replaced — month/LOD shifts of ~10–25 ppm
+ * class, all 41 paleo anchors in bands; the ancient eclipse stack's cycle
+ * counts shift (χ² IMPROVES — recorded with its explanation: this e is
+ * La2004-corroborated in-era; theory-corroborated, never tuned). Beyond
+ * ~5 Myr the table is spectrum-class (phases decohere) — the quasi-periodic
+ * ATTRACTOR (mean e and the 405-kyr-class beat structure) is the claim,
+ * never a pointwise ephemeris.
  *
- * LOAD-BEARING conventions (carried VERBATIM from the era channel —
- * moon/ecc-channel.cjs — so the certified numerics match):
+ * LOAD-BEARING conventions (the certified numerics):
  *  - channelIntegral uses composite Simpson with step ≤ ~4,000 yr
  *    (N ≥ 2, even);
  *  - modulation(tMa, s) takes age in Myr, positive = past, ≡ 1 at J2000;
@@ -63,7 +57,8 @@
  *
  * — ż_J2000 is the run's own z-rate at J2000 (script-written into the
  * artifact by generate.mjs from the banked series: "we are the source"),
- * T_q the H/12 taper the arguments' rate anchors ride. Inside the canon it
+ * T_q the arguments' secular-completion taper (SECULAR_COMPLETION_TAPER_YEARS,
+ * the one the rate anchors ride). Inside the canon it
  * restores the run's slope exactly; beyond ±T_q it is a constant vector
  * offset of ~3e-3, the size of the table's own spectrum-class scatter
  * there, never a growing polynomial. Absent the two fields (an older

package/src/moon/ecc-sensitivities.cjs

@@ -0,0 +1,87 @@
+/**
+ * The lunar perigee/node eccentricity sensitivities — ONE home (plan 23).
+ *
+ * The Sun's mean perturbation on the lunar perigee and node scales as
+ * g(e_E) = (1 − e_E²)^(−3/2); the of-date rates ride the channel
+ * rate(t) = rate₀ · [g(e_E(t))/g₀]^s. The pair the record fixes is the
+ * MEEUS-EFFECTIVE one: s_ϖ = 2.407 / s_Ω = 1.018 reproduce Meeus Ch. 47's
+ * of-date T² coefficients exactly (doc 66 §1, the (ė, s) degeneracy). Each of
+ * those T² coefficients contains the equinox's own acceleration — the general
+ * precession's T² term, a frame bookkeeping share that has nothing to do with
+ * Earth's eccentricity. Removing it gives the PHYSICAL pair the three-body
+ * laboratory reproduces from pure gravity (2.479 / 0.867; doc 66 §1):
+ *
+ *     s_phys = (s_eff · Ẋ_of-date · κ/2 − T2_frame) / (Ẋ_ICRF · κ/2),
+ *     κ = 3 e₀ ė₀ / (1 − e₀²),   Ẋ_ICRF = Ẋ_of-date − p₀
+ *
+ * — derived here from the injected constants, never typed. The runtime (plan
+ * 23) carries s_phys in the channel and ONE frame term, the model's own
+ * precession of date, on every of-date lunar longitude alike, so the
+ * frame-free arguments M′ = L′ − ϖ and F = L′ − Ω cancel it exactly at every
+ * epoch. Measured before the change (plan 23 §0): with the frame share frozen
+ * inside s_eff on the eccentricity channel, M′ and F inherited L′'s frame term
+ * uncancelled — 2.5° at ±10 kyr, 39° at −1 Myr — and the perigee and node
+ * carried a 3 % share of the channel's own wiggle that is not theirs; in the
+ * historical window the change is ≤ 21″ of ϖ/Ω at ±3000 (seconds of eclipse
+ * time).
+ *
+ * The Meeus Ch. 47 argument RATES live here too (the ONE set the arguments
+ * module, its pure-Meeus reference and this derivation share).
+ */
+
+'use strict';
+
+/** Meeus Ch. 47 mean-argument rates, degrees per Julian century (the J2000 polynomials' linear terms). */
+const MEEUS_ARGUMENT_RATES_DEG_PER_CY = Object.freeze({
+  Lp: 481267.88123421,   // the Moon's mean longitude L′
+  D: 445267.1114034,     // the mean elongation
+  M: 35999.0502909,      // the Sun's mean anomaly
+  Mp: 477198.8675055,    // the Moon's mean anomaly M′
+  F: 483202.0175233,     // the argument of latitude
+});
+
+/** The Meeus-effective pair: Meeus-exact of-date T² by construction (the shipped record values). */
+const MOON_ECC_SENSITIVITY_PERIGEE = 2.407;
+const MOON_ECC_SENSITIVITY_NODE = 1.018;
+
+/**
+ * The physical pair and the rate split, derived from the shipped constants.
+ * @param {{
+ *   eccentricityJ2000: number,
+ *   eccentricityDotJ2000: number,
+ *   frameT2ArcsecPerCy2: number,
+ *   generalPrecessionArcsecPerYr: number,
+ * }} inputs — e₀ (the catalog secular value the Taylor checks use); ė₀ per
+ *   Julian century; the general precession's T² coefficient the of-date Meeus
+ *   polynomials embed (Lieske 1976, the ELP frame), ″/cy²; p₀, the IAU 2006 p_A
+ *   linear rate, ″/yr
+ * @returns {Readonly<{
+ *   perigeeEffective: number, nodeEffective: number,
+ *   perigeePhysical: number, nodePhysical: number,
+ *   kappaPerCy: number, frameT2DegPerCy2: number, generalPrecessionDegPerCy: number,
+ *   perigeeRateOfDateDegPerCy: number, nodeRateOfDateDegPerCy: number,
+ *   perigeeRateIcrfDegPerCy: number, nodeRateIcrfDegPerCy: number,
+ * }>}
+ */
+function deriveMoonEccSensitivities({ eccentricityJ2000, eccentricityDotJ2000, frameT2ArcsecPerCy2, generalPrecessionArcsecPerYr }) {
+  const R = MEEUS_ARGUMENT_RATES_DEG_PER_CY;
+  const e0 = eccentricityJ2000, ed = eccentricityDotJ2000;
+  const kappaPerCy = 3 * e0 * ed / (1 - e0 * e0);
+  const generalPrecessionDegPerCy = generalPrecessionArcsecPerYr * 100 / 3600;
+  const frameT2DegPerCy2 = frameT2ArcsecPerCy2 / 3600;
+  const perigeeRateOfDateDegPerCy = R.Lp - R.Mp;   // ϖ̇ of date (+4069.0137) = ϖ̇_ICRF + p₀
+  const nodeRateOfDateDegPerCy = R.Lp - R.F;       // Ω̇ of date (−1934.1363) = Ω̇_ICRF + p₀
+  const perigeeRateIcrfDegPerCy = perigeeRateOfDateDegPerCy - generalPrecessionDegPerCy;
+  const nodeRateIcrfDegPerCy = nodeRateOfDateDegPerCy - generalPrecessionDegPerCy;
+  const half = kappaPerCy / 2;
+  const perigeePhysical = (MOON_ECC_SENSITIVITY_PERIGEE * perigeeRateOfDateDegPerCy * half - frameT2DegPerCy2) / (perigeeRateIcrfDegPerCy * half);
+  const nodePhysical = (MOON_ECC_SENSITIVITY_NODE * nodeRateOfDateDegPerCy * half - frameT2DegPerCy2) / (nodeRateIcrfDegPerCy * half);
+  return Object.freeze({
+    perigeeEffective: MOON_ECC_SENSITIVITY_PERIGEE, nodeEffective: MOON_ECC_SENSITIVITY_NODE,
+    perigeePhysical, nodePhysical,
+    kappaPerCy, frameT2DegPerCy2, generalPrecessionDegPerCy,
+    perigeeRateOfDateDegPerCy, nodeRateOfDateDegPerCy, perigeeRateIcrfDegPerCy, nodeRateIcrfDegPerCy,
+  });
+}
+
+module.exports = { MEEUS_ARGUMENT_RATES_DEG_PER_CY, MOON_ECC_SENSITIVITY_PERIGEE, MOON_ECC_SENSITIVITY_NODE, deriveMoonEccSensitivities };

package/src/moon/month-chain.cjs

@@ -33,10 +33,7 @@
  *    pair is 2.479/0.867 after removing the IAU frame term — doc 66 §1).
  *  - The of-date perigee/node periods are COMPOSITIONS of the inertial chain
  *    with the precession of date (the engines' `…OfDateCyclesBetween` count
- *    identities N_trop − N_anom and N_drac − N_trop). The former 'OfDate'
- *    family here — N·(H(t)/H₀)² counts per anchor unit and period ∝ T_yr/H —
- *    was the era device's counter law (doc 99's "Lunar Precession
- *    Invariant"); it left at plan 09 step 5c with the per-H counts.
+ *    identities N_trop − N_anom and N_drac − N_trop).
  *  - apsidalMeetsNodal / lunarLeveling existed ONLY in the browser before
  *    this move (the Node scene aliased apsidal-of-date on a cancellation
  *    argument valid for the paired scene nodes only) — the Node engine gains
@@ -70,13 +67,10 @@
  *   eccentricity channel's modulation; constants are the engine's derived
  *   J2000 anchors (both engines derive them from the same JSON).
  *   fns.precessionPeriodYearsAtAge is the engine's lunisolar precession period
- *   of date T_p(t), Julian years (the composed rate's period; plan 09 step
- *   5c — the tropical month's equinox turn, formerly the counter's 13/H(t),
- *   0.086 % slow: the chain's J2000 tropical month sat 5.85 ms above the IAU
- *   input, the 1/T_p form is within 0.1 ms of it).
+ *   of date T_p(t), Julian years (the composed rate's period — the tropical
+ *   month's equinox turn; within 0.1 ms of the IAU input at J2000).
  *   fns.distanceMetresAtAge is the engine's CITED distance history
- *   (deltat/moon-distance-history; plan 12 option A — the internal quartic
- *   twin this chain carried until then is deleted; null beyond the span).
+ *   (deltat/moon-distance-history; null beyond the span).
  */
 function createMoonMonthChain({ constants, fns }) {
   const {
@@ -136,8 +130,7 @@ function createMoonMonthChain({ constants, fns }) {
 
   /** Tropical month in seconds (equinox-referenced): the sidereal month less
    *  the equinox's own motion over one month — one turn per the precession
-   *  period of date T_p(t). (Plan 09 step 5c: formerly 13 turns per the
-   *  counter H(t), 0.086 % slow.) @param {number} tMa @returns {number | null} */
+   *  period of date T_p(t). @param {number} tMa @returns {number | null} */
   function tropicalMonthSecondsAtAge(tMa) {
     const tSm = siderealMonthSecondsAtAge(tMa);
     if (tSm === null) return null;
@@ -146,10 +139,8 @@ function createMoonMonthChain({ constants, fns }) {
     return tSm * (1 - tSm / (/** @type {number} */ (tP) * tYr));
   }
 
-  // (Plan 09 step 5c: the H² of-date family — apsidal/nodal "cycles per H"
-  // N·(H(t)/H₀)² and the of-date periods ∝ T_yr/H — is deleted with the per-H
-  // counts. The of-date perigee and node of date are the engines' count
-  // compositions of this chain's inertial periods with the tropical month.)
+  // The of-date perigee and node are the engines' count compositions of this
+  // chain's inertial periods with the tropical month.
 
   /** Perigee precession period in seconds — Brouwer–Clemence m² scaling ×
    *  e_E-channel modulation (the factored law: period = invariant mean /

package/src/moon/series-extension.cjs

@@ -52,14 +52,14 @@
  * A1-class correlated-subsample effect (the tracked events sit −1.6″
  * below the +1.4″ fleet mean and sample the near-annual arguments at
  * correlated phases; the era-split refutes anchor double-counting and
- * the modern era improves most, 3.57 → 3.34). The api gate (8″ then; 12″
- * since plan 06 R3 item 1 — the physical ΔT-convention floor) holds
+ * the modern era improves most, 3.57 → 3.34). The api gate (12″ — the
+ * physical ΔT-convention floor) holds
  * (max 6.2″). Coefficients are stored with the run→real argument
  * mapping already applied (the extraction's heliocentric-planet vs
  * geocentric-sun π-offset is folded into the signs).
  *
  * THE J2 NODE FAMILY (FQ-7 Round 3, plan §12i) — five derived terms on
- * Ω-family arguments (NOT expressible on the integer Delaunay lattice,
+ * Ω-family arguments (NOT expressible as integer combinations of the Delaunay arguments,
  * which is why every earlier extraction missed them; the 200-yr band
  * probe named them, the dense 2-day JPL sample confirmed them real, and
  * the channel isolation identified them as EARTH'S J2 acting on the

package/src/moon/series.cjs

@@ -11,8 +11,8 @@
  *
  * Full scene form: 60 longitude + 60 latitude terms with E/E² scaling on
  * M-bearing terms, A1 (Venus, Meeus-observed rate — the 18V−16E−M′
- * near-resonance makes it hypersensitive; no lattice identity), A2/A3
- * (D2-derived lattice rates, CHAIN-INTEGRATED under deep time through
+ * near-resonance makes it hypersensitive; no chain identity), A2/A3
+ * (D2-derived rates, CHAIN-INTEGRATED under deep time through
  * their identified content), all six latitude corrections, the EoC-half
  * subtraction (the off-centre orbit geometry already provides half the
  * equation of centre), and the two-term ellipse distance.
@@ -26,7 +26,7 @@
 
 'use strict';
 
-// Plan 06 R3 item 1: the DERIVED series-extension tail (the D2 planetary and
+// The DERIVED series-extension tail (the D2 planetary and
 // node terms, moon/series-extension.cjs) is part of the ONE scene Moon —
 // formerly added by the besselian tier alone, so the rendered Moon and the
 // eclipse-location Moon were two different Moons. The truncated finder forms
@@ -98,8 +98,6 @@ function createMoonSeries({ constants, fns }) {
       const nAps = apsidalOfDateCyclesBetween(yA0, yA);
       // A3 is the STAR-referenced lunar longitude (Meeus' rate 481,266.484 °/cy
       // ≡ 360°/sidereal month): the chain's sidereal-orbit count directly.
-      // Plan 09 step 5c — it was the tropical count minus the counter's 13/H
-      // precession turns (0.086 % slow on the precession).
       const nSid = siderealOrbitsBetween(yA0, yA);
       const nJ = jupiterOrbitsBetween(yA0, yA);
       if (nT !== null && nAps !== null && nSid !== null && nJ !== null) {
@@ -175,9 +173,8 @@ function createMoonSeries({ constants, fns }) {
    *  Returns everything the scene blocks write:
    *  thetaAddRad — the hierarchy θ increment (EoC-half-subtracted Σl);
    *  lonDeg — full ecliptic longitude (GEOMETRIC, mean equinox of date)
-   *  incl. the derived series-extension tail. (The fitted mean-longitude
-   *  anchor moonMeeusLpCorrection was retired to 0 at plan 06 R3 item 1 and
-   *  its parameter deleted at plan 11 step 2: measured against Horizons' apparent
+   *  incl. the derived series-extension tail. (No fitted mean-longitude
+   *  anchor — doc 109 §23: measured against Horizons' apparent
    *  Moon over 1970–2049 the series needs no anchor, −1.0″ ± 1.5″ flat in
    *  elongation; the former +32.75″ was the eclipse tier's mean Sun
    *  compensated — its aberration κ, the I2 long inequality and the trend-ΔT