caelus 0.14.0 → 0.15.0

package/dist/src/chart.d.ts

@@ -10,6 +10,37 @@ export declare const SIGNS: string[];
 export declare const ASPECTS: Record<string, number>;
 export declare const DEFAULT_ORBS: Record<string, number>;
 export type HouseSystem = "placidus" | "porphyry" | "equal" | "whole_sign" | "koch" | "regiomontanus" | "campanus" | "alcabitius" | "morinus" | "meridian" | "polich_page" | "vehlow";
+/** The canonical house-system ids, in a stable order (also used for error text). */
+export declare const HOUSE_SYSTEMS: readonly HouseSystem[];
+/** Resolve a forgiving house-system string (any case, spaces or hyphens, or a
+ *  known alias) to a canonical {@link HouseSystem}, or throw listing the valid
+ *  ids. Lets MCP, share links, and hand-written calls pass "whole sign",
+ *  "Whole_Sign", "whole", etc. without tripping the strict union. */
+export declare function normalizeHouseSystem(raw: string): HouseSystem;
+export type Element = "fire" | "earth" | "air" | "water";
+export type Modality = "cardinal" | "fixed" | "mutable";
+/** Triplicity (element) of a sign: `"fire"`, `"earth"`, `"air"`, or `"water"`. */
+export declare function element(sign: number | string): Element;
+/** Quadruplicity (modality) of a sign: `"cardinal"`, `"fixed"`, or `"mutable"`. */
+export declare function modality(sign: number | string): Modality;
+/** 1-based quadrant (I–IV) of a 1-based house number: houses 1–3 -> 1, etc. */
+export declare function quadrant(house: number): number;
+/**
+ * Essential dignities a body holds in a sign: any of `"domicile"`,
+ * `"exaltation"`, `"detriment"`, `"fall"` (the last two are the signs opposite
+ * domicile and exaltation). Empty when the body is peregrine there or has no
+ * classical rulership (the outer planets, Chiron, the nodes).
+ *
+ * @param body Body id, e.g. `"mars"`.
+ * @param sign A sign index `0`–`11` (Aries = 0) or its name, e.g. `"Aries"`.
+ * @returns The dignities held, in the order above; empty if none.
+ * @example
+ * ```ts
+ * dignities("mars", "Aries"); // ["domicile"]
+ * dignities("sun", "Libra");  // ["fall"]
+ * ```
+ */
+export declare function dignities(body: string, sign: number | string): string[];
 export type Ayanamsa = keyof typeof AYANAMSA_J2000 & string;
 export type Zodiac = "tropical" | `sidereal:${string}`;
 export interface Observer {
@@ -58,6 +89,33 @@ export interface Position {
     /** Equatorial declination, true equinox of date, degrees. */
     dec: number;
 }
+/** A {@link Position} enriched with chart-relative placement, as returned per
+ *  body by {@link Engine.chart} and {@link Engine.chartAt}. */
+export interface ChartBody extends Position {
+    /** 1-based house the body falls in, by the chart's cusps (1–12). */
+    house: number;
+    /** Essential dignities held in the body's sign (see {@link dignities});
+     *  empty when peregrine or for bodies without classical rulerships. */
+    dignities: string[];
+}
+/** Default chart bodies that are Chebyshev-packed, so they can fall outside
+ *  their fitted range (and be omitted from a chart). Opt-in asteroids are
+ *  packed too, but arrive as arbitrary ids through the string index. */
+export type PackedBody = "chiron";
+/** Bodies guaranteed to be in every chart: the analytic Sun–Pluto and the lunar
+ *  nodes, which resolve across all supported epochs. (Chiron is Chebyshev-packed
+ *  and can fall outside its fitted range, so it is *not* guaranteed.) */
+export type AlwaysBody = Exclude<Body, PackedBody>;
+/**
+ * A chart's bodies, keyed by id. The analytic core ({@link AlwaysBody}) is
+ * always present and needs no presence check. {@link PackedBody} bodies (Chiron)
+ * and any opt-in extras requested via {@link ChartOptions.bodies} may be absent
+ * when the instant is outside their fitted range (see {@link Chart.unavailable}),
+ * so those accesses are typed `ChartBody | undefined` and must be guarded.
+ */
+export type ChartBodies = Record<AlwaysBody, ChartBody> & Partial<Record<PackedBody, ChartBody>> & {
+    [id: string]: ChartBody | undefined;
+};
 /** One aspect between two bodies in a {@link Chart}. */
 export interface Aspect {
     /** First body id. */
@@ -81,8 +139,14 @@ export interface Chart {
     houseSystem: HouseSystem;
     /** The house system originally requested, before any polar fallback. */
     houseSystemRequested: HouseSystem;
-    /** Apparent {@link Position} per body, keyed by body id. */
-    bodies: Record<string, Position>;
+    /** Apparent position per body, enriched with house and dignities, keyed by
+     *  body id. See {@link ChartBody}. */
+    bodies: ChartBodies;
+    /** Body ids that were requested but omitted because the instant falls outside
+     *  their fitted range (e.g. Chiron and other Chebyshev-packed bodies before
+     *  ~1850 or after ~2150). Empty for the usual modern dates. The analytic
+     *  bodies (Sun through Pluto and the nodes) are always present. */
+    unavailable: string[];
     /** Chart angles in degrees: Ascendant, Midheaven, Vertex, East Point. */
     angles: {
         asc: number;
@@ -235,10 +299,10 @@ export declare class Engine {
      * instant and place.
      *
      * The first six arguments are calendar fields in **UT** — not local civil
-     * time, and not a Julian Day. Passing a JD in `y` builds an instant far
-     * outside the fitted range and throws `RangeError`; use {@link Engine.chartAt}
-     * for a chart from a JD. For a birth time given in a local time zone, resolve
-     * it to UT first (see the `caelus-birth` package).
+     * time, and not a Julian Day. Passing a JD in `y` builds an absurd instant and
+     * throws `RangeError`; use {@link Engine.chartAt} for a chart from a JD. For a
+     * birth time given in a local time zone, resolve it to UT first (see the
+     * `caelus-birth` package).
      *
      * @param y Year in UT, e.g. `1990` — a calendar year, not a Julian Day.
      * @param mo Month, `1`–`12`.
@@ -254,9 +318,12 @@ export declare class Engine {
      *   custom orbs. Defaults to Placidus houses in the tropical zodiac.
      * @returns A {@link Chart}: `bodies`, `cusps`, `angles`, and `aspects`, plus
      *   `jdUt` and the house system actually used (Placidus and Koch fall back to
-     *   whole-sign above the polar circles).
-     * @throws RangeError if the instant lands outside the fitted range
-     *   (1800–2149) — most often from passing a Julian Day where a year belongs.
+     *   whole-sign above the polar circles). A body outside its fitted range
+     *   (e.g. Chiron before ~1850) is omitted from `bodies` and listed in
+     *   `unavailable` rather than failing the whole chart.
+     * @throws RangeError only if the instant itself is absurd — far outside any
+     *   supported epoch — which almost always means a Julian Day was passed where
+     *   calendar fields belong.
      * @example
      * ```ts
      * // 1990-06-10 14:30 UT at Tampa, FL (27.95° N, 82.46° W), Placidus houses

package/dist/src/chart.js

@@ -23,7 +23,92 @@ export const ASPECTS = {
 export const DEFAULT_ORBS = {
     conjunction: 8, sextile: 4, square: 7, trine: 7, opposition: 8,
 };
+/** The canonical house-system ids, in a stable order (also used for error text). */
+export const HOUSE_SYSTEMS = [
+    "placidus", "porphyry", "equal", "whole_sign", "koch", "regiomontanus",
+    "campanus", "alcabitius", "morinus", "meridian", "polich_page", "vehlow",
+];
+// Short or alternate names that normalization (lowercase + space/hyphen -> "_")
+// can't reach on its own. "whole sign", "Polich Page", etc. already normalize to
+// their canonical id, so only genuinely different spellings live here.
+const HOUSE_ALIASES = {
+    whole: "whole_sign", signs: "whole_sign", wholesign: "whole_sign",
+    equal_house: "equal", porphyrius: "porphyry", placidean: "placidus",
+};
+/** Resolve a forgiving house-system string (any case, spaces or hyphens, or a
+ *  known alias) to a canonical {@link HouseSystem}, or throw listing the valid
+ *  ids. Lets MCP, share links, and hand-written calls pass "whole sign",
+ *  "Whole_Sign", "whole", etc. without tripping the strict union. */
+export function normalizeHouseSystem(raw) {
+    const key = raw.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    if (HOUSE_SYSTEMS.includes(key))
+        return key;
+    const alias = HOUSE_ALIASES[key];
+    if (alias)
+        return alias;
+    throw new Error(`unknown house system '${raw}' (valid: ${HOUSE_SYSTEMS.join(", ")})`);
+}
+const ELEMENTS = ["fire", "earth", "air", "water"];
+const MODALITIES = ["cardinal", "fixed", "mutable"];
+/** Sign index `0`–`11` (Aries = 0) from an index or a sign name (`"Aries"`). */
+function signIndex(sign) {
+    return typeof sign === "number" ? mod(Math.floor(sign), 12) : SIGNS.indexOf(sign);
+}
+/** Triplicity (element) of a sign: `"fire"`, `"earth"`, `"air"`, or `"water"`. */
+export function element(sign) {
+    return ELEMENTS[mod(signIndex(sign), 4)];
+}
+/** Quadruplicity (modality) of a sign: `"cardinal"`, `"fixed"`, or `"mutable"`. */
+export function modality(sign) {
+    return MODALITIES[mod(signIndex(sign), 3)];
+}
+/** 1-based quadrant (I–IV) of a 1-based house number: houses 1–3 -> 1, etc. */
+export function quadrant(house) {
+    return Math.floor(mod(house - 1, 12) / 3) + 1;
+}
+// ----------------------------------------------------------- essential dignities
+const DOMICILE = {
+    sun: [4], moon: [3], mercury: [2, 5], venus: [1, 6],
+    mars: [0, 7], jupiter: [8, 11], saturn: [9, 10],
+};
+const EXALTATION = {
+    sun: 0, moon: 1, mercury: 5, venus: 11, mars: 9, jupiter: 3, saturn: 6,
+};
+/**
+ * Essential dignities a body holds in a sign: any of `"domicile"`,
+ * `"exaltation"`, `"detriment"`, `"fall"` (the last two are the signs opposite
+ * domicile and exaltation). Empty when the body is peregrine there or has no
+ * classical rulership (the outer planets, Chiron, the nodes).
+ *
+ * @param body Body id, e.g. `"mars"`.
+ * @param sign A sign index `0`–`11` (Aries = 0) or its name, e.g. `"Aries"`.
+ * @returns The dignities held, in the order above; empty if none.
+ * @example
+ * ```ts
+ * dignities("mars", "Aries"); // ["domicile"]
+ * dignities("sun", "Libra");  // ["fall"]
+ * ```
+ */
+export function dignities(body, sign) {
+    const idx = signIndex(sign);
+    const dom = DOMICILE[body] ?? [];
+    const out = [];
+    if (dom.includes(idx))
+        out.push("domicile");
+    if (EXALTATION[body] === idx)
+        out.push("exaltation");
+    if (dom.map((d) => mod(d + 6, 12)).includes(idx))
+        out.push("detriment");
+    if (body in EXALTATION && mod(EXALTATION[body] + 6, 12) === idx)
+        out.push("fall");
+    return out;
+}
 const KM_PER_AU = 149597870.7;
+// A generous window for the analytic models. Every real chart, however
+// historical, sits well inside it; an instant far outside almost always means a
+// Julian Day was passed to chart() where calendar fields belong.
+const JD_SANE_MIN = -2_000_000; // ~ 10000 BC
+const JD_SANE_MAX = 9_000_000; // ~ 20000 AD
 function parseZodiac(zodiac) {
     if (zodiac === "tropical")
         return null;
@@ -339,10 +424,10 @@ export class Engine {
      * instant and place.
      *
      * The first six arguments are calendar fields in **UT** — not local civil
-     * time, and not a Julian Day. Passing a JD in `y` builds an instant far
-     * outside the fitted range and throws `RangeError`; use {@link Engine.chartAt}
-     * for a chart from a JD. For a birth time given in a local time zone, resolve
-     * it to UT first (see the `caelus-birth` package).
+     * time, and not a Julian Day. Passing a JD in `y` builds an absurd instant and
+     * throws `RangeError`; use {@link Engine.chartAt} for a chart from a JD. For a
+     * birth time given in a local time zone, resolve it to UT first (see the
+     * `caelus-birth` package).
      *
      * @param y Year in UT, e.g. `1990` — a calendar year, not a Julian Day.
      * @param mo Month, `1`–`12`.
@@ -358,9 +443,12 @@ export class Engine {
      *   custom orbs. Defaults to Placidus houses in the tropical zodiac.
      * @returns A {@link Chart}: `bodies`, `cusps`, `angles`, and `aspects`, plus
      *   `jdUt` and the house system actually used (Placidus and Koch fall back to
-     *   whole-sign above the polar circles).
-     * @throws RangeError if the instant lands outside the fitted range
-     *   (1800–2149) — most often from passing a Julian Day where a year belongs.
+     *   whole-sign above the polar circles). A body outside its fitted range
+     *   (e.g. Chiron before ~1850) is omitted from `bodies` and listed in
+     *   `unavailable` rather than failing the whole chart.
+     * @throws RangeError only if the instant itself is absurd — far outside any
+     *   supported epoch — which almost always means a Julian Day was passed where
+     *   calendar fields belong.
      * @example
      * ```ts
      * // 1990-06-10 14:30 UT at Tampa, FL (27.95° N, 82.46° W), Placidus houses
@@ -393,8 +481,12 @@ export class Engine {
      * @see {@link Engine.chart} for the calendar-field entry point.
      */
     chartAt(jdUt, lat, lonEast, opts = "placidus") {
+        if (!Number.isFinite(jdUt) || jdUt < JD_SANE_MIN || jdUt > JD_SANE_MAX) {
+            throw new RangeError(`chart instant (jd ${jdUt}) is far outside the supported range; if you ` +
+                `meant a calendar date, pass year/month/day to chart() rather than a Julian Day.`);
+        }
         const o = typeof opts === "string" ? { houseSystem: opts } : opts;
-        const houseSystem = o.houseSystem ?? "placidus";
+        const houseSystem = normalizeHouseSystem(o.houseSystem ?? "placidus");
         const zodiac = o.zodiac ?? "tropical";
         const mode = parseZodiac(zodiac);
         const calc = {
@@ -406,8 +498,22 @@ export class Engine {
             ...BODIES, ...(o.bodies ?? []).filter((b) => !BODIES.includes(b)),
         ];
         const bodies = {};
-        for (const b of names)
-            bodies[b] = this.position(b, jdUt, calc);
+        const unavailable = [];
+        for (const b of names) {
+            try {
+                bodies[b] = this.position(b, jdUt, calc);
+            }
+            catch (e) {
+                // A Chebyshev-packed body (Chiron, fitted asteroids) outside its fitted
+                // range throws RangeError. Omit it and report it rather than discarding
+                // the whole chart; the analytic bodies still resolve. Any other error
+                // (e.g. a missing data pack) is a real fault and propagates.
+                if (e instanceof RangeError)
+                    unavailable.push(b);
+                else
+                    throw e;
+            }
+        }
         const [asc, mc, armc, eps] = H.angles(this.data, jdUt, lat, lonEast);
         const [vtx, east] = H.vertexEastPoint(armc, lat * DEG, eps);
         const phi = lat * DEG;
@@ -454,7 +560,7 @@ export class Engine {
                 cusps = H.housesVehlow(armc, phi, eps);
             }
             else {
-                throw new Error(`unknown house system '${houseSystem}'`);
+                throw new Error(`unknown house system '${houseSystem}' (valid: ${HOUSE_SYSTEMS.join(", ")})`);
             }
         }
         catch (err) {
@@ -477,21 +583,44 @@ export class Engine {
         else {
             cuspsDeg = cusps.map(outDeg);
         }
+        // Enrich each position with chart-relative placement (house) and the
+        // essential dignities of its sign, so callers don't recompute from cusps.
+        const chartBodies = {};
+        for (const b of names) {
+            const p = bodies[b];
+            if (!p)
+                continue; // omitted: outside its fitted range (see `unavailable`)
+            chartBodies[b] = {
+                ...p,
+                house: houseIndex(p.lon, cuspsDeg),
+                dignities: dignities(b, Math.floor(mod(p.lon, 360) / 30)),
+            };
+        }
         return {
             jdUt,
             zodiac,
             houseSystem: used,
             houseSystemRequested: houseSystem,
-            bodies,
+            bodies: chartBodies,
+            unavailable,
             angles: {
                 asc: outDeg(asc), mc: outDeg(mc),
                 vertex: outDeg(vtx), eastPoint: outDeg(east),
             },
             cusps: cuspsDeg,
-            aspects: findAspects(bodies, o.orbs ?? DEFAULT_ORBS),
+            aspects: findAspects(chartBodies, o.orbs ?? DEFAULT_ORBS),
         };
     }
 }
+/** 1-based house for an ecliptic longitude (degrees) given the twelve cusp
+ *  longitudes (degrees), wrapping across 0. */
+function houseIndex(lon, cusps) {
+    for (let i = 0; i < 12; i++) {
+        if (mod(lon - cusps[i], 360) < mod(cusps[(i + 1) % 12] - cusps[i], 360))
+            return i + 1;
+    }
+    return 12;
+}
 export function findAspects(bodies, orbs = DEFAULT_ORBS) {
     const out = [];
     const names = Object.keys(bodies).filter((b) => !NOT_ASPECTABLE.has(b));
@@ -511,8 +640,11 @@ export function findAspects(bodies, orbs = DEFAULT_ORBS) {
     return out;
 }
 export function fmtLon(deg) {
-    const sign = SIGNS[Math.floor(deg / 30)];
-    const d = mod(deg, 30);
+    // Normalize first: a raw or rounded longitude (e.g. exactly 360, or a small
+    // negative) would otherwise index SIGNS out of range and render "undefined".
+    const norm = mod(deg, 360);
+    const sign = SIGNS[Math.floor(norm / 30)];
+    const d = mod(norm, 30);
     const m = mod(d, 1) * 60;
     return `${String(Math.floor(d)).padStart(2)}°${String(Math.floor(m)).padStart(2, "0")}' ${sign}`;
 }

package/dist/src/derived.d.ts

@@ -109,21 +109,6 @@ export declare function declinationAspects(engine: Engine, bodies: BodyId[], jd:
 /** |declination| minus the mean obliquity, degrees. Positive = out of bounds. */
 export declare function outOfBoundsMargin(engine: Engine, body: BodyId, jd: number): number;
 export declare function outOfBounds(engine: Engine, body: BodyId, jd: number): boolean;
-/**
- * Essential dignities a body holds in a sign: any of `"domicile"`,
- * `"exaltation"`, `"detriment"`, `"fall"` (the last two are the signs opposite
- * domicile and exaltation). Empty when the body is peregrine there.
- *
- * @param body Body id, e.g. `"mars"`.
- * @param sign A sign index `0`–`11` (Aries = 0) or its name, e.g. `"Aries"`.
- * @returns The dignities held, in the order above; empty if none.
- * @example
- * ```ts
- * dignities("mars", "Aries"); // ["domicile"]
- * dignities("sun", "Libra");  // ["fall"]
- * ```
- */
-export declare function dignities(body: string, sign: number | string): string[];
 export declare function dignityOf(engine: Engine, body: BodyId, jd: number, zodiac?: Zodiac): string[];
 /** Diurnal when the Sun is above the horizon at the given place. */
 export declare function isDayChart(engine: Engine, jd: number, lat: number, lonEast: number): boolean;

package/dist/src/derived.js

@@ -9,7 +9,7 @@
  * golden fixtures pin the two together.
  */
 import { mod, meanObliquity, jdTT, DEG } from "./core.js";
-import { SIGNS } from "./chart.js";
+import { dignities } from "./chart.js";
 import { crossings } from "./events.js";
 import { azAlt } from "./pheno.js";
 export const TROPICAL_YEAR = 365.24219; // mean tropical year, days
@@ -198,44 +198,9 @@ export function outOfBounds(engine, body, jd) {
     return outOfBoundsMargin(engine, body, jd) > 0;
 }
 // ----------------------------------------------------------- dignities
-const DOMICILE = {
-    sun: [4], moon: [3], mercury: [2, 5], venus: [1, 6],
-    mars: [0, 7], jupiter: [8, 11], saturn: [9, 10],
-};
-const EXALTATION = {
-    sun: 0, moon: 1, mercury: 5, venus: 11, mars: 9, jupiter: 3, saturn: 6,
-};
-function signIndex(sign) {
-    return typeof sign === "number" ? sign : SIGNS.indexOf(sign);
-}
-/**
- * Essential dignities a body holds in a sign: any of `"domicile"`,
- * `"exaltation"`, `"detriment"`, `"fall"` (the last two are the signs opposite
- * domicile and exaltation). Empty when the body is peregrine there.
- *
- * @param body Body id, e.g. `"mars"`.
- * @param sign A sign index `0`–`11` (Aries = 0) or its name, e.g. `"Aries"`.
- * @returns The dignities held, in the order above; empty if none.
- * @example
- * ```ts
- * dignities("mars", "Aries"); // ["domicile"]
- * dignities("sun", "Libra");  // ["fall"]
- * ```
- */
-export function dignities(body, sign) {
-    const idx = signIndex(sign);
-    const dom = DOMICILE[body] ?? [];
-    const out = [];
-    if (dom.includes(idx))
-        out.push("domicile");
-    if (EXALTATION[body] === idx)
-        out.push("exaltation");
-    if (dom.map((d) => mod(d + 6, 12)).includes(idx))
-        out.push("detriment");
-    if (body in EXALTATION && mod(EXALTATION[body] + 6, 12) === idx)
-        out.push("fall");
-    return out;
-}
+// The pure `dignities(body, sign)` table now lives in chart.ts (with the other
+// sign primitives); re-exported through the package index from there. This
+// engine-aware wrapper resolves a body's sign at an instant first.
 export function dignityOf(engine, body, jd, zodiac = "tropical") {
     const lon = engine.longitude(body, jd, { zodiac });
     return dignities(body, mod(Math.floor(lon / 30), 12));

package/dist/src/rajayoga.js

@@ -9,6 +9,7 @@ export const TRIKONAS = [1, 5, 9];
 export const DHANA_HOUSES = [2, 5, 9, 11];
 const PURE_KENDRAS = [4, 7, 10];
 const PURE_TRIKONAS = [5, 9];
+// The seven classical grahas: all analytic, so always present in a chart.
 const PLANETS = ["sun", "moon", "mars", "mercury", "jupiter", "venus", "saturn"];
 /** The traditional ruler of a sign index (0 = Aries). */
 export function signLord(sign) {

package/dist/src/yogas.d.ts

@@ -12,8 +12,8 @@
  * variant-laden yogas (Kemadruma, lordship-based raja/dhana) are left to a later
  * step. Mirrors the Python reference (astroengine/yogas.py).
  */
-import { Engine, BodyId, Zodiac } from "./chart.js";
-export declare const YOGA_PLANETS: BodyId[];
+import { Engine, Zodiac, AlwaysBody } from "./chart.js";
+export declare const YOGA_PLANETS: readonly AlwaysBody[];
 export interface Yoga {
     yoga: string;
     planets: string[];

package/dist/src/yogas.js

@@ -1,10 +1,25 @@
-import { dignities } from "./derived.js";
+/**
+ * astroengine yogas -- classical Vedic yogas (planetary combinations) judged on
+ * the sidereal rasi (D1) chart.
+ *
+ * Covers the well-defined, placement-based yogas with no textual variation: the
+ * five Pancha Mahapurusha yogas (a non-luminary in its own sign or exaltation
+ * AND in a kendra from the Ascendant -- Ruchaka/Mars, Bhadra/Mercury,
+ * Hamsa/Jupiter, Malavya/Venus, Shasha/Saturn); Gajakesari (Jupiter in a kendra
+ * from the Moon); Budha-Aditya (Sun and Mercury in one sign); and
+ * Chandra-Mangala (Moon and Mars in one sign). Own-sign/exaltation use the
+ * engine's `dignities`; houses are whole-sign from the Ascendant. The
+ * variant-laden yogas (Kemadruma, lordship-based raja/dhana) are left to a later
+ * step. Mirrors the Python reference (astroengine/yogas.py).
+ */
+import { dignities } from "./chart.js";
 /** Pancha Mahapurusha: [yoga name, planet]. */
 const MAHAPURUSHA = [
     ["Ruchaka", "mars"], ["Bhadra", "mercury"], ["Hamsa", "jupiter"],
     ["Malavya", "venus"], ["Shasha", "saturn"],
 ];
 const KENDRA = new Set([1, 4, 7, 10]);
+// The seven classical grahas: all analytic, so always present in a chart.
 export const YOGA_PLANETS = ["sun", "moon", "mars", "mercury", "jupiter", "venus", "saturn"];
 /** The placement yogas present in a chart. `signs` maps each of the seven
  *  classical planets to its 0-based sign index; `ascSign` is the Ascendant's

package/package.json

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