@essrt/physics 1.9.0 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@essrt/physics",
-  "version": "1.9.0",
+  "version": "1.11.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",

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

@@ -58,6 +58,17 @@
  * recomputes it from live constants and fails on mismatch. The api
  * centerline gate (≤8″ shadow-plane) backstops gross staleness
  * independently.
+ *
+ * E4/E5 PAIRING VERDICT (20.3h Phase 0): the framework-native Sun
+ * landing REPLACED the finder Sun form (Meeus Ch. 25 → the assembled
+ * framework Sun with the f(Y)+torque drift). The re-derivation this
+ * header calls for was MEASURED INSTEAD: the residual 2lE re-fit under
+ * the new chain is noise (−0.12″ sin / −0.03″ cos vs the declared-fitted
+ * +1.42″ — tools/explore/e3b-native-sun.mjs §2), the all-phase Sun
+ * residual improved to 0.95″, and every gate stayed green — the table's
+ * planetary content is chain-independent physics and the pairing holds
+ * WITHOUT re-extraction. The +1.42″ 2lE term is thereby measured to be
+ * genuinely planetary-class, not a Meeus-EoC absorber.
  */
 
 'use strict';

package/src/model.js

@@ -829,6 +829,81 @@ 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 6c 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) PLUS the derived
+  //          TORQUE term (E5): the year harmonics carry only the GEOMETRIC
+  //          equinox displacement (the tilt nodes — the exact 8:3 amplitude
+  //          signature); the classical luni-solar torque adds a precession-
+  //          RATE modulation δp = −p₀·tan ε·δε(t) on the model's own
+  //          two-component obliquity law (−A cos φ₃ + A cos φ₈). Both
+  //          lengthen the year at obliquity max, so they ADD; per-divisor
+  //          drift scale 1 + p₀·tan²ε·H/(2π·div) = 1.306 (H/8) / 1.815
+  //          (H/3) — the structure the ancient corpus blind-selected before
+  //          the derivation existed. Zero new constants. 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;
+    const precessionP0DegPerYr = 13 * 360 / H;
+    const tanEps = Math.tan(earthtiltMean * Math.PI / 180);
+    /** E5 — the two-component obliquity excursion, radians, integrated phase.
+     * @param {number} year @returns {number} */
+    const obliquityExcursionRad = (year) => (
+      -earthInclAmplitude * Math.cos(phaseRadians(balancedYear, year, 3))
+      + earthInclAmplitude * Math.cos(phaseRadians(balancedYear, year, 8))
+    ) * Math.PI / 180;
+    /** @param {number} year @returns {number} */
+    const rateSIYr = (year) => 360 * (365.25 * 86400)
+      / (tropicalYearDirectDays(year)
+        * (deepLod.lodSecondsAtAge(yearToTMa(year)) ?? meanLengthOfDay))
+      - precessionP0DegPerYr * tanEps * obliquityExcursionRad(year);
+    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
@@ -841,6 +916,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,
@@ -956,6 +1038,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

@@ -62,7 +62,14 @@ const DELAUNAY = {
 };
 
 /** Longitude tail: [kD, kM, kMp, kF, sin″] — 47 derived terms ≥ 0.1″
- *  (RMS content 2.02″). */
+ *  (RMS content 2.02″), plus the 20.3h ROUND-2 block at the end: five
+ *  dt-halving-converged terms beyond the D2 catalog's order-7 bound
+ *  (m20h-extraction-r2.mjs, the same D1 3-body lab). The lead term
+ *  [6,0,−2,0] extracted at 0.572″ vs the MPP02-comparison target 0.57″
+ *  (m20h-alias-breaker.mjs) — the integrator predicted the independent
+ *  reference again. 4-gate out-of-sample (m20h-gate-preview.mjs):
+ *  all-phase λ 3.03 → 2.96″, β unchanged, fleet improves, centerlines
+ *  2.71 → 2.69″ with the 2001 max 7.3 → 6.7″. */
 const LON_TERMS = [
   [2, 0, 1, 2, -0.9900],
   [2, 0, -4, 0, 0.9465],
@@ -111,6 +118,12 @@ const LON_TERMS = [
   [1, 0, -3, 0, -0.1252],
   [2, 0, 2, 2, -0.1236],
   [1, -1, 1, 0, -0.1225],
+  // 20.3h ROUND 2 — beyond the order-7 catalog bound (see header note):
+  [6, 0, -2, 0, 0.572],
+  [6, 0, -3, 0, 0.294],
+  [4, 0, -2, 2, -0.169],
+  [4, -2, -2, 0, 0.161],
+  [0, 0, 5, 0, 0.112],
 ];
 
 /** Latitude tail: [kD, kM, kMp, kF, sin″] — 30 derived terms ≥ 0.1″