@essrt/physics 1.0.0

package/src/moon/series.cjs

@@ -0,0 +1,211 @@
+/**
+ * Meeus Ch. 47 lunar periodic series — THE shared implementation (8.2-6).
+ *
+ * Replaces THREE copies: the browser scene block (moveModel), the tools
+ * scene block (both the full production evaluation), and hosts the
+ * TRUNCATED eclipse-finder variant beside it. The dual form is DELIBERATE
+ * (doc 66 §Layer 1b): the truncated `_eclMoon*` helpers are the form the
+ * certified eclipse statistics were produced with (NASA canon recall
+ * 99.58/74.62/98.66, knife-edge at the γ ≈ 1.0/1.5 boundaries) — upgrading
+ * them to the full series is a RE-CERTIFICATION item, not a refactor.
+ *
+ * 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
+ * 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.
+ *
+ * The correction literals (3958/1962/318; −2235/382/175/175/127/−115;
+ * phases 119.75/53.09/313.45; Meeus A/B rates 479264.290/481266.484) are
+ * Meeus Ch. 47 STRUCTURE and live here, like the argument polynomials
+ * (8.2-5 S2 precedent). The 60-term tables are INJECTED — they are fitted
+ * coefficients (the engines' two sources are byte-identical).
+ */
+
+'use strict';
+
+/**
+ * @typedef {Array<[number, number, number, number, number]>} MeeusTermTable
+ */
+
+/**
+ * @param {{
+ *   constants: {
+ *     moonL: MeeusTermTable,
+ *     moonB: MeeusTermTable,
+ *     j2000JD: number,
+ *     julianCenturyDays: number,
+ *     moonMeeusLpCorrectionDeg: number,
+ *     fwA2RateDegPerCy: number,
+ *     fwA3RateDegPerCy: number,
+ *   },
+ *   fns: {
+ *     argsAt: (jdTT: number) => {Lp: number, D: number, M: number, Mp: number, F: number},
+ *     eFactorForD: (dDaysTT: number, T: number, T2: number) => number,
+ *     eFactorAtJdTT: (jdTT: number, T: number, T2: number) => number,
+ *     getMoonDistanceKm: () => number,
+ *     getEccentricityBase: () => number,
+ *     deltaTSeconds: (jdUT: number) => number,
+ *     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),
+ *     jupiterOrbitsBetween: (yearA: number, yearB: number) => (number | null),
+ *     isDeepTime: () => boolean,
+ *     isFrameworkNative: () => boolean,
+ *   },
+ * }} deps — argsAt is the engine's dispatcher (probe hook and mode toggle
+ *   ride along); eFactorForD preserves each engine's exact E-factor call
+ *   shape (S11: the two convert d→years with differently-associated
+ *   expressions); distance/eccentricity are GETTERS because the browser's
+ *   moonDistance is deep-time-mutable.
+ */
+function createMoonSeries({ constants, fns }) {
+  const {
+    moonL, moonB, j2000JD, julianCenturyDays,
+    moonMeeusLpCorrectionDeg, fwA2RateDegPerCy, fwA3RateDegPerCy,
+  } = constants;
+  const {
+    argsAt, eFactorForD, eFactorAtJdTT, getMoonDistanceKm, getEccentricityBase, deltaTSeconds,
+    jdToSIyear, tropicalOrbitsBetween, apsidalOfDateCyclesBetween,
+    cyclesBetween, jupiterOrbitsBetween, isDeepTime, isFrameworkNative,
+  } = fns;
+
+  const D2R = Math.PI / 180;
+
+  /** A1/A2/A3 in radians at T centuries TT (deep time: A2/A3 chain-integrated).
+   *  @param {number} T @param {number} dDaysTT
+   *  @returns {{A1: number, A2: number, A3: number}} */
+  function additionalArgs(T, dDaysTT) {
+    const A1 = (119.75 + 131.849 * T) * D2R;
+    let a2Deg = 53.09 + (isFrameworkNative() ? fwA2RateDegPerCy : 479264.290) * T;
+    let a3Deg = 313.45 + (isFrameworkNative() ? fwA3RateDegPerCy : 481266.484) * T;
+    if (isDeepTime() && isFrameworkNative()) {
+      const yA0 = jdToSIyear(j2000JD);
+      const yA = jdToSIyear(j2000JD + dDaysTT);
+      const nT = tropicalOrbitsBetween(yA0, yA);
+      const nAps = apsidalOfDateCyclesBetween(yA0, yA);
+      const nP13 = cyclesBetween(yA0, yA, 13);
+      const nJ = jupiterOrbitsBetween(yA0, yA);
+      if (nT !== null && nAps !== null && nP13 !== null && nJ !== null) {
+        a3Deg = 313.45 + 360 * (nT - nP13);
+        a2Deg = 53.09 + 360 * (nT + nAps - 2 * nJ);
+      }
+    }
+    return { A1, A2: a2Deg * D2R, A3: a3Deg * D2R };
+  }
+
+  /** One 60-term table pass with E/E² on M-bearing terms (micro-degrees).
+   *  @param {MeeusTermTable} table @param {number} Dr @param {number} Mr
+   *  @param {number} Mpr @param {number} Fr @param {number} E
+   *  @param {number} E2 @returns {number} */
+  function sumTable(table, Dr, Mr, Mpr, Fr, E, E2) {
+    let s = 0;
+    for (let i = 0; i < table.length; i++) {
+      const r = table[i];
+      const arg = r[0] * Dr + r[1] * Mr + r[2] * Mpr + r[3] * Fr;
+      let term = r[4] * Math.sin(arg);
+      const absM = r[1] < 0 ? -r[1] : r[1];
+      if (absM === 1) term *= E;
+      else if (absM === 2) term *= E2;
+      s += term;
+    }
+    return s;
+  }
+
+  /** The PRODUCTION scene evaluation at d days TT from J2000 (the caller
+   *  owns the UT→TT conversion — engine timing conventions differ).
+   *  Returns everything the scene blocks write:
+   *  thetaAddRad — the hierarchy θ increment (EoC-half-subtracted Σl);
+   *  lonDeg — full ecliptic longitude incl. moonMeeusLpCorrection;
+   *  latRad/latDeg — Σb with all six corrections (BOTH computed from Σb
+   *  directly: the browser stores radians, the Node engine degrees, and
+   *  (x·D2R)/D2R is not bit-exactly x); distKm — two-term ellipse; T.
+   *  @param {number} dDaysTT
+   *  @returns {{thetaAddRad: number, lonDeg: number, latRad: number, latDeg: number, distKm: number, T: number}} */
+  function sceneEvalAt(dDaysTT) {
+    const d = dDaysTT;
+    const T = d / julianCenturyDays;
+    const T2 = T * T;
+    const args = argsAt(j2000JD + d);
+    const Lp = args.Lp * D2R;
+    const Dr = args.D * D2R, Mr = args.M * D2R, Mpr = args.Mp * D2R, Fr = args.F * D2R;
+    const E = eFactorForD(d, T, T2);
+    const E2 = E * E;
+    const { A1, A2, A3 } = additionalArgs(T, d);
+
+    let Sl = sumTable(moonL, Dr, Mr, Mpr, Fr, E, E2);
+    Sl += 3958 * Math.sin(A1) + 1962 * Math.sin(Lp - Fr) + 318 * Math.sin(A2);
+    // Subtract the EoC portion the off-centre orbit geometry already provides.
+    const eocHalf = getEccentricityBase() / 2;
+    Sl -= (2 * eocHalf / D2R * 1e6) * Math.sin(Mpr);
+    Sl -= (1.25 * eocHalf * eocHalf / D2R * 1e6) * Math.sin(2 * Mpr);
+    const thetaAddRad = Sl * 1e-6 * D2R;
+
+    let Sb = sumTable(moonB, Dr, Mr, Mpr, Fr, E, E2);
+    Sb += -2235 * Math.sin(Lp) + 382 * Math.sin(A3);
+    Sb += 175 * Math.sin(A1 - Fr) + 175 * Math.sin(A1 + Fr);
+    Sb += 127 * Math.sin(Lp - Mpr) - 115 * Math.sin(Lp + Mpr);
+    const latRad = Sb * 1e-6 * D2R;
+    const latDeg = Sb * 1e-6;
+
+    // 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 distKm = getMoonDistanceKm() * (1 - getEccentricityBase() * Math.cos(Mpr));
+    return { thetaAddRad, lonDeg, latRad, latDeg, distKm, T };
+  }
+
+  /** TRUNCATED eclipse-finder longitude (doc 66 §Layer 1b): the certified
+   *  form — no EoC subtraction, no A3/latitude-family, no LpCorrection.
+   *  Accepts JD_UT; converts to TT via the injected ΔT.
+   *  @param {number} jdUT @returns {number} degrees 0–360 */
+  function truncatedLonDeg(jdUT) {
+    const jdTT = jdUT + deltaTSeconds(jdUT) / 86400;
+    const T = (jdTT - j2000JD) / julianCenturyDays;
+    const T2 = T * T;
+    const args = argsAt(jdTT);
+    const LpMean = args.Lp;
+    const Dr = args.D * D2R, Mr = args.M * D2R, Mpr = args.Mp * D2R, Fr = args.F * D2R;
+    // Original-JD call shape — (j2000JD + (jdTT − j2000JD)) is NOT bit-exactly
+    // jdTT, so the truncated path keeps its own E-factor entry.
+    const E = eFactorAtJdTT(jdTT, T, T2);
+    const E2 = E * E;
+    let Sl = sumTable(moonL, Dr, Mr, Mpr, Fr, E, E2);
+    const A1 = (119.75 + 131.849 * T) * D2R;
+    const A2 = (53.09 + (isFrameworkNative() ? fwA2RateDegPerCy : 479264.290) * T) * D2R;
+    Sl += 3958 * Math.sin(A1) + 1962 * Math.sin(LpMean * D2R - Fr) + 318 * Math.sin(A2);
+    return (((LpMean + Sl * 1e-6) % 360) + 360) % 360;
+  }
+
+  /** TRUNCATED eclipse-finder latitude (doc 66 §Layer 1b): table only — the
+   *  six additional corrections are DELIBERATELY absent (the certified
+   *  eclipse statistics were produced with this form; the ~2.2 mdeg
+   *  −2235·sin(Lp) family would move knife-edge canon events).
+   *  @param {number} jdUT @returns {number} degrees */
+  function truncatedBetaDeg(jdUT) {
+    const jdTT = jdUT + deltaTSeconds(jdUT) / 86400;
+    const T = (jdTT - j2000JD) / julianCenturyDays;
+    const T2 = T * T;
+    const args = argsAt(jdTT);
+    const Dr = args.D * D2R, Mr = args.M * D2R, Mpr = args.Mp * D2R, Fr = args.F * D2R;
+    const E = eFactorAtJdTT(jdTT, T, T2);
+    const E2 = E * E;
+    return sumTable(moonB, Dr, Mr, Mpr, Fr, E, E2) * 1e-6;
+  }
+
+  /** Two-term ellipse distance at JD_UT (shared with the scene form).
+   *  @param {number} jdUT @returns {number} km */
+  function truncatedDistanceKm(jdUT) {
+    const jdTT = jdUT + deltaTSeconds(jdUT) / 86400;
+    const Mpr = argsAt(jdTT).Mp * D2R;
+    return getMoonDistanceKm() * (1 - getEccentricityBase() * Math.cos(Mpr));
+  }
+
+  return { sceneEvalAt, truncatedLonDeg, truncatedBetaDeg, truncatedDistanceKm, additionalArgs };
+}
+
+module.exports = { createMoonSeries };

package/src/phase/index.cjs

@@ -0,0 +1,186 @@
+/**
+ * Integrated-phase machinery — THE shared implementation (Phase 7.1).
+ *
+ * The cumulative ∫1/H(t)dt table and everything derived from it: cycle counts,
+ * the J2000 drift correction, and the inverse lookup. Extracted VERBATIM from
+ * tools/lib/deep-time.js, which was itself the port of src/script.js — this
+ * file replaces both copies (and is the reference the website's deepTime.ts
+ * must match; Phase E measured what happens when it doesn't).
+ *
+ * CommonJS on purpose: `tools/lib` is CJS and cannot require an ESM module
+ * synchronously; ESM (`src/script.js`, bundlers) imports CJS natively. One
+ * file, every engine.
+ *
+ * THE CONVENTIONS ARE LOAD-BEARING — the fitted coefficients were produced
+ * against THIS discretization, so the numerics ship with the coefficients:
+ *
+ *  - TRAPEZOID rule on 10-kyr cells with LINEAR interpolation between cells.
+ *    An analytically better integrator is WRONG here: the website's adaptive
+ *    Simpson disagreed by ~1e-6 cycles at −280 kyr = ~18 s of cardinal-point
+ *    JD through the ×16 braid phase (Gate E measured 24.7 s before the fix).
+ *  - R2: the table must be built under the LATTICE α — the CONSTANT moment of
+ *    inertia, not the climate-modulated α(t). The `holisticHAtAgeMa` the
+ *    caller injects must already be pinned (see each engine's construction
+ *    site). The always-on climate modulation integrates into a linear phase
+ *    drift (the same ~18 s class — the dominant Phase E bug).
+ *  - R3: the drift-correction anchor is identified by CALL SHAPE, never by
+ *    distance from J2000 — the old distance heuristic put a 2·drift
+ *    = 6.80e-5-cycle STEP DISCONTINUITY at yearB == yearA, worth 0.393 d of
+ *    apsis displacement and 100% of 6d's anomalistic residual.
+ *  - The table zero sits at the cell nearest `tableAnchorYear` (2000.5,
+ *    startmodelYear); the drift reference is `driftRefYear`
+ *    (startModelYearWithCorrection ≈ 2000.4977) — TWO different constants,
+ *    half a day apart. Do not "unify" them.
+ */
+
+'use strict';
+
+/**
+ * @param {{
+ *   holisticHAtAgeMa: (tMa: number) => (number | null),
+ *   tableAnchorYear: number,
+ *   driftRefYear: number,
+ *   hJ2000: number,
+ *   yearMin?: number,
+ *   yearMax?: number,
+ *   stepYears?: number,
+ * }} cfg — holisticHAtAgeMa MUST be the lattice-α form; tableAnchorYear is
+ *   startmodelYear (2000.5, table zero + t_Ma convention); driftRefYear is
+ *   startModelYearWithCorrection (the R3 drift anchor); hJ2000 the snapshot
+ *   rate the drift compares against; 10-kyr cells match both engines'
+ *   historic tables.
+ */
+function createPhaseMachinery({
+  holisticHAtAgeMa,
+  tableAnchorYear,
+  driftRefYear,
+  hJ2000,
+  yearMin = -500e6,
+  yearMax = 500e6,
+  stepYears = 10000,
+}) {
+  /** @type {Float64Array | null} */
+  let table = null;
+  let j2000Idx = -1;
+
+  function ensureTable() {
+    if (table !== null) return;
+    const N = Math.ceil((yearMax - yearMin) / stepYears) + 1;
+    const t = new Float64Array(N);
+    j2000Idx = Math.round((tableAnchorYear - yearMin) / stepYears);
+
+    /** @param {number} year */
+    const invH = (year) => {
+      const t_Ma = (tableAnchorYear - year) / 1e6;
+      const H = holisticHAtAgeMa(t_Ma);
+      return H === null ? null : 1 / H;
+    };
+
+    t[j2000Idx] = 0;
+    let prev = invH(yearMin + j2000Idx * stepYears);
+    for (let i = j2000Idx + 1; i < N; i++) {
+      const year_i = yearMin + i * stepYears;
+      const curr = invH(year_i);
+      t[i] = (prev !== null && curr !== null)
+        ? t[i - 1] + 0.5 * (prev + curr) * stepYears
+        : NaN;
+      prev = curr;
+    }
+    prev = invH(yearMin + j2000Idx * stepYears);
+    for (let i = j2000Idx - 1; i >= 0; i--) {
+      const year_i = yearMin + i * stepYears;
+      const curr = invH(year_i);
+      t[i] = (prev !== null && curr !== null)
+        ? t[i + 1] - 0.5 * (prev + curr) * stepYears
+        : NaN;
+      prev = curr;
+    }
+    table = t;
+  }
+
+  /** Cumulative ∫1/H at a year (linear interpolation). null outside the range
+   *  or where the physics is undefined (past the tidal-lock asymptote).
+   *  @param {number} year @returns {number | null} */
+  function cumulAtYear(year) {
+    ensureTable();
+    if (year < yearMin || year > yearMax) return null;
+    const t = /** @type {Float64Array} */ (table);
+    const idx_f = (year - yearMin) / stepYears;
+    const idx_lo = Math.floor(idx_f);
+    const idx_hi = Math.min(idx_lo + 1, t.length - 1);
+    const v_lo = t[idx_lo];
+    const v_hi = t[idx_hi];
+    if (Number.isNaN(v_lo) || Number.isNaN(v_hi)) return null;
+    return v_lo + (idx_f - idx_lo) * (v_hi - v_lo);
+  }
+
+  /** ∫_{yearA}^{yearB} 1/H(t') dt'. null if either endpoint is out of domain.
+   *  @param {number} yearA @param {number} yearB @returns {number | null} */
+  function integralBetween(yearA, yearB) {
+    if (yearA === yearB) return 0;
+    const cA = cumulAtYear(yearA);
+    const cB = cumulAtYear(yearB);
+    if (cA === null || cB === null) return null;
+    return cB - cA;
+  }
+
+  /** How far the integrated form has drifted from the J2000-snapshot form over
+   *  (yearA → driftRefYear). Subtracting it at the anchor restores the
+   *  snapshot-fitted harmonic calibration at J2000 without changing the
+   *  integrated form's shape at deep time.
+   *  @param {number} yearA @returns {number} */
+  function j2000Drift(yearA) {
+    const integral = integralBetween(yearA, driftRefYear);
+    if (integral === null) return 0;
+    const snapshot = (driftRefYear - yearA) / hJ2000;
+    return integral - snapshot;
+  }
+
+  /** Total cycles between two years for a cycle of period H/divisorN.
+   *  R3: the anchor is identified from the CALL SHAPE — two shapes exist,
+   *  (anchor, movingYear, N) and (J2000, anchor, N) where yearA IS the J2000
+   *  reference itself. The correction depends only on a FIXED endpoint, so it
+   *  is constant across any scan. Returns null past the tidal-lock asymptote.
+   *  @param {number} yearA @param {number} yearB @param {number} divisorN
+   *  @returns {number | null} */
+  function cyclesBetween(yearA, yearB, divisorN) {
+    const integral = integralBetween(yearA, yearB);
+    if (integral === null) return null;
+    const anchorIsA = (yearA !== driftRefYear);
+    const correction = anchorIsA ? j2000Drift(yearA) : -j2000Drift(yearB);
+    return divisorN * (integral - correction);
+  }
+
+  /** Inverse of cumulAtYear — the year at a given cumulative ∫1/H (binary
+   *  search over the monotone table). null outside the table domain.
+   *  @param {number} targetCumul @returns {number | null} */
+  function yearAtCumul(targetCumul) {
+    ensureTable();
+    const t = /** @type {Float64Array} */ (table);
+    const N = t.length;
+    let lo = 0, hi = N - 1;
+    while (lo < N && Number.isNaN(t[lo])) lo++;
+    while (hi >= 0 && Number.isNaN(t[hi])) hi--;
+    if (lo >= hi) return null;
+    if (targetCumul < t[lo] || targetCumul > t[hi]) return null;
+    while (lo < hi - 1) {
+      const mid = (lo + hi) >> 1;
+      if (t[mid] <= targetCumul) lo = mid; else hi = mid;
+    }
+    const v_lo = t[lo], v_hi = t[hi];
+    const frac = (v_lo === v_hi) ? 0 : (targetCumul - v_lo) / (v_hi - v_lo);
+    return yearMin + (lo + frac) * stepYears;
+  }
+
+  /** Grid geometry — consumed by the engines' days/pos tables, which share
+   *  this grid but keep their own integrands (they move at Phase 8). */
+  function grid() {
+    ensureTable();
+    const t = /** @type {Float64Array} */ (table);
+    return { yearMin, yearMax, stepYears, j2000Idx, length: t.length };
+  }
+
+  return { ensureTable, cumulAtYear, integralBetween, j2000Drift, cyclesBetween, yearAtCumul, grid };
+}
+
+module.exports = { createPhaseMachinery };

package/src/planets/asc-node-integrator.cjs

@@ -0,0 +1,120 @@
+/**
+ * Dynamic ascending node — rate-based segment integration (Phase 8.3, L5).
+ *
+ * dΩ/dε = −sin(Ω)/tan(i), integrated over obliquity change with segment
+ * handling at obliquity extrema and Earth-inclination crossovers (the
+ * inclination DIRECTION flips the sign of the effect per segment).
+ *
+ * Extracted from tools/lib/orbital-engine.js
+ * calculateDynamicAscendingNodeFromTilts (itself the mirror of the
+ * browser's 6-arg variant — S-P5). The BROWSER variant remains engine-side
+ * this slice: neither copy is fixture-pinned, so the signature unification
+ * is deferred to the factory pass, WITH probes first (recorded follow-up).
+ *
+ * §2h BOUNDARY: this module takes {ascendingNodeDeg, inclinationDeg} — the
+ * Tychosium `orbitTilta/orbitTiltb` scheme names never enter the package;
+ * the engines own the atan2/hypot decomposition at their edge.
+ *
+ * All time-dependent inputs are INJECTED per call: the engine's obliquity
+ * and Earth-inclination evaluators, the precomputed obliquity-extrema
+ * lookup, the inclination-crossing finder, and (optionally) the per-planet
+ * dynamic ecliptic inclination.
+ */
+
+'use strict';
+
+/**
+ * @param {{ ascendingNodeDeg: number, inclinationDeg: number }} tilt —
+ *   static node and inclination (engine-decomposed from its scene scheme)
+ * @param {number} currentYear
+ * @param {{
+ *   obliquityAt: (year: number) => number,
+ *   earthInclinationAt: (year: number) => number,
+ *   obliquityExtremaInRange: (yearMin: number, yearMax: number) => number[],
+ *   inclinationCrossingsInRange: (inclinationDeg: number, yearMin: number, yearMax: number) => number[],
+ *   eclipticInclinationAt: ((year: number) => number) | null,
+ *   earthInclinationMeanDeg: number,
+ *   earthInclinationAmplitudeDeg: number,
+ *   epochYear?: number,
+ * }} deps — eclipticInclinationAt non-null enables the dynamic-inclination
+ *   crossover search and per-segment rates (the planetName path).
+ * @returns {number} dynamic ascending node longitude, degrees 0–360
+ */
+function integrateAscendingNode(tilt, currentYear, deps) {
+  const DEG2RAD = Math.PI / 180;
+  const RAD2DEG = 180 / Math.PI;
+
+  const staticOmega = ((tilt.ascendingNodeDeg % 360) + 360) % 360;
+  const planetInclination = tilt.inclinationDeg;
+
+  if (planetInclination < 1e-6) return staticOmega;
+
+  const i = planetInclination * DEG2RAD;
+  const OmegaRad = staticOmega * DEG2RAD;
+  const tanI = Math.tan(i);
+  if (Math.abs(tanI) < 1e-10) return staticOmega;
+
+  const sinOmega = Math.sin(OmegaRad);
+  const EPOCH_YEAR = deps.epochYear !== undefined ? deps.epochYear : 2000;
+
+  /** @param {number} fromYear @param {number} toYear @returns {number} */
+  const integrateEffect = (fromYear, toYear) => {
+    if (Math.abs(toYear - fromYear) < 0.1) return 0;
+
+    const yearMin = Math.min(fromYear, toYear);
+    const yearMax = Math.max(fromYear, toYear);
+    const dir = toYear >= fromYear ? 1 : -1;   // integration direction — signs the total
+
+    /** @type {number[]} */
+    let criticalYears = [yearMin, yearMax];
+
+    criticalYears.push(...deps.obliquityExtremaInRange(yearMin, yearMax));
+
+    // Find ALL inclination crossings
+    const minEarthIncl = deps.earthInclinationMeanDeg - deps.earthInclinationAmplitudeDeg;
+    const maxEarthIncl = deps.earthInclinationMeanDeg + deps.earthInclinationAmplitudeDeg;
+
+    // With a dynamic ecliptic inclination the planet can enter Earth's range
+    // even if the static value is outside — always search for crossovers.
+    if (deps.eclipticInclinationAt || (planetInclination >= minEarthIncl && planetInclination <= maxEarthIncl)) {
+      const crossIncl = deps.eclipticInclinationAt
+        ? deps.eclipticInclinationAt((yearMin + yearMax) / 2)
+        : planetInclination;
+      criticalYears.push(...deps.inclinationCrossingsInRange(crossIncl, yearMin, yearMax));
+    }
+
+    criticalYears = [...new Set(criticalYears)].sort((a, b) => a - b);
+
+    // Integrate over segments
+    let effect = 0;
+    for (let idx = 0; idx < criticalYears.length - 1; idx++) {
+      const segStart = criticalYears[idx];
+      const segEnd = criticalYears[idx + 1];
+
+      const oblStart = deps.obliquityAt(segStart);
+      const oblEnd = deps.obliquityAt(segEnd);
+      const deltaObl = (oblEnd - oblStart) * DEG2RAD;
+
+      const midYear = (segStart + segEnd) / 2;
+      const earthInclAtMid = deps.earthInclinationAt(midYear);
+
+      const dynIncl = deps.eclipticInclinationAt
+        ? deps.eclipticInclinationAt(midYear)
+        : planetInclination;
+      const inclDirection = earthInclAtMid > dynIncl ? 1 : -1;
+      const dynTanI = Math.tan(dynIncl * DEG2RAD);
+      if (Math.abs(dynTanI) < 1e-10) continue; // skip near-zero inclination
+      const segRate = -sinOmega / dynTanI;
+
+      effect += segRate * inclDirection * deltaObl * RAD2DEG;
+    }
+    return effect * dir;
+  };
+
+  const effectFromEpoch = integrateEffect(EPOCH_YEAR, currentYear);
+
+  let newOmega = staticOmega + effectFromEpoch;
+  return ((newOmega % 360) + 360) % 360;
+}
+
+module.exports = { integrateAscendingNode };

package/src/planets/corrections.cjs

@@ -0,0 +1,167 @@
+/**
+ * Fitted post-hoc corrections — THE shared evaluators (Phase 8.3, L8).
+ *
+ * The parallax RA/Dec basis: ~80 fitted coefficient slots (A..CA) over a
+ * geometric state (orbital phase u from the ascending node, inverse
+ * geocentric distance, inverse heliocentric distance, Julian centuries,
+ * the triple-synodic conjunction phase, the Sun mean longitude, and the
+ * inner-planet mean anomaly). ONE basis served four hand-copies: browser
+ * dec, browser RA, Node dec, Node RA (~80 duplicated terms each).
+ *
+ * MATCHED PAIR: these coefficients were fitted against exactly this basis
+ * and this state derivation — the expression text is transcribed verbatim
+ * (including the (x || 0) missing-slot guards and the AU_ key, which
+ * avoids a collision with the AU unit name). Do not simplify.
+ *
+ * The engines OWN the state derivation (scene vectors, JD conventions) and
+ * the application sign convention (RA subtracts, Dec adds) — this module
+ * only evaluates.
+ *
+ * GRAVITATION (planet-planet perturbation harmonics): evaluated here PER
+ * TERM — the engines apply each term inside their own loops, because
+ * (x−a)−b ≠ x−(a+b) at the last bit and the fixtures pin the per-term
+ * application order.
+ *
+ * ELONGATION (elongation × Earth-perihelion geometry, 21 fitted slots per
+ * axis): BROWSER ASSOCIATION FORM — the six d² slots per table use the
+ * precomputed invD² ((a·b)·invD²); the Node mirror carried inline
+ * invD·invD (((a·b)·invD)·invD) at those sites — same 1-ULP class as the
+ * five parallax slots, measured by the fixture recorders at extraction.
+ */
+
+'use strict';
+
+/**
+ * @typedef {{ u: number, invD: number, invS: number, T: number,
+ *   cp: number, Lsun: number,
+ *   sinM: number, cosM: number, sin2M: number, cos2M: number }} ParallaxState
+ */
+
+/**
+ * Evaluate the fitted parallax basis for one coefficient table (RA or Dec —
+ * same basis, different tables). Returns DEGREES (the engines apply their
+ * own sign and rad conversion).
+ * @param {Record<string, number>} c @param {ParallaxState} s
+ * @returns {number} */
+function evaluateParallaxBasis(c, s) {
+  const { u: _u, invD: _invD, invS: _invS, T: _T, Lsun: _Lsun } = s;
+  const _invD2 = _invD * _invD;
+  const _invD3 = _invD2 * _invD;
+  const _invS2 = _invS * _invS;
+  const _invDS = _invD * _invS;
+  const _sinU = Math.sin(_u), _cosU = Math.cos(_u);
+  const _sin2U = Math.sin(2 * _u), _cos2U = Math.cos(2 * _u);
+  const _sin3U = Math.sin(3 * _u), _cos3U = Math.cos(3 * _u);
+  const _sinCP = Math.sin(s.cp), _cosCP = Math.cos(s.cp);
+  const _sin2CP = Math.sin(2 * s.cp), _cos2CP = Math.cos(2 * s.cp);
+  const _sinL = Math.sin(_Lsun), _cosL = Math.cos(_Lsun);
+  const _sinM = s.sinM, _cosM = s.cosM, _sin2M = s.sin2M, _cos2M = s.cos2M;
+  return c.A + c.B * _invD + (c.C || 0) * _T
+    + (c.D * _sinU + c.E * _cosU + c.F * _sin2U + c.G * _cos2U
+     + (c.H || 0) * _sin3U + (c.I || 0) * _cos3U) * _invD
+    + _T * ((c.J || 0) * _sinU + (c.K || 0) * _cosU) * _invD
+    + (c.L || 0) * _invS + (c.M || 0) * _sinU * _invD2
+    + (c.N || 0) * _sin2U * _invS + (c.O || 0) * _cosU * _invS
+    + (c.P || 0) * _T * _sin2U * _invD + (c.Q || 0) * _T * _cos2U * _invD
+    + (c.R || 0) * _T * _sinU * _invS
+    + (c.S || 0) * _T * _invD + (c.U || 0) * _cosU * _invD2
+    + (c.V || 0) * _invS2 + (c.W || 0) * _sinU * _invS2
+    + (c.X || 0) * _cos3U * _invS + (c.Y || 0) * _sin3U * _invS
+    + (c.Z || 0) * _invDS + (c.AA || 0) * _sinU * _invDS
+    + (c.AB || 0) * _cos2U * _invDS + (c.AC || 0) * _T * _sin2U * _invS
+    + (c.AD || 0) * _cos3U * _invD2 + (c.AE || 0) * _sin2U * _invS2
+    + (c.AF || 0) * _sin3U * _invS2 + (c.AG || 0) * _cos3U * _invS2
+    + (c.AH || 0) * _cosU * _invS2 + (c.AI || 0) * _sinU * _invD2 * _invS
+    + (c.AJ || 0) * Math.cos(4 * _u) * _invS + (c.AK || 0) * _sin2U * _invD2 * _invS
+    + (c.AL || 0) * Math.sin(4 * _u) * _invD + (c.AM || 0) * Math.cos(4 * _u) * _invD
+    + (c.AN || 0) * _T * _sinU * _invD2 + (c.AO || 0) * _T * _cosU * _invD2
+    + (c.AP || 0) * _sinU * _invD2 * _invD + (c.AQ || 0) * _cosU * _invD2 * _invD
+    + (c.AR || 0) * _sinCP + (c.AS || 0) * _cosCP
+    + (c.AT || 0) * _sin2CP + (c.AU_ || 0) * _cos2CP
+    + (c.AV || 0) * _sinCP * _invD + (c.AW || 0) * _cosCP * _invD
+    + (c.AX || 0) * _sinL * _invD + (c.AY || 0) * _cosL * _invD
+    + (c.AZ || 0) * _sinL + (c.BA || 0) * _cosL
+    + (c.BB || 0) * _T * _sinL * _invD + (c.BC || 0) * _T * _cosL * _invD
+    + (c.BD || 0) * _T * _sinL + (c.BE || 0) * _T * _cosL
+    + (c.BF || 0) * _cosU * _sinL * _invD2 + (c.BG || 0) * _cosU * _cosL * _invD2
+    + (c.BH || 0) * _sinL * _invD3 + (c.BI || 0) * _cosL * _invD3
+    + (c.BJ || 0) * Math.sin(_u - _Lsun) * _invD2 + (c.BK || 0) * Math.cos(_u - _Lsun) * _invD2
+    + (c.BL || 0) * _T * _T * _invD + (c.BM || 0) * _T * _T * _sinU * _invD + (c.BN || 0) * _T * _T * _cosU * _invD
+    + (c.BO || 0) * _sin2U * _invD3 + (c.BP || 0) * _cos2U * _invD3
+    + (c.BQ || 0) * _sinU * _invD3 * _invD
+    + (c.BR || 0) * _sinM * _invD + (c.BS || 0) * _cosM * _invD
+    + (c.BT || 0) * _sin2M * _invD + (c.BU || 0) * _cos2M * _invD
+    + (c.BV || 0) * _sinM + (c.BW || 0) * _cosM
+    + (c.BX || 0) * _sin2M + (c.BY || 0) * _cos2M
+    + (c.BZ || 0) * _sinM * _invD2 + (c.CA || 0) * _cosM * _invD2;
+}
+
+/**
+ * Gravitation-correction term deltas, in DEGREES, one entry per fitted
+ * term. The engines apply these PER TERM (sign convention and the
+ * degrees→radians conversion stay engine-side).
+ * @param {Array<{ period: number, raSin: number, raCos: number,
+ *   decSin: number, decCos: number }>} terms
+ * @param {number} yearsFrom2000
+ * @returns {Array<{ raDeg: number, decDeg: number }>} */
+function gravitationTermDeltasDeg(terms, yearsFrom2000) {
+  const out = [];
+  for (const term of terms) {
+    const phase = 2 * Math.PI * yearsFrom2000 / term.period;
+    const sp = Math.sin(phase), cp = Math.cos(phase);
+    out.push({
+      raDeg: term.raSin * sp + term.raCos * cp,
+      decDeg: term.decSin * sp + term.decCos * cp,
+    });
+  }
+  return out;
+}
+
+/**
+ * @typedef {{ elongRad: number, vFromWERad: number, synPhaseRad: number,
+ *   invD: number }} ElongationState
+ */
+
+/**
+ * Evaluate the fitted 21-slot elongation basis for one axis. Returns
+ * DEGREES; `suffix` selects the coefficient table ('ra' or 'dec' — same
+ * basis, different fitted slots). The engines derive the state (frame Sun
+ * RA, Earth-perihelion angle, exact synodic phase from the integer orbit
+ * count) and apply their own sign and rad conversion.
+ * @param {Record<string, number>} vc @param {ElongationState} s
+ * @param {'ra'|'dec'} suffix
+ * @returns {number} */
+function evaluateElongationBasis(vc, s, suffix) {
+  const sinEl = Math.sin(s.elongRad), cosEl = Math.cos(s.elongRad);
+  const cosVwE = Math.cos(s.vFromWERad), sinVwE = Math.sin(s.vFromWERad);
+  const sin2VwE = Math.sin(2 * s.vFromWERad), cos2VwE = Math.cos(2 * s.vFromWERad);
+  const sin3VwE = Math.sin(3 * s.vFromWERad), cos3VwE = Math.cos(3 * s.vFromWERad);
+  const sin4VwE = Math.sin(4 * s.vFromWERad), cos4VwE = Math.cos(4 * s.vFromWERad);
+  const invD = s.invD;
+  const invD2 = invD * invD;
+  /** @param {string} k @returns {number} */
+  const c = (k) => vc[k + suffix] || 0;
+  return c('cosVwE_sinEl_') * cosVwE * sinEl
+    + c('sinEl_d_') * sinEl * invD
+    + c('sinVwE_sinEl_') * sinVwE * sinEl
+    + c('sin2VwE_sinEl_') * sin2VwE * sinEl
+    + c('cos2VwE_sinEl_') * cos2VwE * sinEl
+    + c('cos4VwE_sinEl_') * cos4VwE * sinEl
+    + c('sin4VwE_sinEl_') * sin4VwE * sinEl
+    + c('sinVwE_sinEl_d2_') * sinVwE * sinEl * invD2
+    + c('cos3VwE_sinEl_') * cos3VwE * sinEl
+    + c('sin3VwE_sinEl_') * sin3VwE * sinEl
+    + c('sin2syn_') * Math.sin(2 * s.synPhaseRad)
+    + c('cos1syn_') * Math.cos(s.synPhaseRad)
+    + c('sin3VwE_sinEl_d2_') * sin3VwE * sinEl * invD2
+    + c('sin2VwE_sinEl_d2_') * sin2VwE * sinEl * invD2
+    + c('cos2VwE_sinEl_d2_') * cos2VwE * sinEl * invD2
+    + c('cosEl_d_') * cosEl * invD
+    + c('cosVwE_cosEl_d_') * cosVwE * cosEl * invD
+    + c('sinVwE_cosEl_d_') * sinVwE * cosEl * invD
+    + c('cosEl_d2_') * cosEl * invD2
+    + c('cosVwE_cosEl_d2_') * cosVwE * cosEl * invD2
+    + c('sinVwE_cosEl_d2_') * sinVwE * cosEl * invD2;
+}
+
+module.exports = { evaluateParallaxBasis, gravitationTermDeltasDeg, evaluateElongationBasis };