caelus 0.12.0 → 0.14.0

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

@@ -0,0 +1,32 @@
+import { Engine, Zodiac } from "./chart.js";
+/** Period length in 360-day years for each sign, Aries..Pisces. */
+export declare const ZR_PERIODS: readonly [15, 8, 20, 25, 19, 20, 8, 15, 12, 27, 30, 12];
+/** Days per period unit at each level (each a twelfth of the one above). */
+export declare const LEVEL_UNIT: Record<number, number>;
+export interface ZrPeriod {
+    level: number;
+    sign: string;
+    lord: string;
+    start: number;
+    end: number;
+    /** True when this period is the loosing of the bond (jumped to the opposite sign). */
+    lb: boolean;
+}
+/** Flat timeline of releasing periods down to `maxLevel` over `horizonYears`
+ *  (360-day years) from birth. */
+export declare function zrRelease(lotSign: number, natalJd: number, maxLevel?: number, horizonYears?: number): ZrPeriod[];
+export interface ZrActive {
+    l1: string;
+    l2: string;
+    l3: string;
+    l4: string;
+}
+/** The L1..L4 releasing signs active at `targetJd`; null outside the span. */
+export declare function zrActive(lotSign: number, natalJd: number, targetJd: number): ZrActive | null;
+/** Zodiacal releasing active at `targetJd`, releasing from the Lot of Spirit
+ *  (default) or Fortune of the natal chart. */
+export declare function zrAt(engine: Engine, natalJd: number, targetJd: number, lat: number, lonEast: number, lot?: "spirit" | "fortune", zodiac?: Zodiac): {
+    lot: string;
+    lot_sign: string;
+    day: boolean;
+} & Partial<ZrActive>;

package/dist/src/releasing.js

@@ -0,0 +1,109 @@
+/**
+ * astroengine releasing -- zodiacal releasing (aphesis), the Hellenistic
+ * time-lord technique from Vettius Valens, released from a Lot (usually Spirit
+ * or Fortune).
+ *
+ * From the Lot's sign, periods release sign by sign. A sign's period length is
+ * its planetary minor years (Aries 15, Taurus 8, Gemini 20, Cancer 25, Leo 19,
+ * Virgo 20, Libra 8, Scorpio 15, Sagittarius 12, Capricorn 27, Aquarius 30,
+ * Pisces 12). Convention: 360-day years, each level a twelfth of the one above
+ * (L1 = period x 360 days, L2 = x 30, L3 = x 2.5, L4 = x 2.5/12). Within a
+ * period the next level releases from the same sign and fills it (last
+ * sub-period truncates at the boundary); when a sub-level returns to the sign it
+ * began on it looses the bond, jumping to the opposite sign (+6) once. Mirrors
+ * the Python reference (astroengine/releasing.py); the golden fixtures pin the
+ * two together.
+ */
+import { SIGNS } from "./chart.js";
+import { isDayChart } from "./derived.js";
+import { lotSpirit, lotFortune } from "./lots.js";
+import { SIGN_RULERS } from "./profections.js";
+/** Period length in 360-day years for each sign, Aries..Pisces. */
+export const ZR_PERIODS = [15, 8, 20, 25, 19, 20, 8, 15, 12, 27, 30, 12];
+/** Days per period unit at each level (each a twelfth of the one above). */
+export const LEVEL_UNIT = { 1: 360, 2: 30, 3: 2.5, 4: 2.5 / 12 };
+const FULL_CYCLE = ZR_PERIODS.reduce((a, b) => a + b, 0) * 360; // one full L1 cycle, days
+const EPS = 1e-9;
+function release(out, level, maxLevel, startSign, spanStart, spanEnd, horizon) {
+    const unit = LEVEL_UNIT[level];
+    let sign = startSign;
+    let lb = false;
+    let pendingLb = false;
+    let cur = spanStart;
+    while (cur < spanEnd - EPS && cur < horizon - EPS) {
+        const plen = ZR_PERIODS[sign] * unit;
+        const subEnd = Math.min(cur + plen, spanEnd, horizon);
+        out.push({ level, sign: SIGNS[sign], lord: SIGN_RULERS[sign], start: cur, end: subEnd, lb: pendingLb });
+        if (level < maxLevel) {
+            release(out, level + 1, maxLevel, sign, cur, Math.min(cur + plen, spanEnd), horizon);
+        }
+        cur += plen;
+        pendingLb = false;
+        const nxt = (sign + 1) % 12;
+        if (nxt === startSign && !lb) {
+            sign = (startSign + 6) % 12;
+            lb = true;
+            pendingLb = true;
+        }
+        else {
+            sign = nxt;
+        }
+    }
+}
+/** Flat timeline of releasing periods down to `maxLevel` over `horizonYears`
+ *  (360-day years) from birth. */
+export function zrRelease(lotSign, natalJd, maxLevel = 2, horizonYears = 100) {
+    const out = [];
+    const horizon = natalJd + horizonYears * 360;
+    release(out, 1, maxLevel, lotSign, natalJd, natalJd + FULL_CYCLE, horizon);
+    return out;
+}
+/** The (sign, start, end) of the sub-period containing `target`, or null. */
+function subAt(unit, startSign, spanStart, spanEnd, target) {
+    let sign = startSign;
+    let lb = false;
+    let cur = spanStart;
+    while (cur < spanEnd - EPS) {
+        const plen = ZR_PERIODS[sign] * unit;
+        const subEnd = Math.min(cur + plen, spanEnd);
+        if (cur <= target && target < subEnd)
+            return [sign, cur, subEnd];
+        cur += plen;
+        const nxt = (sign + 1) % 12;
+        if (nxt === startSign && !lb) {
+            sign = (startSign + 6) % 12;
+            lb = true;
+        }
+        else
+            sign = nxt;
+    }
+    return null;
+}
+/** The L1..L4 releasing signs active at `targetJd`; null outside the span. */
+export function zrActive(lotSign, natalJd, targetJd) {
+    const l1 = subAt(360, lotSign, natalJd, natalJd + FULL_CYCLE, targetJd);
+    if (l1 === null)
+        return null;
+    const l2 = subAt(30, l1[0], l1[1], l1[2], targetJd);
+    if (l2 === null)
+        return null;
+    const l3 = subAt(2.5, l2[0], l2[1], l2[2], targetJd);
+    if (l3 === null)
+        return null;
+    const l4 = subAt(2.5 / 12, l3[0], l3[1], l3[2], targetJd);
+    if (l4 === null)
+        return null;
+    return { l1: SIGNS[l1[0]], l2: SIGNS[l2[0]], l3: SIGNS[l3[0]], l4: SIGNS[l4[0]] };
+}
+/** Zodiacal releasing active at `targetJd`, releasing from the Lot of Spirit
+ *  (default) or Fortune of the natal chart. */
+export function zrAt(engine, natalJd, targetJd, lat, lonEast, lot = "spirit", zodiac = "tropical") {
+    const asc = engine.chartAt(natalJd, lat, lonEast, { zodiac }).angles.asc;
+    const day = isDayChart(engine, natalJd, lat, lonEast);
+    const sun = engine.longitude("sun", natalJd, { zodiac });
+    const moon = engine.longitude("moon", natalJd, { zodiac });
+    const lotLon = (lot === "spirit" ? lotSpirit : lotFortune)(asc, sun, moon, day);
+    const lotSign = ((Math.floor(lotLon / 30) % 12) + 12) % 12;
+    const active = zrActive(lotSign, natalJd, targetJd) ?? {};
+    return { lot, lot_sign: SIGNS[lotSign], day, ...active };
+}

package/dist/src/vargas.d.ts

@@ -0,0 +1,32 @@
+/**
+ * astroengine vargas -- Vedic divisional charts (vargas).
+ *
+ * A varga D-n divides each 30-degree sign into n equal parts and maps each part
+ * to a sign by a classical (Parashari) rule. This covers the unambiguous,
+ * textbook set: D1 (rasi), D3 (drekkana), D9 (navamsa), D10 (dasamsa), and D12
+ * (dwadasamsa); the contested hora (D2) and unequal trimsamsa (D30) are left to
+ * a later step. Rules (rasi/div 0-based; an "odd sign" is the 1st, 3rd, ... =
+ * even rasi index): D1 the sign; D3 (rasi + 4*div); D9 element start
+ * ([Aries, Capricorn, Libra, Cancer] by element) + div; D10 odd (rasi + div),
+ * even (rasi + 8 + div); D12 (rasi + div). Computed from rasi = floor(lon/30)
+ * and div = floor(within/(30/n)) so sign boundaries stay robust and
+ * `Math.floor` matches Python's `math.floor`. Built on the validated sidereal
+ * longitudes. Mirrors the Python reference (astroengine/vargas.py).
+ */
+import { Engine, BodyId, Zodiac } from "./chart.js";
+/** Supported divisions. */
+export declare const VARGA_DIVISIONS: readonly [1, 2, 3, 9, 10, 12, 30];
+export interface Varga {
+    varga: number;
+    rasi: string;
+    rasi_index: number;
+    sign: string;
+    sign_index: number;
+    division: number;
+}
+/** The varga D-n placement of a sidereal longitude. */
+export declare function varga(siderealLon: number, n: number): Varga;
+/** The varga D-n of a body (default the Moon) at jd, in a sidereal zodiac. */
+export declare function vargaAt(engine: Engine, jdUt: number, n: number, body?: BodyId, zodiac?: Zodiac): Varga;
+/** The full divisional chart D-n at jd: the varga sign of each body. */
+export declare function vargaChart(engine: Engine, jdUt: number, n: number, bodies?: BodyId[], zodiac?: Zodiac): Record<string, Varga>;

package/dist/src/vargas.js

@@ -0,0 +1,76 @@
+/**
+ * astroengine vargas -- Vedic divisional charts (vargas).
+ *
+ * A varga D-n divides each 30-degree sign into n equal parts and maps each part
+ * to a sign by a classical (Parashari) rule. This covers the unambiguous,
+ * textbook set: D1 (rasi), D3 (drekkana), D9 (navamsa), D10 (dasamsa), and D12
+ * (dwadasamsa); the contested hora (D2) and unequal trimsamsa (D30) are left to
+ * a later step. Rules (rasi/div 0-based; an "odd sign" is the 1st, 3rd, ... =
+ * even rasi index): D1 the sign; D3 (rasi + 4*div); D9 element start
+ * ([Aries, Capricorn, Libra, Cancer] by element) + div; D10 odd (rasi + div),
+ * even (rasi + 8 + div); D12 (rasi + div). Computed from rasi = floor(lon/30)
+ * and div = floor(within/(30/n)) so sign boundaries stay robust and
+ * `Math.floor` matches Python's `math.floor`. Built on the validated sidereal
+ * longitudes. Mirrors the Python reference (astroengine/vargas.py).
+ */
+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, 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;
+        case 12: return (rasi + div) % 12;
+        default: throw new Error(`unsupported varga D${n}`);
+    }
+}
+/** The varga D-n placement of a sidereal longitude. */
+export function varga(siderealLon, n) {
+    const lon = ((siderealLon % 360) + 360) % 360;
+    const rasi = Math.floor(lon / 30) % 12;
+    const within = lon - rasi * 30;
+    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") {
+    return varga(engine.longitude(body, jdUt, { zodiac }), n);
+}
+/** The full divisional chart D-n at jd: the varga sign of each body. */
+export function vargaChart(engine, jdUt, n, bodies = BODIES, zodiac = "sidereal:lahiri") {
+    const out = {};
+    for (const b of bodies)
+        out[b] = varga(engine.longitude(b, jdUt, { zodiac }), n);
+    return out;
+}

package/dist/src/vedic.d.ts

@@ -0,0 +1,66 @@
+/**
+ * astroengine vedic -- the Vedic/Jyotish layer: nakshatras and the Vimshottari
+ * dasha, built on the already-validated sidereal longitudes.
+ *
+ * A nakshatra is one of 27 equal lunar mansions of 13 deg 20' in the sidereal
+ * zodiac, each with four padas and a ruling planet cycling Ketu, Venus, Sun,
+ * Moon, Mars, Rahu, Jupiter, Saturn, Mercury. The Vimshottari dasha is a
+ * 120-year sequence of planetary periods in that order; the starting dasha is
+ * the lord of the Moon's birth nakshatra, with the elapsed portion set by how
+ * far the Moon has moved through it. Mahadashas subdivide into antardashas and
+ * pratyantardashas of the nine lords, proportional to their years. Nakshatra
+ * placement is exact division of the sidereal longitude; the dasha year is a
+ * fixed 365.25 days by default (the common Jyotish convention). Mirrors the
+ * Python reference (astroengine/vedic.py); the golden fixtures pin the two.
+ */
+import { Engine, BodyId, Zodiac } from "./chart.js";
+export declare const NAKSHATRAS: readonly ["Ashwini", "Bharani", "Krittika", "Rohini", "Mrigashira", "Ardra", "Punarvasu", "Pushya", "Ashlesha", "Magha", "Purva Phalguni", "Uttara Phalguni", "Hasta", "Chitra", "Swati", "Vishakha", "Anuradha", "Jyeshtha", "Mula", "Purva Ashadha", "Uttara Ashadha", "Shravana", "Dhanishta", "Shatabhisha", "Purva Bhadrapada", "Uttara Bhadrapada", "Revati"];
+/** The Vimshottari order and each lord's period in years (totalling 120). */
+export declare const VIMSHOTTARI_ORDER: readonly ["ketu", "venus", "sun", "moon", "mars", "rahu", "jupiter", "saturn", "mercury"];
+export declare const VIMSHOTTARI_YEARS: Record<(typeof VIMSHOTTARI_ORDER)[number], number>;
+export declare const NAK_SPAN: number;
+export declare const DASHA_YEAR = 365.25;
+export interface Nakshatra {
+    index: number;
+    name: string;
+    pada: number;
+    lord: string;
+    /** Degrees into the nakshatra, 0..13.333. */
+    pos: number;
+}
+/** The nakshatra of a sidereal longitude. */
+export declare function nakshatra(siderealLon: number): Nakshatra;
+/** The nakshatra of a body (default the Moon) at jd, in a sidereal zodiac. */
+export declare function nakshatraAt(engine: Engine, jdUt: number, body?: BodyId, zodiac?: Zodiac): Nakshatra;
+export interface DashaSub {
+    lord: string;
+    start: number;
+    end: number;
+}
+export interface Dasha {
+    level: number;
+    lord: string;
+    start: number;
+    end: number;
+    sub: DashaSub[];
+}
+export interface DashaTimeline {
+    start_lord: string;
+    balance_years: number;
+    dashas: Dasha[];
+}
+/** The Vimshottari dasha timeline from the Moon's sidereal longitude. */
+export declare function vimshottariDashas(moonLon: number, natalJd: number, levels?: number, yearLength?: number, count?: number): DashaTimeline;
+export interface DashaActive {
+    maha: string;
+    antar: string | null;
+    pratyantar: string | null;
+}
+/** The mahadasha, antardasha, and pratyantardasha lords active at targetJd. */
+export declare function vimshottariActive(moonLon: number, natalJd: number, targetJd: number, yearLength?: number): DashaActive | null;
+/** Vimshottari dasha active at targetJd, from the natal Moon's nakshatra. */
+export declare function vimshottariAt(engine: Engine, natalJd: number, targetJd: number, zodiac?: Zodiac, yearLength?: number): {
+    moon_nakshatra: string;
+    moon_pada: number;
+    start_lord: string;
+} & Partial<DashaActive>;

package/dist/src/vedic.js

@@ -0,0 +1,101 @@
+export const NAKSHATRAS = [
+    "Ashwini", "Bharani", "Krittika", "Rohini", "Mrigashira", "Ardra",
+    "Punarvasu", "Pushya", "Ashlesha", "Magha", "Purva Phalguni",
+    "Uttara Phalguni", "Hasta", "Chitra", "Swati", "Vishakha", "Anuradha",
+    "Jyeshtha", "Mula", "Purva Ashadha", "Uttara Ashadha", "Shravana",
+    "Dhanishta", "Shatabhisha", "Purva Bhadrapada", "Uttara Bhadrapada", "Revati",
+];
+/** The Vimshottari order and each lord's period in years (totalling 120). */
+export const VIMSHOTTARI_ORDER = [
+    "ketu", "venus", "sun", "moon", "mars", "rahu", "jupiter", "saturn", "mercury",
+];
+export const VIMSHOTTARI_YEARS = {
+    ketu: 7, venus: 20, sun: 6, moon: 10, mars: 7, rahu: 18, jupiter: 16, saturn: 19, mercury: 17,
+};
+export const NAK_SPAN = 360 / 27; // 13 deg 20'
+const VIMSHOTTARI_TOTAL = 120;
+export const DASHA_YEAR = 365.25; // days per dasha-year (common Jyotish convention)
+function mod360(x) {
+    return ((x % 360) + 360) % 360;
+}
+/** The nakshatra of a sidereal longitude. */
+export function nakshatra(siderealLon) {
+    const lon = mod360(siderealLon);
+    const i = Math.floor(lon / NAK_SPAN) % 27;
+    const pos = lon - i * NAK_SPAN;
+    const pada = Math.floor(pos / (NAK_SPAN / 4)) + 1;
+    return { index: i, name: NAKSHATRAS[i], pada, lord: VIMSHOTTARI_ORDER[i % 9], pos };
+}
+/** The nakshatra of a body (default the Moon) at jd, in a sidereal zodiac. */
+export function nakshatraAt(engine, jdUt, body = "moon", zodiac = "sidereal:lahiri") {
+    return nakshatra(engine.longitude(body, jdUt, { zodiac }));
+}
+/** The Vimshottari dasha timeline from the Moon's sidereal longitude. */
+export function vimshottariDashas(moonLon, natalJd, levels = 2, yearLength = DASHA_YEAR, count = 9) {
+    const lon = mod360(moonLon);
+    const nakI = Math.floor(lon / NAK_SPAN) % 27;
+    const pos = lon - nakI * NAK_SPAN;
+    const startLord = VIMSHOTTARI_ORDER[nakI % 9];
+    const elapsed = pos / NAK_SPAN;
+    const y0 = VIMSHOTTARI_YEARS[startLord];
+    const li = VIMSHOTTARI_ORDER.indexOf(startLord);
+    let t = natalJd - elapsed * y0 * yearLength;
+    const dashas = [];
+    for (let k = 0; k < count; k++) {
+        const lord = VIMSHOTTARI_ORDER[(li + k) % 9];
+        const years = VIMSHOTTARI_YEARS[lord];
+        const span = years * yearLength;
+        const maha = { level: 1, lord, start: t, end: t + span, sub: [] };
+        if (levels >= 2) {
+            const sli = VIMSHOTTARI_ORDER.indexOf(lord);
+            let st = t;
+            for (let j = 0; j < 9; j++) {
+                const sl = VIMSHOTTARI_ORDER[(sli + j) % 9];
+                const subSpan = (years * VIMSHOTTARI_YEARS[sl] / VIMSHOTTARI_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 };
+}
+function activeIn(periods, target) {
+    return periods.find((p) => p.start <= target && target < p.end) ?? null;
+}
+/** The mahadasha, antardasha, and pratyantardasha lords active at targetJd. */
+export function vimshottariActive(moonLon, natalJd, targetJd, yearLength = DASHA_YEAR) {
+    const timeline = vimshottariDashas(moonLon, natalJd, 2, yearLength, 10).dashas;
+    const maha = activeIn(timeline, targetJd);
+    if (maha === null)
+        return null;
+    const antar = activeIn(maha.sub, targetJd);
+    if (antar === null)
+        return { maha: maha.lord, antar: null, pratyantar: null };
+    const ay = VIMSHOTTARI_YEARS[maha.lord]
+        * VIMSHOTTARI_YEARS[antar.lord] / VIMSHOTTARI_TOTAL;
+    const sli = VIMSHOTTARI_ORDER.indexOf(antar.lord);
+    let st = antar.start;
+    let pratyantar = null;
+    for (let j = 0; j < 9; j++) {
+        const sl = VIMSHOTTARI_ORDER[(sli + j) % 9];
+        const span = (ay * VIMSHOTTARI_YEARS[sl] / VIMSHOTTARI_TOTAL) * yearLength;
+        if (st <= targetJd && targetJd < st + span) {
+            pratyantar = sl;
+            break;
+        }
+        st += span;
+    }
+    return { maha: maha.lord, antar: antar.lord, pratyantar };
+}
+/** Vimshottari dasha active at targetJd, from the natal Moon's nakshatra. */
+export function vimshottariAt(engine, natalJd, targetJd, zodiac = "sidereal:lahiri", yearLength = DASHA_YEAR) {
+    const moonLon = engine.longitude("moon", natalJd, { zodiac });
+    const nak = nakshatra(moonLon);
+    const active = vimshottariActive(moonLon, natalJd, targetJd, yearLength) ?? {};
+    return {
+        moon_nakshatra: nak.name, moon_pada: nak.pada,
+        start_lord: VIMSHOTTARI_ORDER[nak.index % 9], ...active,
+    };
+}

package/dist/src/yogas.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 { Engine, BodyId, Zodiac } from "./chart.js";
+export declare const YOGA_PLANETS: BodyId[];
+export interface Yoga {
+    yoga: string;
+    planets: string[];
+}
+/** 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
+ *  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

@@ -0,0 +1,68 @@
+import { dignities } from "./derived.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]);
+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
+ *  sign index. */
+export function detectYogas(signs, ascSign) {
+    const house = (sign) => ((sign - ascSign) % 12 + 12) % 12 + 1;
+    const out = [];
+    for (const [name, p] of MAHAPURUSHA) {
+        const dig = dignities(p, signs[p]);
+        if ((dig.includes("domicile") || dig.includes("exaltation")) && KENDRA.has(house(signs[p]))) {
+            out.push({ yoga: name, planets: [p] });
+        }
+    }
+    const jkFromMoon = ((signs.jupiter - signs.moon) % 12 + 12) % 12;
+    if (jkFromMoon === 0 || jkFromMoon === 3 || jkFromMoon === 6 || jkFromMoon === 9) {
+        out.push({ yoga: "Gajakesari", planets: ["jupiter", "moon"] });
+    }
+    if (signs.sun === signs.mercury)
+        out.push({ yoga: "Budha-Aditya", planets: ["sun", "mercury"] });
+    if (signs.moon === signs.mars)
+        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 });
+    const ascSign = Math.floor(chart.angles.asc / 30) % 12;
+    const signs = {};
+    for (const b of YOGA_PLANETS)
+        signs[b] = Math.floor(chart.bodies[b].lon / 30) % 12;
+    return detectYogas(signs, ascSign);
+}