caelus 0.13.0 → 0.15.0

package/README.md

@@ -100,4 +100,4 @@ test/golden.test.ts  conformance suite vs Python fixtures
 - caelus — this package
 - [caelus-birth](https://www.npmjs.com/package/caelus-birth) — local birth time + place → UT (charts take UT; use this)
 - [caelus-wheel](https://www.npmjs.com/package/caelus-wheel) — React SVG chart wheel
-- [caelus-mcp](https://www.npmjs.com/package/caelus-mcp) — MCP server, eighteen chart tools over stdio
+- [caelus-mcp](https://www.npmjs.com/package/caelus-mcp) — MCP server, twenty-two chart tools over stdio

package/accuracy.json

@@ -273,7 +273,7 @@
   "counts": {
     "house_systems": 12,
     "sidereal_ayanamsas": 7,
-    "mcp_tools": 18,
+    "mcp_tools": 22,
     "default_bodies": 13
   }
 }

package/dist/src/ashtottari.d.ts

@@ -0,0 +1,50 @@
+/**
+ * astroengine ashtottari -- the Ashtottari dasha, a 108-year conditional dasha.
+ *
+ * Eight lords rule in order -- Sun 6, Moon 15, Mars 8, Mercury 17, Saturn 10,
+ * Jupiter 19, Rahu 12, Venus 21 years (totalling 108). Unlike Vimshottari the
+ * nakshatra-to-lord mapping is in irregular groups, and the elapsed portion of
+ * the first period is measured across the lord's whole multi-nakshatra span.
+ *
+ * Convention: the JHora/PVR Narasimha Rao mapping (the PyJHora implementation),
+ * which the texts vary around; the lord ranges and across-span balance are
+ * reproduced from it, validated against the named source in `validate_jyotish`
+ * rather than asserted. Mirrors the Python reference (astroengine/ashtottari.py);
+ * the golden fixtures pin the two together.
+ */
+import { Engine, Zodiac } from "./chart.js";
+export declare const ASHTOTTARI_ORDER: readonly ["sun", "moon", "mars", "mercury", "saturn", "jupiter", "rahu", "venus"];
+export declare const ASHTOTTARI_YEARS: Record<(typeof ASHTOTTARI_ORDER)[number], number>;
+/** The Ashtottari dasha lord governing a nakshatra index (0-based). */
+export declare function ashtottariLord(nakIndex: number): string;
+export interface AshtottariSub {
+    lord: string;
+    start: number;
+    end: number;
+}
+export interface AshtottariPeriod {
+    level: number;
+    lord: string;
+    years: number;
+    start: number;
+    end: number;
+    sub: AshtottariSub[];
+}
+export interface AshtottariTimeline {
+    start_lord: string;
+    balance_years: number;
+    dashas: AshtottariPeriod[];
+}
+/** The Ashtottari dasha timeline from the Moon's sidereal longitude. */
+export declare function ashtottariDashas(moonLon: number, natalJd: number, levels?: number, yearLength?: number, count?: number): AshtottariTimeline;
+export interface AshtottariActive {
+    maha: string;
+    antar: string | null;
+}
+/** The maha and antar lord active at targetJd; null before the first period. */
+export declare function ashtottariActive(moonLon: number, natalJd: number, targetJd: number, yearLength?: number): AshtottariActive | null;
+/** Ashtottari dasha active at targetJd, from the natal Moon's nakshatra. */
+export declare function ashtottariAt(engine: Engine, natalJd: number, targetJd: number, zodiac?: Zodiac, yearLength?: number): {
+    moon_nakshatra: string;
+    start_lord: string;
+} & Partial<AshtottariActive>;

package/dist/src/ashtottari.js

@@ -0,0 +1,71 @@
+import { nakshatra, NAK_SPAN, DASHA_YEAR } from "./vedic.js";
+export const ASHTOTTARI_ORDER = [
+    "sun", "moon", "mars", "mercury", "saturn", "jupiter", "rahu", "venus",
+];
+export const ASHTOTTARI_YEARS = {
+    sun: 6, moon: 15, mars: 8, mercury: 17, saturn: 10, jupiter: 19, rahu: 12, venus: 21,
+};
+const ASHTOTTARI_TOTAL = 108;
+// Each lord's nakshatra group: [lord, start nakshatra index, span]. Rahu wraps
+// past 27 (nakshatras 26, 0, 1, 2).
+const ASHTOTTARI_RANGES = [
+    ["sun", 6, 4], ["moon", 10, 3], ["mars", 13, 4], ["mercury", 17, 3],
+    ["saturn", 20, 3], ["jupiter", 23, 3], ["rahu", 26, 4], ["venus", 3, 3],
+];
+/** The Ashtottari dasha lord governing a nakshatra index (0-based). */
+export function ashtottariLord(nakIndex) {
+    for (const [lord, start, span] of ASHTOTTARI_RANGES) {
+        if (((nakIndex - start) % 27 + 27) % 27 < span)
+            return lord;
+    }
+    throw new Error(`no Ashtottari lord for nakshatra ${nakIndex}`);
+}
+/** The Ashtottari dasha timeline from the Moon's sidereal longitude. */
+export function ashtottariDashas(moonLon, natalJd, levels = 2, yearLength = DASHA_YEAR, count = 8) {
+    const lon = ((moonLon % 360) + 360) % 360;
+    const nakI = Math.floor(lon / NAK_SPAN) % 27;
+    const startLord = ashtottariLord(nakI);
+    const [, startNak, spanNak] = ASHTOTTARI_RANGES.find((r) => r[0] === startLord);
+    const lordStartDeg = startNak * NAK_SPAN;
+    const spanDeg = spanNak * NAK_SPAN;
+    const elapsed = (((lon - lordStartDeg) % 360) + 360) % 360 / spanDeg;
+    const y0 = ASHTOTTARI_YEARS[startLord];
+    const li = ASHTOTTARI_ORDER.indexOf(startLord);
+    let t = natalJd - elapsed * y0 * yearLength;
+    const dashas = [];
+    for (let k = 0; k < count; k++) {
+        const lord = ASHTOTTARI_ORDER[(li + k) % 8];
+        const years = ASHTOTTARI_YEARS[lord];
+        const span = years * yearLength;
+        const maha = { level: 1, lord, years, start: t, end: t + span, sub: [] };
+        if (levels >= 2) {
+            const sli = ASHTOTTARI_ORDER.indexOf(lord);
+            let st = t;
+            for (let j = 0; j < 8; j++) {
+                const sl = ASHTOTTARI_ORDER[(sli + j) % 8];
+                const subSpan = (years * ASHTOTTARI_YEARS[sl] / ASHTOTTARI_TOTAL) * yearLength;
+                maha.sub.push({ lord: sl, start: st, end: st + subSpan });
+                st += subSpan;
+            }
+        }
+        dashas.push(maha);
+        t += span;
+    }
+    return { start_lord: startLord, balance_years: (1 - elapsed) * y0, dashas };
+}
+/** The maha and antar lord active at targetJd; null before the first period. */
+export function ashtottariActive(moonLon, natalJd, targetJd, yearLength = DASHA_YEAR) {
+    const timeline = ashtottariDashas(moonLon, natalJd, 2, yearLength, 16).dashas;
+    const maha = timeline.find((p) => p.start <= targetJd && targetJd < p.end);
+    if (!maha)
+        return null;
+    const antar = maha.sub.find((s) => s.start <= targetJd && targetJd < s.end);
+    return { maha: maha.lord, antar: antar ? antar.lord : null };
+}
+/** Ashtottari dasha active at targetJd, from the natal Moon's nakshatra. */
+export function ashtottariAt(engine, natalJd, targetJd, zodiac = "sidereal:lahiri", yearLength = DASHA_YEAR) {
+    const moonLon = engine.longitude("moon", natalJd, { zodiac });
+    const nak = nakshatra(moonLon);
+    const active = ashtottariActive(moonLon, natalJd, targetJd, yearLength) ?? {};
+    return { moon_nakshatra: nak.name, start_lord: ashtottariLord(nak.index), ...active };
+}

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/directions.d.ts

@@ -15,6 +15,21 @@ export interface DirectionArcs {
 export declare function directionArcs(alpha: number, delta: number, ramc: number, phi: number): DirectionArcs;
 /** Years of life corresponding to an arc of direction under a time key. */
 export declare function directionYears(arc: number, key?: string): number;
+/** Placidus semi-arc mundane directional arc (degrees) for promissor P to
+ *  significator S: arc = MD_p - (MD_s / SA_s) * SA_p. null if either body is
+ *  circumpolar. Reduces to the to-MC arc when S is on the meridian, and to 0
+ *  when P and S coincide. */
+export declare function mundaneDirectionArc(alphaP: number, deltaP: number, alphaS: number, deltaS: number, ramc: number, phi: number): number | null;
+export interface MundaneDirection {
+    promissor: string;
+    significator: string;
+    arc: number;
+    years: number;
+    jd: number;
+}
+/** Direct mundane (Placidus semi-arc) directions of each promissor to each other
+ *  significator within `maxYears`, sorted by years. */
+export declare function mundaneDirections(engine: Engine, natalJd: number, lat: number, lonEast: number, bodies?: BodyId[], key?: string, maxYears?: number, yearLength?: number): MundaneDirection[];
 export interface PrimaryDirection {
     body: string;
     angle: "MC" | "IC" | "ASC" | "DSC";

package/dist/src/directions.js

@@ -44,6 +44,56 @@ export function directionArcs(alpha, delta, ramc, phi) {
 export function directionYears(arc, key = "naibod") {
     return arc / KEYS[key];
 }
+/** A body's signed meridian distance from its nearest meridian and the matching
+ *  semi-arc, [MD, SA] in degrees; null when circumpolar. */
+function semiArcPosition(alpha, delta, ramc, phi) {
+    const t = Math.tan(phi * RAD) * Math.tan(delta * RAD);
+    if (Math.abs(t) > 1)
+        return null;
+    const ad = Math.asin(t) * DEG;
+    const mdu = ((alpha - ramc + 180) % 360 + 360) % 360 - 180; // upper meridian distance
+    if (Math.abs(mdu) <= 90 + ad)
+        return [mdu, 90 + ad];
+    const sign = mdu >= 0 ? 1 : -1;
+    return [sign * (180 - Math.abs(mdu)), 90 - ad];
+}
+/** Placidus semi-arc mundane directional arc (degrees) for promissor P to
+ *  significator S: arc = MD_p - (MD_s / SA_s) * SA_p. null if either body is
+ *  circumpolar. Reduces to the to-MC arc when S is on the meridian, and to 0
+ *  when P and S coincide. */
+export function mundaneDirectionArc(alphaP, deltaP, alphaS, deltaS, ramc, phi) {
+    const pp = semiArcPosition(alphaP, deltaP, ramc, phi);
+    const ps = semiArcPosition(alphaS, deltaS, ramc, phi);
+    if (pp === null || ps === null)
+        return null;
+    const [mdP, saP] = pp;
+    const [mdS, saS] = ps;
+    return mdP - (mdS / saS) * saP;
+}
+/** Direct mundane (Placidus semi-arc) directions of each promissor to each other
+ *  significator within `maxYears`, sorted by years. */
+export function mundaneDirections(engine, natalJd, lat, lonEast, bodies = TRADITIONAL, key = "naibod", maxYears = 90, yearLength = YEAR_DAYS) {
+    const ramc = angles(engine.data, natalJd, lat, lonEast)[2] * DEG;
+    const pos = {};
+    for (const b of bodies)
+        pos[b] = engine.position(b, natalJd);
+    const out = [];
+    for (const p of bodies) {
+        for (const s of bodies) {
+            if (p === s)
+                continue;
+            const arc = mundaneDirectionArc(pos[p].ra, pos[p].dec, pos[s].ra, pos[s].dec, ramc, lat);
+            if (arc === null)
+                continue;
+            const years = directionYears(arc, key);
+            if (years >= 0 && years <= maxYears) {
+                out.push({ promissor: p, significator: s, arc, years, jd: natalJd + years * yearLength });
+            }
+        }
+    }
+    out.sort((a, b) => a.years - b.years);
+    return out;
+}
 /** Direct primary directions of the bodies to the four angles within
  *  `maxYears`, by the given time key, sorted by years. */
 export function primaryDirections(engine, natalJd, lat, lonEast, bodies = TRADITIONAL, key = "naibod", maxYears = 90, yearLength = YEAR_DAYS) {

package/dist/src/index.d.ts

@@ -24,3 +24,5 @@ export * from "./directions.js";
 export * from "./vargas.js";
 export * from "./yogini.js";
 export * from "./yogas.js";
+export * from "./ashtottari.js";
+export * from "./rajayoga.js";

package/dist/src/index.js

@@ -24,3 +24,5 @@ export * from "./directions.js";
 export * from "./vargas.js";
 export * from "./yogini.js";
 export * from "./yogas.js";
+export * from "./ashtottari.js";
+export * from "./rajayoga.js";

package/dist/src/rajayoga.d.ts

@@ -0,0 +1,50 @@
+/**
+ * astroengine rajayoga -- the lordship-and-aspect layer for Vedic yogas, and the
+ * raja/dhana yogas built on it.
+ *
+ * Layers: house lordship (traditional ruler of each whole-sign house from the
+ * Ascendant); graha drishti (every planet aspects the 7th sign; Mars also 4/8,
+ * Jupiter 5/9, Saturn 3/10); association (conjunction, mutual aspect, or
+ * parivartana exchange); then raja yoga (a kendra lord 1/4/7/10 associated with
+ * a trikona lord 1/5/9), dhana yoga (two wealth-house 2/5/9/11 lords), and the
+ * yogakaraka (a planet ruling both a pure kendra 4/7/10 and a pure trikona 5/9).
+ * Definitions follow BPHS, validated against the named source in
+ * `validate_jyotish`. Mirrors the Python reference (astroengine/rajayoga.py).
+ */
+import { Engine, Zodiac } from "./chart.js";
+/** Graha drishti: the house-distances (1-based) each planet aspects. */
+export declare const DRISHTI: Record<string, number[]>;
+export declare const KENDRAS: number[];
+export declare const TRIKONAS: number[];
+export declare const DHANA_HOUSES: number[];
+/** The traditional ruler of a sign index (0 = Aries). */
+export declare function signLord(sign: number): string;
+/** The sign on the given whole-sign house (1-12) from the Ascendant. */
+export declare function houseSign(ascSign: number, house: number): number;
+/** The lord of the given whole-sign house from the Ascendant. */
+export declare function houseLord(ascSign: number, house: number): string;
+/** The whole-sign house (1-12) a sign falls in from the Ascendant. */
+export declare function houseFromAsc(ascSign: number, sign: number): number;
+/** Whether `planet` at `planetSign` casts a graha drishti onto `targetSign`. */
+export declare function aspectsSign(planet: string, planetSign: number, targetSign: number): boolean;
+/** Sign exchange: a sits in b's sign and b sits in a's sign. */
+export declare function parivartana(planetA: string, signA: number, planetB: string, signB: number): boolean;
+/** How two planets associate: "conjunction" | "exchange" | "aspect" | null. */
+export declare function associationType(planetA: string, signA: number, planetB: string, signB: number): string | null;
+/** Planets ruling both a pure kendra (4/7/10) and a pure trikona (5/9), sorted. */
+export declare function yogakarakas(ascSign: number): string[];
+export interface LordPairYoga {
+    lords: string[];
+    via: string;
+}
+/** Raja yogas: associations between a kendra lord and a trikona lord. */
+export declare function rajaYogas(signs: Record<string, number>, ascSign: number): LordPairYoga[];
+/** Dhana yogas: associations between two wealth-house (2/5/9/11) lords. */
+export declare function dhanaYogas(signs: Record<string, number>, ascSign: number): LordPairYoga[];
+/** Raja yogas of a natal chart, with the chart's yogakarakas. */
+export declare function rajaYogasAt(engine: Engine, natalJd: number, lat: number, lonEast: number, zodiac?: Zodiac): {
+    raja: LordPairYoga[];
+    yogakarakas: string[];
+};
+/** Dhana yogas of a natal chart. */
+export declare function dhanaYogasAt(engine: Engine, natalJd: number, lat: number, lonEast: number, zodiac?: Zodiac): LordPairYoga[];

package/dist/src/rajayoga.js

@@ -0,0 +1,106 @@
+import { SIGN_RULERS } from "./profections.js";
+/** Graha drishti: the house-distances (1-based) each planet aspects. */
+export const DRISHTI = {
+    sun: [7], moon: [7], mercury: [7], venus: [7],
+    mars: [4, 7, 8], jupiter: [5, 7, 9], saturn: [3, 7, 10],
+};
+export const KENDRAS = [1, 4, 7, 10];
+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) {
+    return SIGN_RULERS[((sign % 12) + 12) % 12];
+}
+/** The sign on the given whole-sign house (1-12) from the Ascendant. */
+export function houseSign(ascSign, house) {
+    return (ascSign + house - 1) % 12;
+}
+/** The lord of the given whole-sign house from the Ascendant. */
+export function houseLord(ascSign, house) {
+    return signLord(houseSign(ascSign, house));
+}
+/** The whole-sign house (1-12) a sign falls in from the Ascendant. */
+export function houseFromAsc(ascSign, sign) {
+    return ((sign - ascSign) % 12 + 12) % 12 + 1;
+}
+/** Whether `planet` at `planetSign` casts a graha drishti onto `targetSign`. */
+export function aspectsSign(planet, planetSign, targetSign) {
+    const dist = ((targetSign - planetSign) % 12 + 12) % 12 + 1;
+    return (DRISHTI[planet] ?? [7]).includes(dist);
+}
+/** Sign exchange: a sits in b's sign and b sits in a's sign. */
+export function parivartana(planetA, signA, planetB, signB) {
+    return signLord(signA) === planetB && signLord(signB) === planetA;
+}
+/** How two planets associate: "conjunction" | "exchange" | "aspect" | null. */
+export function associationType(planetA, signA, planetB, signB) {
+    if (planetA === planetB)
+        return null;
+    if (signA === signB)
+        return "conjunction";
+    if (parivartana(planetA, signA, planetB, signB))
+        return "exchange";
+    if (aspectsSign(planetA, signA, signB) && aspectsSign(planetB, signB, signA))
+        return "aspect";
+    return null;
+}
+/** Planets ruling both a pure kendra (4/7/10) and a pure trikona (5/9), sorted. */
+export function yogakarakas(ascSign) {
+    const out = [];
+    for (const p of PLANETS) {
+        const ruled = new Set();
+        for (let h = 1; h <= 12; h++)
+            if (houseLord(ascSign, h) === p)
+                ruled.add(h);
+        if (PURE_KENDRAS.some((h) => ruled.has(h)) && PURE_TRIKONAS.some((h) => ruled.has(h)))
+            out.push(p);
+    }
+    return out.sort();
+}
+function lordPairYogas(ascSign, signs, housesA, housesB) {
+    const lordsA = [...new Set(housesA.map((h) => houseLord(ascSign, h)))].sort();
+    const lordsB = [...new Set(housesB.map((h) => houseLord(ascSign, h)))].sort();
+    const seen = new Map();
+    for (const la of lordsA) {
+        for (const lb of lordsB) {
+            const via = associationType(la, signs[la], lb, signs[lb]);
+            if (via === null)
+                continue;
+            const pair = [la, lb].sort().join("|");
+            if (!seen.has(pair))
+                seen.set(pair, via);
+        }
+    }
+    return [...seen.entries()].sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([pair, via]) => ({ lords: pair.split("|"), via }));
+}
+/** Raja yogas: associations between a kendra lord and a trikona lord. */
+export function rajaYogas(signs, ascSign) {
+    return lordPairYogas(ascSign, signs, KENDRAS, TRIKONAS);
+}
+/** Dhana yogas: associations between two wealth-house (2/5/9/11) lords. */
+export function dhanaYogas(signs, ascSign) {
+    return lordPairYogas(ascSign, signs, DHANA_HOUSES, DHANA_HOUSES);
+}
+function signsOf(engine, natalJd, lat, lonEast, zodiac) {
+    const chart = engine.chartAt(natalJd, lat, lonEast, { zodiac });
+    const ascSign = Math.floor(chart.angles.asc / 30) % 12;
+    const signs = {};
+    for (const p of PLANETS)
+        signs[p] = Math.floor(chart.bodies[p].lon / 30) % 12;
+    return { signs, ascSign };
+}
+/** Raja yogas of a natal chart, with the chart's yogakarakas. */
+export function rajaYogasAt(engine, natalJd, lat, lonEast, zodiac = "sidereal:lahiri") {
+    const { signs, ascSign } = signsOf(engine, natalJd, lat, lonEast, zodiac);
+    return { raja: rajaYogas(signs, ascSign), yogakarakas: yogakarakas(ascSign) };
+}
+/** Dhana yogas of a natal chart. */
+export function dhanaYogasAt(engine, natalJd, lat, lonEast, zodiac = "sidereal:lahiri") {
+    const { signs, ascSign } = signsOf(engine, natalJd, lat, lonEast, zodiac);
+    return dhanaYogas(signs, ascSign);
+}

package/dist/src/vargas.d.ts

@@ -15,7 +15,7 @@
  */
 import { Engine, BodyId, Zodiac } from "./chart.js";
 /** Supported divisions. */
-export declare const VARGA_DIVISIONS: readonly [1, 3, 9, 10, 12];
+export declare const VARGA_DIVISIONS: readonly [1, 2, 3, 9, 10, 12, 30];
 export interface Varga {
     varga: number;
     rasi: string;

package/dist/src/vargas.js

@@ -17,10 +17,26 @@ import { BODIES, SIGNS } from "./chart.js";
 /** Element start sign for the navamsa (fire, earth, air, water by rasi % 4). */
 const NAVAMSA_START = [0, 9, 6, 3];
 /** Supported divisions. */
-export const VARGA_DIVISIONS = [1, 3, 9, 10, 12];
+export const VARGA_DIVISIONS = [1, 2, 3, 9, 10, 12, 30];
+// Trimsamsa (D30): five unequal degree-bands per sign mapping to a non-luminary's
+// sign. Odd: Mars 0-5 -> Aries, Saturn 5-10 -> Aquarius, Jupiter 10-18 ->
+// Sagittarius, Mercury 18-25 -> Gemini, Venus 25-30 -> Libra. Even reverses with
+// the planets' even signs. Each is [upper-degree-bound, result sign index].
+const TRIMSAMSA_ODD = [[5, 0], [10, 10], [18, 8], [25, 2], [30, 6]];
+const TRIMSAMSA_EVEN = [[5, 1], [12, 5], [20, 11], [25, 9], [30, 7]];
+function trimsamsa(rasi, within) {
+    const bands = rasi % 2 === 0 ? TRIMSAMSA_ODD : TRIMSAMSA_EVEN;
+    for (let i = 0; i < bands.length; i++)
+        if (within < bands[i][0])
+            return [bands[i][1], i + 1];
+    return [bands[bands.length - 1][1], 5];
+}
 function vargaSign(rasi, div, n) {
     switch (n) {
         case 1: return rasi;
+        // Parashari hora: odd sign first half -> Leo, second half -> Cancer; even
+        // sign reversed (odd sign == even rasi index).
+        case 2: return ((rasi % 2 === 0) === (div === 0)) ? 4 : 3;
         case 3: return (rasi + 4 * div) % 12;
         case 9: return (NAVAMSA_START[rasi % 4] + div) % 12;
         case 10: return rasi % 2 === 0 ? (rasi + div) % 12 : (rasi + 8 + div) % 12;
@@ -33,11 +49,19 @@ export function varga(siderealLon, n) {
     const lon = ((siderealLon % 360) + 360) % 360;
     const rasi = Math.floor(lon / 30) % 12;
     const within = lon - rasi * 30;
-    let div = Math.floor(within / (30 / n));
-    if (div >= n)
-        div = n - 1; // guard a boundary rounding to n
-    const s = vargaSign(rasi, div, n);
-    return { varga: n, rasi: SIGNS[rasi], rasi_index: rasi, sign: SIGNS[s], sign_index: s, division: div + 1 };
+    let s;
+    let division;
+    if (n === 30) { // trimsamsa: unequal bands
+        [s, division] = trimsamsa(rasi, within);
+    }
+    else {
+        let div = Math.floor(within / (30 / n));
+        if (div >= n)
+            div = n - 1; // guard a boundary rounding to n
+        s = vargaSign(rasi, div, n);
+        division = div + 1;
+    }
+    return { varga: n, rasi: SIGNS[rasi], rasi_index: rasi, sign: SIGNS[s], sign_index: s, division };
 }
 /** The varga D-n of a body (default the Moon) at jd, in a sidereal zodiac. */
 export function vargaAt(engine, jdUt, n, body = "moon", zodiac = "sidereal:lahiri") {

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[];
@@ -22,5 +22,16 @@ export interface Yoga {
  *  classical planets to its 0-based sign index; `ascSign` is the Ascendant's
  *  sign index. */
 export declare function detectYogas(signs: Record<string, number>, ascSign: number): Yoga[];
+export interface Kemadruma {
+    present: boolean;
+    planets_checked: string[];
+}
+/** Kemadruma yoga: the Moon is isolated -- no planet in the 2nd or 12th sign
+ *  from it, nor conjunct it. The planet set is parameterized (texts vary): the
+ *  default is the five tara grahas, `includeSun` adds the Sun, `includeNodes`
+ *  adds Rahu/Ketu when present in `signs`. */
+export declare function kemadruma(signs: Record<string, number>, includeSun?: boolean, includeNodes?: boolean): Kemadruma;
+/** Kemadruma yoga of a natal chart, from the sidereal rasi positions. */
+export declare function kemadrumaAt(engine: Engine, natalJd: number, lat: number, lonEast: number, includeSun?: boolean, includeNodes?: boolean, zodiac?: Zodiac): Kemadruma;
 /** The placement yogas of a natal chart, from the sidereal rasi positions. */
 export declare function yogasAt(engine: Engine, natalJd: number, lat: number, lonEast: number, zodiac?: Zodiac): Yoga[];

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
@@ -28,6 +43,35 @@ export function detectYogas(signs, ascSign) {
         out.push({ yoga: "Chandra-Mangala", planets: ["moon", "mars"] });
     return out;
 }
+/** Kemadruma yoga: the Moon is isolated -- no planet in the 2nd or 12th sign
+ *  from it, nor conjunct it. The planet set is parameterized (texts vary): the
+ *  default is the five tara grahas, `includeSun` adds the Sun, `includeNodes`
+ *  adds Rahu/Ketu when present in `signs`. */
+export function kemadruma(signs, includeSun = false, includeNodes = false) {
+    let planets = ["mars", "mercury", "jupiter", "venus", "saturn"];
+    if (includeSun)
+        planets = ["sun", ...planets];
+    if (includeNodes)
+        planets = [...planets, "rahu", "ketu"];
+    planets = planets.filter((p) => p in signs);
+    const moon = signs.moon;
+    const occupied = new Set([((moon - 1) % 12 + 12) % 12, moon, (moon + 1) % 12]);
+    const present = !planets.some((p) => occupied.has(signs[p]));
+    return { present, planets_checked: planets };
+}
+/** Kemadruma yoga of a natal chart, from the sidereal rasi positions. */
+export function kemadrumaAt(engine, natalJd, lat, lonEast, includeSun = false, includeNodes = false, zodiac = "sidereal:lahiri") {
+    const chart = engine.chartAt(natalJd, lat, lonEast, { zodiac });
+    const bodies = includeNodes ? [...YOGA_PLANETS, "mean_node"] : YOGA_PLANETS;
+    const signs = {};
+    for (const b of bodies)
+        signs[b] = Math.floor(chart.bodies[b].lon / 30) % 12;
+    if (includeNodes) {
+        signs.rahu = signs.mean_node;
+        signs.ketu = (signs.mean_node + 6) % 12;
+    }
+    return kemadruma(signs, includeSun, includeNodes);
+}
 /** The placement yogas of a natal chart, from the sidereal rasi positions. */
 export function yogasAt(engine, natalJd, lat, lonEast, zodiac = "sidereal:lahiri") {
     const chart = engine.chartAt(natalJd, lat, lonEast, { zodiac });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caelus",
-  "version": "0.13.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",
@@ -21,6 +21,10 @@
     "test": "node dist/test/golden.test.js"
   },
   "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "devDependencies": {
     "@types/node": "^25.9.2",
     "typescript": "^6.0.3"