tonus 0.1.0

package/dist/engines/planet/orbital.js

@@ -0,0 +1,223 @@
+export const ORBITAL_ELEMENTS = new Map([
+    [
+        "Mercury",
+        {
+            name: "Mercury",
+            symbol: "☿",
+            datasets: [
+                [
+                    [0.38709927, 0.00000037],
+                    [0.20563593, 0.00001906],
+                    [7.00497902, -0.00594749],
+                    [252.2503235, 149472.67411175],
+                    [77.45779628, 0.16047689],
+                    [48.33076593, -0.12534081],
+                ],
+                [
+                    [0.38709843, 0],
+                    [0.20563661, 0.00002123],
+                    [7.00559432, -0.00590158],
+                    [252.25166724, 149472.67486623],
+                    [77.45771895, 0.15940013],
+                    [48.33961819, -0.12214182],
+                ],
+            ],
+            radius: 2439.4,
+            rotation_period: 58.6462,
+        },
+    ],
+    [
+        "Venus",
+        {
+            name: "Venus",
+            symbol: "♀",
+            datasets: [
+                [
+                    [0.72333566, 0.0000039],
+                    [0.00676399, -0.00005107],
+                    [3.39467605, -0.0007889],
+                    [181.9790995, 58517.81538729],
+                    [131.60246718, 0.00268329],
+                    [76.67984255, -0.27769418],
+                ],
+                [
+                    [0.72332102, -0.00000026],
+                    [-0.00005107, 0.01673163],
+                    [3.39777545, 0.00043494],
+                    [181.9797085, 58517.8156026],
+                    [131.76755713, 0.05679648],
+                    [76.67261496, -0.27274174],
+                ],
+            ],
+            radius: 6051.8,
+            rotation_period: -243.018,
+        },
+    ],
+    [
+        "Earth",
+        {
+            name: "Earth",
+            symbol: "♁",
+            datasets: [
+                [
+                    [1.00000261, 0.00000562],
+                    [0.01671123, -0.00004392],
+                    [-0.00001531, -0.01294668],
+                    [100.46457166, 35999.37244981],
+                    [102.93768193, 0.32327364],
+                    [0, 0],
+                ],
+                [
+                    [1.00000018, 1.52371243],
+                    [0.01673163, -0.00003661],
+                    [-0.00054346, -0.01337178],
+                    [100.46691572, 35999.37306329],
+                    [102.93005885, 0.3179526],
+                    [-5.11260389, -0.24123856],
+                ],
+            ],
+            radius: 6371.0084,
+            rotation_period: 0.99726968,
+        },
+    ],
+    [
+        "Mars",
+        {
+            name: "Mars",
+            symbol: "♂",
+            datasets: [
+                [
+                    [1.52371034, 0.00001847],
+                    [0.0933941, 0.00007882],
+                    [1.84969142, -0.00813131],
+                    [-4.55343205, 19140.30268499],
+                    [-23.94362959, 0.44441088],
+                    [49.55953891, -0.29257343],
+                ],
+                [
+                    [1.52371243, 0.00000097],
+                    [0.09336511, 0.00009149],
+                    [1.85181869, -0.00724757],
+                    [-4.56813164, 19140.29934243],
+                    [-23.91744784, 0.45223625],
+                    [49.71320984, -0.26852431],
+                ],
+            ],
+            radius: 3389.5,
+            rotation_period: 1.02595676,
+        },
+    ],
+    [
+        "Jupiter",
+        {
+            name: "Jupiter",
+            symbol: "♃",
+            datasets: [
+                [
+                    [5.202887, -0.00011607],
+                    [0.04838624, -0.00013253],
+                    [1.30439695, -0.00183714],
+                    [34.39644051, 3034.74612775],
+                    [14.72847983, 0.21252668],
+                    [100.47390909, 0.20469106],
+                ],
+                [
+                    [5.20248019, -0.00002864],
+                    [0.0485359, 0.00018026],
+                    [1.29861416, -0.00322699],
+                    [34.33479152, 3034.90371757],
+                    [14.27495244, 0.18199196],
+                    [100.29282654, 0.13024619],
+                ],
+                [0.00012452, 0.0606406, -0.35635438, 38.35125],
+            ],
+            radius: 69911,
+            rotation_period: 0.41354,
+        },
+    ],
+    [
+        "Saturn",
+        {
+            name: "Saturn",
+            symbol: "♄",
+            datasets: [
+                [
+                    [9.53667594, -0.0012506],
+                    [0.05386179, -0.00050991],
+                    [2.48599187, 0.00193609],
+                    [49.95424423, 1222.49362201],
+                    [92.59887831, -0.41897216],
+                    [113.66242448, -0.28867794],
+                ],
+                [
+                    [9.54149883, -0.00003065],
+                    [0.05550825, -0.00032044],
+                    [2.49424102, 0.00451969],
+                    [50.07571329, 1222.11494724],
+                    [92.86136063, 0.54179478],
+                    [113.639987, -0.25015002],
+                ],
+                [0.00025899, -0.13434469, 0.87320147, 38.35125],
+            ],
+            radius: 58232,
+            rotation_period: 0.44401,
+        },
+    ],
+    [
+        "Uranus",
+        {
+            name: "Uranus",
+            symbol: "♅",
+            datasets: [
+                [
+                    [19.18916464, -0.00196176],
+                    [0.04725744, -0.00004397],
+                    [0.77263783, -0.00242939],
+                    [313.23810451, 428.48202785],
+                    [170.9542763, 0.40805281],
+                    [74.01692503, 0.04240589],
+                ],
+                [
+                    [19.18797948, -0.00020455],
+                    [0.0468574, -0.0000155],
+                    [0.77298127, -0.00180155],
+                    [314.20276625, 428.49512595],
+                    [172.43404441, 0.09266985],
+                    [73.96250215, 0.05739699],
+                ],
+                [0.00058331, -0.97731848, 0.17689245, 7.67025],
+            ],
+            radius: 25362,
+            rotation_period: -0.718,
+        },
+    ],
+    [
+        "Neptune",
+        {
+            name: "Neptune",
+            symbol: "♆",
+            datasets: [
+                [
+                    [30.06992276, 0.00026291],
+                    [0.00859048, 0.00005105],
+                    [1.77004347, 0.00035372],
+                    [-55.12002969, 218.45945325],
+                    [44.96476227, -0.32241464],
+                    [131.78422574, -0.00508664],
+                ],
+                [
+                    [30.06952752, 0.00006447],
+                    [0.00895439, 0.00000818],
+                    [1.7700552, 0.000224],
+                    [304.22289287, 218.46515314],
+                    [46.68158724, 0.01009938],
+                    [131.78635853, -0.00606302],
+                ],
+                [-0.00041348, 0.68346318, -0.10162547, 7.67025],
+            ],
+            radius: 24622,
+            rotation_period: 0.67125,
+        },
+    ],
+]);
+//# sourceMappingURL=orbital.js.map

package/dist/engines/planet/planet.d.ts

@@ -0,0 +1,13 @@
+import type { Cosmos, CosmosQuery } from "./types.js";
+/**
+ * Ephemeris lookup (`tonus.caelum`). Computes geocentric and heliocentric
+ * positions, zodiac signs, retrogradation, and aspects for the classical
+ * bodies at an instant (JPL Keplerian elements, 3000 BC – 3000 AD). A
+ * `from`/`to` range returns a stepped series.
+ */
+export declare function getCosmos(query: CosmosQuery & {
+    from: Date;
+    to: Date;
+}): Cosmos[];
+export declare function getCosmos(query?: CosmosQuery): Cosmos;
+//# sourceMappingURL=planet.d.ts.map

package/dist/engines/planet/planet.js

@@ -0,0 +1,198 @@
+// ---------------------------------------------------------------------------
+// engines/planet/planet — planetary snapshot builder
+// ---------------------------------------------------------------------------
+import { angleDelta, wrapAngle } from "./math.js";
+import { getState, sunPos, moonPos, planetPos } from "./position.js";
+import { sunAppearance, moonAppearance, planetAppearance } from "./appearance.js";
+import { detectAspects } from "./aspects.js";
+import { ORBITAL_ELEMENTS } from "./orbital.js";
+import { latinName } from "./types.js";
+import { DEFAULT_EPOCH } from "../epoch.js";
+const MS_PER_DAY = 86400000;
+const ALL_BODIES = ["Sun", "Moon", "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn"];
+const SIGNS = [
+    "Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo",
+    "Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces",
+];
+const zodiac = (lon) => Math.floor(wrapAngle(lon) / 30) % 12;
+const sign = (lon) => SIGNS[zodiac(lon)];
+function computeSpeed(geoLon, name, ts) {
+    const nextState = getState(ts + MS_PER_DAY);
+    const nextSun = sunPos(nextState);
+    let nextLon;
+    if (name === "Sun") {
+        nextLon = nextSun.geo.lon;
+    }
+    else if (name === "Moon") {
+        nextLon = moonPos(nextState, nextSun).geo.lon;
+    }
+    else {
+        nextLon = planetPos(name, nextState, nextSun).geo.lon;
+    }
+    return angleDelta(geoLon, nextLon);
+}
+function buildSun(ts) {
+    const state = getState(ts);
+    const pos = sunPos(state);
+    const app = sunAppearance(pos.geo.dist);
+    const speed = computeSpeed(pos.geo.lon, "Sun", ts);
+    return {
+        name: "Sun",
+        nomen: latinName("Sun"),
+        symbol: "☉",
+        helio: { lon: pos.helio.lon, lat: pos.helio.lat, dist: pos.helio.dist },
+        geo: pos.geo,
+        speed,
+        retrograde: speed < 0,
+        magnitude: app.magnitude,
+        elongation: 0,
+        phase: 1,
+        apparentDiameter: app.apparentDiameter,
+        zodiac: zodiac(pos.geo.lon),
+        sign: sign(pos.geo.lon),
+    };
+}
+function buildMoon(ts) {
+    const state = getState(ts);
+    const sun = sunPos(state);
+    const pos = moonPos(state, sun);
+    const app = moonAppearance({
+        sunLongitude: sun.geo.lon,
+        moonLongitude: pos.geo.lon,
+        moonLatitude: pos.geo.lat,
+        distEarthRadii: pos.distEarthRadii,
+    });
+    const speed = computeSpeed(pos.geo.lon, "Moon", ts);
+    return {
+        name: "Moon",
+        nomen: latinName("Moon"),
+        symbol: "☾",
+        helio: { lon: 0, lat: 0, dist: 0 },
+        geo: {
+            lon: pos.geo.lon,
+            lat: pos.geo.lat,
+            dist: pos.geo.dist,
+            equatorial: pos.geo.equatorial,
+        },
+        speed,
+        retrograde: speed < 0,
+        magnitude: -12.6,
+        elongation: app.elongation,
+        phase: app.phase,
+        apparentDiameter: app.apparentDiameter,
+        zodiac: zodiac(pos.geo.lon),
+        sign: sign(pos.geo.lon),
+        distEarthRadii: pos.distEarthRadii,
+    };
+}
+function buildPlanet(name, ts) {
+    const state = getState(ts);
+    const sun = sunPos(state);
+    const pos = planetPos(name, state, sun);
+    const elem = ORBITAL_ELEMENTS.get(name);
+    const app = planetAppearance({
+        name,
+        heliocentricDistance: pos.helio.dist,
+        geocentricDistance: pos.geo.dist,
+        geocentricLongitude: pos.geo.lon,
+        geocentricLatitude: pos.geo.lat,
+        sunDistance: sun.geo.dist,
+        J: state.J,
+    });
+    const speed = computeSpeed(pos.geo.lon, name, ts);
+    return {
+        name,
+        nomen: latinName(name),
+        symbol: elem.symbol,
+        helio: { lon: pos.helio.lon, lat: pos.helio.lat, dist: pos.helio.dist },
+        geo: {
+            lon: pos.geo.lon, lat: pos.geo.lat, dist: pos.geo.dist,
+            equatorial: pos.geo.equatorial,
+        },
+        speed,
+        retrograde: speed < 0,
+        magnitude: app.magnitude,
+        elongation: app.elongation,
+        phase: app.phase,
+        apparentDiameter: app.apparentDiameter,
+        zodiac: zodiac(pos.helio.lon),
+        sign: sign(pos.helio.lon),
+    };
+}
+function buildEarth(ts) {
+    const state = getState(ts);
+    const sun = sunPos(state);
+    const pos = planetPos("Earth", state, sun);
+    const elem = ORBITAL_ELEMENTS.get("Earth");
+    const speed = computeSpeed(pos.geo.lon, "Earth", ts);
+    return {
+        name: "Earth",
+        nomen: latinName("Earth"),
+        symbol: elem.symbol,
+        helio: { lon: pos.helio.lon, lat: pos.helio.lat, dist: pos.helio.dist },
+        geo: {
+            lon: pos.geo.lon, lat: pos.geo.lat, dist: pos.geo.dist,
+            equatorial: pos.geo.equatorial,
+        },
+        speed,
+        retrograde: speed < 0,
+        magnitude: 0,
+        elongation: 0,
+        phase: 1,
+        apparentDiameter: 0,
+        zodiac: zodiac(pos.helio.lon),
+        sign: sign(pos.helio.lon),
+    };
+}
+const BODY_BUILDERS = {
+    Sun: buildSun,
+    Moon: buildMoon,
+    Mercury: (ts) => buildPlanet("Mercury", ts),
+    Venus: (ts) => buildPlanet("Venus", ts),
+    Earth: buildEarth,
+    Mars: (ts) => buildPlanet("Mars", ts),
+    Jupiter: (ts) => buildPlanet("Jupiter", ts),
+    Saturn: (ts) => buildPlanet("Saturn", ts),
+};
+const MAX_FRAMES = 10000;
+function snapshotAt(date, requested, orbLimit) {
+    const ts = date.getTime();
+    const bodies = requested.map((name) => BODY_BUILDERS[name](ts));
+    const geoLons = {};
+    for (const body of bodies) {
+        if (body.name !== "Earth")
+            geoLons[body.name] = body.geo.lon;
+    }
+    const aspects = detectAspects(geoLons, { orbLimit });
+    return { date, bodies, aspects };
+}
+export function getCosmos(query = {}) {
+    const requested = query.bodies ?? ALL_BODIES;
+    if (query.from != null || query.to != null) {
+        if (query.from == null || query.to == null) {
+            throw new RangeError("caelum range requires both from and to");
+        }
+        if (query.to.getTime() < query.from.getTime()) {
+            throw new RangeError("caelum range: to must be >= from");
+        }
+        const step = query.step ?? 1;
+        if (step <= 0) {
+            throw new RangeError("caelum range: step must be > 0");
+        }
+        const stepMs = step * MS_PER_DAY;
+        const startTs = query.from.getTime();
+        const endTs = query.to.getTime();
+        const frameCount = Math.floor((endTs - startTs) / stepMs) + 1;
+        if (frameCount > MAX_FRAMES) {
+            throw new RangeError(`caelum range would produce ${frameCount} frames (max ${MAX_FRAMES})`);
+        }
+        const frames = [];
+        for (let ts = startTs; ts <= endTs; ts += stepMs) {
+            frames.push(snapshotAt(new Date(ts), requested, query.orbLimit));
+        }
+        return frames;
+    }
+    const date = query.date ?? query.feast?.date ?? DEFAULT_EPOCH;
+    return snapshotAt(date, requested, query.orbLimit);
+}
+//# sourceMappingURL=planet.js.map

package/dist/engines/planet/position.d.ts

@@ -0,0 +1,62 @@
+export declare const EARTH_RADIUS_AU: number;
+export interface AstroState {
+    JD: number;
+    TT: number;
+    TS: number;
+    J: number;
+    T: number;
+    eps: number;
+}
+export declare function getState(ts: number): AstroState;
+export interface ComputedPos {
+    geo: {
+        x: number;
+        y: number;
+        z: number;
+        lon: number;
+        lat: number;
+        dist: number;
+        equatorial: {
+            x: number;
+            y: number;
+            z: number;
+            ra: number;
+            dec: number;
+            dist: number;
+        };
+    };
+}
+export interface SunPos extends ComputedPos {
+    helio: {
+        lon: number;
+        lat: number;
+        dist: number;
+    };
+    orbit: {
+        L: number;
+        M: number;
+        omega: number;
+        e: number;
+    };
+}
+export interface PlanetPos extends ComputedPos {
+    helio: {
+        x: number;
+        y: number;
+        z: number;
+        lon: number;
+        lat: number;
+        dist: number;
+    };
+}
+export interface MoonPos extends ComputedPos {
+    helio: Record<string, never>;
+    geo: ComputedPos["geo"] & {
+        distEarthRadii: number;
+    };
+    distEarthRadii: number;
+}
+export declare function sunPos(state: AstroState): SunPos;
+export declare function moonPos(state: AstroState, sun: SunPos): MoonPos;
+export declare function planetPos(name: string, state: AstroState, sun: SunPos): PlanetPos;
+//# sourceMappingURL=position.d.ts.map

package/dist/engines/planet/position.js

@@ -0,0 +1,156 @@
+// ---------------------------------------------------------------------------
+// engines/planet/position — Julian date, astro state, helio/geo position engine
+// ---------------------------------------------------------------------------
+import { sinDeg, cosDeg, atan2Deg, kepler, wrapAngle, toAu, toCartesian, toSpherical, toEquatorial } from "./math.js";
+import { ORBITAL_ELEMENTS } from "./orbital.js";
+const MS_PER_DAY = 86400000;
+// Precomputed Earth radius in AU (used for Moon distance conversion)
+const EARTH_ELEM = ORBITAL_ELEMENTS.get("Earth");
+export const EARTH_RADIUS_AU = toAu(EARTH_ELEM.radius);
+function meanObliquity(T) {
+    const eps0 = 23 + 26 / 60 + 21.406 / 3600;
+    const sec = -46.836769 * T -
+        0.0001831 * T ** 2 +
+        0.0020034 * T ** 3 -
+        0.000000576 * T ** 4 -
+        0.0000000434 * T ** 5;
+    return eps0 + sec / 3600;
+}
+export function getState(ts) {
+    const JD = 2440587.5 + ts / MS_PER_DAY;
+    const _T = (JD - 2451545) / 36525;
+    const dT = 64.7 + 64.7 * _T - 0.6 * _T * _T; // seconds
+    const TT = JD + dT / 86400;
+    const J = TT - 2451545.0;
+    const T = J / 36525;
+    const eps = meanObliquity(T);
+    return { JD, TT, TS: ts, J, T, eps };
+}
+// ── Sun position ──
+export function sunPos(state) {
+    const { J, eps } = state;
+    const omega = 282.9404 + 4.70935e-5 * J;
+    const e = 0.016709 - 1.151e-9 * J;
+    const M = 356.047 + 0.9856002585 * J;
+    const E = M + (180 / Math.PI) * e * sinDeg(M) * (1 + e * cosDeg(M));
+    const xp = cosDeg(E) - e;
+    const yp = Math.sqrt(1 - e * e) * sinDeg(E);
+    const dist = Math.sqrt(xp * xp + yp * yp);
+    const v = atan2Deg(yp, xp);
+    const lambda = v + omega;
+    const L = omega + M;
+    const x = dist * cosDeg(lambda);
+    const y = dist * sinDeg(lambda);
+    const z = 0;
+    const [xe, ye, ze] = toEquatorial(x, y, z, eps);
+    const [ra, dec, rho] = toSpherical(xe, ye, ze);
+    return {
+        helio: { lon: wrapAngle(lambda), lat: 0, dist },
+        orbit: { L: wrapAngle(L), M: wrapAngle(M), omega, e },
+        geo: {
+            x, y, z,
+            lon: wrapAngle(lambda), lat: 0, dist,
+            equatorial: { x: xe, y: ye, z: ze, ra: wrapAngle(ra), dec, dist: rho },
+        },
+    };
+}
+// ── Moon position ──
+export function moonPos(state, sun) {
+    const { J, eps } = state;
+    const Omega = wrapAngle(125.1228 - 0.0529538083 * J);
+    const I = 5.1454;
+    const omega = wrapAngle(318.0634 + 0.1643573223 * J);
+    const a = 60.2666; // Earth radii
+    const e = 0.0549;
+    const M = wrapAngle(115.3654 + 13.0649929509 * J);
+    const E = M + (180 / Math.PI) * e * sinDeg(M) * (1 + e * cosDeg(M));
+    const xh = a * (cosDeg(E) - e);
+    const yh = a * Math.sqrt(1 - e * e) * sinDeg(E);
+    const cO = cosDeg(Omega), sO = sinDeg(Omega);
+    const cw = cosDeg(omega), sw = sinDeg(omega);
+    const cI = cosDeg(I), sI = sinDeg(I);
+    const x = (cw * cO - sw * sO * cI) * xh + (-sw * cO - cw * sO * cI) * yh;
+    const y = (cw * sO + sw * cO * cI) * xh + (-sw * sO + cw * cO * cI) * yh;
+    const z = sw * sI * xh + cw * sI * yh;
+    const [lonE, latE, distE] = toSpherical(x, y, z);
+    const Lm = wrapAngle(Omega + omega + M);
+    const Ms = sun.orbit.M;
+    const Ls = sun.orbit.L;
+    const D = wrapAngle(Lm - Ls);
+    const F = wrapAngle(Lm - Omega);
+    // Lunar perturbations
+    const lonPerturb = -1.274 * sinDeg(M - 2 * D) + 0.658 * sinDeg(2 * D) - 0.186 * sinDeg(Ms) -
+        0.059 * sinDeg(2 * M - 2 * D) - 0.057 * sinDeg(M - 2 * D + Ms) +
+        0.053 * sinDeg(M + 2 * D) + 0.046 * sinDeg(2 * D - Ms) +
+        0.041 * sinDeg(M - Ms) - 0.035 * sinDeg(D) - 0.031 * sinDeg(M + Ms) -
+        0.015 * sinDeg(2 * F - 2 * D) + 0.011 * sinDeg(M - 4 * D);
+    const latPerturb = -0.173 * sinDeg(F - 2 * D) - 0.055 * sinDeg(M - F - 2 * D) -
+        0.046 * sinDeg(M + F - 2 * D) + 0.033 * sinDeg(F + 2 * D) +
+        0.017 * sinDeg(2 * M + F);
+    const distPerturb = -0.58 * cosDeg(M - 2 * D) - 0.46 * cosDeg(2 * D);
+    const lon = wrapAngle(lonE + lonPerturb);
+    const lat = latE + latPerturb;
+    const rER = distE + distPerturb; // Earth radii
+    const [xc, yc, zc] = toCartesian(lon, lat, rER);
+    const xAu = xc * EARTH_RADIUS_AU;
+    const yAu = yc * EARTH_RADIUS_AU;
+    const zAu = zc * EARTH_RADIUS_AU;
+    const distAu = rER * EARTH_RADIUS_AU;
+    const [xe, ye, ze] = toEquatorial(xAu, yAu, zAu, eps);
+    const [ra, dec, rho] = toSpherical(xe, ye, ze);
+    return {
+        helio: {},
+        distEarthRadii: rER,
+        geo: {
+            x: xAu, y: yAu, z: zAu,
+            lon, lat, dist: distAu,
+            distEarthRadii: rER,
+            equatorial: { x: xe, y: ye, z: ze, ra: wrapAngle(ra), dec, dist: rho },
+        },
+    };
+}
+// ── Planet position ──
+export function planetPos(name, state, sun) {
+    const body = ORBITAL_ELEMENTS.get(name);
+    if (!body)
+        throw new Error(`Unknown body: ${name}`);
+    const { J, T, eps } = state;
+    const oe = body.datasets;
+    // Use higher-precision dataset (1800–2050) if in range, otherwise long-range dataset
+    const dataset = J > -73048.5 && J < 18626.5 ? oe[1] : oe[0];
+    const [a, e, I, L, wBar, Omega] = dataset.map(([x0, x1]) => x0 + x1 * T);
+    const omega = wBar - Omega; // argument of periapsis
+    let M = L - wBar; // mean anomaly
+    // Perturbation correction for outer planets
+    if (oe[2]) {
+        const [b, c, s, f] = oe[2];
+        M += b * T * T + c * cosDeg(f * T) + s * sinDeg(f * T);
+    }
+    const E = kepler(M, e);
+    const xh = a * (cosDeg(E) - e);
+    const yh = a * Math.sqrt(1 - e * e) * sinDeg(E);
+    const cO = cosDeg(Omega), sO = sinDeg(Omega);
+    const cw = cosDeg(omega), sw = sinDeg(omega);
+    const cI = cosDeg(I), sI = sinDeg(I);
+    // Ecliptic heliocentric Cartesian
+    const x = (cw * cO - sw * sO * cI) * xh + (-sw * cO - cw * sO * cI) * yh;
+    const y = (cw * sO + sw * cO * cI) * xh + (-sw * sO + cw * cO * cI) * yh;
+    const z = sw * sI * xh + cw * sI * yh;
+    const [helioLon, helioLat, helioR] = toSpherical(x, y, z);
+    // Geocentric (add Sun's geocentric position vector to flip to Earth-centered)
+    const xg = x + sun.geo.x;
+    const yg = y + sun.geo.y;
+    const zg = z + sun.geo.z;
+    const [geoLon, geoLat, geoDist] = toSpherical(xg, yg, zg);
+    const [xe, ye, ze] = toEquatorial(xg, yg, zg, eps);
+    const [ra, dec, rho] = toSpherical(xe, ye, ze);
+    return {
+        helio: { x, y, z, lon: wrapAngle(helioLon), lat: helioLat, dist: helioR },
+        geo: {
+            x: xg, y: yg, z: zg,
+            lon: wrapAngle(geoLon), lat: geoLat, dist: geoDist,
+            equatorial: { x: xe, y: ye, z: ze, ra: wrapAngle(ra), dec, dist: rho },
+        },
+    };
+}
+//# sourceMappingURL=position.js.map