@essrt/physics 4.3.0 → 4.4.1

package/package.json

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

package/src/cardinal/one-source-structure.cjs

@@ -101,6 +101,31 @@ function createCardinalStructure({ sampleAt, tropicalYearSecondsAtYearFn }) {
       + eocOffsetSeconds(year + 1, type) - eocOffsetSeconds(year, type);
   }
 
+  /**
+   * The ANOMALISTIC year — time between successive perihelion passages,
+   * SI seconds. At perihelion the equation of center is ZERO by definition
+   * (M = 0), so perihelion passages are pure mean-anomaly events and the
+   * closed form needs no EoC term at all:
+   *
+   *   T_anom(year) = T_mean(year+½) · 360 / (360 − Δϖ_yr)
+   *
+   * with Δϖ_yr = ϖ(year+1) − ϖ(year) (wrapped; the year-over-year apsidal
+   * advance RELATIVE TO THE EQUINOX — periOfDateDeg is equinox-referenced,
+   * so this is the climatic-precession rate, ~0.017°/yr ≈ +25 min at
+   * J2000). Exact difference form; driven by the ENGINE's ϖ(t) — this is
+   * the model's physics, replacing the retired K-family anomalistic
+   * harmonic fit (the family that measured worst against the one-source
+   * movement: 0.41 s broadband).
+   * @param {number} year the interval starts at this year's perihelion
+   * @returns {number} seconds
+   */
+  function anomalisticYearSeconds(year) {
+    const p0 = sampleAt(year).periOfDateDeg;
+    const p1 = sampleAt(year + 1).periOfDateDeg;
+    const dPeriDeg = ((p1 - p0 + 540) % 360) - 180;   // wrapped, prograde +
+    return tropicalYearSecondsAtYearFn(year + 0.5) * 360 / (360 - dPeriDeg);
+  }
+
   /**
    * The four year lengths minus the mean — the e(t)-proportional spread.
    * @param {number} year
@@ -116,7 +141,7 @@ function createCardinalStructure({ sampleAt, tropicalYearSecondsAtYearFn }) {
     return out;
   }
 
-  return { eocOffsetSeconds, yearLengthSeconds, spreadSeconds };
+  return { eocOffsetSeconds, yearLengthSeconds, spreadSeconds, anomalisticYearSeconds };
 }
 
 module.exports = { createCardinalStructure, equationOfCenterDeg, CARDINAL_LONGITUDE_DEG };

package/src/earth/deep-orbital-history.cjs

@@ -83,6 +83,46 @@ function createDeepOrbitalHistory({
     const s0 = sum(0), R = [anchor[0] - s0[0], anchor[1] - s0[1]];
     return (/** @type {number} */ t) => { const [x, y] = sum(t); return [x + R[0], y + R[1]]; };
   };
+  // CO-ROTATING anchor (the ϖ̇ fix, measured): the DC residual above is a
+  // spurious zero-frequency mode — it preserves the J2000 VALUE but dilutes
+  // the local argument rate by |sum(0)|/|anchor| (z: 11.47 → 7.93″/yr, a
+  // 92 s-class anomalistic-year bias in the mode tier). Here the residual
+  // ROTATES at the raw sum's own local arg-rate g* = Im(ż·z̄)/|z|²
+  // (analytic), so at t=0 both the value AND the rate are exact, and at
+  // depth the residual is one |R|-amplitude term at a physical frequency
+  // instead of a DC offset (deep envelope measured unchanged:
+  // [0.0001, 0.0672] → [0.0003, 0.0678] over 10–50 Myr).
+  // z ONLY: ζ keeps the DC anchor DELIBERATELY — its anchor is ~0 by
+  // definition (Earth's inclination to the J2000 ecliptic at J2000), i.e.
+  // the coordinate origin; a rotating residual there would inject a fake
+  // wobble into n̂(t).
+  const mkAnchoredCoRot = (
+    /** @type {ReadonlyArray<{omegaRadPerYr: number, re: number, im: number}>} */ modes,
+    /** @type {[number, number]} */ anchor,
+  ) => {
+    const sum = (/** @type {number} */ t) => {
+      let re = 0, im = 0;
+      for (const m of modes) {
+        const c = Math.cos(m.omegaRadPerYr * t), s = Math.sin(m.omegaRadPerYr * t);
+        re += m.re * c - m.im * s;
+        im += m.re * s + m.im * c;
+      }
+      return [re, im];
+    };
+    let q0 = 0, p0 = 0, dq0 = 0, dp0 = 0;
+    for (const m of modes) {
+      q0 += m.re; p0 += m.im;
+      dq0 += -m.omegaRadPerYr * m.im;
+      dp0 += m.omegaRadPerYr * m.re;
+    }
+    const gStar = (dp0 * q0 - dq0 * p0) / (q0 * q0 + p0 * p0);
+    const R = [anchor[0] - q0, anchor[1] - p0];
+    return (/** @type {number} */ t) => {
+      const [x, y] = sum(t);
+      const c = Math.cos(gStar * t), s = Math.sin(gStar * t);
+      return [x + R[0] * c - R[1] * s, y + R[0] * s + R[1] * c];
+    };
+  };
   const s2h = Math.sin(anchorInclEclipticDeg / 2 * D2R);
   const zetaAnchor = /** @type {[number, number]} */ (
     [s2h * Math.cos(anchorAscNodeEclipticDeg * D2R), s2h * Math.sin(anchorAscNodeEclipticDeg * D2R)]);
@@ -108,7 +148,7 @@ function createDeepOrbitalHistory({
   }
   const zAnchor = /** @type {[number, number]} */ (
     [anchorE * Math.cos(anchorPeriEclipticDeg * D2R), anchorE * Math.sin(anchorPeriEclipticDeg * D2R)]);
-  const zModeSum = mkAnchored(zModes, zAnchor);
+  const zModeSum = mkAnchoredCoRot(zModes, zAnchor);   // co-rotating residual — the ϖ̇ fix (see mkAnchoredCoRot)
   // C-4a: the z-side one-source path — same construction as zetaSeries
   // (anchored engine series inside the span, anchored mode sum as the tail).
   let zAt = zModeSum;

package/src/model.js

@@ -1175,6 +1175,7 @@ export function assembleModel(C, F, laws = {}) {
       yearLengthSeconds: /** @param {number} year @param {'VE'|'SS'|'AE'|'WS'} type @returns {number} */ (year, type) => cardinalStructureM.yearLengthSeconds(year, type),
       eocOffsetSeconds: /** @param {number} year @param {'VE'|'SS'|'AE'|'WS'} type @returns {number} */ (year, type) => cardinalStructureM.eocOffsetSeconds(year, type),
       spreadSeconds: /** @param {number} year */ (year) => cardinalStructureM.spreadSeconds(year),
+      anomalisticYearSeconds: /** @param {number} year @returns {number} */ (year) => cardinalStructureM.anomalisticYearSeconds(year),
     }),
     moon: Object.freeze({
       distanceKmAtYear: /** @param {number} year @returns {number} */ (year) => moonDistanceMetresAtAge(yearToTMa(year)) / 1000,