@essrt/physics 20.0.1 → 22.0.0

package/src/moon/series.cjs

@@ -47,7 +47,6 @@ const { moonSeriesExtensionDeg } = require('./series-extension.cjs');
  *     moonDistanceJ2000Km: number,
  *     j2000JD: number,
  *     julianCenturyDays: number,
- *     moonMeeusLpCorrectionDeg: number,
  *     fwA2RateDegPerCy: number,
  *     fwA3RateDegPerCy: number,
  *   },
@@ -61,7 +60,7 @@ const { moonSeriesExtensionDeg } = require('./series-extension.cjs');
  *     jdToSIyear: (jd: number) => number,
  *     tropicalOrbitsBetween: (yearA: number, yearB: number) => (number | null),
  *     apsidalOfDateCyclesBetween: (yearA: number, yearB: number) => (number | null),
- *     cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null),
+ *     siderealOrbitsBetween: (yearA: number, yearB: number) => (number | null),
  *     jupiterOrbitsBetween: (yearA: number, yearB: number) => (number | null),
  *     isDeepTime: () => boolean,
  *     isFrameworkNative: () => boolean,
@@ -75,12 +74,12 @@ const { moonSeriesExtensionDeg } = require('./series-extension.cjs');
 function createMoonSeries({ constants, fns }) {
   const {
     moonL, moonB, moonR, moonRMeanKm, moonDistanceJ2000Km, j2000JD, julianCenturyDays,
-    moonMeeusLpCorrectionDeg, fwA2RateDegPerCy, fwA3RateDegPerCy,
+    fwA2RateDegPerCy, fwA3RateDegPerCy,
   } = constants;
   const {
     argsAt, eFactorForD, eFactorAtJdTT, getMoonDistanceKm, getEccentricityBase, deltaTSeconds,
     jdToSIyear, tropicalOrbitsBetween, apsidalOfDateCyclesBetween,
-    cyclesBetween, jupiterOrbitsBetween, isDeepTime, isFrameworkNative,
+    siderealOrbitsBetween, jupiterOrbitsBetween, isDeepTime, isFrameworkNative,
   } = fns;
 
   const D2R = Math.PI / 180;
@@ -97,10 +96,14 @@ function createMoonSeries({ constants, fns }) {
       const yA = jdToSIyear(j2000JD + dDaysTT);
       const nT = tropicalOrbitsBetween(yA0, yA);
       const nAps = apsidalOfDateCyclesBetween(yA0, yA);
-      const nP13 = cyclesBetween(yA0, yA, 13);
+      // 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 && nP13 !== null && nJ !== null) {
-        a3Deg = 313.45 + 360 * (nT - nP13);
+      if (nT !== null && nAps !== null && nSid !== null && nJ !== null) {
+        a3Deg = 313.45 + 360 * nSid;
         a2Deg = 53.09 + 360 * (nT + nAps - 2 * nJ);
       }
     }
@@ -172,8 +175,9 @@ 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 and moonMeeusLpCorrection
-   *  (retired to 0 at plan 06 R3 item 1: measured against Horizons' apparent
+   *  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
    *  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
@@ -216,7 +220,7 @@ function createMoonSeries({ constants, fns }) {
     // Full longitude re-adds the EoC half that θ absorbed.
     const fullSl = Sl + (2 * eocHalf / D2R * 1e6) * Math.sin(Mpr)
                      + (1.25 * eocHalf * eocHalf / D2R * 1e6) * Math.sin(2 * Mpr);
-    const lonDeg = Lp / D2R + fullSl * 1e-6 + moonMeeusLpCorrectionDeg;
+    const lonDeg = Lp / D2R + fullSl * 1e-6;
     const distKm = fullDistanceKm(Dr, Mr, Mpr, Fr, E, E2, j2000JD + d);
     return { thetaAddRad, lonDeg, latRad, latDeg, distKm, T };
   }

package/src/phase/deep-calendar.cjs

@@ -1,8 +1,8 @@
 /**
- * Deep-time calendar — year ↔ JD under the drifting year length, and the
- * H-balanced event finder. ONE implementation for both engines.
+ * Deep-time calendar — year ↔ JD under the drifting year length. ONE
+ * implementation for both engines.
  *
- * Until the year/day collapse these five functions lived twice, hand-mirrored:
+ * Until the year/day collapse these functions lived twice, hand-mirrored:
  * `src/script.js` (the original) and `tools/lib/deep-time.js` (the port,
  * marked PHASE-B-DUPLICATE). The website's runtime twin was a third copy, and
  * both Phase E website bugs (Simpson-vs-trapezoid convention, the missing
@@ -10,26 +10,27 @@
  * VERBATIM from the browser copy — operation for operation — so the numerics
  * are the shipped ones:
  *
- *  - the days-per-year integral rides the phase machinery's grid (10-kyr
- *    cells, trapezoid rule, linear interpolation between cells) — the same
- *    discretization the fitted coefficients were produced against;
+ *  - the days-per-year integral rides the engines' deep-time grid (10-kyr
+ *    cells over ±500 Myr, trapezoid rule, linear interpolation between
+ *    cells — the discretization every year-keyed golden was produced
+ *    against; until plan 09 step 7a the grid was the ∫dt/H phase table's,
+ *    deleted with the unit's counting); the
+ *    integrand is the tropical year of date over the day of date — since plan
+ *    09 step 5d one equinox turn per the composed precession period T_p(t),
+ *    a movement, not the unit's count (the calendar's year is a tropical year);
  *  - the table is built under the LATTICE α (R2): `withLatticeAlpha` is the
  *    engine's pin, injected, so a table build can never see the climate-
  *    modulated α(t);
  *  - `yearToJD` CARRIES A KNOWN 0.6-d ZERO-POINT OFFSET (measured −0.600 d in
  *    both engines): the anchor cell is seeded by linear extrapolation but read
- *    back by interpolation across a 10-kyr cell. DO NOT "fix" it in
- *    isolation — `balancedYearAtCycle` round-trips through `cyclesBetween`,
- *    which absorbs the offset (that is why the bracket lands on
- *    −302635.004 / 32682.268 exactly); normalising the table without
- *    re-checking that round-trip moves the Step 6a window;
- *  - `balancedYearAtCycle` round-trips through the JD deliberately, NOT as a
- *    shortcut to bisecting `cyclesBetween` in calendar units: calendar-year
- *    delta = H_J2000 exactly, but SI-year delta does not — they differ by
- *    ~6.7 SI yr per H. Dropping the round-trip returns the SI label instead of
- *    the calendar year. The Newton step uses H at J2000 (the browser stepped
- *    with its live H; the iteration converges to 1e-12 cycles either way and
- *    the two agree at J2000 scene state by construction).
+ *    back by interpolation across a 10-kyr cell. A recorded property of the
+ *    table — the Step 6a window and every year-keyed golden were produced
+ *    against it; normalising it moves them.
+ *  - (Plan 09 step 5d: the H-balanced event finder `balancedYearAtCycle` —
+ *    the k-th year at which the unit's phase from J2000 is an integer, a
+ *    Newton iteration on the ∫dt/H_era table — and the table's inverse
+ *    `yearAtCumulIntegral` are deleted with the unit's counting; the Step 6a
+ *    exporter reports a plain year window.)
  *
  * CommonJS on purpose, like `./index.cjs`: `tools/lib` is CJS and cannot
  * require an ESM module synchronously; ESM imports CJS natively.
@@ -37,14 +38,6 @@
 
 'use strict';
 
-/**
- * @typedef {Object} PhaseMachinery
- * @property {() => void} ensureTable
- * @property {(year: number) => (number | null)} cumulAtYear
- * @property {(targetCumul: number) => (number | null)} yearAtCumul
- * @property {() => {yearMin: number, yearMax: number, stepYears: number, j2000Idx: number, length: number}} grid
- */
-
 /**
  * @typedef {Object} DeepCalendar
  * @property {(jd: number) => number} jdToSIyear SI-tropical-year label for a
@@ -53,55 +46,49 @@
  *   with the runtime by construction; the round-trip bias Y_SI − Y is −11.0 yr
  *   at −302,635 and grows quadratically).
  * @property {(ySI: number) => number} siYearToJD the exact inverse of jdToSIyear.
- * @property {(targetCumul: number) => (number | null)} yearAtCumulIntegral
- *   inverse of the phase machinery's cumulAtYear — null outside the table.
  * @property {() => void} ensureCumulDaysTable builds the ∫ daysPerYear dt table
  *   (idempotent; under the lattice α).
  * @property {(year: number) => (number | null)} yearToJD calendar year → JD,
  *   integrating days-per-year from startModelYear; null outside the table
  *   domain or past the tidal-lock asymptote; startModelJD exactly at
  *   year = startModelYear.
- * @property {(cycleOffset: number) => (number | null)} balancedYearAtCycle
- *   calendar year of the k-th H-balanced event, k = 0 being `balancedYear`;
- *   negative k = past; null outside the table domain.
  * @property {() => (number | null)} cumulDaysTableLength diagnostic — the
  *   table length once built, null before.
  */
 
 /**
  * @param {{
- *   phase: () => PhaseMachinery,
  *   meanYearInDaysAtAgeMa: (tMa: number) => (number | null),
  *   withLatticeAlpha: (build: () => void) => void,
  *   startModelJD: number,
  *   startModelYear: number,
  *   startModelYearWithCorrection: number,
  *   siTropicalYearDays: number,
- *   balancedYear: number,
- *   hJ2000: number,
- *   cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null),
- * }} deps — `phase` is the engine's (lazily built) phase machinery, whose
- *   grid the days table shares; `meanYearInDaysAtAgeMa` the engine's
- *   days-per-year source (the LOD channel's `yearInDaysAtAge`);
- *   `withLatticeAlpha` the engine's R2 pin; `cyclesBetween` the engine's
- *   cycle counter (the browser passes its toggle-aware form, Node the
- *   integrated form — the caller's convention, preserved); `startModelYear`
- *   is the table zero (2000.5) and `startModelYearWithCorrection` the SI-axis
- *   anchor (≈ 2000.4977) — two different constants, do not unify.
+ *   yearMin?: number,
+ *   yearMax?: number,
+ *   stepYears?: number,
+ * }} deps — `meanYearInDaysAtAgeMa` is the engine's days-per-year source
+ *   (the LOD channel's `yearInDaysAtAge`); `withLatticeAlpha` the engine's
+ *   R2 pin; `startModelYear` is the table zero (2000.5) and
+ *   `startModelYearWithCorrection` the SI-axis anchor (≈ 2000.4977) — two
+ *   different constants, do not unify; the grid (±500 Myr, 10-kyr cells)
+ *   is the engines' deep-time grid — the table zero sits at the cell
+ *   nearest `startModelYear`.
  * @returns {DeepCalendar}
  */
 function createDeepCalendar({
-  phase,
   meanYearInDaysAtAgeMa,
   withLatticeAlpha,
   startModelJD,
   startModelYear,
   startModelYearWithCorrection,
   siTropicalYearDays,
-  balancedYear,
-  hJ2000,
-  cyclesBetween,
+  yearMin = -500e6,
+  yearMax = 500e6,
+  stepYears = 10000,
 }) {
+  const j2000Idx = Math.round((startModelYear - yearMin) / stepYears);
+  const N = Math.ceil((yearMax - yearMin) / stepYears) + 1;
   /** @type {(jd: number) => number} */
   const jdToSIyear = (jd) => startModelYearWithCorrection + (jd - startModelJD) / siTropicalYearDays;
   /** The exact inverse: SI-year label → JD (the Moon layers' argument clock
@@ -109,10 +96,7 @@ function createDeepCalendar({
    *  @type {(ySI: number) => number} */
   const siYearToJD = (ySI) => startModelJD + (ySI - startModelYearWithCorrection) * siTropicalYearDays;
 
-  /** @type {(targetCumul: number) => (number | null)} */
-  const yearAtCumulIntegral = (targetCumul) => phase().yearAtCumul(targetCumul);
-
-  /** ∫ daysPerYear dt from startModelYear, on the phase grid. @type {Float64Array | null} */
+  /** ∫ daysPerYear dt from startModelYear, on the deep-time grid. @type {Float64Array | null} */
   let cumulDaysTable = null;
 
   function ensureCumulDaysTable() {
@@ -121,9 +105,6 @@ function createDeepCalendar({
   }
 
   function buildCumulDaysTable() {
-    const P = phase();
-    P.ensureTable();
-    const { yearMin, stepYears, j2000Idx, length: N } = P.grid();
     const table = new Float64Array(N);
 
     /** @type {(year: number) => (number | null)} */
@@ -159,7 +140,6 @@ function createDeepCalendar({
     if (!Number.isFinite(year)) return null;
     ensureCumulDaysTable();
     const table = /** @type {Float64Array} */ (cumulDaysTable);
-    const { yearMin, yearMax, stepYears } = phase().grid();
     if (year < yearMin || year > yearMax) return null;
     const idx_f = (year - yearMin) / stepYears;
     const idx_lo = Math.floor(idx_f);
@@ -171,36 +151,11 @@ function createDeepCalendar({
     return startModelJD + daysFromStartModel;
   }
 
-  /** @type {(cycleOffset: number) => (number | null)} */
-  function balancedYearAtCycle(cycleOffset) {
-    // No cycleOffset === 0 short-circuit: returning balancedYear directly
-    // skips the JD round-trip below, misses the exact integer-cycle JD by
-    // ~0.5 d and gives ~21″ obliquity drift + ~3e-9 e drift at cycle 0.
-    const refCumul = phase().cumulAtYear(balancedYear);
-    if (refCumul === null) return null;
-    let Y = yearAtCumulIntegral(refCumul + cycleOffset);
-    if (Y === null) return null;
-    for (let iter = 0; iter < 5; iter++) {
-      const jd = yearToJD(Y);
-      if (jd === null) return Y;
-      const Y_SI = jdToSIyear(jd);
-      if (!Number.isFinite(Y_SI)) return Y;
-      const corrected = cyclesBetween(balancedYear, Y_SI, 1);
-      if (corrected === null) return Y;
-      const error = corrected - cycleOffset;
-      if (Math.abs(error) < 1e-12) break;
-      Y = Y - error * hJ2000;
-    }
-    return Y;
-  }
-
   return Object.freeze({
     jdToSIyear,
     siYearToJD,
-    yearAtCumulIntegral,
     ensureCumulDaysTable,
     yearToJD,
-    balancedYearAtCycle,
     cumulDaysTableLength: () => (cumulDaysTable === null ? null : cumulDaysTable.length),
   });
 }