caelus 0.4.0 → 0.6.0

package/README.md

@@ -10,8 +10,8 @@ ephemeris files. 1:1 port of the Python reference, checked by golden fixtures.
    true node ≤ 1′ vs SE's built-in ephemeris (≤ 1″ vs JPL DE431)
    (vs full DE431 files, 1850–2149), angles and Placidus cusps ≤ 3.2″ — all
    invisible at the arcminute display precision chart software uses.
-2. TypeScript port verified against Python golden fixtures: **3,177 checks,
-   0 failures, worst deviation 1.64 nano-arcseconds.** The two implementations
+2. TypeScript port verified against Python golden fixtures: **3,218 checks,
+   0 failures, worst deviation 0.41 nano-arcseconds.** The two implementations
    are numerically identical.
 
 Regenerate fixtures any time from the Python side; any future TS change must

package/accuracy.json

@@ -107,9 +107,9 @@
     },
     {
       "name": "Sidereal longitudes",
-      "max": "0.1",
+      "max": "—",
       "rms": "—",
-      "note": "ayanamsa model vs SE ≤0.30″ at the 1900/2099 edges (IAU 1976 vs Vondrák precession); Sun worst-case 0.08″ at 120 sampled epochs"
+      "note": "ayanamsa model vs SE ≤0.005″ (Vondrák 2011, same model both sides); sidereal longitudes inherit each body's tropical bound"
     },
     {
       "name": "RA / Dec",
@@ -119,7 +119,7 @@
     },
     {
       "name": "Topocentric Moon",
-      "max": "2.7",
+      "max": "2.5",
       "rms": "—",
       "note": "parallax model adds ≤0.1″ over the geocentric bound"
     },
@@ -176,6 +176,30 @@
       "max": "2.3",
       "rms": "—",
       "note": "Hamburg-school constant-element Kepler orbits, elements fitted to SE 2.10's built-in definitions (fit_uranian.py prints per-body figures; Zeus is fit-noise-limited at ~3″ heliocentric). Uranian practice works in arcminutes"
+    },
+    {
+      "name": "Fixed stars (318-star catalog)",
+      "max": "0.3",
+      "rms": "—",
+      "note": "HYG-derived catalog (ICRS J2000 + proper motions, full 3D space motion, Vondrák 2011 precession); vs swe_fixstar fed the same rows"
+    },
+    {
+      "name": "Star-anchored ayanamsas",
+      "max": "0.5",
+      "rms": "—",
+      "note": "galcent_0sag and true_citra computed from the apparent star; bound tracks the fixed-star chain (≤0.3″) plus the body's tropical accuracy"
+    },
+    {
+      "name": "Gauquelin sectors",
+      "max": "0.0001 sectors",
+      "rms": "—",
+      "note": "rise/set of disc center with refraction (SE method 3): exact to the rise/set bound"
+    },
+    {
+      "name": "Eclipses (solar + lunar)",
+      "max": "9 s",
+      "rms": "—",
+      "note": "times of maximum vs swe; types exact over 1990-2030 (92 lunar + 89 solar, zero mismatches); lunar magnitudes ≤0.0013 (Danjon parallax enlargement, recovered empirically). Contact times typically ≤15 s, minutes for grazing geometries. Global circumstances only — no ground paths"
     }
   ],
   "summary": [
@@ -211,10 +235,6 @@
       "label": "Mean Lilith",
       "bound": "≤ 1.3″"
     },
-    {
-      "label": "Sidereal (5 ayanamsas)",
-      "bound": "≤ 0.3″ added"
-    },
     {
       "label": "8 new house systems",
       "bound": "exact (0.0″)"
@@ -234,6 +254,18 @@
     {
       "label": "Uranian bodies",
       "bound": "≤ 2.3″"
+    },
+    {
+      "label": "Fixed stars",
+      "bound": "≤ 0.3″"
+    },
+    {
+      "label": "Sidereal (7 ayanamsas)",
+      "bound": "≤ 0.005″ added"
+    },
+    {
+      "label": "Eclipses",
+      "bound": "types exact; max ≤ 9 s"
     }
   ],
   "v03_harness": "python/validate_swiss.py regenerates every figure above the line against pyswisseph 2.10 (Moshier mode)",

package/dist/src/chart.d.ts

@@ -78,6 +78,20 @@ export declare class Engine {
      *  Building block for the events module; chart consumers want
      *  position() instead. */
     ecliptic(body: BodyId, jde: number): [number, number, number | null];
+    /** Degrees to subtract from a true-equinox tropical longitude. */
+    private ayanShift;
+    /** Apparent place of a catalog star: lon/lat/ra/dec (deg), sign, mag. */
+    fixedStar(name: string, jdUt: number, opts?: CalcOptions): {
+        lon: number;
+        lat: number;
+        ra: number;
+        dec: number;
+        mag: number;
+        sign: string;
+        signDeg: number;
+    };
+    /** Names in the loaded fixed-star catalog (sorted). */
+    starNames(): string[];
     private lonOnly;
     /** Apparent geocentric ecliptic longitude (deg). Tropical: true equinox
      *  of date. Sidereal: mean equinox minus ayanamsa. */

package/dist/src/chart.js

@@ -1,5 +1,6 @@
 /** astroengine chart -- public API: natal charts, aspects, retrogrades. */
 import { DEG, mod, jdTT, julianDay, ChebSeries, planetApparent, sunApparent, moonApparentSeries, moonApparentPrecise, plutoApparent, chironApparent, meanNode, trueNodeSeries, trueNodePrecise, equatorial, ayanamsa, AYANAMSA_J2000, meanLilith, topocentricEcl, oscApogeePrecise, oscApogeeSeries, KeplerOrbit, trueObliquity, nutation, plutoHeliocentric, vsopHeliocentric, precessEcliptic, J2000, } from "./core.js";
+import { starApparent } from "./stars.js";
 import * as H from "./houses.js";
 const TWO_PI = 2 * Math.PI;
 export const BODIES = [
@@ -28,11 +29,18 @@ function parseZodiac(zodiac) {
         return null;
     if (zodiac.startsWith("sidereal:")) {
         const mode = zodiac.slice("sidereal:".length);
-        if (AYANAMSA_J2000[mode] !== undefined)
+        if (AYANAMSA_J2000[mode] !== undefined || STAR_AYANAMSAS[mode])
             return mode;
     }
     throw new Error(`unknown zodiac ${JSON.stringify(zodiac)}`);
 }
+/** Star-anchored ayanamsas: the named star sits at the fixed sidereal
+ *  longitude by definition (Galactic Center at 0 Sagittarius; Spica at
+ *  0 Libra "citra"). Need the fixed-star catalog loaded. */
+const STAR_AYANAMSAS = {
+    galcent_0sag: ["Galactic Center", 240.0],
+    true_citra: ["Spica", 180.0],
+};
 const VSOP_BODIES = new Set([
     "mercury", "venus", "earth", "mars", "jupiter", "saturn", "uranus", "neptune",
 ]);
@@ -120,6 +128,39 @@ export class Engine {
             return planetApparent(this.data, body, jde);
         throw new Error(`no data loaded for body '${body}'`);
     }
+    /** Degrees to subtract from a true-equinox tropical longitude. */
+    ayanShift(jde, mode) {
+        const star = STAR_AYANAMSAS[mode];
+        if (star) {
+            const s = this.data.fixedStars?.stars[star[0]];
+            if (!s)
+                throw new Error(`zodiac 'sidereal:${mode}' needs the fixed-star catalog loaded`);
+            const [lon] = starApparent(this.data, s, jde);
+            return mod(lon / DEG - star[1], 360);
+        }
+        return mod(nutation(this.data, jde)[0] / DEG + ayanamsa(jde, mode), 360);
+    }
+    /** Apparent place of a catalog star: lon/lat/ra/dec (deg), sign, mag. */
+    fixedStar(name, jdUt, opts = {}) {
+        const s = this.data.fixedStars?.stars[name];
+        if (!s)
+            throw new Error(`no fixed-star catalog entry for '${name}'`);
+        const mode = parseZodiac(opts.zodiac ?? "tropical");
+        const jde = jdTT(jdUt);
+        const [lonR, latR] = starApparent(this.data, s, jde);
+        const [ra, dec] = equatorial(lonR, latR, trueObliquity(this.data, jde));
+        let lon = lonR / DEG;
+        if (mode !== null)
+            lon = mod(lon - this.ayanShift(jde, mode), 360);
+        return {
+            lon, lat: latR / DEG, ra: ra / DEG, dec: dec / DEG, mag: s.mag,
+            sign: SIGNS[Math.floor(lon / 30)], signDeg: mod(lon, 30),
+        };
+    }
+    /** Names in the loaded fixed-star catalog (sorted). */
+    starNames() {
+        return Object.keys(this.data.fixedStars?.stars ?? {}).sort();
+    }
     lonOnly(body, jdUt, mode, topo) {
         const jde = jdTT(jdUt);
         let [lon, lat, dist] = this.ecliptic(body, jde);
@@ -128,9 +169,8 @@ export class Engine {
             [lon, lat, dist] = topocentricEcl(lon, lat, dist, lst, topo.lat * DEG, topo.altM ?? 0.0, trueObliquity(this.data, jde));
         }
         let lonDeg = lon / DEG;
-        if (mode !== null) {
-            lonDeg = mod(lonDeg - nutation(this.data, jde)[0] / DEG - ayanamsa(jde, mode), 360);
-        }
+        if (mode !== null)
+            lonDeg = mod(lonDeg - this.ayanShift(jde, mode), 360);
         return lonDeg;
     }
     /** Apparent geocentric ecliptic longitude (deg). Tropical: true equinox
@@ -186,9 +226,8 @@ export class Engine {
         }
         const [ra, dec] = equatorial(lonR, latR, trueObliquity(this.data, jde));
         let lon = lonR / DEG;
-        if (mode !== null) {
-            lon = mod(lon - nutation(this.data, jde)[0] / DEG - ayanamsa(jde, mode), 360);
-        }
+        if (mode !== null)
+            lon = mod(lon - this.ayanShift(jde, mode), 360);
         const h = 0.25; // days; central difference
         const l0 = this.lonOnly(body, jdUt - h, mode, topo);
         const l1 = this.lonOnly(body, jdUt + h, mode, topo);
@@ -276,9 +315,8 @@ export class Engine {
         }
         const jde = jdTT(jdUt);
         let shift = 0.0;
-        if (mode !== null) {
-            shift = nutation(this.data, jde)[0] / DEG + ayanamsa(jde, mode);
-        }
+        if (mode !== null)
+            shift = this.ayanShift(jde, mode);
         const outDeg = (rad) => mod(rad / DEG - shift, 360);
         let cuspsDeg;
         if (mode !== null && used === "whole_sign") {

package/dist/src/core.d.ts

@@ -56,6 +56,8 @@ export interface EngineData {
     chebPacks?: Record<string, ChebData>;
     /** Hamburg-school (Uranian) constant-element orbits; see fit_uranian.py. */
     keplerPack?: KeplerPack;
+    /** Fixed-star catalog (HYG-derived; ICRS J2000 + proper motions). */
+    fixedStars?: import("./stars.js").StarPack;
 }
 export declare function julianDay(y: number, mo: number, d: number, h?: number, mi?: number, s?: number): number;
 /** TT - UT1 in seconds. Observed IERS 1955-2025, E&M polynomials before,
@@ -67,7 +69,8 @@ export declare function vsopHeliocentric(series: VsopSeries, jde: number): [numb
 export declare function nutation(data: EngineData, jde: number): [number, number];
 export declare function meanObliquity(jde: number): number;
 export declare function trueObliquity(data: EngineData, jde: number): number;
-/** Precession of ecliptic coordinates (Meeus 21.7). */
+/** Precession of ecliptic coordinates between epochs (Vondrak 2011):
+ *  ecliptic-of-from -> J2000 equatorial -> ecliptic-of-to. */
 export declare function precessEcliptic(lon: number, lat: number, jdeFrom: number, jdeTo: number): [number, number];
 /** Apparent geocentric ecliptic lon/lat (true equinox of date), distance. */
 export declare function planetApparent(data: EngineData, name: string, jde: number): [number, number, number];
@@ -94,9 +97,9 @@ export declare function trueNodeSeries(data: EngineData, jde: number): number;
 /** Ecliptic lon/lat -> right ascension, declination (all radians). */
 export declare function equatorial(lon: number, lat: number, eps: number): [number, number];
 /** Mean ayanamsa at J2000.0 (degrees) per mode. Standard epoch anchors
- *  (matched to Swiss Ephemeris 2.10 to 1e-9 deg); propagation uses IAU 1976
- *  ecliptic precession. Agreement with Swiss Ephemeris over 1900-2099 is
- *  <=0.30 arcsec (precession-model difference: SE uses Vondrak 2011). */
+ *  (matched to Swiss Ephemeris 2.10 to 1e-9 deg); propagation uses Vondrak
+ *  2011 ecliptic precession, the same model Swiss Ephemeris uses:
+ *  agreement over 1900-2099 is <=0.005 arcsec. */
 export declare const AYANAMSA_J2000: Record<string, number>;
 /** Mean ayanamsa in degrees. Sidereal longitude = (tropical true-equinox
  *  longitude - nutation in longitude) - ayanamsa: the sidereal zodiac is

package/dist/src/core.js

@@ -140,48 +140,138 @@ function fk5Correction(L, B, jde) {
     const dB = 0.03916 * ARCSEC * (Math.cos(Lp) - Math.sin(Lp));
     return [L + dL, B + dB];
 }
-/** Precession of ecliptic coordinates (Meeus 21.7). */
+// ------------------------------------------------- Vondrak 2011 precession
+// Long-term precession of the ecliptic and equator (Vondrak, Capitaine &
+// Wallace 2011, A&A 534 A22; coefficient tables as carried by ERFA under
+// BSD-3). Replaces the IAU 1976 angles.
+const PQ_POL = [
+    [5851.607687, -0.1189, -0.00028913, 0.000000101],
+    [-1600.8863, 1.1689818, -0.0000002, -0.000000437],
+];
+const PQ_PER = [
+    [708.15, -5486.751211, -684.66156, 667.66673, -5523.863691],
+    [2309.0, -17.127623, 2446.28388, -2354.886252, -549.74745],
+    [1620.0, -617.517403, 399.671049, -428.152441, -310.998056],
+    [492.2, 413.44294, -356.652376, 376.202861, 421.535876],
+    [1183.0, 78.614193, -186.387003, 184.778874, -36.776172],
+    [622.0, -180.732815, -316.80007, 335.321713, -145.278396],
+    [882.0, -87.676083, 198.296701, -185.138669, -34.74445],
+    [547.0, 46.140315, 101.135679, -120.97283, 22.885731],
+];
+const XY_POL = [
+    [5453.282155, 0.4252841, -0.00037173, -0.000000152],
+    [-73750.93035, -0.7675452, -0.00018725, 0.000000231],
+];
+const XY_PER = [
+    [256.75, -819.940624, 75004.344875, 81491.287984, 1558.515853],
+    [708.15, -8444.676815, 624.033993, 787.163481, 7774.939698],
+    [274.2, 2600.009459, 1251.136893, 1251.296102, -2219.534038],
+    [241.45, 2755.17563, -1102.212834, -1257.950837, -2523.969396],
+    [2309.0, -167.659835, -2660.66498, -2966.79973, 247.850422],
+    [492.2, 871.855056, 699.291817, 639.744522, -846.485643],
+    [396.1, 44.769698, 153.16722, 131.600209, -1393.124055],
+    [288.9, -512.313065, -950.865637, -445.040117, 368.526116],
+    [231.1, -819.415595, 499.754645, 584.522874, 749.045012],
+    [1610.0, -538.071099, -145.18821, -89.756563, 444.704518],
+    [620.0, -189.793622, 558.116553, 524.42963, 235.934465],
+    [157.87, -402.922932, -23.923029, -13.549067, 374.049623],
+    [220.3, 179.516345, -165.405086, -210.157124, -171.33018],
+    [1200.0, -9.814756, 9.344131, -44.919798, -22.899655],
+];
+const EPS0_V = 84381.406 * ARCSEC; // J2000 obliquity of the Vondrak model
+const EPS0_FRAME = 84381.448 * ARCSEC; // obliquity defining our ecliptic-J2000 data
+function ltpPecl(jde) {
+    const t = (jde - J2000) / 36525.0;
+    let p = 0.0;
+    let q = 0.0;
+    const w = 2.0 * Math.PI * t;
+    for (const [per, c1, c2, s1, s2] of PQ_PER) {
+        const a = w / per;
+        const ca = Math.cos(a);
+        const sa = Math.sin(a);
+        p += ca * c1 + sa * s1;
+        q += ca * c2 + sa * s2;
+    }
+    let tn = 1.0;
+    for (let i = 0; i < 4; i++) {
+        p += PQ_POL[0][i] * tn;
+        q += PQ_POL[1][i] * tn;
+        tn *= t;
+    }
+    p *= ARCSEC;
+    q *= ARCSEC;
+    const z = Math.sqrt(Math.max(1.0 - p * p - q * q, 0.0));
+    const s = Math.sin(EPS0_V);
+    const c = Math.cos(EPS0_V);
+    return [p, -q * c - z * s, -q * s + z * c];
+}
+function ltpPequ(jde) {
+    const t = (jde - J2000) / 36525.0;
+    let x = 0.0;
+    let y = 0.0;
+    const w = 2.0 * Math.PI * t;
+    for (const [per, c1, c2, s1, s2] of XY_PER) {
+        const a = w / per;
+        const ca = Math.cos(a);
+        const sa = Math.sin(a);
+        x += ca * c1 + sa * s1;
+        y += ca * c2 + sa * s2;
+    }
+    let tn = 1.0;
+    for (let i = 0; i < 4; i++) {
+        x += XY_POL[0][i] * tn;
+        y += XY_POL[1][i] * tn;
+        tn *= t;
+    }
+    x *= ARCSEC;
+    y *= ARCSEC;
+    return [x, y, Math.sqrt(Math.max(1.0 - x * x - y * y, 0.0))];
+}
+/** Rows of the rotation J2000-equatorial -> mean ecliptic/equinox of date
+ *  (ERFA eraLtecm): x = equinox, z = ecliptic pole, y = z cross x. */
+function ltpEclMatrix(jde) {
+    const p = ltpPequ(jde);
+    const z = ltpPecl(jde);
+    const wx = [
+        p[1] * z[2] - p[2] * z[1], p[2] * z[0] - p[0] * z[2], p[0] * z[1] - p[1] * z[0],
+    ];
+    const n = Math.sqrt(wx[0] ** 2 + wx[1] ** 2 + wx[2] ** 2);
+    const x = [wx[0] / n, wx[1] / n, wx[2] / n];
+    const y = [
+        z[1] * x[2] - z[2] * x[1], z[2] * x[0] - z[0] * x[2], z[0] * x[1] - z[1] * x[0],
+    ];
+    return [x, y, z];
+}
+/** Precession of ecliptic coordinates between epochs (Vondrak 2011):
+ *  ecliptic-of-from -> J2000 equatorial -> ecliptic-of-to. */
 export function precessEcliptic(lon, lat, jdeFrom, jdeTo) {
-    const T = (jdeFrom - J2000) / 36525.0;
-    const t = (jdeTo - jdeFrom) / 36525.0;
-    const eta = ((47.0029 - 0.06603 * T + 0.000598 * T * T) * t
-        + (-0.03302 + 0.000598 * T) * t * t + 0.00006 * t ** 3) * ARCSEC;
-    const Pi = (174.876384 * 3600 + 3289.4789 * T + 0.60622 * T * T) * ARCSEC
-        - ((869.8089 + 0.50491 * T) * t - 0.03536 * t * t) * ARCSEC;
-    const p = ((5029.0966 + 2.22226 * T - 0.000042 * T * T) * t
-        + (1.11113 - 0.000042 * T) * t * t - 0.000006 * t ** 3) * ARCSEC;
-    const se = Math.sin(eta);
-    const ce = Math.cos(eta);
-    const A = ce * Math.cos(lat) * Math.sin(Pi - lon) - se * Math.sin(lat);
-    const Bv = Math.cos(lat) * Math.cos(Pi - lon);
-    const C = ce * Math.sin(lat) + se * Math.cos(lat) * Math.sin(Pi - lon);
-    return [mod(p + Pi - Math.atan2(A, Bv), TWO_PI), Math.asin(C)];
-}
-/** Rotate a vector from ecliptic-J2000 to ecliptic-of-date frame. */
+    const cb = Math.cos(lat);
+    const v = [cb * Math.cos(lon), cb * Math.sin(lon), Math.sin(lat)];
+    const [xf, yf, zf] = ltpEclMatrix(jdeFrom);
+    const e = [0, 1, 2].map((i) => xf[i] * v[0] + yf[i] * v[1] + zf[i] * v[2]);
+    const [xt, yt, zt] = ltpEclMatrix(jdeTo);
+    const u = [
+        xt[0] * e[0] + xt[1] * e[1] + xt[2] * e[2],
+        yt[0] * e[0] + yt[1] * e[1] + yt[2] * e[2],
+        zt[0] * e[0] + zt[1] * e[1] + zt[2] * e[2],
+    ];
+    return [mod(Math.atan2(u[1], u[0]), TWO_PI),
+        Math.asin(Math.max(-1, Math.min(1, u[2])))];
+}
+/** Rotate a vector from the ecliptic-J2000 data frame (obliquity 84381.448
+ *  arcsec, as used by Horizons/Meeus) to the mean ecliptic of date
+ *  (Vondrak 2011). */
 function eclJ2000ToEclDate(v, jde) {
-    let [x, y, z] = v;
-    const e0 = 84381.448 * ARCSEC;
-    [y, z] = [y * Math.cos(e0) - z * Math.sin(e0), y * Math.sin(e0) + z * Math.cos(e0)];
-    const T = (jde - J2000) / 36525.0;
-    const zeta = (2306.2181 * T + 0.30188 * T * T + 0.017998 * T ** 3) * ARCSEC;
-    const zz = (2306.2181 * T + 1.09468 * T * T + 0.018203 * T ** 3) * ARCSEC;
-    const th = (2004.3109 * T - 0.42665 * T * T - 0.041833 * T ** 3) * ARCSEC;
-    const rz = (a) => {
-        const c = Math.cos(a);
-        const s = Math.sin(a);
-        [x, y] = [c * x + s * y, -s * x + c * y];
-    };
-    const ry = (a) => {
-        const c = Math.cos(a);
-        const s = Math.sin(a);
-        [x, z] = [c * x - s * z, s * x + c * z];
-    };
-    rz(-zeta);
-    ry(th);
-    rz(-zz);
-    const e = meanObliquity(jde);
-    [y, z] = [y * Math.cos(e) + z * Math.sin(e), -y * Math.sin(e) + z * Math.cos(e)];
-    return [x, y, z];
+    const [x, y, z] = v;
+    const s = Math.sin(EPS0_FRAME);
+    const c = Math.cos(EPS0_FRAME);
+    const e = [x, y * c - z * s, y * s + z * c];
+    const [xt, yt, zt] = ltpEclMatrix(jde);
+    return [
+        xt[0] * e[0] + xt[1] * e[1] + xt[2] * e[2],
+        yt[0] * e[0] + yt[1] * e[1] + yt[2] * e[2],
+        zt[0] * e[0] + zt[1] * e[1] + zt[2] * e[2],
+    ];
 }
 // ---------------------------------------------------------------- planets
 function geoVector(data, name, jde) {
@@ -385,9 +475,9 @@ export function equatorial(lon, lat, eps) {
     return [ra, dec];
 }
 /** Mean ayanamsa at J2000.0 (degrees) per mode. Standard epoch anchors
- *  (matched to Swiss Ephemeris 2.10 to 1e-9 deg); propagation uses IAU 1976
- *  ecliptic precession. Agreement with Swiss Ephemeris over 1900-2099 is
- *  <=0.30 arcsec (precession-model difference: SE uses Vondrak 2011). */
+ *  (matched to Swiss Ephemeris 2.10 to 1e-9 deg); propagation uses Vondrak
+ *  2011 ecliptic precession, the same model Swiss Ephemeris uses:
+ *  agreement over 1900-2099 is <=0.005 arcsec. */
 export const AYANAMSA_J2000 = {
     lahiri: 23.857092325,
     fagan_bradley: 24.740299966,

package/dist/src/eclipses.d.ts

@@ -0,0 +1,24 @@
+import { Engine } from "./chart.js";
+export interface LunarEclipse {
+    tMax: number;
+    type: "total" | "partial" | "penumbral";
+    magUmbral: number;
+    magPenumbral: number;
+    penumbralBegin: number | null;
+    penumbralEnd: number | null;
+    partialBegin: number | null;
+    partialEnd: number | null;
+    totalBegin: number | null;
+    totalEnd: number | null;
+}
+export interface SolarEclipse {
+    tMax: number;
+    type: "total" | "annular" | "hybrid" | "partial";
+    gamma: number;
+    begin: number;
+    end: number;
+}
+/** Lunar eclipses in [jdStart, jdEnd] (UT JDs). */
+export declare function lunarEclipses(engine: Engine, jdStart: number, jdEnd: number): LunarEclipse[];
+/** Solar eclipses (global circumstances) in [jdStart, jdEnd] (UT JDs). */
+export declare function solarEclipses(engine: Engine, jdStart: number, jdEnd: number): SolarEclipse[];

package/dist/src/eclipses.js

@@ -0,0 +1,163 @@
+/**
+ * astroengine eclipses -- solar and lunar eclipse search.
+ *
+ * Lunar: direct shadow geometry at the anti-solar point with Danjon's
+ * enlargement (lunar parallax x 86/85 on the flattened Earth) — the rule
+ * Swiss Ephemeris uses, recovered empirically: magnitudes match to 0.001,
+ * types exactly; times of maximum to ~9 s (contact times typically <=15 s,
+ * up to ~2 min for grazing geometries where the crossing flattens).
+ *
+ * Solar (global): shadow-axis geometry. gamma = closest approach of the
+ * Sun-Moon axis to the geocenter in Earth radii; the umbral cone's reach
+ * at the surface separates total from annular, a sign change along the
+ * track marks hybrids. Types match Swiss Ephemeris exactly over decades.
+ * Local circumstances (where/visibility) are not computed here.
+ */
+import { ARCSEC, jdTT, mod } from "./core.js";
+const KM_PER_AU = 149597870.7;
+const R_EARTH = 6378.14;
+const R_SUN = 696000.0;
+const R_MOON = 1737.4;
+const PI_SUN = 8.794 * ARCSEC;
+const DANJON = (1 + 1 / 85.0) * 0.99834;
+function lunarGeom(engine, jd) {
+    const jde = jdTT(jd);
+    const [slon, slat, sdist] = engine.ecliptic("sun", jde);
+    const [mlon, mlat, mdist] = engine.ecliptic("moon", jde);
+    const alon = mod(slon + Math.PI, 2 * Math.PI);
+    const alat = -slat;
+    const cosd = Math.sin(alat) * Math.sin(mlat)
+        + Math.cos(alat) * Math.cos(mlat) * Math.cos(alon - mlon);
+    const theta = Math.acos(Math.max(-1, Math.min(1, cosd)));
+    const mkm = mdist * KM_PER_AU;
+    const piEff = DANJON * Math.asin(R_EARTH / mkm);
+    const sM = Math.asin(R_MOON / mkm);
+    const sS = Math.asin(R_SUN / (sdist * KM_PER_AU));
+    return [theta, piEff - sS + PI_SUN, piEff + sS + PI_SUN, sM];
+}
+function solarGeom(engine, jd) {
+    const jde = jdTT(jd);
+    const [slon, slat, sdist] = engine.ecliptic("sun", jde);
+    const [mlon, mlat, mdist] = engine.ecliptic("moon", jde);
+    const vec = (lon, lat, r) => [
+        r * Math.cos(lat) * Math.cos(lon),
+        r * Math.cos(lat) * Math.sin(lon),
+        r * Math.sin(lat),
+    ];
+    const S = vec(slon, slat, sdist * KM_PER_AU);
+    const M = vec(mlon, mlat, mdist * KM_PER_AU);
+    const SM = [M[0] - S[0], M[1] - S[1], M[2] - S[2]];
+    const smn = Math.sqrt(SM[0] ** 2 + SM[1] ** 2 + SM[2] ** 2);
+    const d = SM.map((c) => c / smn);
+    const t0 = -(M[0] * d[0] + M[1] * d[1] + M[2] * d[2]);
+    const P = [M[0] + t0 * d[0], M[1] + t0 * d[1], M[2] + t0 * d[2]];
+    const dAxis = Math.sqrt(P[0] ** 2 + P[1] ** 2 + P[2] ** 2);
+    const f1 = Math.asin((R_SUN + R_MOON) / smn);
+    const f2 = Math.asin((R_SUN - R_MOON) / smn);
+    const rPen = (R_MOON / Math.tan(f1) + t0) * Math.tan(f1);
+    const rUmb = (R_MOON / Math.tan(f2) - t0) * Math.tan(f2);
+    return [dAxis, rPen, rUmb, t0, f2];
+}
+function minimize(f, lo, hi) {
+    for (let i = 0; i < 60; i++) {
+        const m1 = lo + (hi - lo) / 3;
+        const m2 = hi - (hi - lo) / 3;
+        if (f(m1) < f(m2))
+            hi = m2;
+        else
+            lo = m1;
+    }
+    return (lo + hi) / 2;
+}
+function bisect(f, a, b) {
+    let fa = f(a);
+    for (let i = 0; i < 50; i++) {
+        const m = (a + b) / 2;
+        if (fa * f(m) <= 0) {
+            b = m;
+        }
+        else {
+            a = m;
+            fa = f(a);
+        }
+    }
+    return (a + b) / 2;
+}
+function syzygies(engine, jdStart, jdEnd, angle) {
+    const f = (t) => {
+        const e = mod(engine.longitude("moon", t) - engine.longitude("sun", t), 360);
+        return mod(e - angle + 180, 360) - 180;
+    };
+    const out = [];
+    const step = 5.0;
+    let prev = f(jdStart);
+    for (let t = jdStart + step; t <= jdEnd + step; t += step) {
+        const cur = f(t);
+        if (prev * cur < 0 && Math.abs(cur - prev) < 180) {
+            out.push(bisect(f, t - step, t));
+        }
+        prev = cur;
+    }
+    return out;
+}
+/** Lunar eclipses in [jdStart, jdEnd] (UT JDs). */
+export function lunarEclipses(engine, jdStart, jdEnd) {
+    const out = [];
+    for (const tFull of syzygies(engine, jdStart - 1, jdEnd + 1, 180.0)) {
+        const tMax = minimize((t) => lunarGeom(engine, t)[0], tFull - 0.3, tFull + 0.3);
+        const [theta, u, pen, sM] = lunarGeom(engine, tMax);
+        const magU = (u + sM - theta) / (2 * sM);
+        const magP = (pen + sM - theta) / (2 * sM);
+        if (magP <= 0 || tMax < jdStart || tMax > jdEnd)
+            continue;
+        const kind = magU >= 1 ? "total" : magU > 0 ? "partial" : "penumbral";
+        const cross = (idx, sign) => {
+            const f = (t) => {
+                const g = lunarGeom(engine, t);
+                return g[0] - (g[idx] + sign * g[3]);
+            };
+            return [bisect(f, tMax - 0.35, tMax), bisect(f, tMax, tMax + 0.35)];
+        };
+        const [penB, penE] = cross(2, 1);
+        const [parB, parE] = magU > 0 ? cross(1, 1) : [null, null];
+        const [totB, totE] = magU >= 1 ? cross(1, -1) : [null, null];
+        out.push({
+            tMax, type: kind,
+            magUmbral: Math.max(magU, 0), magPenumbral: magP,
+            penumbralBegin: penB, penumbralEnd: penE,
+            partialBegin: parB, partialEnd: parE,
+            totalBegin: totB, totalEnd: totE,
+        });
+    }
+    return out;
+}
+/** Solar eclipses (global circumstances) in [jdStart, jdEnd] (UT JDs). */
+export function solarEclipses(engine, jdStart, jdEnd) {
+    const out = [];
+    for (const tNew of syzygies(engine, jdStart - 1, jdEnd + 1, 0.0)) {
+        const tMax = minimize((t) => solarGeom(engine, t)[0], tNew - 0.4, tNew + 0.4);
+        const [dAxis, rPen, rUmb, , f2] = solarGeom(engine, tMax);
+        if (dAxis > R_EARTH + rPen || tMax < jdStart || tMax > jdEnd)
+            continue;
+        const gamma = dAxis / R_EARTH;
+        let kind;
+        if (dAxis < R_EARTH) {
+            const depth = Math.sqrt(Math.max(R_EARTH ** 2 - dAxis ** 2, 0));
+            const rUmbSurface = rUmb + depth * Math.tan(f2);
+            kind = rUmb > 0 ? "total" : rUmbSurface > 0 ? "hybrid" : "annular";
+        }
+        else {
+            kind = "partial";
+        }
+        const f = (t) => {
+            const g = solarGeom(engine, t);
+            return g[0] - (R_EARTH + g[1]);
+        };
+        out.push({
+            tMax, type: kind, gamma,
+            begin: bisect(f, tMax - 0.35, tMax),
+            end: bisect(f, tMax, tMax + 0.35),
+        });
+    }
+    return out;
+}

package/dist/src/events.d.ts

@@ -5,6 +5,8 @@ export interface RiseSetOptions {
     pressure?: number;
     tempC?: number;
     searchDays?: number;
+    /** Rise/set of the disc center instead of the upper limb. */
+    discCenter?: boolean;
 }
 /** Next rise/set/meridian transit (UT JD) after jdStart, or null when the
  *  event does not occur in the window (polar day/night). */
@@ -20,3 +22,8 @@ export declare function lunarPhases(engine: Engine, jdStart: number, jdEnd: numb
  *  turns]. Sun and Moon never station. Station timing is ill-conditioned:
  *  expect minute-level differences between ephemerides. */
 export declare function stations(engine: Engine, body: BodyId, jdStart: number, jdEnd: number, maxHits?: number): Array<[number, "retrograde" | "direct"]>;
+/** Gauquelin sector (1..36, float) from rise/set times of the disc center
+ *  with refraction (Swiss Ephemeris method 3). Sectors run from rise: 1-18
+ *  above the horizon, 19-36 below. Null in polar no-rise/no-set
+ *  conditions. */
+export declare function gauquelinSector(engine: Engine, body: BodyId, jdUt: number, latDeg: number, lonDeg: number): number | null;

package/dist/src/events.js

@@ -73,7 +73,7 @@ export function riseSet(engine, body, jdStart, latDeg, lonDeg, kind = "rise", op
         const [alt, , dist] = topoAltHa(engine, body, t, latDeg, lonDeg, altM);
         let sd = 0.0;
         const diam = DIAMETER_KM[body];
-        if (diam !== undefined && dist !== null) {
+        if (!opts.discCenter && diam !== undefined && dist !== null) {
             sd = Math.asin(diam / (2 * dist * KM_PER_AU));
         }
         const h0 = -((R0_ARCMIN / 60.0) * scale * DEG + sd);
@@ -154,3 +154,31 @@ export function stations(engine, body, jdStart, jdEnd, maxHits = 30) {
     }
     return out;
 }
+/** Gauquelin sector (1..36, float) from rise/set times of the disc center
+ *  with refraction (Swiss Ephemeris method 3). Sectors run from rise: 1-18
+ *  above the horizon, 19-36 below. Null in polar no-rise/no-set
+ *  conditions. */
+export function gauquelinSector(engine, body, jdUt, latDeg, lonDeg) {
+    const surrounding = (kind) => {
+        let t = riseSet(engine, body, jdUt - 1.3, latDeg, lonDeg, kind, { discCenter: true });
+        let prev = null;
+        while (t !== null && t <= jdUt) {
+            prev = t;
+            t = riseSet(engine, body, t + 1e-4, latDeg, lonDeg, kind, { discCenter: true });
+        }
+        return [prev, t];
+    };
+    const [prevRise] = surrounding("rise");
+    const [prevSet, nextSetA] = surrounding("set");
+    if (prevRise === null || prevSet === null)
+        return null;
+    if (prevRise > prevSet) {
+        if (nextSetA === null)
+            return null;
+        return 1 + (18 * (jdUt - prevRise)) / (nextSetA - prevRise);
+    }
+    const [, nextRise] = surrounding("rise");
+    if (nextRise === null)
+        return null;
+    return 19 + (18 * (jdUt - prevSet)) / (nextRise - prevSet);
+}

package/dist/src/index.d.ts

@@ -3,3 +3,6 @@ export * from "./houses.js";
 export * from "./chart.js";
 export * from "./pheno.js";
 export * from "./events.js";
+export * from "./stars.js";
+export * from "./eclipses.js";
+export * from "./query.js";

package/dist/src/index.js

@@ -3,3 +3,6 @@ export * from "./houses.js";
 export * from "./chart.js";
 export * from "./pheno.js";
 export * from "./events.js";
+export * from "./stars.js";
+export * from "./eclipses.js";
+export * from "./query.js";

package/dist/src/node-loader.js

@@ -31,6 +31,9 @@ export function loadNodeData(dir, level = "embedded", moonTier = "full") {
     if (existsSync(join(dir, "uranian_kepler.json"))) {
         data.keplerPack = j("uranian_kepler.json");
     }
+    if (existsSync(join(dir, "fixed_stars.json"))) {
+        data.fixedStars = j("fixed_stars.json");
+    }
     // asteroid packs (Horizons fits): loaded when present, ~380 KB total
     for (const b of ["ceres", "pallas", "juno", "vesta", "pholus"]) {
         if (existsSync(join(dir, `${b}_cheb.json`))) {

package/dist/src/query.d.ts

@@ -0,0 +1,32 @@
+import { Engine, BodyId, Zodiac } from "./chart.js";
+export declare const QUERY_ASPECTS: Record<string, number>;
+export type Interval = [number, number];
+/** Margin function (true where >= 0) carrying the bodies it depends on. */
+export interface Predicate {
+    (engine: Engine, t: number): number;
+    bodies: Set<string>;
+}
+/** True while `body` is within `orb` deg of an exact `kind` aspect to
+ *  `target` -- a fixed ecliptic longitude (deg) or another body name. */
+export declare function aspect(body: BodyId, kind: string, target: number | BodyId, orb?: number, zodiac?: Zodiac): Predicate;
+/** True while `body` is in `sign` (index 0=Aries..11=Pisces, or name). */
+export declare function inSign(body: BodyId, sign: number | string, zodiac?: Zodiac): Predicate;
+/** True while `body` is in apparent retrograde motion. */
+export declare function retrograde(body: BodyId, zodiac?: Zodiac): Predicate;
+/** True while `body` is direct or stationary. */
+export declare function notRetrograde(body: BodyId, zodiac?: Zodiac): Predicate;
+/** True where every predicate is true (interval intersection). */
+export declare function allOf(...preds: Predicate[]): Predicate;
+/** True where any predicate is true (interval union). */
+export declare function anyOf(...preds: Predicate[]): Predicate;
+/** True where `pred` is false (interval complement). */
+export declare function notOf(pred: Predicate): Predicate;
+export interface WhenOptions {
+    step?: number;
+    maxIntervals?: number;
+}
+/** Time intervals (jdStartUt, jdEndUt) in [jdStart, jdEnd] where `predicate`
+ *  is true. Endpoints touching the range bounds are clamped. The scan step
+ *  defaults to 0.125 d when a fast body (Moon, nodes, Lilith) is involved
+ *  and 1 d otherwise. */
+export declare function when(engine: Engine, predicate: Predicate, jdStart: number, jdEnd: number, opts?: WhenOptions): Interval[];

package/dist/src/query.js

@@ -0,0 +1,161 @@
+/**
+ * astroengine query -- declarative time queries ("when is ...?").
+ *
+ * The engine answers "where is the body?"; this answers "when is the
+ * configuration true?" over a time range. A predicate is a continuous
+ * "margin" function, true exactly where margin >= 0 (e.g. aspect-within-orb
+ * -> orb minus angular distance from exact). A boolean combination is then
+ * itself a margin -- AND = min of the parts, OR = max, NOT = negation -- so
+ * any query reduces to one continuous function and `when()` returns the
+ * intervals where it is true using the same coarse-scan-then-bisect root
+ * finder as events.crossings.
+ *
+ *   when(engine, allOf(aspect("saturn", "square", natalMoon),
+ *                      notRetrograde("mercury"),
+ *                      inSign("venus", "Taurus")), jdStart, jdEnd)
+ *
+ * Mirrors the Python reference (astroengine/query.py); the golden fixtures
+ * pin the two implementations together.
+ */
+import { mod } from "./core.js";
+import { SIGNS } from "./chart.js";
+export const QUERY_ASPECTS = {
+    conjunction: 0, semisextile: 30, sextile: 60, square: 90,
+    trine: 120, quincunx: 150, opposition: 180,
+};
+const FAST = new Set([
+    "moon", "mean_node", "true_node", "mean_lilith", "true_lilith",
+]);
+function wrap180(d) {
+    return mod(d + 180, 360) - 180;
+}
+function mk(fn, bodies) {
+    const p = fn;
+    p.bodies = bodies;
+    return p;
+}
+// ---------------------------------------------------------------- predicates
+/** True while `body` is within `orb` deg of an exact `kind` aspect to
+ *  `target` -- a fixed ecliptic longitude (deg) or another body name. */
+export function aspect(body, kind, target, orb = 1.0, zodiac = "tropical") {
+    const ang = QUERY_ASPECTS[kind];
+    if (ang === undefined)
+        throw new Error(`unknown aspect ${kind}`);
+    const isLon = typeof target === "number";
+    const bodies = new Set([body]);
+    if (!isLon)
+        bodies.add(target);
+    return mk((engine, t) => {
+        const lon = engine.longitude(body, t, { zodiac });
+        const tl = isLon
+            ? target
+            : engine.longitude(target, t, { zodiac });
+        const sep = lon - tl;
+        return orb - Math.min(Math.abs(wrap180(sep - ang)), Math.abs(wrap180(sep + ang)));
+    }, bodies);
+}
+/** True while `body` is in `sign` (index 0=Aries..11=Pisces, or name). */
+export function inSign(body, sign, zodiac = "tropical") {
+    const idx = typeof sign === "number" ? sign : SIGNS.indexOf(sign);
+    if (idx < 0)
+        throw new Error(`unknown sign ${sign}`);
+    const lo = idx * 30;
+    return mk((engine, t) => {
+        const d = mod(engine.longitude(body, t, { zodiac }) - lo, 360);
+        // signed distance to the nearest 30-deg band edge, positive inside
+        return d <= 30 ? Math.min(d, 30 - d) : -Math.min(d - 30, 360 - d);
+    }, new Set([body]));
+}
+/** True while `body` is in apparent retrograde motion. */
+export function retrograde(body, zodiac = "tropical") {
+    const h = 0.25;
+    return mk((engine, t) => {
+        const l0 = engine.longitude(body, t - h, { zodiac });
+        const l1 = engine.longitude(body, t + h, { zodiac });
+        return -wrap180(l1 - l0) / (2 * h); // >= 0 when moving backwards
+    }, new Set([body]));
+}
+/** True while `body` is direct or stationary. */
+export function notRetrograde(body, zodiac = "tropical") {
+    return notOf(retrograde(body, zodiac));
+}
+// --------------------------------------------------------------- combinators
+function combine(op, preds) {
+    const bodies = new Set();
+    for (const p of preds)
+        for (const b of p.bodies)
+            bodies.add(b);
+    return mk((engine, t) => op(preds.map((p) => p(engine, t))), bodies);
+}
+/** True where every predicate is true (interval intersection). */
+export function allOf(...preds) {
+    return combine((xs) => Math.min(...xs), preds);
+}
+/** True where any predicate is true (interval union). */
+export function anyOf(...preds) {
+    return combine((xs) => Math.max(...xs), preds);
+}
+/** True where `pred` is false (interval complement). */
+export function notOf(pred) {
+    return mk((engine, t) => -pred(engine, t), new Set(pred.bodies));
+}
+// --------------------------------------------------------------- solver
+function bisect(f, a, b, tol = 1e-6) {
+    let fa = f(a);
+    for (let i = 0; i < 60; i++) {
+        const m = 0.5 * (a + b);
+        if (Math.abs(b - a) < tol)
+            return m;
+        const fm = f(m);
+        if ((fa < 0) !== (fm < 0)) {
+            b = m;
+        }
+        else {
+            a = m;
+            fa = fm;
+        }
+    }
+    return 0.5 * (a + b);
+}
+/** Time intervals (jdStartUt, jdEndUt) in [jdStart, jdEnd] where `predicate`
+ *  is true. Endpoints touching the range bounds are clamped. The scan step
+ *  defaults to 0.125 d when a fast body (Moon, nodes, Lilith) is involved
+ *  and 1 d otherwise. */
+export function when(engine, predicate, jdStart, jdEnd, opts = {}) {
+    let step = opts.step;
+    if (step === undefined) {
+        let fast = false;
+        for (const b of predicate.bodies)
+            if (FAST.has(b))
+                fast = true;
+        step = fast ? 0.125 : 1.0;
+    }
+    const maxIntervals = opts.maxIntervals ?? 500;
+    const f = (t) => predicate(engine, t);
+    const intervals = [];
+    let prev = f(jdStart);
+    let openStart = prev >= 0 ? jdStart : null;
+    let t = jdStart + step;
+    while (t <= jdEnd + 1e-9 && intervals.length < maxIntervals) {
+        if (t > jdEnd)
+            t = jdEnd;
+        const cur = f(t);
+        if ((prev < 0) !== (cur < 0)) {
+            const edge = bisect(f, t - step, t);
+            if (cur >= 0) {
+                openStart = edge;
+            }
+            else if (openStart !== null) {
+                intervals.push([openStart, edge]);
+                openStart = null;
+            }
+        }
+        prev = cur;
+        if (t >= jdEnd)
+            break;
+        t += step;
+    }
+    if (openStart !== null)
+        intervals.push([openStart, jdEnd]);
+    return intervals;
+}

package/dist/src/stars.d.ts

@@ -0,0 +1,28 @@
+/**
+ * astroengine stars -- fixed stars: apparent places from the HYG-derived
+ * catalog (data/fixed_stars.json; ICRS J2000 with proper motions).
+ *
+ * Chain: full 3D space motion (proper motion + radial velocity at the
+ * parallax distance) -> ICRS equatorial -> ecliptic J2000 -> Vondrak 2011
+ * precession to date -> annual aberration (classic elliptic form, as for
+ * Pluto/Chiron) -> nutation. Validated against swe_fixstar fed the same
+ * catalog rows: <=0.3 arcsec over 1900-2099.
+ */
+import { EngineData } from "./core.js";
+export interface StarEntry {
+    ra: number;
+    dec: number;
+    pmra: number;
+    pmdec: number;
+    rv: number;
+    plx: number;
+    mag: number;
+    bayer: string;
+}
+export interface StarPack {
+    provenance: string;
+    frame: string;
+    stars: Record<string, StarEntry>;
+}
+/** Apparent ecliptic [lon, lat] of date (rad) for a catalog entry. */
+export declare function starApparent(data: EngineData, s: StarEntry, jde: number): [number, number];

package/dist/src/stars.js

@@ -0,0 +1,52 @@
+/**
+ * astroengine stars -- fixed stars: apparent places from the HYG-derived
+ * catalog (data/fixed_stars.json; ICRS J2000 with proper motions).
+ *
+ * Chain: full 3D space motion (proper motion + radial velocity at the
+ * parallax distance) -> ICRS equatorial -> ecliptic J2000 -> Vondrak 2011
+ * precession to date -> annual aberration (classic elliptic form, as for
+ * Pluto/Chiron) -> nutation. Validated against swe_fixstar fed the same
+ * catalog rows: <=0.3 arcsec over 1900-2099.
+ */
+import { DEG, ARCSEC, J2000, mod, nutation, precessEcliptic, vsopHeliocentric, } from "./core.js";
+const TWO_PI = 2 * Math.PI;
+const KM_PER_AU = 149597870.7;
+const AU_PER_PC = 206264.806;
+/** Apparent ecliptic [lon, lat] of date (rad) for a catalog entry. */
+export function starApparent(data, s, jde) {
+    const t = (jde - J2000) / 365.25;
+    const ra = s.ra * DEG;
+    const dec = s.dec * DEG;
+    const rAu = s.plx > 0 ? AU_PER_PC / (s.plx * 1e-3) : 1e9 * AU_PER_PC;
+    const cd = Math.cos(dec);
+    const sd = Math.sin(dec);
+    const cr = Math.cos(ra);
+    const sr = Math.sin(ra);
+    const p = [cd * cr, cd * sr, sd];
+    const east = [-sr, cr, 0.0];
+    const north = [-sd * cr, -sd * sr, cd];
+    const pmra = s.pmra * 1e-3 * ARCSEC;
+    const pmdec = s.pmdec * 1e-3 * ARCSEC;
+    const rv = (s.rv * 86400 * 365.25) / KM_PER_AU;
+    const pos = [0, 1, 2].map((i) => p[i] * rAu + (east[i] * pmra * rAu + north[i] * pmdec * rAu + p[i] * rv) * t);
+    const rn = Math.sqrt(pos[0] ** 2 + pos[1] ** 2 + pos[2] ** 2);
+    const x = pos[0] / rn;
+    const y = pos[1] / rn;
+    const z = pos[2] / rn;
+    const ra2 = Math.atan2(y, x);
+    const dec2 = Math.asin(z);
+    const e0 = 84381.448 * ARCSEC;
+    let lat = Math.asin(Math.sin(dec2) * Math.cos(e0) - Math.cos(dec2) * Math.sin(e0) * Math.sin(ra2));
+    let lon = mod(Math.atan2(Math.sin(ra2) * Math.cos(e0) + Math.tan(dec2) * Math.sin(e0), Math.cos(ra2)), TWO_PI);
+    [lon, lat] = precessEcliptic(lon, lat, J2000, jde);
+    const [L0] = vsopHeliocentric(data.vsop.earth, jde);
+    const sunLon = mod(L0 + Math.PI, TWO_PI);
+    const T = (jde - J2000) / 36525.0;
+    const k = 20.4898 * ARCSEC;
+    const e = 0.016708634 - 0.000042037 * T;
+    const piPer = (102.93735 + 1.71946 * T) * DEG;
+    lon += (-k * Math.cos(sunLon - lon) + e * k * Math.cos(piPer - lon)) / Math.cos(lat);
+    lat += -k * Math.sin(lat) * (Math.sin(sunLon - lon) - e * Math.sin(piPer - lon));
+    lon = mod(lon + nutation(data, jde)[0], TWO_PI);
+    return [lon, lat];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caelus",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Astrological ephemeris engine. MIT, no AGPL, no ephemeris files. Checked against Swiss Ephemeris.",
   "type": "module",
   "main": "dist/src/index.js",