@essrt/physics 1.9.0 → 1.10.0

package/package.json

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

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/model.js

@@ -829,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
@@ -841,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,
@@ -956,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),