caelus 0.13.0 → 0.14.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/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,105 @@
+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];
+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

@@ -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

@@ -28,6 +28,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.14.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"