@essrt/physics 9.2.0 → 11.0.0

package/README.md

@@ -87,6 +87,27 @@ solar/lunar eclipse search over a JD window, greatest-eclipse convention),
 records and orientation at epoch). Validation targets are refused as
 inputs — a counterfactual cannot move the goalposts it is judged by.
 
+### The series artifact
+
+Earth's published orbit history (eccentricity, perihelion, obliquity) is
+the engine's banked N-body series — a 9-MB governed artifact kept in the
+[public repository](https://github.com/dvansonsbeek/3d)
+(`data/nbody-secular-series.json`), not inside this package. Pass it in to
+get the published values:
+
+```js
+const series = JSON.parse(readFileSync('nbody-secular-series.json', 'utf8'));
+const model = createModel(undefined, { secularSeriesArtifact: series });
+model.earth.eccentricity(2000 - 100000);   // 0.04008 — the series (La2004: 0.04006)
+createModel().earth.eccentricity(2000 - 100000);   // 0.03374 — the mode table
+```
+
+Without the artifact `createModel()` evaluates the embedded 18-term mode
+table at every epoch: exact at J2000, a compact approximation away from it
+(RMS 3.6·10⁻³ in e against La2010a over the last 500 kyr, where the series
+reads 2.5·10⁻⁵). The hosted API, the MCP server and the simulator always
+pass the artifact.
+
 ## Underneath: a parts library
 
 `createModel()` is assembly over unassembled factories. Each factory

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@essrt/physics",
-  "version": "9.2.0",
+  "version": "11.0.0",
   "description": "ESSRT (Expanding Solar System Resonance Theory) physics core — 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": "v14.0",
+    "modelVersion": "v16.0",
     "_note": "The model identity this package version ships (IP-unified-architecture §10: package semver tracks the API axis; the model version + CONSTANTS_HASH/COEFFICIENTS_HASH in src/constants/ carry the scientific identity). The version-pinning gate enforces this pairing against public/input/model-version.json."
   },
   "type": "module",

package/src/climate/l1-orbital.cjs

@@ -85,17 +85,35 @@ function laggedL1Terms(l1Terms, relaxationKyr) {
  *   relaxationKyr: number,
  *   alphaGiaRateJ2000PerYr: number,
  *   alphaJ2000: number,
- * }} cfg - relaxationKyr and alphaGiaRateJ2000PerYr are model-parameters
- *   deepTime constants; alphaJ2000 the IERS moment-of-inertia factor
+ *   j2RateJ2000PerYr?: number,
+ *   j2J2000?: number,
+ * }} cfg - relaxationKyr, alphaGiaRateJ2000PerYr and j2RateJ2000PerYr are
+ *   model-parameters deepTime constants; alphaJ2000 the IERS
+ *   moment-of-inertia factor; j2J2000 Earth's J₂ (astro-reference)
  * @returns {{
  *   alphaAt: (year: number) => number,
+ *   j2RatioAt: (year: number) => number,
  *   laggedL1PermilAt: (year: number) => number,
  *   kPerPermille: number,
  *   relaxationKyr: number,
  *   laggedL1Terms: Array<{period_kyr: number, a: number, b: number}>,
  * }}
+ *
+ * THE SAME REDISTRIBUTION, ITS SECOND OBSERVABLE — j2RatioAt(year) = J₂(t)/J₂₀.
+ * The mass that changes the polar moment changes the oblateness, and the
+ * luni-solar precession rate is proportional to it (ψ̇ ∝ (C − A)/C; the
+ * consumer is the spin integration, earth/deep-orbital-history). The J₂ side
+ * is scaled on its OWN observation, exactly as the α side is on its rate:
+ *
+ *   J₂(t) = J₂₀ − k_J · [ L1'(t) − L1'(2000) ],   k_J = −(dJ₂/dt)_obs / (dL1'/dt)₂₀₀₀
+ *
+ * so dJ₂/dt(J2000) IS the observed satellite rate (Cox & Chao 2002) by
+ * construction, and the J₂→α conversion factor never enters. A constant
+ * dJ₂/dt would be a rate valid at a point used across a span; this is the
+ * history. Bounded: ±5·10⁻⁴ over the glacial cycles, no secular part.
+ * Without the two constants the ratio is 1 at every year.
  */
-function createAlphaGiaChannel({ l1Terms, yStdDenormalization, relaxationKyr, alphaGiaRateJ2000PerYr, alphaJ2000 }) {
+function createAlphaGiaChannel({ l1Terms, yStdDenormalization, relaxationKyr, alphaGiaRateJ2000PerYr, alphaJ2000, j2RateJ2000PerYr, j2J2000 }) {
   const lagged = laggedL1Terms(l1Terms, relaxationKyr);
   const regime = { l1Terms: lagged, yStdDenormalization };
   // dL'/dyear at J2000 in closed form: with t = (2000 − year)/1000,
@@ -105,8 +123,14 @@ function createAlphaGiaChannel({ l1Terms, yStdDenormalization, relaxationKyr, al
   const slopeJ2000PermillePerYr = (-sum / 1000) * yStdDenormalization;
   const kPerPermille = -alphaGiaRateJ2000PerYr / slopeJ2000PermillePerYr;   // dα/dt = −k · dL'/dt
   const laggedJ2000 = evalClimateL1OrbitalPermil(2000, regime);
+  const hasJ2 = j2RateJ2000PerYr !== undefined && j2J2000 !== undefined;
+  // (k_J / J₂₀) per ‰ — the relative oblateness coupling, from the observed dJ₂/dt
+  const j2RelPerPermille = hasJ2 ? (-j2RateJ2000PerYr / slopeJ2000PermillePerYr) / j2J2000 : 0;
   return {
     alphaAt: (year) => alphaJ2000 - kPerPermille * (evalClimateL1OrbitalPermil(year, regime) - laggedJ2000),
+    j2RatioAt: hasJ2
+      ? (year) => 1 - j2RelPerPermille * (evalClimateL1OrbitalPermil(year, regime) - laggedJ2000)
+      : () => 1,
     laggedL1PermilAt: (year) => evalClimateL1OrbitalPermil(year, regime),
     kPerPermille,
     relaxationKyr,

package/src/constants/generated.d.ts

@@ -2,14 +2,14 @@
 // Gives the TypeScript website full type safety at the boundary (§2g) while
 // packages/physics stays JavaScript.
 
-export declare const CONSTANTS_HASH: "b9c4d78647577e67";
+export declare const CONSTANTS_HASH: "726b10e23d8ace09";
 
 export declare const MODEL_VERSION: string;
 
 export declare const PREPRINT_DOI: string;
 
 export declare const DEFAULT_CONSTANTS: {
-  readonly hash: "b9c4d78647577e67";
+  readonly hash: "726b10e23d8ace09";
   readonly additionalBodies: {
     "pluto": {
       "name": string;
@@ -136,6 +136,7 @@ export declare const DEFAULT_CONSTANTS: {
     "alpha4PerMa4": number;
     "alphaGiaRateJ2000PerYr": number;
     "alphaGiaRelaxationKyr": number;
+    "j2RateJ2000PerYr": number;
     "dtStackTaperFullHalfwidthYr": number;
     "dtStackTaperTotalHalfwidthYr": number;
     "recessionRegime": {

package/src/constants/generated.js

@@ -33,17 +33,17 @@
  * carry it so a counterfactual is reproducible (§2d).
  * @type {string}
  */
-export const CONSTANTS_HASH = "b9c4d78647577e67";
+export const CONSTANTS_HASH = "726b10e23d8ace09";
 
 /** Model version label — single source: public/input/model-version.json (§10 two-axis scheme). */
-export const MODEL_VERSION = "v14.0";
+export const MODEL_VERSION = "v16.0";
 
 /** Canonical preprint DOI — single source: public/input/model-version.json. */
 export const PREPRINT_DOI = "10.21203/rs.3.rs-8758810/v4";
 
 /** @type {Readonly<Record<string, unknown>>} */
 export const DEFAULT_CONSTANTS = Object.freeze({
-  hash: "b9c4d78647577e67",
+  hash: "726b10e23d8ace09",
   additionalBodies: {
     "pluto": {
       "name": "Pluto",
@@ -182,6 +182,7 @@ export const DEFAULT_CONSTANTS = Object.freeze({
     "alpha4PerMa4": 1.3619800519e-16,
     "alphaGiaRateJ2000PerYr": -1.35e-11,
     "alphaGiaRelaxationKyr": 6,
+    "j2RateJ2000PerYr": -2.7e-11,
     "dtStackTaperFullHalfwidthYr": 300000,
     "dtStackTaperTotalHalfwidthYr": 400000,
     "recessionRegime": {

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

@@ -45,6 +45,8 @@
  *   axialPrecessionYearsJ2000: number,
  *   obliquityJ2000Deg: number,
  *   axialPrecessionYearsAtYearFn?: (year: number) => number,
+ *   solarTorqueShareJ2000?: number,
+ *   dynamicalEllipticityRatioAtYearFn?: (year: number) => number,
  * }} deps — mode tables from the governed deep artifact (choose the ζ tier
  *   per consumer: era = its own 8-term extraction, deep = the 16-term
  *   table; NEVER a slice); anchors from the chain artifact's one home; the
@@ -57,13 +59,17 @@
  *   vs La2004 over −200 kyr vs the deep tier's 0.069° — the C-1 verdict,
  *   plan 02) and zetaModes serves only as the TAIL beyond the span (the
  *   seam at the span edge is the extraction residual, far outside every
- *   certified window).
+ *   certified window). solarTorqueShareJ2000 and
+ *   dynamicalEllipticityRatioAtYearFn: THE PRECESSION OF DATE — the two
+ *   factors on the precession constant (see alphaAtGeneral below); absent,
+ *   the constant is the secular law alone, bit-identical.
  */
 function createDeepOrbitalHistory({
   zModes, zetaModes, zetaSeries, zSeries,
   anchorE, anchorPeriEclipticDeg, anchorInclEclipticDeg, anchorAscNodeEclipticDeg,
   axialPrecessionYearsJ2000, obliquityJ2000Deg,
   axialPrecessionYearsAtYearFn,
+  solarTorqueShareJ2000, dynamicalEllipticityRatioAtYearFn,
 }) {
   const D2R = Math.PI / 180, R2D = 180 / Math.PI;
 
@@ -198,10 +204,59 @@ function createDeepOrbitalHistory({
   // dynamical). No new constants: ψ̇(t)'s J2000 anchor is the same
   // certified year-length machinery; only its deep-time scaling is injected. Absent the option, α stays constant (the
   // pre-D1 ±Myr-class behavior, bit-identical).
-  const alphaAtGeneral = axialPrecessionYearsAtYearFn
+  const alphaSecular = axialPrecessionYearsAtYearFn
     ? (/** @type {number} */ t) =>
         ((2 * Math.PI) / axialPrecessionYearsAtYearFn(2000 + t)) / Math.cos(EPS0)
     : () => ALPHA;
+  // THE PRECESSION OF DATE (plan 06 §9 item 10 — owner: "adopt it in the
+  // model"). The secular law above scales the J2000 rate on the tidal history;
+  // the torque of date carries two more factors, both exactly 1 at J2000:
+  //
+  //   SOLAR TORQUE — ∝ (1 − e²)^(−3/2): the Sun's share f_S of the torque is
+  //   the engine's own solar-share formula, which holds e at its J2000 value;
+  //   here it rides the eccentricity OF DATE, the z this factory already
+  //   carries. Measured: the frozen form runs the precession 0.032 % slow on
+  //   the million-year mean (the mean e² sits above today's) — 4.5° of
+  //   equinox at −1 Myr, the obliquity ~100″ rms off La2004 there; with the
+  //   factor it holds 12″ rms over the last Myr (La2004 integrates the same
+  //   eccentricity-dependent torque).
+  //
+  //   DYNAMICAL ELLIPTICITY — ψ̇ ∝ (C − A)/C ∝ J₂: the injected J₂(t)/J₂₀ of
+  //   the engine's GIA channel (climate/l1-orbital j2RatioAt — the ice-age
+  //   mass redistribution the length-of-day side already carries, scaled on
+  //   the observed dJ₂/dt). Bounded ±5·10⁻⁴, no secular part.
+  //
+  // Together they close the millennial equinox: against Vondrák et al. (2011)
+  // the lag was −26.5″ at −2950 and −20.1″ at −2450 (the Sun's whole residual
+  // against Horizons there); with them −6.3″ and −3.7″, ≤ 0.3″ inside
+  // −450…+2500 (banked by tools/verify/equinox-vs-vondrak.js, which refuses
+  // to write if a factor is dropped). Absent both options the constant is
+  // the secular law alone — bit-identical to the pre-adoption factory.
+  const hasOfDate = solarTorqueShareJ2000 !== undefined || dynamicalEllipticityRatioAtYearFn !== undefined;
+  const oneMinusE0Sq = (() => { const [x0, y0] = zAt(0); return 1 - (x0 * x0 + y0 * y0); })();
+  const solarTorqueFactor = solarTorqueShareJ2000 !== undefined
+    ? (/** @type {number} */ t) => {
+        const [zx, zy] = zAt(t);
+        return 1 + solarTorqueShareJ2000 * (Math.pow((1 - (zx * zx + zy * zy)) / oneMinusE0Sq, -1.5) - 1);
+      }
+    : () => 1;
+  const ellipticityFactor = dynamicalEllipticityRatioAtYearFn
+    ? (/** @type {number} */ t) => dynamicalEllipticityRatioAtYearFn(2000 + t)
+    : () => 1;
+  // Two-entry memo on the precession constant of date: RK4 asks k2 and k3 at
+  // the same instant and the next step's k1 repeats this step's k4 — half
+  // the evaluations of the secular law AND of the two factors (measured: the
+  // tier builds cost what they did before the factors), the values
+  // bit-identical (a pure function of t).
+  let memoT0 = NaN, memoV0 = 0, memoT1 = NaN, memoV1 = 0;
+  const alphaOfDate = (/** @type {number} */ t) => {
+    if (t === memoT0) return memoV0;
+    if (t === memoT1) return memoV1;
+    const v = alphaSecular(t) * (solarTorqueFactor(t) * ellipticityFactor(t));
+    memoT1 = memoT0; memoV1 = memoV0; memoT0 = t; memoV0 = v;
+    return v;
+  };
+  const alphaAtGeneral = hasOfDate ? alphaOfDate : alphaSecular;
 
   const cross = (/** @type {number[]} */ a, /** @type {number[]} */ b) =>
     [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
@@ -287,12 +342,46 @@ function createDeepOrbitalHistory({
     return [o[0] / r, o[1] / r, o[2] / r];
   };
 
-  /** Equinox-node longitude only (J2000 ecliptic frame) — the light read
-   *  used for the node-rate finite difference at store time. */
-  function eqLonOnlyDeg(/** @type {number[]} */ s, /** @type {number} */ t) {
+  /** The equinox's GENERAL-PRECESSION longitude (deg, J2000 ecliptic frame):
+   *  the broken angle through the ascending node of the ecliptic of date on
+   *  the J2000 ecliptic — Π (the node's longitude) plus the arc along the
+   *  ecliptic of date from that node to the equinox. This is the p_A of the
+   *  precession literature (Lieske 1977; Simon et al. 1994: p_A = Λ_A − Π_A):
+   *  the quantity the mean longitude OF DATE subtracts from the fixed-frame
+   *  mean longitude — the N-body λ = Ω + ω + M is itself this broken angle
+   *  (lattice-long-window-test.mjs), so the tropical year of date must be
+   *  built on THIS rate. NOT the projected longitude atan2(g_y, g_x)
+   *  (equinoxLonJ2000Deg, which the frame reconstruction needs): the two
+   *  agree at J2000, where the ecliptic of date coincides with the J2000
+   *  ecliptic, and part with the SQUARE of the ecliptic's tilt to its J2000
+   *  position — (i²/4)·sin 2u class: 0.9″ at 0 AD, 5.9″ at −3000,
+   *  arcminutes at deep time; as a rate 0.05 s of tropical year at ±4 kyr,
+   *  0.1–0.2 s at ±10 kyr, ~1 s beyond 100 kyr (measured 2026-09: the scene's
+   *  own sidereal angle read exactly this against the projected-rate law at
+   *  16 epochs, and the re-booked Sun is flat against DE441 in the inertial
+   *  frame over −2500…+2000 where the projected booking ramped to +5.6″).
+   *  Degenerate node as i → 0: the dogleg's two parts compensate each other's
+   *  error, and below 1e-9 the projected form is the exact limit.
+   *  @param {number[]} n the ecliptic pole of date @param {number[]} gu the unit equinox */
+  function generalPrecessionLonDeg(n, gu) {
+    const Nx = -n[1], Ny = n[0];            // ẑ × n̂ — the ascending node of the ecliptic of date
+    const sN = Math.hypot(Nx, Ny);
+    if (sN < 1e-9) return Math.atan2(gu[1], gu[0]) * R2D;
+    const N = [Nx / sN, Ny / sN, 0];
+    const Pi = Math.atan2(N[1], N[0]);
+    const u = Math.atan2(dot(n, cross(N, gu)), dot(N, gu));
+    return (Pi + u) * R2D;
+  }
+
+  /** Equinox-node longitudes only (J2000 ecliptic frame; projected and
+   *  general-precession forms) — the light read used for the node-rate
+   *  finite differences at store time. */
+  function eqLonsOnlyDeg(/** @type {number[]} */ s, /** @type {number} */ t) {
     const n = orbitNormal(t);
     const g = cross(s, n);
-    return Math.atan2(g[1], g[0]) * R2D;
+    const gn = Math.hypot(g[0], g[1], g[2]);
+    const gu = [g[0] / gn, g[1] / gn, g[2] / gn];
+    return { proj: Math.atan2(gu[1], gu[0]) * R2D, general: generalPrecessionLonDeg(n, gu) };
   }
 
   /** One quantity bundle at time t (years from J2000) from spin axis s. */
@@ -328,26 +417,38 @@ function createDeepOrbitalHistory({
       // interpolation on the grid is exact to the ζ series' own resolution.
       orbitNormalX: n[0],
       orbitNormalY: n[1],
-      // The equinox node (ŝ×n̂) longitude in the J2000 ecliptic frame —
-      // its year-over-year retrograde advance IS the general precession of
-      // date, wobble included (the n̂(t) geometry generates the equinox
-      // wobble; ψ̇ itself is the secular α(H(t))). Consumers derive the
-      // tropical year of date from it: T_trop = T_sid·(1 − p_yr/360°).
-      // ⚠ RATE-CONSUMER CONTRACT (measured): this field's rate is correct
+      // The equinox node (ŝ×n̂) PROJECTED longitude in the J2000 ecliptic
+      // frame — the frame reconstruction's input (frame-of-date.cjs rebuilds
+      // the unit equinox from it). Its rate is the general precession only
+      // to first order in the ecliptic's tilt to its J2000 position: the
+      // tropical-year consumers read generalPrecessionLonDeg below (measured
+      // 2026-09 — the projected rate booked the Sun's mean longitude of date
+      // 5.9″ off at −3000 and the sidereal year of date 1 s off at depth).
+      // ⚠ RATE-CONSUMER CONTRACT (measured): these fields' rates are correct
       // AS IS — α is self-anchored to the LUNISOLAR rate at construction
       // (K_LUNI, the one-RK4-step probe above), so the realized general
-      // precession p_geom(J2000) equals 360/axialPrecessionYearsJ2000 by
-      // construction. No correction, no δ subtraction. History (why this
-      // contract exists): before the self-anchor, α carried the GENERAL
-      // sid/(sid−sol) rate and the n̂(t) geometry re-added the planetary
-      // mean — a double-count of +0.097″/yr ≈ +2.4 s of tropical year at
-      // J2000 — and consumers had to subtract the runtime anchor
+      // precession p_geom(J2000) equals 360/axialPrecessionYearsJ2000 per
+      // JULIAN year (the sampler's time unit) by construction. No
+      // correction, no δ subtraction. History (why this contract exists):
+      // before the self-anchor, α carried the GENERAL sid/(sid−sol) rate and
+      // the n̂(t) geometry re-added the planetary mean — a double-count of
+      // +0.097″/yr ≈ +2.4 s of tropical year at J2000 — and consumers had to
+      // subtract the runtime anchor
       //   δ = p_geom(J2000) − 360/axialPrecessionYearsJ2000.
       // A consumer may still measure δ at runtime as a SELF-CHECK; it
       // must read ≈0 (sub-1e-4 ″/yr class). The LONGITUDE itself is raw
       // geometry and has always needed no correction.
       equinoxLonJ2000Deg: ((Math.atan2(gu[1], gu[0]) * R2D) % 360 + 360) % 360,
       equinoxLonRateDegPerYr: 0,   // filled at store time (build's ±2.5-yr central difference)
+      // The equinox's GENERAL-PRECESSION longitude (the broken angle through
+      // the node of the ecliptic of date — the literature's p_A; see
+      // generalPrecessionLonDeg above): its year-over-year retrograde advance
+      // IS the general precession of date, wobble included (the n̂(t)
+      // geometry generates the equinox wobble; ψ̇ itself is the secular
+      // α(H(t)) times the two factors of date). The tropical year of date is
+      // built on this rate (earth/year-lengths.cjs).
+      generalPrecessionLonDeg: ((generalPrecessionLonDeg(n, gu) % 360) + 360) % 360,
+      generalPrecessionLonRateDegPerYr: 0,   // filled at store time (build's ±2.5-yr central difference)
     };
   }
 
@@ -390,9 +491,10 @@ function createDeepOrbitalHistory({
       const storeWithRate = (/** @type {number} */ key, /** @type {number[]} */ sv, /** @type {number} */ tv) => {
         const smp = sampleAt(sv, tv);
         const hR = 2.5;
-        const lp = eqLonOnlyDeg(rk4(sv, tv, +hR), tv + hR);
-        const lm = eqLonOnlyDeg(rk4(sv, tv, -hR), tv - hR);
-        smp.equinoxLonRateDegPerYr = (((lp - lm + 540) % 360) - 180) / (2 * hR);
+        const lp = eqLonsOnlyDeg(rk4(sv, tv, +hR), tv + hR);
+        const lm = eqLonsOnlyDeg(rk4(sv, tv, -hR), tv - hR);
+        smp.equinoxLonRateDegPerYr = (((lp.proj - lm.proj + 540) % 360) - 180) / (2 * hR);
+        smp.generalPrecessionLonRateDegPerYr = (((lp.general - lm.general + 540) % 360) - 180) / (2 * hR);
         grid.set(key, smp);
       };
       storeWithRate(0, s, 0);
@@ -421,6 +523,19 @@ function createDeepOrbitalHistory({
         const f = (tYr - k0) / stepYr;
         const lerp = (/** @type {number} */ x, /** @type {number} */ y) => x + (y - x) * f;
         const dAng = (/** @type {number} */ x, /** @type {number} */ y) => x + (((y - x + 540) % 360) - 180) * f;
+        // C1 (cubic Hermite) on a wrapped angle with node rates (deg/yr) —
+        // linear interpolation here made the realized equinox RATE
+        // piecewise-constant per grid cell (the measured per-year
+        // precession staircase). Node rates come from the build's own
+        // ±2.5-yr central differences.
+        const hermiteAngle = (/** @type {number} */ l0, /** @type {number} */ l1, /** @type {number} */ r0, /** @type {number} */ r1) => {
+          const dl = ((l1 - l0 + 540) % 360) - 180;   // unwrapped segment
+          const m0 = r0 * stepYr, m1 = r1 * stepYr;
+          const f2 = f * f, f3 = f2 * f;
+          const v = (2 * f3 - 3 * f2 + 1) * l0 + (f3 - 2 * f2 + f) * m0
+            + (-2 * f3 + 3 * f2) * (l0 + dl) + (f3 - f2) * m1;
+          return ((v % 360) + 360) % 360;
+        };
         return {
           epsDeg: lerp(a.epsDeg, b.epsDeg),
           e: lerp(a.e, b.e),
@@ -430,21 +545,12 @@ function createDeepOrbitalHistory({
           inclEclDeg: lerp(a.inclEclDeg, b.inclEclDeg),
           orbitNormalX: lerp(a.orbitNormalX, b.orbitNormalX),
           orbitNormalY: lerp(a.orbitNormalY, b.orbitNormalY),
-          // C1 (cubic Hermite) — linear interpolation here made the
-          // realized equinox RATE piecewise-constant per grid cell (the
-          // measured per-year precession staircase). Node rates come from
-          // the build's own ±2.5-yr central differences.
-          equinoxLonJ2000Deg: (() => {
-            const l0 = a.equinoxLonJ2000Deg;
-            const dl = ((b.equinoxLonJ2000Deg - l0 + 540) % 360) - 180;   // unwrapped segment
-            const m0 = a.equinoxLonRateDegPerYr * stepYr;
-            const m1 = (b.equinoxLonRateDegPerYr ?? a.equinoxLonRateDegPerYr) * stepYr;
-            const f2 = f * f, f3 = f2 * f;
-            const v = (2 * f3 - 3 * f2 + 1) * l0 + (f3 - 2 * f2 + f) * m0
-              + (-2 * f3 + 3 * f2) * (l0 + dl) + (f3 - f2) * m1;
-            return ((v % 360) + 360) % 360;
-          })(),
+          equinoxLonJ2000Deg: hermiteAngle(a.equinoxLonJ2000Deg, b.equinoxLonJ2000Deg, a.equinoxLonRateDegPerYr, b.equinoxLonRateDegPerYr ?? a.equinoxLonRateDegPerYr),
           equinoxLonRateDegPerYr: lerp(a.equinoxLonRateDegPerYr, b.equinoxLonRateDegPerYr ?? a.equinoxLonRateDegPerYr),
+          // the same C1 form for the general-precession longitude (its
+          // year-over-year difference is the tropical-year law's p).
+          generalPrecessionLonDeg: hermiteAngle(a.generalPrecessionLonDeg, b.generalPrecessionLonDeg, a.generalPrecessionLonRateDegPerYr, b.generalPrecessionLonRateDegPerYr ?? a.generalPrecessionLonRateDegPerYr),
+          generalPrecessionLonRateDegPerYr: lerp(a.generalPrecessionLonRateDegPerYr, b.generalPrecessionLonRateDegPerYr ?? a.generalPrecessionLonRateDegPerYr),
         };
       },
     };
@@ -456,6 +562,12 @@ function createDeepOrbitalHistory({
     // D4e diagnostics: the self-anchored lunisolar rate actually integrated.
     alphaLunisolarArcsecPerYr: ALPHA * K_LUNI * R2D * 3600,
     axialPrecessionYearsLunisolarJ2000: axialPrecessionYearsJ2000 / K_LUNI,
+    /** THE PRECESSION OF DATE — the two factors this integration applies to
+     *  the secular precession constant at t years from J2000 (both 1 at
+     *  t = 0; both 1 everywhere when the options are absent). ONE home for
+     *  the published surface and the docs.
+     *  @param {number} t @returns {{solarTorque: number, ellipticity: number}} */
+    precessionOfDateFactorsAt: (t) => ({ solarTorque: solarTorqueFactor(t), ellipticity: ellipticityFactor(t) }),
   };
 }