@essrt/physics 20.0.1 → 22.0.0

package/types/phase/deep-calendar.d.cts

@@ -1,15 +1,3 @@
-export type PhaseMachinery = {
-    ensureTable: () => void;
-    cumulAtYear: (year: number) => (number | null);
-    yearAtCumul: (targetCumul: number) => (number | null);
-    grid: () => {
-        yearMin: number;
-        yearMax: number;
-        stepYears: number;
-        j2000Idx: number;
-        length: number;
-    };
-};
 export type DeepCalendar = {
     /**
      * SI-tropical-year label for a
@@ -23,10 +11,6 @@ export type DeepCalendar = {
      * the exact inverse of jdToSIyear.
      */
     siYearToJD: (ySI: number) => number;
-    /**
-     *   inverse of the phase machinery's cumulAtYear — null outside the table.
-     */
-    yearAtCumulIntegral: (targetCumul: number) => (number | null);
     /**
      * builds the ∫ daysPerYear dt table
      * (idempotent; under the lattice α).
@@ -39,24 +23,12 @@ export type DeepCalendar = {
      * year = startModelYear.
      */
     yearToJD: (year: number) => (number | null);
-    /**
-     *   calendar year of the k-th H-balanced event, k = 0 being `balancedYear`;
-     *   negative k = past; null outside the table domain.
-     */
-    balancedYearAtCycle: (cycleOffset: number) => (number | null);
     /**
      * diagnostic — the
      * table length once built, null before.
      */
     cumulDaysTableLength: () => (number | null);
 };
-/**
- * @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
@@ -65,51 +37,43 @@ export type DeepCalendar = {
  *   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}
  */
-export function createDeepCalendar({ phase, meanYearInDaysAtAgeMa, withLatticeAlpha, startModelJD, startModelYear, startModelYearWithCorrection, siTropicalYearDays, balancedYear, hJ2000, cyclesBetween, }: {
-    phase: () => PhaseMachinery;
+export function createDeepCalendar({ meanYearInDaysAtAgeMa, withLatticeAlpha, startModelJD, startModelYear, startModelYearWithCorrection, siTropicalYearDays, yearMin, yearMax, stepYears, }: {
     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);
+    yearMin?: number;
+    yearMax?: number;
+    stepYears?: number;
 }): DeepCalendar;

package/types/planets/display-names.d.cts

@@ -0,0 +1,2 @@
+/** @type {Readonly<Record<string, string>>} */
+export const PLANET_DISPLAY_NAMES: Readonly<Record<string, string>>;

package/types/planets/geometry.d.cts

@@ -1,7 +1,7 @@
 export type PlanetGeometryBody = {
     key: string;
-    type?: string;
-    solarYearInput: number;
+    periodDays: number;
+    semiMajorAxisAu?: number;
     orbitalEccentricityBase?: number;
     longitudePerihelion?: number;
     ascendingNode?: number;
@@ -11,8 +11,8 @@ export type PlanetGeometryBody = {
 /**
  * @typedef {{
  *   key: string,
- *   type?: string,
- *   solarYearInput: number,
+ *   periodDays: number,
+ *   semiMajorAxisAu?: number,
  *   orbitalEccentricityBase?: number,
  *   longitudePerihelion?: number,
  *   ascendingNode?: number,
@@ -21,35 +21,35 @@ export type PlanetGeometryBody = {
  * }} PlanetGeometryBody
  */
 /**
- * @param {PlanetGeometryBody} body
+ * @param {PlanetGeometryBody} body — `periodDays` the body's sidereal orbital
+ *   period in SI days; `semiMajorAxisAu` the chain's J2000 a where a chain
+ *   exists (else Kepler's a from the period, in the scene's solar-year units)
  * @param {{
- *   holisticYears: number,
  *   meanSolarYearDays: number,
  *   currentAUDistanceKm: number,
  *   earthEccentricityJ2000: number,
  *   earthPerihelionLongitudeJ2000Deg: number,
- * }} env — the engine's J2000 values (browser passes its live globals at
- *   load time, preserving its original initial-derivation semantics; the
- *   epoch machinery that later mutates the browser's `let` aliases is
- *   untouched by this layer).
+ * }} env — the engine's J2000 values; `meanSolarYearDays` is the scene's
+ *   year unit (`pos` counts mean solar years), so `periodYears` is the period
+ *   in that unit, the scaffold's `speed` = 2π/periodYears.
  * @returns {{
- *   solarYearCount: number, orbitDistance: number, periodYears: number,
+ *   orbitDistance: number, periodYears: number, periodDays: number,
  *   realOrbitalEccentricity: (number | undefined),
  *   elipticOrbit: (number | undefined), perihelionDistance: (number | undefined),
  *   speedKmh: number, rotationPeriodHours: (number | undefined),
  *   eccentricityPerihelion: (number | undefined), lowestPoint: (number | undefined),
+ *   ellipseFamily: (string | undefined),
  * }}
  */
 export function derivePlanetGeometry(body: PlanetGeometryBody, env: {
-    holisticYears: number;
     meanSolarYearDays: number;
     currentAUDistanceKm: number;
     earthEccentricityJ2000: number;
     earthPerihelionLongitudeJ2000Deg: number;
 }): {
-    solarYearCount: number;
     orbitDistance: number;
     periodYears: number;
+    periodDays: number;
     realOrbitalEccentricity: (number | undefined);
     elipticOrbit: (number | undefined);
     perihelionDistance: (number | undefined);
@@ -57,4 +57,27 @@ export function derivePlanetGeometry(body: PlanetGeometryBody, env: {
     rotationPeriodHours: (number | undefined);
     eccentricityPerihelion: (number | undefined);
     lowestPoint: (number | undefined);
+    ellipseFamily: (string | undefined);
 };
+/**
+ * The scaffold's orbit inputs for one body — ONE home for the rule (plan 09
+ * step 7b): where the governed engine-D chain artifact has the body, the
+ * chain's J2000 semi-major axis and its fitted era-window mean motion (deg
+ * per Julian year → the period in SI days); otherwise the body's observed
+ * period input (the no-chain bodies Pluto, Halley, Eros, Ceres).
+ * @param {string} key
+ * @param {any} chainArtifact the CHAIN_ARTIFACT (or the governed JSON it embeds)
+ * @param {number} fallbackPeriodDays the observed period input, SI days
+ * @returns {{ periodDays: number, semiMajorAxisAu: (number | undefined) }}
+ */
+export function scaffoldOrbitInputs(key: string, chainArtifact: any, fallbackPeriodDays: number): {
+    periodDays: number;
+    semiMajorAxisAu: (number | undefined);
+};
+/**
+ * Each body's scaffold ellipse family (the survey's measured taxonomy above).
+ * Pluto, Halley and Ceres take their body-name branches; a key absent here
+ * has no ellipse family (geometry-only).
+ * @type {Readonly<Record<string, string>>}
+ */
+export const SCAFFOLD_ELLIPSE_FAMILY: Readonly<Record<string, string>>;

package/types/planets/model.d.cts

@@ -1,8 +1,7 @@
 export type PlanetModelBody = {
     /**
-     * - geometry type branch ('I' | 'II' | 'III')
+     * - the observed sidereal period input, SI days (the scaffold period of the no-chain bodies; the chain planets ride the artifact's elements)
      */
-    type?: string | undefined;
     solarYearInput: number;
     invPlaneInclinationJ2000?: number | undefined;
     longitudePerihelion?: number | undefined;
@@ -26,7 +25,10 @@ export type PlanetModelBody = {
     orbitDistanceOverride?: number | undefined;
 };
 export type PlanetModelEnv = {
-    holisticYears: number;
+    /**
+     * - the governed engine-D chain artifact (CHAIN_ARTIFACT): the seven chain planets' scaffold a and period ride its J2000 elements (plan 09 step 7b)
+     */
+    chainArtifact?: any;
     meanSolarYearDays: number;
     balancedYear: number;
     systemResetN: number;
@@ -41,8 +43,7 @@ export type PlanetModelRecord = {
 };
 /**
  * @typedef {Object} PlanetModelBody
- * @property {string} [type] - geometry type branch ('I' | 'II' | 'III')
- * @property {number} solarYearInput
+ * @property {number} solarYearInput - the observed sidereal period input, SI days (the scaffold period of the no-chain bodies; the chain planets ride the artifact's elements)
  * @property {number} [invPlaneInclinationJ2000]
  * @property {number} [longitudePerihelion]
  * @property {number} [wobblePeriodYears] - carriers: the chain's g-mode beat (input since Phase 7 commit 2)
@@ -57,7 +58,7 @@ export type PlanetModelRecord = {
  */
 /**
  * @typedef {Object} PlanetModelEnv
- * @property {number} holisticYears
+ * @property {any} [chainArtifact] - the governed engine-D chain artifact (CHAIN_ARTIFACT): the seven chain planets' scaffold a and period ride its J2000 elements (plan 09 step 7b)
  * @property {number} meanSolarYearDays
  * @property {number} balancedYear
  * @property {number} systemResetN

package/types/planets/spin-channel.d.cts

@@ -99,6 +99,8 @@ export function createPlanetSpinChannel(deps: {
         meanDeg: number;
         maxDeg: number;
     } | null;
+    spinAxisEclipticJ2000AtYear: (year: number) => number[] | null;
+    orbitNormalEclipticJ2000AtYear: (year: number) => number[];
     stepYr: number;
     maxSpanYr: 10000000;
 }>;
@@ -152,6 +154,8 @@ export function createPlanetSpinChannelFromArtifacts(deps: {
         meanDeg: number;
         maxDeg: number;
     } | null;
+    spinAxisEclipticJ2000AtYear: (year: number) => number[] | null;
+    orbitNormalEclipticJ2000AtYear: (year: number) => number[];
     stepYr: number;
     maxSpanYr: 10000000;
 }>;

package/src/cardinal/index.cjs

@@ -1,324 +0,0 @@
-/**
- * Cardinal-point model — THE shared implementation (Phase 7.2).
- *
- * The §10 derived form and everything on it, extracted verbatim from
- * tools/lib/orbital-engine.js (which the browser mirrored function-for-
- * function — this file replaces both copies):
- *
- *   JD_X(Y)  = anchor_X + ΣT_trop(Y) + δ_X(Y) − δ_X(2000)
- *   ΣT_trop  = lincoef·(Y−2000) + driftTerm(Y) + Ih(Y)
- *   δ_X      = sinusoids + equation-of-centre orders (e(t)ⁿ·sin(nM), e(t)
- *              the LAW OF COSINES) + §10g quadrature-locked joint sidebands
- *   T_X(Y)   = the EXACT term-by-term derivative of JD_X
- *
- * LOAD-BEARING, do not "improve":
- *  - lincoef/h0/h1 come from the fit and are used VERBATIM — recomputing
- *    lincoef from the 1-year anchor injects a −12,276 s ramp; holding H
- *    constant inside Ih costs up to 5.2 s (§10c/§10e-quinquies).
- *  - The drift term is Simpson on 2000-yr NODE SPACING (not a fixed node
- *    count: that was exact in-window and −33,758 s at −380 Ma) plus the
- *    Euler–Maclaurin endpoint term (omitting it costs 6–13 s).
- *  - The equation-of-centre terms are {order,sin,cos}, NOT sinusoids — read
- *    as H/16+H/32 harmonics they are wrong by the whole ~1.78 d braid.
- *  - §10g joint sidebands are SHARED across the four points with phase
- *    order·λ_X − 2π·div·c — COUNTER-rotating. The minus sign is load-bearing:
- *    the co-rotating sense captures NOTHING (measured — the sign experiment,
- *    doc 99 "the braid law").
- *  - The year-length derivative keeps ONE deliberate divergence from the
- *    exact derivative: its drift part uses the real-LOD convention
- *    (`meanYearRealLodDays`) — the tweakpane's epoch-local days ("~400 days
- *    at the Devonian") — where the JD form integrates the SI form. Equal at
- *    J2000 up to the known 118 ms fit-basis gap.
- *
- * The `cyclesBetween` the caller injects is the ENGINE'S OWN function, so
- * each engine's deep-time/snapshot toggle semantics are preserved exactly;
- * under deep time both engines now route it through @essrt/physics/phase.
- */
-
-'use strict';
-
-/** @type {Record<string, number>} */
-const JOINT_LAMBDA = { SS: 0, AE: Math.PI / 2, WS: Math.PI, VE: 1.5 * Math.PI };
-
-const DRIFT_NODE_SPACING_YEARS = 2000;
-const DRIFT_SIMPSON_N_MIN = 64;
-
-/** @typedef {{ lincoef: number, h0: number, h1: number }} DerivedCoefs */
-/** @typedef {{ order: number, sin: number, cos: number }} EccTerm */
-/** @typedef {{ order: number, div: number, sin: number, cos: number }} JointTerm */
-
-/**
- * @param {{
- *   isDeepTime: () => boolean,
- *   constants: {
- *     anchors: Record<string, number>,
- *     harmonics: Record<string, Array<[number, number, number]>>,
- *     eccTerms: (Record<string, EccTerm[]> | null),
- *     jointTerms: ({ terms: JointTerm[] } | null),
- *     derived: (DerivedCoefs | null),
- *     tropicalHarmonics: Array<[number, number, number]>,
- *     balancedYear: number,
- *     meanSolarYearDays: number,
- *     hJ2000: number,
- *     tiltMeanDeg: number,
- *     raAngleDeg: number,
- *     inclAmplitudeDeg: number,
- *   },
- *   fns: {
- *     cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null),
- *     analyticTropicalDays: (year: number) => (number | null),
- *     meanHAtAgeMa: (tMa: number) => (number | null),
- *     meanYearRealLodDays: (tMa: number) => (number | null),
- *     eccentricityAt: (year: number) => number,
- *     eccentricityRateAt: (year: number) => number,
- *   },
- * }} deps
- */
-function createCardinalModel({ isDeepTime, constants, fns }) {
-  const {
-    anchors,               // { SS, WS, VE, AE } — J2000 event JDs
-    harmonics,             // { type: [[div, sin, cos], …] } — δ sinusoids
-    eccTerms,              // { type: [{order, sin, cos}, …] } | null
-    jointTerms,            // { terms: [{order, div, sin, cos}, …] } | null
-    derived,               // { lincoef, h0, h1 } — fit-calibrated, VERBATIM
-    tropicalHarmonics,     // TROPICAL_YEAR_HARMONICS [[div, sin, cos], …]
-    balancedYear,
-    meanSolarYearDays,
-    hJ2000,
-    tiltMeanDeg,           // for RA
-    raAngleDeg,
-    inclAmplitudeDeg,
-  } = constants;
-  const {
-    cyclesBetween,         // (yearA, yearB, divisorN) => cycles | null
-    analyticTropicalDays,  // (year) => SI days | null — the drift integrand base
-    meanHAtAgeMa,          // (t_Ma) => H | null — the derivative's dc/dY
-    meanYearRealLodDays,   // (t_Ma) => days | null — real-LOD drift convention
-    eccentricityAt,        // (year) => e(t) — the model's ONE eccentricity law (H/3 vector sum, plan IP-eccentricity-unification)
-    eccentricityRateAt,    // (year) => de/dyear of the same law — the braid's EoC derivative rides it
-  } = fns;
-
-  /** @param {number} year */
-  const cycleOf = (year) => {
-    const c = cyclesBetween(balancedYear, year, 1);
-    return c === null ? 0 : c;
-  };
-
-  /** @param {number} year */
-  const driftIntegrand = (year) => {
-    const a = analyticTropicalDays(year);
-    return a === null ? 0 : (a - meanSolarYearDays);
-  };
-
-  /** @param {number} year */
-  function driftTerm(year) {
-    const span = year - 2000;
-    if (span === 0) return 0;
-    let n = Math.ceil(Math.abs(span) / DRIFT_NODE_SPACING_YEARS);
-    if (n % 2) n++;
-    if (n < DRIFT_SIMPSON_N_MIN) n = DRIFT_SIMPSON_N_MIN;
-    const h = span / n;
-    const f0 = driftIntegrand(2000), fN = driftIntegrand(year);
-    let acc = f0 + fN;
-    for (let i = 1; i < n; i++) acc += driftIntegrand(2000 + i * h) * ((i % 2) ? 4 : 2);
-    return acc * h / 3 - (fN - f0) / 2;
-  }
-
-  /** Step 6d's self-corrected tropical harmonic series, as a length deviation.
-   *  @param {number} year */
-  function tropHarmonicsAt(year) {
-    const c = cycleOf(year), c0 = cycleOf(2000);
-    let s = 0;
-    for (const [div, sinC, cosC] of tropicalHarmonics) {
-      const th = 2 * Math.PI * div * c, th0 = 2 * Math.PI * div * c0;
-      s += sinC * (Math.sin(th) - Math.sin(th0)) + cosC * (Math.cos(th) - Math.cos(th0));
-    }
-    return s;
-  }
-
-  // Ih(Y) = Σ_{2000→Y} of the tropical harmonics, closed form. H stays INSIDE
-  // the integral (h0 + h1·c) — it moves 27.5 yr across the window and
-  // multiplies the amplitude. Deep-time only, so `derived` is present here.
-  /** @param {number} year */
-  function integratedTropHarmonics(year) {
-    const D = /** @type {DerivedCoefs} */ (derived);
-    const cY = cycleOf(year), c0 = cycleOf(2000);
-    let tot = 0, k0 = 0;
-    for (const [div, sinC, cosC] of tropicalHarmonics) {
-      const k = 2 * Math.PI * div;
-      /** @param {number} c */
-      const F = (c) => {
-        const sn = Math.sin(k * c), cs = Math.cos(k * c), Hc = D.h0 + D.h1 * c;
-        return [-Hc * cs / k + D.h1 * sn / (k * k), Hc * sn / k + D.h1 * cs / (k * k)];
-      };
-      const a = F(c0), b = F(cY);
-      tot += sinC * (b[0] - a[0]) + cosC * (b[1] - a[1]);
-      k0 += sinC * Math.sin(k * c0) + cosC * Math.cos(k * c0);
-    }
-    return tot - k0 * (year - 2000)
-         - (tropHarmonicsAt(year) - tropHarmonicsAt(2000)) / 2;
-  }
-
-  /** @param {number} year */
-  function sigmaTropical(year) {
-    const D = /** @type {DerivedCoefs} */ (derived);
-    return D.lincoef * (year - 2000) + driftTerm(year) + integratedTropHarmonics(year);
-  }
-
-  // δ_X(2000) — the self-correction that pins JD(2000) to the anchor exactly
-  // (sinusoids + ecc orders; the §10g joint terms self-correct inline).
-  // Computed lazily so the phase table builds on the caller's schedule.
-  /** @type {Record<string, number> | null} */
-  let _selfCorr = null;
-  function selfCorr() {
-    if (_selfCorr !== null) return _selfCorr;
-    _selfCorr = {};
-    const c2000 = cycleOf(2000);
-    for (const type of ['SS', 'WS', 'VE', 'AE']) {
-      let h2000 = 0;
-      for (const [div, sinC, cosC] of harmonics[type]) {
-        const th0 = 2 * Math.PI * div * c2000;
-        h2000 += sinC * Math.sin(th0) + cosC * Math.cos(th0);
-      }
-      const ecc = eccTerms && eccTerms[type];
-      if (ecc) {
-        const e0 = eccentricityAt(2000);
-        const th0 = 2 * Math.PI * 16 * c2000;
-        for (const t of ecc) {
-          const eN0 = Math.pow(e0, t.order);
-          h2000 += t.sin * eN0 * Math.sin(t.order * th0) + t.cos * eN0 * Math.cos(t.order * th0);
-        }
-      }
-      _selfCorr[type] = h2000;
-    }
-    return _selfCorr;
-  }
-
-  /** @param {number} year @param {string} [type] */
-  function computeSolsticeJD(year, type) {
-    const cp = type || 'SS';
-    const anchor = anchors[cp];
-    const deep = isDeepTime();
-
-    let jd = deep
-      ? anchor + sigmaTropical(year)
-      : anchor + meanSolarYearDays * (year - 2000);
-
-    const cY = cycleOf(year);
-    for (const [div, sinC, cosC] of harmonics[cp]) {
-      jd += sinC * Math.sin(2 * Math.PI * div * cY) + cosC * Math.cos(2 * Math.PI * div * cY);
-    }
-    const ecc = eccTerms && eccTerms[cp];
-    if (ecc) {
-      const e = eccentricityAt(year);
-      const th = 2 * Math.PI * 16 * cY;
-      for (const t of ecc) {
-        const eN = Math.pow(e, t.order);
-        jd += t.sin * eN * Math.sin(t.order * th) + t.cos * eN * Math.cos(t.order * th);
-      }
-    }
-    if (jointTerms) {
-      const lam = JOINT_LAMBDA[cp];
-      const c2000 = cycleOf(2000);
-      for (const t of jointTerms.terms) {
-        const th  = t.order * lam - 2 * Math.PI * t.div * cY;
-        const th0 = t.order * lam - 2 * Math.PI * t.div * c2000;
-        jd += t.sin * (Math.sin(th) - Math.sin(th0)) + t.cos * (Math.cos(th) - Math.cos(th0));
-      }
-    }
-    jd -= selfCorr()[cp];
-    return jd;
-  }
-
-  /** The EXACT term-by-term derivative of computeSolsticeJD — except the
-   *  drift part, which deliberately stays in the real-LOD convention (see
-   *  the file header). Neglected: the drift Euler–Maclaurin half-sample
-   *  term's own derivative (f′/2, sub-µs).
-   *  @param {number} year @param {string} [type] */
-  function computeSolsticeYearLength(year, type) {
-    const cp = type || 'SS';
-    const deep = isDeepTime();
-    const t_Ma = (2000 - year) / 1e6;
-
-    const H_at = deep ? (meanHAtAgeMa(t_Ma) ?? hJ2000) : hJ2000;
-    const dcdY = 1 / H_at;
-    const cY = cycleOf(year);
-
-    let length;
-    if (deep && derived) {
-      length = derived.lincoef;
-      const mSY_at = meanYearRealLodDays(t_Ma);
-      if (mSY_at !== null) length += (mSY_at - meanSolarYearDays);
-      length += tropHarmonicsAt(year);
-      let dTrop = 0;
-      for (const [div, sinC, cosC] of tropicalHarmonics) {
-        const k = 2 * Math.PI * div, th = k * cY;
-        dTrop += k * dcdY * (sinC * Math.cos(th) - cosC * Math.sin(th));
-      }
-      length -= dTrop / 2;
-    } else {
-      length = meanSolarYearDays;
-    }
-
-    for (const [div, sinC, cosC] of harmonics[cp]) {
-      const k = 2 * Math.PI * div, th = k * cY;
-      length += k * dcdY * (sinC * Math.cos(th) - cosC * Math.sin(th));
-    }
-
-    const ecc = eccTerms && eccTerms[cp];
-    if (ecc) {
-      const th16 = 2 * Math.PI * 16 * cY;
-      const thp = 2 * Math.PI * 16 * dcdY;
-      const e = eccentricityAt(year);
-      // de/dyear from the one law (formerly the H/16 law-of-cosines derivative).
-      // The braid's own phase θ16 stays: it is the perihelion-OF-DATE phase the
-      // equation of centre is seen through — an H/16 quantity by nature.
-      const de = eccentricityRateAt(year);
-      for (const t of ecc) {
-        const n = t.order, nth = n * th16;
-        const eN = Math.pow(e, n), eN1 = Math.pow(e, n - 1);
-        length += t.sin * (n * eN1 * de * Math.sin(nth) + eN * n * thp * Math.cos(nth))
-                + t.cos * (n * eN1 * de * Math.cos(nth) - eN * n * thp * Math.sin(nth));
-      }
-    }
-
-    if (jointTerms) {
-      const lam = JOINT_LAMBDA[cp];
-      for (const t of jointTerms.terms) {
-        const k = 2 * Math.PI * t.div;
-        const th = t.order * lam - k * cY;
-        length += k * dcdY * (-t.sin * Math.cos(th) + t.cos * Math.sin(th));
-      }
-    }
-    return length;
-  }
-
-  /** RA where a cardinal point occurs — fully derived, zero fitted constants.
-   *  INTEGRATED phase: the formula describes where the SCENE puts the point,
-   *  and the scene's H/3 and H/8 objects rotate on integrated phase.
-   *  @param {number} year @param {string} [type] */
-  function computeSolsticeRA(year, type) {
-    const sinE = Math.sin(tiltMeanDeg * Math.PI / 180);
-    const baseRA = /** @type {Record<string, number>} */ ({ SS: 90, WS: 270, VE: 0, AE: 180 })[type || 'SS'];
-    const raMean = baseRA - raAngleDeg / sinE;
-    const amp = inclAmplitudeDeg / sinE;
-    const cY = cycleOf(year);
-    const phase3 = 2 * Math.PI * 3 * cY;
-    const phase8 = 2 * Math.PI * 8 * cY;
-    return raMean + amp * (-Math.sin(phase3) + Math.sin(phase8));
-  }
-
-  /** Tropical year as the mean of the four cardinal intervals — the
-   *  physically correct definition (Σδ_X ≡ 0 makes the braid cancel).
-   *  @param {number} year */
-  function computeTropicalYearLength(year) {
-    return (computeSolsticeYearLength(year, 'SS') +
-            computeSolsticeYearLength(year, 'WS') +
-            computeSolsticeYearLength(year, 'VE') +
-            computeSolsticeYearLength(year, 'AE')) / 4;
-  }
-
-  return { computeSolsticeJD, computeSolsticeYearLength, computeSolsticeRA, computeTropicalYearLength };
-}
-
-module.exports = { createCardinalModel, JOINT_LAMBDA };