@essrt/physics 1.8.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@essrt/physics",
-  "version": "1.8.0",
+  "version": "1.10.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": "v11.0",
@@ -36,6 +36,7 @@
     "./chain-cycles": "./src/chain-cycles/index.cjs",
     "./moon/arguments": "./src/moon/arguments.cjs",
     "./moon/series": "./src/moon/series.cjs",
+    "./moon/series-extension": "./src/moon/series-extension.cjs",
     "./moon/apparent": "./src/moon/apparent.cjs",
     "./planets/geometry": "./src/planets/geometry.cjs",
     "./planets/fibonacci-laws": "./src/planets/fibonacci-laws.cjs",

package/src/eclipse/besselian.cjs

@@ -58,6 +58,7 @@
  *   full-series Moon: ecliptic-of-date longitude/latitude (deg) + distance (km), TT axis (days since J2000)
  * @property {(jdUT: number) => number} sunLonDegAt - geometric mean sun longitude (deg), JD(UT) axis with the finder's internal ΔT
  * @property {(T: number) => number} sunCompletionDeg - planetary completion (deg) at T centuries TT, SUBTRACTED from the finder sun (see eclipse/sun-planetary-completion.cjs; the finders deliberately stay without it — their fitted anchors and certified canon statistics were produced on the bare form, and elongation-class timing absorbs the omission into the fitted phases)
+ * @property {(T: number) => {dLonDeg: number, dLatDeg: number}} moonExtensionAt - derived series-extension tail (deg) at T centuries TT, ADDED to the full-series Moon longitude/latitude (see moon/series-extension.cjs; same finder-scoping rationale as sunCompletionDeg — the finders stay on the bare series)
  * @property {(jd: number) => number} deltaTSecondsAt - framework ΔT (J2000-zeroed convention)
  * @property {(year: number) => number} obliquityDegAt - framework obliquity (deg) at calendar year
  * @property {(year: number) => number} eccentricityAt - framework Earth-orbit eccentricity at calendar year
@@ -126,29 +127,41 @@ function createBesselian(deps) {
     const dTT = (jb - K.j2000JD) + deps.deltaTSecondsAt(jb) / 86400;
     const sunLon = deps.sunLonDegAt(jb) - deps.sunCompletionDeg(dTT / K.julianCenturyDays);
     const moon = deps.moonFullAtDaysTT(dTT);
+    const ext = deps.moonExtensionAt(dTT / K.julianCenturyDays);
     return {
       S: eclToEq(sunLon, 0, sunDistanceKm(year, sunLon), eps),
-      M: eclToEq(moon.lonDeg, moon.latDeg, moon.distKm, eps),
+      M: eclToEq(moon.lonDeg + ext.dLonDeg, moon.latDeg + ext.dLatDeg, moon.distKm, eps),
     };
   }
 
   /** Umbra-axis ground intersection at JD(UT): geodetic latitude, east
    *  longitude — or null when the axis misses the ellipsoid.
+   *  EXACT axis ∩ ellipsoid: scaling z by 1/(1−f) turns the WGS84 quadric
+   *  into a sphere of radius R_E. The earlier R_E-SPHERE intersection put
+   *  the hit up to R_E·f·sin²φ ≈ 21 km above the true surface, and the
+   *  offset projects into the shadow-plane metric as ~height·cos(alt) —
+   *  a latitude/sun-altitude-correlated phantom error (measured: 2021
+   *  Antarctica 12.8″ → 6.9″, 2008 Arctic 7.3″ → 1.6″, 2026 Iberia
+   *  low-sun 4.4″ → 1.2″; NASA path tables are ellipsoid-based). The
+   *  geodetic latitude is then exact for the on-surface point:
+   *  tan φ = z / ((1−f)²·ρ).
    *  @param {number} jdUT @returns {{latDeg: number, lonDeg: number} | null} */
   function umbraGroundAt(jdUT) {
     const { S, M } = bodiesAt(jdUT);
     const dv = [M[0] - S[0], M[1] - S[1], M[2] - S[2]];
     const dl = Math.hypot(dv[0], dv[1], dv[2]);
     const d = [dv[0] / dl, dv[1] / dl, dv[2] / dl];
-    const MdotD = M[0] * d[0] + M[1] * d[1] + M[2] * d[2];
-    const MdotM = M[0] * M[0] + M[1] * M[1] + M[2] * M[2];
-    const disc = MdotD * MdotD - (MdotM - R_E_KM * R_E_KM);
+    const w = 1 / (1 - F);
+    const Ms = [M[0], M[1], M[2] * w], ds = [d[0], d[1], d[2] * w];
+    const A = ds[0] * ds[0] + ds[1] * ds[1] + ds[2] * ds[2];
+    const B = Ms[0] * ds[0] + Ms[1] * ds[1] + Ms[2] * ds[2];
+    const Cq = Ms[0] * Ms[0] + Ms[1] * Ms[1] + Ms[2] * Ms[2] - R_E_KM * R_E_KM;
+    const disc = B * B - A * Cq;
     if (disc < 0) return null;
-    const s = -MdotD - Math.sqrt(disc);
+    const s = (-B - Math.sqrt(disc)) / A;
     const hit = [M[0] + s * d[0], M[1] + s * d[1], M[2] + s * d[2]];
-    const r = Math.hypot(hit[0], hit[1], hit[2]);
-    const latGc = Math.asin(Math.max(-1, Math.min(1, hit[2] / r)));
-    const latDeg = Math.atan(Math.tan(latGc) / ((1 - F) * (1 - F))) / D2R;
+    const rho = Math.hypot(hit[0], hit[1]);
+    const latDeg = Math.atan2(hit[2], (1 - F) * (1 - F) * rho) / D2R;
     let lonDeg = Math.atan2(hit[1], hit[0]) / D2R - gmstDeg(jdUT);
     lonDeg = ((lonDeg + 540) % 360) - 180;
     return { latDeg, lonDeg };

package/src/eclipse/finders.cjs

@@ -35,6 +35,17 @@
 
 'use strict';
 
+/**
+ * @typedef {Object} FrameworkSunDeps
+ * @property {number} sunMeanLongitudeJ2000Deg - L0 anchor (input anchor, 280.46646)
+ * @property {number} tropicalRateDegPerCy - the framework tropical rate (from the year chain)
+ * @property {(year: number) => number} eccentricityAt - the framework e(t) law
+ * @property {(year: number) => number} perihelionLongitudeDegAt - the framework ϖ(t) law (heliocentric)
+ * @property {(year: number) => number} [meanLongitudeDegAt] - optional epoch-dependent
+ *   mean longitude L(t) (e.g. L0 + ∫rate·dt from the f(Y) tropical-year chain);
+ *   absent = the linear form L0 + rate·T
+ */
+
 /**
  * @typedef {Object} EclipseFinderDeps
  * @property {(jd: number) => number} moonLonDegAt - truncated-series ecliptic longitude
@@ -43,6 +54,13 @@
  * @property {(jd: number) => number} deltaTSecondsAt - the engine's ΔT convention
  * @property {() => number} getSynodicMonthDays - live (epoch-mutable)
  * @property {() => number} getSunDistanceKm - live (epoch-mutable)
+ * @property {FrameworkSunDeps} [frameworkSun] - E4 (the native-Sun landing,
+ *   plan §12i item 11): when present, sunLonDegAt uses the FRAMEWORK form —
+ *   linear tropical rate + Kepler EoC (to e³) on the framework e(t)/ϖ(t)
+ *   laws, TT clock unchanged — instead of the Meeus Ch. 25 polynomials.
+ *   Absent = the historical Meeus form (every certified number's current
+ *   basis). The swap is a conscious matched-pair event: the D2 completion's
+ *   fitted 2lE residue and the certified statistics re-measure with it.
  * @property {{ rEarthMetres: number, moonDiameterKm: number,
  *   sunDiameterKm: number, j2000JD: number, julianCenturyDays: number }} constants
  */
@@ -52,10 +70,27 @@ function createEclipseFinders(deps) {
   const K = deps.constants;
 
   /** Sun's geocentric ecliptic longitude in degrees (0–360) at given JD_UT.
-   * MEAN GEOMETRIC — see the module header. @param {number} jd @returns {number} */
+   * MEAN GEOMETRIC — see the module header. Two forms (E4): the framework
+   * form when deps.frameworkSun is injected, else Meeus Ch. 25.
+   * @param {number} jd @returns {number} */
   function sunLonDegAt(jd) {
     const _d2r = Math.PI / 180;
     const T = (jd + deps.deltaTSecondsAt(jd) / 86400 - K.j2000JD) / K.julianCenturyDays;
+    if (deps.frameworkSun) {
+      // E4 framework form: linear tropical rate + Kepler EoC (to e³) on the
+      // framework e(t)/ϖ(t) laws. Same TT clock; same L0 input anchor.
+      const F = deps.frameworkSun;
+      const year = 2000 + T * 100;
+      const L = F.meanLongitudeDegAt
+        ? F.meanLongitudeDegAt(year)
+        : F.sunMeanLongitudeJ2000Deg + F.tropicalRateDegPerCy * T;
+      const e = F.eccentricityAt(year);
+      const M = (L - (F.perihelionLongitudeDegAt(year) + 180)) * _d2r;
+      const C = (2 * e - e * e * e / 4) * Math.sin(M)
+              + 1.25 * e * e * Math.sin(2 * M)
+              + (13 / 12) * e * e * e * Math.sin(3 * M);
+      return ((L + C / _d2r) % 360 + 360) % 360;
+    }
     const L0 = 280.46646 + 36000.76983 * T + 0.0003032 * T * T;
     const M = (357.52911 + 35999.05029 * T - 0.0001537 * T * T) * _d2r;
     const C = (1.914602 - 0.004817 * T - 0.000014 * T * T) * Math.sin(M)

package/src/eclipse/sun-planetary-completion.cjs

@@ -1,88 +1,201 @@
 /**
- * Sun planetary completion — the 20.3h location-tier term table.
+ * Sun planetary completion v2 — the DERIVED table (Stage D2, plan §12i
+ * item 10; supersedes the v1 fitted 10-term table).
  *
- * The finder Sun (framework linear rate + Kepler EoC + the fitted
- * SUN_HARMONICS) omits the classical planetary perturbations of the
- * geocentric Sun (the Newcomb Venus/Jupiter/Mars terms and the
- * Earth-around-EMB wobble). Measured against JPL Horizons (ObsEcLon,
- * geocentric, leading-nutation-bridged to mean-of-date) on 960
- * deterministic all-phase epochs 1970–2049: the omission is 10.0″ RMS
- * of Sun-longitude scatter; this table removes the coherent part,
- * 10.0″ → 2.9″ RMS, with every term era-stable (amplitude and phase
- * agree between the 1970–2009 and 2010–2049 half-samples).
+ * DERIVATION, not fit: the table is extracted from the framework's OWN
+ * physics — twin epoch-phased 8-body RK4 integrations (Sun, planets, EMB)
+ * built entirely from framework constants, planet phases taken from the
+ * engine scene graph, differenced full-vs-base3 to isolate the planetary
+ * signal, with the EMB secular-perihelion channel projected out (that
+ * channel belongs to the framework's own ϖ(t)/e(t) laws). The 68 terms
+ * below are the analytic reading of that derived signal: main synodic
+ * tones plus eccentricity-modulation sidebands (main ± mean anomaly of
+ * the modulating planet, main ± M_E). Table-vs-signal fidelity 0.64″.
+ * JPL Horizons enters only as VALIDATION, never as fit target: the
+ * derived signal matches JPL residuals at corr −0.997 / slope −0.999
+ * (0.60″ combined), and shipping it takes the all-phase Sun residual
+ * 3.48″ → 2.12″, the 179-eclipse syzygy fleet 5.51″ → 3.99″, and the
+ * NASA centerline reference set 5.30″ → 3.94″ shadow-plane (jointly
+ * with the derived Moon series extension, moon/series-extension.cjs —
+ * the pre-registered acceptance was all four gates, never a subset).
+ * Instruments: tools/explore/d2-derived-sun.mjs (signal),
+ * d2-sun-table-extraction.mjs (table), d2-joint-preview.mjs /
+ * d2-widened-centerlines.mjs (validation).
  *
- * THE CONSTANT-ATTRIBUTION RULE (the 20.3h-lite trap, resolved here):
- * the table carries NO constant term — the all-phase fit attributes the
- * constant to the tier's existing anchors, so the terms ship without
- * the +6″ syzygy-mean penalty that an eclipse-sample fit produced (at
- * new moon the EMB argument D locks near 0 and its cos-component
- * becomes a constant; fitting on eclipses alone poisons the mean).
- * Verified on the 179-eclipse-syzygy sample: elongation mean stays
- * +1.1″ → +1.5″ while RMS drops 10.6″ → 5.5″; and on the 15 NASA
- * path-table centerline points: shadow-plane mean 6.0″ → 3.6″, max
- * 10.1″ → 5.0″, every event improved.
+ * DECLARED INPUTS (the three non-framework residues):
+ *  (i)  planet/Sun mass ratios — observed IAU constants (shared with the
+ *       whole framework; nothing here fits them);
+ *  (ii) argument polynomials — IAU-class instrument literals, phase
+ *       carriers only; their framework-native derivation is research
+ *       item 20.3e;
+ *  (iii) the 2lE term (+1.42″ sin 2lE) — DECLARED FITTED, not derived: a
+ *       finder-annual artifact of the current SUN_HARMONICS chain, to be
+ *       absorbed at the next Step-0 refit. Everything else in this file
+ *       is derived. The Earth-around-EMB wobble, fitted −6.64″ in v1, is
+ *       now DERIVED: amplitude a_M·μ/AU with μ = 1/(1+M_E/M_M), injected
+ *       by the factory below from live package constants (6.4399″ at the
+ *       current constants), sign negative in the subtract convention.
  *
- * Arguments are of-date mean longitudes (IAU-class instrument
- * polynomials, degrees/Julian-century TT). They are phase carriers for
- * the fitted amplitudes — the framework-native derivation of these
- * term tables is the 20.3e research item. Terms with ambiguous
- * identifications (the ~8-yr band, the 414-day Venus/three-planet
- * blend, E−M, E−S) are deliberately NOT shipped: each failed the
- * half-sample stability test or has no unique two-planet argument at
- * the window's frequency resolution (~1.5″ RSS accepted as floor).
+ * THE CONSTANT-ATTRIBUTION RULE (v1's 20.3h-lite trap, still honored):
+ * the table carries NO constant term — the constant is attributed to the
+ * tier's existing anchors, so the terms ship without the +6″ syzygy-mean
+ * penalty an eclipse-sample fit produced.
  *
- * Sign convention: the table models (framework − truth), so consumers
- * SUBTRACT the evaluation from the finder Sun longitude.
+ * Sign convention: unchanged from v1 — the evaluation models
+ * (framework − truth), so consumers SUBTRACT it from the finder Sun
+ * longitude. TERMS literals are stored in the extraction's native sign
+ * (d2-sun-table.local.json) and negated in the evaluator, exactly as the
+ * validated joint-preview instrument composes them.
+ *
+ * MATCHED PAIR: the amplitudes are the residual of the CURRENT finder
+ * Sun chain (framework rate + EoC + SUN_HARMONICS) and must be
+ * RE-DERIVED whenever that chain moves — a Step-0 SUN_HARMONICS refit,
+ * an eccentricity/perihelion definition change, or 20.3e. Re-derivation
+ * is the D2 instrument chain above (regenerate d2-sun-table.local.json,
+ * re-embed). ENFORCED: PAIRED_SUN_HARMONICS_SHA256 below is the
+ * fingerprint of the SUN_LONGITUDE_HARMONICS this table was derived
+ * under; the create-model parity gate (test:model, in `npm run check`)
+ * recomputes it from live constants and fails on mismatch. The api
+ * centerline gate (≤8″ shadow-plane) backstops gross staleness
+ * independently.
  */
 
 'use strict';
 
-/** Of-date mean-longitude polynomials, degrees per Julian century TT. */
-const ARG_RATES = {
-  lV: [181.979801, 58517.815676],   // Venus
-  lE: [100.466457, 36000.769780],   // Earth (EMB)
-  lM: [355.433000, 19141.696300],   // Mars
-  lJ: [34.351519, 3036.302389],     // Jupiter
-  D: [297.8501921, 445267.1114034], // Moon mean elongation (EMB wobble carrier)
-};
+/** Of-date mean-longitude polynomials, degrees per Julian century TT
+ *  (IAU-class instrument literals — phase carriers, see header (ii)).
+ *  Body order everywhere below: Mercury, Venus, Earth (EMB), Mars,
+ *  Jupiter, Saturn. */
+const ARG_L0 = [252.250906, 181.979801, 100.466457, 355.433000, 34.351519, 50.077444];
+const ARG_L1 = [149472.674, 58517.815676, 36000.769780, 19141.696300, 3036.302389, 1223.511013];
+/** J2000 perihelion longitudes (deg), same body order — mean anomaly
+ *  M_X = l_X − ϖ_X; slow ϖ drift is absorbed by the sidebands over the
+ *  valid window. */
+const PERI = [77.456, 131.564, 102.937, 336.060, 14.331, 93.057];
+/** Moon mean elongation (deg/cy TT) — the EMB-wobble carrier. */
+const ARG_D = [297.8501921, 445267.1114034];
 
 /**
- * The fitted table: [k·lV, k·lE, k·lM, k·lJ, k·D, cosAmp″, sinAmp″].
- * Fit: 960-epoch all-phase LSQ vs JPL Horizons DE441-class ObsEcLon,
- * free constant excluded from shipment; SE 0.13″ per coefficient.
+ * The derived table, extraction-native sign (negated in the evaluator):
+ * [[6 mean-longitude multipliers lMe,lV,lE,lM,lJ,lS],
+ *  [6 mean-anomaly multipliers MMe,MV,ME,MMa,MJ,MS], cos″, sin″].
+ * 68 terms ≥ 0.05″ from the D2 extraction (79-term LSQ, fidelity 0.64″).
+ * @type {Array<[number[], number[], number, number]>}
  */
 const TERMS = [
-  [1, -1, 0, 0, 0, 0, -5.08],   // V−E      (Venus synodic)
-  [2, -2, 0, 0, 0, 0, 5.55],    // 2(V−E)
-  [3, -3, 0, 0, 0, 0, 0.68],    // 3(V−E)
-  [2, -3, 0, 0, 0, -2.64, 0],   // 2V−3E    (the classic Newcomb Venus term)
-  [0, 1, 0, -1, 0, 0, 7.19],    // E−J      (Jupiter synodic)
-  [0, 2, 0, -2, 0, 0, -2.81],   // 2(E−J)
-  [0, 1, 0, -2, 0, -1.34, 0.97],// E−2J
-  [0, 2, -2, 0, 0, 0, 2.05],    // 2(E−M)   (Mars)
-  [0, 2, 0, 0, 0, 0, 1.42],     // 2lE      (semiannual Kepler leftover)
-  [0, 0, 0, 0, 1, 0, -6.64],    // D        (Earth-around-EMB wobble, 6.44″ theory)
+  [[0, 0, 1, 0, -1, 0], [0, 0, 0, 0, 0, 0], -0.0841, -11.6309],
+  [[0, 0, 2, 0, -2, 0], [0, 0, -1, 0, 0, 0], -0.3235, 8.2645],
+  [[0, 0, 1, -1, 0, 0], [0, 0, 0, -1, 0, 0], -2.9917, -6.8503],
+  [[0, 0, 2, -2, 0, 0], [0, 0, -1, 0, 0, 0], -6.2197, -2.1203],
+  [[0, 2, -2, 0, 0, 0], [0, 0, 0, 0, 0, 0], 0.0199, -6.4326],
+  [[0, 0, 1, 0, -2, 0], [0, 0, 1, 0, 0, 0], 1.7254, 4.5991],
+  [[0, 1, -1, 0, 0, 0], [0, 0, 0, 0, 0, 0], 0.1362, 4.8325],
+  [[0, 0, 1, 0, -2, 0], [0, 0, 0, 0, 1, 0], 1.1469, 4.2788],
+  [[0, 0, 1, 0, -2, 0], [0, 0, 0, 0, 0, 0], -3.8890, 1.2230],
+  [[0, 0, 2, 0, -2, 0], [0, 0, 0, 0, 0, 0], 3.3414, 1.5744],
+  [[0, 0, 1, 0, -1, 0], [0, 0, 0, 0, -1, 0], -2.6985, -1.2967],
+  [[0, 3, -4, 0, 0, 0], [0, 0, 0, 0, 0, 0], 2.9374, -0.5408],
+  [[0, 0, 1, 0, -1, 0], [0, 0, -1, 0, 0, 0], -2.5406, -0.1812],
+  [[0, 0, 2, -2, 0, 0], [0, 0, 0, 0, 0, 0], 1.3755, -2.0301],
+  [[0, 0, 2, -3, 0, 0], [0, 0, 0, 1, 0, 0], -2.2367, -0.4398],
+  [[0, 0, -1, 2, 0, 0], [0, 0, 0, 0, 0, 0], 1.8705, 0.3499],
+  [[0, 3, -3, 0, 0, 0], [0, -1, 0, 0, 0, 0], -1.3492, 1.2893],
+  [[0, 0, 2, 0, -3, 0], [0, 0, 0, 0, 1, 0], 1.5453, 0.1289],
+  [[0, 2, -3, 0, 0, 0], [0, 0, 0, 0, 0, 0], 1.3344, -0.4621],
+  [[0, 3, -3, 0, 0, 0], [0, 0, -1, 0, 0, 0], -0.0755, -1.4049],
+  [[0, 0, -2, 4, 0, 0], [0, 0, 0, 0, 0, 0], 0.2780, 1.2111],
+  [[0, 0, -1, 2, 0, 0], [0, 0, -1, 0, 0, 0], -0.7161, 0.8440],
+  [[0, 3, -4, 0, 0, 0], [0, 0, -1, 0, 0, 0], 0.9894, 0.3587],
+  [[0, 0, 2, 0, -3, 0], [0, 0, 0, 0, 0, 0], 0.0063, 1.0463],
+  [[0, 2, -3, 0, 0, 0], [0, 0, 1, 0, 0, 0], 0.9834, 0.1318],
+  [[0, 0, 2, -3, 0, 0], [0, 0, 0, -1, 0, 0], 0.4834, 0.8318],
+  [[0, 1, -1, 0, 0, 0], [0, -1, 0, 0, 0, 0], -0.5335, 0.5905],
+  [[0, 0, 2, -2, 0, 0], [0, 0, 0, -1, 0, 0], 0.5371, -0.5685],
+  [[0, 0, 2, -3, 0, 0], [0, 0, 0, 0, 0, 0], -0.7373, -0.0880],
+  [[0, 2, -2, 0, 0, 0], [0, 0, -1, 0, 0, 0], 0.0163, -0.7372],
+  [[0, 0, -1, 2, 0, 0], [0, 0, 0, -1, 0, 0], -0.0119, 0.6500],
+  [[0, 0, 2, 0, -2, 0], [0, 0, 0, 0, 1, 0], 0.0023, -0.6287],
+  [[0, 0, 1, 0, -1, 0], [0, 0, 1, 0, 0, 0], 0.5714, -0.1358],
+  [[0, 0, -2, 4, 0, 0], [0, 0, -1, 0, 0, 0], -0.5046, 0.2858],
+  [[0, 0, 1, 0, -1, 0], [0, 0, 0, 0, 1, 0], -0.5567, 0.1036],
+  [[0, 2, -3, 0, 0, 0], [0, 0, -1, 0, 0, 0], 0.5469, -0.0167],
+  [[0, 2, -3, 0, 0, 0], [0, 1, 0, 0, 0, 0], -0.4309, 0.2809],
+  [[0, 0, 2, 0, -2, 0], [0, 0, 0, 0, -1, 0], 0.2206, -0.4616],
+  [[0, 3, -4, 0, 0, 0], [0, -1, 0, 0, 0, 0], -0.4549, -0.2097],
+  [[0, 0, 2, 0, -3, 0], [0, 0, -1, 0, 0, 0], 0.2809, 0.3489],
+  [[0, 0, 1, -1, 0, 0], [0, 0, 0, 0, 0, 0], 0.2863, 0.3116],
+  [[0, 0, 2, -3, 0, 0], [0, 0, -1, 0, 0, 0], -0.4141, -0.0359],
+  [[0, 0, 1, 0, 0, -1], [0, 0, 0, 0, 0, 0], 0.0863, -0.4015],
+  [[0, 0, -1, 2, 0, 0], [0, 0, 0, 1, 0, 0], -0.2200, 0.3372],
+  [[0, 1, -1, 0, 0, 0], [0, 0, -1, 0, 0, 0], -0.2017, 0.2910],
+  [[0, 2, -2, 0, 0, 0], [0, -1, 0, 0, 0, 0], 0.2499, -0.1777],
+  [[0, 0, 1, 0, -2, 0], [0, 0, 0, 0, -1, 0], -0.2254, 0.1676],
+  [[0, 3, -3, 0, 0, 0], [0, 0, 0, 0, 0, 0], -0.1859, -0.1961],
+  [[0, 0, 1, 0, 0, -1], [0, 0, 0, 0, 0, 1], -0.0710, 0.2499],
+  [[0, 0, -2, 4, 0, 0], [0, 0, 0, -1, 0, 0], 0.2125, -0.1175],
+  [[0, 0, 1, 0, 0, -1], [0, 0, -1, 0, 0, 0], -0.0460, 0.2379],
+  [[0, 3, -4, 0, 0, 0], [0, 1, 0, 0, 0, 0], -0.1410, 0.1566],
+  [[0, 0, 1, -1, 0, 0], [0, 0, 0, 1, 0, 0], -0.0476, 0.1897],
+  [[0, 2, -2, 0, 0, 0], [0, 0, 1, 0, 0, 0], -0.1559, -0.1155],
+  [[0, 0, 2, 0, -3, 0], [0, 0, 1, 0, 0, 0], 0.1631, -0.0164],
+  [[0, 1, -1, 0, 0, 0], [0, 1, 0, 0, 0, 0], 0.1307, -0.0678],
+  [[0, 0, 2, -3, 0, 0], [0, 0, 1, 0, 0, 0], 0.1331, -0.0291],
+  [[0, 0, -2, 4, 0, 0], [0, 0, 1, 0, 0, 0], 0.1227, 0.0482],
+  [[0, 0, 2, 0, 0, -2], [0, 0, 0, 0, 0, 0], -0.0388, 0.1044],
+  [[0, 0, 1, 0, 0, -1], [0, 0, 0, 0, 0, -1], -0.0309, 0.1027],
+  [[0, 0, 1, 0, -2, 0], [0, 0, -1, 0, 0, 0], -0.0741, 0.0308],
+  [[0, 0, 2, 0, -3, 0], [0, 0, 0, 0, -1, 0], 0.0102, 0.0783],
+  [[0, 1, -1, 0, 0, 0], [0, 0, 1, 0, 0, 0], -0.0026, 0.0765],
+  [[0, 0, 2, 0, -2, 0], [0, 0, 1, 0, 0, 0], -0.0084, 0.0686],
+  [[0, 3, -4, 0, 0, 0], [0, 0, 1, 0, 0, 0], 0.0273, -0.0576],
+  [[0, 0, 1, -1, 0, 0], [0, 0, 1, 0, 0, 0], 0.0570, 0.0117],
+  [[0, 0, 2, -2, 0, 0], [0, 0, 0, 1, 0, 0], 0.0426, -0.0336],
+  [[0, 0, 1, -1, 0, 0], [0, 0, -1, 0, 0, 0], -0.0335, -0.0395],
 ];
 
+/** The declared-fitted semiannual leftover (header (iii)): +1.42″ sin 2lE. */
+const FITTED_2LE_ARCSEC = 1.42;
+
 const D2R = Math.PI / 180;
 
 /**
- * Planetary-completion correction to the finder Sun longitude.
- * @param {number} T - Julian centuries TT from J2000
- * @returns {number} degrees — SUBTRACT from the finder Sun longitude
+ * @param {{ embWobbleArcsec: number }} opts - the DERIVED Earth-around-EMB
+ *   wobble amplitude a_M·μ/AU in arcsec (μ = 1/(1+M_E/M_M)); computed
+ *   from live constants by the model wiring so it tracks the constants.
+ * @returns {{ sunPlanetaryCompletionDeg: (T: number) => number }}
  */
-function sunPlanetaryCompletionDeg(T) {
-  const lV = (ARG_RATES.lV[0] + ARG_RATES.lV[1] * T) * D2R;
-  const lE = (ARG_RATES.lE[0] + ARG_RATES.lE[1] * T) * D2R;
-  const lM = (ARG_RATES.lM[0] + ARG_RATES.lM[1] * T) * D2R;
-  const lJ = (ARG_RATES.lJ[0] + ARG_RATES.lJ[1] * T) * D2R;
-  const D = (ARG_RATES.D[0] + ARG_RATES.D[1] * T) * D2R;
-  let arcsec = 0;
-  for (const [kV, kE, kM, kJ, kD, cA, sA] of TERMS) {
-    const th = kV * lV + kE * lE + kM * lM + kJ * lJ + kD * D;
-    arcsec += cA * Math.cos(th) + sA * Math.sin(th);
+function createSunPlanetaryCompletion({ embWobbleArcsec }) {
+  if (!Number.isFinite(embWobbleArcsec)) {
+    throw new Error('createSunPlanetaryCompletion: embWobbleArcsec must be a finite number (derived a_M·μ/AU in arcsec)');
   }
-  return arcsec / 3600;
+  /**
+   * Planetary-completion correction to the finder Sun longitude.
+   * @param {number} T - Julian centuries TT from J2000
+   * @returns {number} degrees — SUBTRACT from the finder Sun longitude
+   */
+  function sunPlanetaryCompletionDeg(T) {
+    const l = new Float64Array(6), M = new Float64Array(6);
+    for (let i = 0; i < 6; i++) {
+      l[i] = (ARG_L0[i] + ARG_L1[i] * T) * D2R;
+      M[i] = l[i] - PERI[i] * D2R;
+    }
+    let table = 0;
+    for (const [kl, kM, cA, sA] of TERMS) {
+      let th = 0;
+      for (let i = 0; i < 6; i++) th += kl[i] * l[i] + kM[i] * M[i];
+      table += cA * Math.cos(th) + sA * Math.sin(th);
+    }
+    const D = (ARG_D[0] + ARG_D[1] * T) * D2R;
+    const arcsec = -table - embWobbleArcsec * Math.sin(D)
+      + FITTED_2LE_ARCSEC * Math.sin(2 * l[2]);
+    return arcsec / 3600;
+  }
+  return { sunPlanetaryCompletionDeg };
 }
 
-module.exports = { sunPlanetaryCompletionDeg };
+/** sha256/16 of JSON.stringify(FITTED_COEFFICIENTS.SUN_LONGITUDE_HARMONICS)
+ *  at derivation time — the matched-pair fingerprint asserted by test:model.
+ *  Unchanged from v1: SUN_HARMONICS did not move in the D2 landing. */
+const PAIRED_SUN_HARMONICS_SHA256 = 'e2cf42e9770c9e0a';
+
+module.exports = { createSunPlanetaryCompletion, PAIRED_SUN_HARMONICS_SHA256 };

package/src/model.js

@@ -31,7 +31,8 @@ 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 { sunPlanetaryCompletionDeg } from './eclipse/sun-planetary-completion.cjs';
+import { createSunPlanetaryCompletion } from './eclipse/sun-planetary-completion.cjs';
+import { moonSeriesExtensionDeg } from './moon/series-extension.cjs';
 import { createEclipseFinders } from './eclipse/finders.cjs';
 import { createBesselian } from './eclipse/besselian.cjs';
 import { driver2PeriodSecondsAtAge } from './planets/orbit-chain.cjs';
@@ -828,6 +829,63 @@ export function assembleModel(C, F) {
     },
   });
 
+  // ── E4: the framework-native Sun (§12i item 11 — the 3b landing) ─────────
+  // Assembled from the model's own laws, ZERO fitted sun constants:
+  //   e(t) = the H/16 eccentricity-channel law + the derived H/3
+  //          inclination-coupling imprint (amplitude base/2, lattice phase,
+  //          J2000-anchored difference form) — the osculating decomposition:
+  //          osculating e = H/16 channel + inclination coupling.
+  //   L(t) = L0 + the mean tropical rate + the f(Y) drift SHAPE only,
+  //          ∫(rate_SI(y) − rate_SI(2000)) dy: the rate ANCHOR stays the mean
+  //          year (eclipse-endorsed); the drift is the Step 6d year-harmonic
+  //          claim in SI/TT (year-in-days × LOD — the LOD-day part of the
+  //          raw drift is UT-vs-TT and stays ΔT's job). Trapezoid table,
+  //          10-yr steps over −3000..3000; outside, the drift freezes at the
+  //          edge (rate reverts to linear — the finder domain is the corpus
+  //          era).
+  //   ϖ(t) = the shipped H/16 perihelion law (earthPerihelionDeg).
+  // Measured (tools/explore/e3b-native-sun.mjs): beats the Meeus Ch. 25
+  // basis on JPL all-phase (0.95″ vs 1.28″ scatter) and on ancient-corpus
+  // timing structure (0.37 vs 0.50 min detrended vs Meeus-T²); required-ΔT
+  // shift 2–4 min ≈ 0.23σ of Stephenson scatter (lunar bias improves); the
+  // D2 completion table is unchanged (residual 2lE re-fit ≈ 0.1″ — noise).
+  const sunL0Deg = C.earthOrbital.sunMeanLongitudeJ2000_deg;
+  const sunTropicalRateDegPerCy = 360 * julianCenturyDays / meanSolarYearDays;
+  /** @param {number} year @returns {number} */
+  const sunEccentricityAt = (year) => {
+    const cos3 = -Math.cos(phaseRadians(balancedYear, year, 3));
+    const cos3J2000 = -Math.cos(phaseRadians(balancedYear, 2000, 3));
+    return eccentricityAt(year) + (eccentricityBase / 2) * (cos3 - cos3J2000);
+  };
+  const sunMeanLongitudeDegAt = (() => {
+    const Y_LO = -3000, Y_HI = 3000, STEP = 10;
+    /** @type {Float64Array|null} */
+    let cum = null;
+    /** @param {number} year @returns {number} */
+    const rateSIYr = (year) => 360 * (365.25 * 86400)
+      / (tropicalYearDirectDays(year)
+        * (deepLod.lodSecondsAtAge(yearToTMa(year)) ?? meanLengthOfDay));
+    return /** @param {number} year @returns {number} */ (year) => {
+      if (cum === null) {
+        const n = (Y_HI - Y_LO) / STEP + 1;
+        cum = new Float64Array(n);
+        const ref = rateSIYr(2000);
+        let prev = rateSIYr(Y_LO) - ref;
+        for (let i = 1; i < n; i++) {
+          const next = rateSIYr(Y_LO + i * STEP) - ref;
+          cum[i] = cum[i - 1] + 0.5 * (prev + next) * STEP;
+          prev = next;
+        }
+        const at2000 = cum[(2000 - Y_LO) / STEP];
+        for (let i = 0; i < n; i++) cum[i] -= at2000;
+      }
+      const x = (Math.min(Math.max(year, Y_LO), Y_HI) - Y_LO) / STEP;
+      const i = Math.min(Math.floor(x), cum.length - 2);
+      const drift = cum[i] + (x - i) * (cum[i + 1] - cum[i]);
+      return sunL0Deg + sunTropicalRateDegPerCy * (year - 2000) / 100 + drift;
+    };
+  })();
+
   // 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
@@ -840,6 +898,13 @@ export function assembleModel(C, F) {
     deltaTSecondsAt: frameworkDeltaTSecondsAtJD,
     getSynodicMonthDays: () => moonSynodicMonthDays,
     getSunDistanceKm: () => currentAUDistance,
+    frameworkSun: {
+      sunMeanLongitudeJ2000Deg: sunL0Deg,
+      tropicalRateDegPerCy: sunTropicalRateDegPerCy,
+      eccentricityAt: sunEccentricityAt,
+      perihelionLongitudeDegAt: earthPerihelionDeg,
+      meanLongitudeDegAt: sunMeanLongitudeDegAt,
+    },
     constants: {
       rEarthMetres: (C.bodyDiametersKm.earth / 2) * 1000,
       moonDiameterKm: C.bodyDiametersKm.moon,
@@ -856,6 +921,11 @@ export function assembleModel(C, F) {
   // curve, the same convention every other ΔT consumer reads). Both axis
   // conventions are measured against the NASA path-table centerlines —
   // see eclipse/besselian.cjs.
+  // Derived Earth-around-EMB wobble for the Sun completion: a_M·μ/AU,
+  // μ = 1/(1+M_E/M_M) — 6.4399″ at current constants, tracks them live.
+  const embWobbleArcsec = (moonDistanceKm / (MASS_RATIO_EARTH_MOON + 1) / currentAUDistance)
+    * (648000 / Math.PI);
+  const { sunPlanetaryCompletionDeg } = createSunPlanetaryCompletion({ embWobbleArcsec });
   const besselian = createBesselian({
     moonFullAtDaysTT: /** @param {number} dDaysTT */ (dDaysTT) => {
       const ev = moonSeries.sceneEvalAt(dDaysTT);
@@ -863,6 +933,7 @@ export function assembleModel(C, F) {
     },
     sunLonDegAt: /** @param {number} jdUT */ (jdUT) => eclipseFinders.sunLonDegAt(jdUT),
     sunCompletionDeg: sunPlanetaryCompletionDeg,
+    moonExtensionAt: moonSeriesExtensionDeg,
     deltaTSecondsAt: /** @param {number} jd */ (jd) => (jdTTFromUT(jd) - jd) * 86400,
     obliquityDegAt: obliquityDeg,
     eccentricityAt,
@@ -949,6 +1020,18 @@ export function assembleModel(C, F) {
       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,
+      // E4 — the framework-native Sun deps, exported so the OTHER finder
+      // construction sites (tools/verify/eclipse-audit.js, the browser
+      // _eclipse twins) spread the SAME assembly into their own
+      // createEclipseFinders call instead of triplicating it (the
+      // three-runtimes rule — cf. recession-history):
+      frameworkSunDeps: Object.freeze({
+        sunMeanLongitudeJ2000Deg: sunL0Deg,
+        tropicalRateDegPerCy: sunTropicalRateDegPerCy,
+        eccentricityAt: sunEccentricityAt,
+        perihelionLongitudeDegAt: earthPerihelionDeg,
+        meanLongitudeDegAt: sunMeanLongitudeDegAt,
+      }),
       // 20.3g location tier (see eclipse/besselian.cjs):
       umbraGroundAtJD: /** @param {number} jd @returns {{latDeg: number, lonDeg: number} | null} */ (jd) => besselian.umbraGroundAt(jd),
       solarLocalCircumstances: /** @param {number} jdGreatest @param {number} latDeg @param {number} lonDeg */ (jdGreatest, latDeg, lonDeg) => besselian.localCircumstances(jdGreatest, latDeg, lonDeg),

package/src/moon/series-extension.cjs

@@ -0,0 +1,205 @@
+/**
+ * Moon series extension — the DERIVED Delaunay tail beyond the shipped
+ * Meeus-60 head (Stage D2 Phase A, plan §12i item 10).
+ *
+ * DERIVATION, not fit: the amplitudes come from the Stage-D1 3-body lab
+ * (tools/explore/derive-meeus-amplitudes.js — RK4 on framework constants,
+ * IC calibration to the free elements), joint-LSQ over [Meeus-60 head +
+ * extended Delaunay catalog] on a 120-yr window. Head fidelity
+ * 100.00–100.03% (the derivation reproduces the shipped head, so the
+ * tail is the same physics one order deeper); dt-halving drift 0.000″.
+ * Extraction: tools/explore/d2-extension-extraction.mjs.
+ *
+ * JPL enters only as OUT-OF-SAMPLE VALIDATION (960 all-phase epochs):
+ * shipped-Moon residual λ 3.68″ → 3.12″ (predicted 3.08″) and
+ * β 1.04″ → 0.65″ (predicted 0.66″) with the extension ADDED; the
+ * sign-flipped control degrades both — the integrator predicted reality.
+ * Ships JOINTLY with the derived Sun completion v2
+ * (eclipse/sun-planetary-completion.cjs): the Moon-only form degrades
+ * the NASA centerline reference set (its tail was cancelling Sun-side
+ * leftover tones there), and the pre-registered acceptance was all four
+ * gates, never a subset.
+ *
+ * Arguments are the instrument-grade Delaunay polynomials (IAU/Meeus
+ * class, degrees/Julian-century TT) — phase carriers only, same
+ * epistemic status as the Sun completion's argument literals (their
+ * framework-native derivation is research item 20.3e).
+ *
+ * Sign convention: sine terms, ADDED to the full-series Moon longitude
+ * and latitude (the validated sense; see besselian.cjs bodiesAt).
+ *
+ * THE A2 PLANETARY TAIL (the second derived section below): the Moon's
+ * direct planetary perturbations, derived from epoch-phased twin 8-body
+ * integrations (full = planets+J2 vs base = J2-only; planet phases from
+ * the engine graph, the Moon at its true epoch Delaunay phases; fitted
+ * on the run's own arguments with a main-problem absorber catalog,
+ * absorbers discarded — instrument
+ * tools/explore/d2-planetary-moon-epoch.mjs). Cross-validated: V−E
+ * +0.849″ sin (independent JPL fit: +0.85), E−J −0.681″ (JPL: −0.69);
+ * content 0.896″. JPL out-of-sample (960 all-phase epochs): λ scatter
+ * 3.12″ → 3.03″ (the extraction predicted 2.98); the sign-flipped
+ * control degrades to 3.47″; the syzygy fleet improves 3.99″ → 3.82″
+ * in EVERY era. The β rows (0.074″ content) measurably do NOT help and
+ * are not shipped. RECORDED TENSION (owner-accepted at shipping): the
+ * 13-event NASA centerline scoreboard moves 2.22″ → 2.68″ mean — the
+ * 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 ≤8″ api gate 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).
+ */
+
+'use strict';
+
+/** Delaunay argument polynomials [deg at J2000, deg/cy, deg/cy²] TT. */
+const DELAUNAY = {
+  D: [297.8501921, 445267.1114034, -0.0018819],  // mean elongation
+  M: [357.5291092, 35999.0502909, -0.0001536],   // Sun mean anomaly
+  Mp: [134.9633964, 477198.8675055, 0.0087414],  // Moon mean anomaly
+  F: [93.2720950, 483202.0175233, -0.0036539],   // argument of latitude
+};
+
+/** Longitude tail: [kD, kM, kMp, kF, sin″] — 47 derived terms ≥ 0.1″
+ *  (RMS content 2.02″). */
+const LON_TERMS = [
+  [2, 0, 1, 2, -0.9900],
+  [2, 0, -4, 0, 0.9465],
+  [2, -2, 1, 0, 0.7524],
+  [0, 1, -3, 0, -0.6704],
+  [4, 1, -1, 0, -0.6323],
+  [1, 0, 2, 0, -0.5864],
+  [1, 0, 0, -2, -0.5813],
+  [2, 0, -2, -2, -0.5631],
+  [1, -1, 0, 0, -0.5617],
+  [0, 1, 3, 0, -0.5455],
+  [2, 0, -2, 2, -0.5253],
+  [2, -1, -3, 0, 0.4674],
+  [2, 0, 2, -2, -0.4625],
+  [2, -1, -1, 2, -0.4271],
+  [0, 1, 0, 2, 0.4173],
+  [6, 0, -1, 0, 0.3954],
+  [2, -1, 1, -2, -0.3876],
+  [2, -1, 0, 2, -0.3816],
+  [2, 2, -1, -2, -0.3654],
+  [2, 2, 1, -2, -0.3615],
+  [4, 1, -2, 0, -0.3575],
+  [0, 0, 3, 2, -0.3281],
+  [4, -2, -1, 0, 0.3106],
+  [0, 1, -1, -2, 0.3016],
+  [2, -2, -2, 0, 0.2964],
+  [4, 0, -1, -2, 0.2963],
+  [2, 1, 2, 0, -0.2897],
+  [4, 1, 0, 0, -0.2887],
+  [4, -1, 1, 0, 0.2833],
+  [0, 1, 1, 2, 0.2643],
+  [2, 2, -2, 0, -0.2635],
+  [1, 1, -2, 0, 0.2569],
+  [1, 0, 0, 2, 0.2524],
+  [4, 0, 2, 0, 0.2190],
+  [4, 0, -1, 2, -0.2007],
+  [0, 2, -2, 0, -0.1813],
+  [0, 0, 3, -2, -0.1784],
+  [2, 2, 0, 0, -0.1684],
+  [2, 0, -1, -2, 0.1634],
+  [4, -2, 0, 0, 0.1549],
+  [2, 2, -3, 0, 0.1545],
+  [1, -1, -1, 0, -0.1479],
+  [2, 1, -3, 0, 0.1290],
+  [6, 0, 0, 0, 0.1268],
+  [1, 0, -3, 0, -0.1252],
+  [2, 0, 2, 2, -0.1236],
+  [1, -1, 1, 0, -0.1225],
+];
+
+/** Latitude tail: [kD, kM, kMp, kF, sin″] — 30 derived terms ≥ 0.1″
+ *  (RMS content 0.80″). */
+const LAT_TERMS = [
+  [4, -1, -1, 1, 0.3390],
+  [2, 0, -1, -3, 0.3282],
+  [2, -2, -1, 1, 0.3148],
+  [0, 1, 2, -1, -0.3050],
+  [0, 1, -2, 1, -0.2988],
+  [2, 0, 1, -3, -0.2919],
+  [2, -2, -1, -1, 0.2685],
+  [0, 0, 4, 1, 0.2636],
+  [2, 0, -3, 1, 0.2526],
+  [2, 0, -1, 3, -0.2447],
+  [2, 1, 1, 1, -0.2369],
+  [4, 0, 1, 1, 0.2128],
+  [2, 2, 0, -1, -0.1749],
+  [4, 1, -1, -1, -0.1737],
+  [4, -1, 0, 1, 0.1581],
+  [2, 0, 3, -1, 0.1465],
+  [0, 0, 2, -3, -0.1461],
+  [2, 0, 0, 3, -0.1444],
+  [1, 0, -1, 1, 0.1387],
+  [2, 0, 3, 1, 0.1381],
+  [2, 0, -4, -1, 0.1335],
+  [2, -1, 2, -1, 0.1283],
+  [2, -1, 2, 1, 0.1241],
+  [0, 2, -1, -1, -0.1208],
+  [0, 0, 2, 3, -0.1178],
+  [4, 1, 0, -1, -0.1128],
+  [2, 2, -1, -1, -0.1127],
+  [1, 0, -2, -1, -0.1093],
+  [2, 2, -1, 1, -0.1044],
+  [1, 1, 1, 1, 0.1014],
+];
+
+/** Planetary mean-longitude polynomials, degrees per Julian century TT
+ *  (IAU-class instrument literals — same carriers as the Sun completion).
+ *  Order: Venus, Earth (EMB), Mars, Jupiter, Saturn. */
+const PLANET_L0 = [181.979801, 100.466457, 355.433000, 34.351519, 50.077444];
+const PLANET_L1 = [58517.815676, 36000.769780, 19141.696300, 3036.302389, 1223.511013];
+
+/**
+ * The A2 planetary longitude tail:
+ * [[kV, kE, kMa, kJ, kSa, kD, kMp], cos″, sin″] — 15 derived terms
+ * (content 0.896″), run→real argument mapping folded into the signs.
+ * @type {Array<[number[], number, number]>}
+ */
+const PLANETARY_LON_TERMS = [
+  [[1, -1, 0, 0, 0, 0, 0], -0.0056, -0.8488],
+  [[2, -2, 0, 0, 0, 0, 0], -0.0034, 0.3166],
+  [[3, -3, 0, 0, 0, 0, 0], -0.0051, -0.0387],
+  [[0, 1, 0, -1, 0, 0, 0], 0.0325, 0.6814],
+  [[0, 2, 0, -2, 0, 0, 0], -0.0084, -0.1835],
+  [[0, 2, -2, 0, 0, 0, 0], 0.0002, 0.2205],
+  [[0, 1, 0, 0, -1, 0, 0], 0.0078, 0.0463],
+  [[1, -1, 0, 0, 0, 2, 0], -0.0020, -0.0308],
+  [[1, -1, 0, 0, 0, -2, 0], 0.0045, -0.1193],
+  [[0, 1, 0, -1, 0, 2, 0], 0.0014, 0.0322],
+  [[0, 1, 0, -1, 0, -2, 0], 0.0161, 0.2141],
+  [[1, -1, 0, 0, 0, 0, 1], 0.0023, -0.1929],
+  [[1, -1, 0, 0, 0, 0, -1], -0.0029, -0.2306],
+  [[0, 1, 0, -1, 0, 0, 1], 0.0059, 0.1729],
+  [[0, 1, 0, -1, 0, 0, -1], -0.0077, 0.2235],
+];
+
+const D2R = Math.PI / 180;
+
+/**
+ * Derived series-extension correction to the full-series Moon:
+ * the Delaunay tail plus the A2 planetary tail (longitude only).
+ * @param {number} T - Julian centuries TT from J2000
+ * @returns {{dLonDeg: number, dLatDeg: number}} degrees — ADD to the
+ *   full-series Moon longitude/latitude
+ */
+function moonSeriesExtensionDeg(T) {
+  const poly = /** @param {number[]} p */ (p) => (p[0] + (p[1] + p[2] * T) * T) * D2R;
+  const D = poly(DELAUNAY.D), M = poly(DELAUNAY.M), Mp = poly(DELAUNAY.Mp), F = poly(DELAUNAY.F);
+  let lon = 0, lat = 0;
+  for (const [kD, kM, kMp, kF, s] of LON_TERMS) lon += s * Math.sin(kD * D + kM * M + kMp * Mp + kF * F);
+  for (const [kD, kM, kMp, kF, s] of LAT_TERMS) lat += s * Math.sin(kD * D + kM * M + kMp * Mp + kF * F);
+  const l = new Float64Array(5);
+  for (let i = 0; i < 5; i++) l[i] = (PLANET_L0[i] + PLANET_L1[i] * T) * D2R;
+  for (const [k, cA, sA] of PLANETARY_LON_TERMS) {
+    const th = k[0] * l[0] + k[1] * l[1] + k[2] * l[2] + k[3] * l[3] + k[4] * l[4] + k[5] * D + k[6] * Mp;
+    lon += cA * Math.cos(th) + sA * Math.sin(th);
+  }
+  return { dLonDeg: lon / 3600, dLatDeg: lat / 3600 };
+}
+
+module.exports = { moonSeriesExtensionDeg };