@essrt/physics 20.0.1 → 21.0.0

package/src/planets/ecc-channel.cjs

@@ -1,59 +0,0 @@
-/**
- * Planet eccentricity channel — THE shared implementation (Phase 8.3, L3).
- * The law-of-cosines oscillation every body's runtime eccentricity rides
- * (Earth on H/16, each planet on its OWN wobble period — S-P1):
- *
- *   e(t) = √(base² + amp² − 2·base·amp·cos θ),  θ = 2π·N·∫1/H dt
- *
- * — the distance between two circular orbits (body orbits the wobble
- * centre at radius amp; the centre orbits the Sun at radius base).
- *
- * Extracted from src/script.js computeEccentricityEarth (the browser's
- * 5-arg generic form) and tools/lib/orbital-engine.js computeEccentricity
- * (identical law; R6 aligned its phase to integrated). The structural twin
- * of moon/ecc-channel — but a DIFFERENT law (H/16 orbit law vs the Moon
- * channel's H/3 line; doc 66 keeps the two deliberately distinct).
- *
- * Engine null/toggle semantics stay ENGINE-SIDE, deliberately:
- *  - the browser's cyclesBetween carries its DEEP_TIME_MODE toggle and maps
- *    null (past tidal lock) → the MEAN eccentricity;
- *  - the Node engine pre-computes its snapshot cycles and keeps them when
- *    the integrated phase is null (its documented R6 flag polarity).
- * Both call the same law; the dispatch difference is recorded here so
- * nobody "unifies" it without measuring.
- */
-
-'use strict';
-
-/**
- * The law of cosines over resolved cycles. null cycles → the MEAN
- * eccentricity √(base² + amp²) (past the tidal-lock asymptote).
- * @param {number | null} cycles @param {number} base @param {number} amplitude
- * @returns {number} */
-function eccentricityFromCycles(cycles, base, amplitude) {
-  if (cycles === null) {
-    return Math.sqrt(base * base + amplitude * amplitude);
-  }
-  const phase = cycles * 2 * Math.PI;
-  return Math.sqrt(
-    base * base + amplitude * amplitude - 2 * base * amplitude * Math.cos(phase)
-  );
-}
-
-/**
- * Browser-convention evaluator: J2000-FIXED anchor + cycle length, divisor
- * N = H_J2000/cycleLength, integrated phase via the injected engine
- * cyclesBetween (toggle semantics ride along), null → mean.
- * @param {number} currentYear @param {number} anchorYearJ2000
- * @param {number} cycleLengthYearsJ2000 @param {number} base
- * @param {number} amplitude
- * @param {{ holisticYearJ2000: number,
- *   cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null) }} env
- * @returns {number} */
-function computeEccentricityIntegrated(currentYear, anchorYearJ2000, cycleLengthYearsJ2000, base, amplitude, env) {
-  const divisorN = env.holisticYearJ2000 / cycleLengthYearsJ2000;
-  const cycles = env.cyclesBetween(anchorYearJ2000, currentYear, divisorN);
-  return eccentricityFromCycles(cycles, base, amplitude);
-}
-
-module.exports = { eccentricityFromCycles, computeEccentricityIntegrated };

package/src/sun/longitude-correction.cjs

@@ -1,68 +0,0 @@
-/**
- * Sun longitude correction — the fitted H-lattice harmonic stack
- * (Phase 9, S-P8). THE shared evaluator behind what were THREE verbatim
- * copies: the browser's sunLongitudeCorrection and two inline blocks in
- * tools/lib/scene-graph (moveModel and the fast animator).
- *
- * The ~200″→~7″ RMS Sun-only correction (Phase Z-B): a fitted harmonic
- * table on H-lattice divisors, with the H-LATTICE FILTER applied at
- * evaluation — a divisor is structurally on-lattice iff EITHER
- *   (a) it is a year-multiple of H (integer year period), OR
- *   (b) it is a small precession divisor (1..20 — Earth's Fibonacci
- *       named cycles H/3, H/5, H/8, H/13, H/16, …), OR
- *   (c) it is one of the two lunar precession divisors (auto-tracked
- *       from the Meeus anchors).
- * Divisors failing all three are design-rule violating and silently
- * skipped. (Clause (d) "sharesFactorWithH" was removed 2026-07-15 — it
- * admitted mid-range fit artifacts, divisors 84/92/115/122, that are
- * not physically motivated. See tools/fit/sun-longitude-harmonics.js.)
- *
- * MATCHED PAIR: every dep is the J2000-FIXED value — the table was
- * fitted against J2000 H and mSY (the Node engines' documented
- * convention). The browser copy historically read the MUTABLE
- * holisticyearLength/balancedYear globals; measured divergence under
- * epoch shift was 8.2e-10 deg (~3 µas) — aligned onto the fitted
- * convention at extraction (9-1), zero fixture drift.
- *
- * The engines own the application (θ −= corr·d2r on the Sun node only)
- * and their enable flags.
- */
-
-'use strict';
-
-/**
- * @typedef {Object} SunLongitudeCorrectionDeps
- * @property {number} hYears - H, J2000-fixed (the fitted axis)
- * @property {number} balancedYear - J2000-fixed
- * @property {number} j2000JD
- * @property {number} meanDeg - the fitted mean offset
- * @property {Array<[number, number, number]>} harmonics - [divisor, sinC, cosC]
- * @property {number} nNodalJ2000 - lunar nodal divisor (per 8H convention)
- * @property {number} nApsidalJ2000 - lunar apsidal divisor
- */
-
-/** @param {SunLongitudeCorrectionDeps} deps */
-function createSunLongitudeCorrection(deps) {
-  /** Correction in DEGREES at JD (subtract from the raw Sun longitude).
-   * @param {number} jd @returns {number} */
-  function correctionDegAt(jd) {
-    const year = 2000 + (jd - deps.j2000JD) / 365.25;
-    const t = year - deps.balancedYear;
-    let corr = deps.meanDeg;
-    const H_round = Math.round(deps.hYears);
-    for (const h of deps.harmonics) {
-      const divisor = h[0];
-      const isYearMultiple = divisor >= H_round && divisor % H_round === 0;
-      const isPrecessionDivisor = divisor > 0 && divisor <= 20;
-      const isLunarPrecession = divisor === deps.nNodalJ2000 || divisor === deps.nApsidalJ2000;
-      if (!isYearMultiple && !isPrecessionDivisor && !isLunarPrecession) continue;
-      const phase = 2 * Math.PI * t / (deps.hYears / divisor);
-      corr += h[1] * Math.sin(phase) + h[2] * Math.cos(phase);
-    }
-    return corr;
-  }
-
-  return { correctionDegAt };
-}
-
-module.exports = { createSunLongitudeCorrection };

package/types/cardinal/index.d.cts

@@ -1,80 +0,0 @@
-export type DerivedCoefs = {
-    lincoef: number;
-    h0: number;
-    h1: number;
-};
-export type EccTerm = {
-    order: number;
-    sin: number;
-    cos: number;
-};
-export type JointTerm = {
-    order: number;
-    div: number;
-    sin: number;
-    cos: number;
-};
-/** @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
- */
-export function createCardinalModel({ isDeepTime, constants, fns }: {
-    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;
-    };
-}): {
-    computeSolsticeJD: (year: number, type?: string) => number;
-    computeSolsticeYearLength: (year: number, type?: string) => number;
-    computeSolsticeRA: (year: number, type?: string) => number;
-    computeTropicalYearLength: (year: number) => number;
-};
-/** @type {Record<string, number>} */
-export const JOINT_LAMBDA: Record<string, number>;

package/types/moon/ecc-channel.d.cts

@@ -1,30 +0,0 @@
-/**
- * @param {{
- *   cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null),
- *   eccentricityBase: number,
- *   eccentricityJ2000?: number,
- *   perihelionLongitudeJ2000Deg: number,
- *   inclinationCycleAnchorDeg: number,
- * }} deps — cyclesBetween MUST be the engine's own H-lattice phase counter
- *   (integrated under deep time); perihelionLongitudeJ2000Deg is ϖ_ICRF at
- *   J2000 (102.94719°, the FULL value — a truncated copy once cost 0.684″);
- *   inclinationCycleAnchorDeg is the H/3 inclination anchor (21.77°).
- */
-export function createMoonEccChannel({ cyclesBetween, eccentricityBase, perihelionLongitudeJ2000Deg, inclinationCycleAnchorDeg, eccentricityJ2000, }: {
-    cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null);
-    eccentricityBase: number;
-    eccentricityJ2000?: number;
-    perihelionLongitudeJ2000Deg: number;
-    inclinationCycleAnchorDeg: number;
-}): {
-    eccAt: (tYr: number) => number;
-    eccRateAt: (tYr: number) => number;
-    modulation: (tMa: number, s: number) => number;
-    channelIntegral: (T: number, s: number) => number;
-    eFactorAt: (tYr: number) => number;
-    th0: number;
-    amplitude: number;
-    mean: number;
-    e0: number;
-    g0: number;
-};

package/types/phase/index.d.cts

@@ -1,38 +0,0 @@
-/**
- * @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.
- */
-export function createPhaseMachinery({ holisticHAtAgeMa, tableAnchorYear, driftRefYear, hJ2000, yearMin, yearMax, stepYears, }: {
-    holisticHAtAgeMa: (tMa: number) => (number | null);
-    tableAnchorYear: number;
-    driftRefYear: number;
-    hJ2000: number;
-    yearMin?: number;
-    yearMax?: number;
-    stepYears?: number;
-}): {
-    ensureTable: () => void;
-    cumulAtYear: (year: number) => number | null;
-    integralBetween: (yearA: number, yearB: number) => number | null;
-    j2000Drift: (yearA: number) => number;
-    cyclesBetween: (yearA: number, yearB: number, divisorN: number) => number | null;
-    yearAtCumul: (targetCumul: number) => number | null;
-    grid: () => {
-        yearMin: number;
-        yearMax: number;
-        stepYears: number;
-        j2000Idx: number;
-        length: number;
-    };
-};

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

@@ -1,20 +0,0 @@
-/**
- * The law of cosines over resolved cycles. null cycles → the MEAN
- * eccentricity √(base² + amp²) (past the tidal-lock asymptote).
- * @param {number | null} cycles @param {number} base @param {number} amplitude
- * @returns {number} */
-export function eccentricityFromCycles(cycles: number | null, base: number, amplitude: number): number;
-/**
- * Browser-convention evaluator: J2000-FIXED anchor + cycle length, divisor
- * N = H_J2000/cycleLength, integrated phase via the injected engine
- * cyclesBetween (toggle semantics ride along), null → mean.
- * @param {number} currentYear @param {number} anchorYearJ2000
- * @param {number} cycleLengthYearsJ2000 @param {number} base
- * @param {number} amplitude
- * @param {{ holisticYearJ2000: number,
- *   cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null) }} env
- * @returns {number} */
-export function computeEccentricityIntegrated(currentYear: number, anchorYearJ2000: number, cycleLengthYearsJ2000: number, base: number, amplitude: number, env: {
-    holisticYearJ2000: number;
-    cyclesBetween: (yearA: number, yearB: number, divisorN: number) => (number | null);
-}): number;

package/types/sun/longitude-correction.d.cts

@@ -1,41 +0,0 @@
-export type SunLongitudeCorrectionDeps = {
-    /**
-     * - H, J2000-fixed (the fitted axis)
-     */
-    hYears: number;
-    /**
-     * - J2000-fixed
-     */
-    balancedYear: number;
-    j2000JD: number;
-    /**
-     * - the fitted mean offset
-     */
-    meanDeg: number;
-    /**
-     * - [divisor, sinC, cosC]
-     */
-    harmonics: Array<[number, number, number]>;
-    /**
-     * - lunar nodal divisor (per 8H convention)
-     */
-    nNodalJ2000: number;
-    /**
-     * - lunar apsidal divisor
-     */
-    nApsidalJ2000: number;
-};
-/**
- * @typedef {Object} SunLongitudeCorrectionDeps
- * @property {number} hYears - H, J2000-fixed (the fitted axis)
- * @property {number} balancedYear - J2000-fixed
- * @property {number} j2000JD
- * @property {number} meanDeg - the fitted mean offset
- * @property {Array<[number, number, number]>} harmonics - [divisor, sinC, cosC]
- * @property {number} nNodalJ2000 - lunar nodal divisor (per 8H convention)
- * @property {number} nApsidalJ2000 - lunar apsidal divisor
- */
-/** @param {SunLongitudeCorrectionDeps} deps */
-export function createSunLongitudeCorrection(deps: SunLongitudeCorrectionDeps): {
-    correctionDegAt: (jd: number) => number;
-};