caelus 0.12.0 → 0.13.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, nine chart tools over stdio
+- [caelus-mcp](https://www.npmjs.com/package/caelus-mcp) — MCP server, eighteen chart tools over stdio

package/accuracy.json

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

package/dist/src/directions.d.ts

@@ -0,0 +1,27 @@
+import { Engine, BodyId } from "./chart.js";
+/** Degrees of arc that equal one year of life, per time key. */
+export declare const KEYS: Record<string, number>;
+export declare const TRADITIONAL: BodyId[];
+export interface DirectionArcs {
+    mc: number;
+    ic: number;
+    asc: number | null;
+    dsc: number | null;
+}
+/** Direct primary-direction arcs (degrees, [0, 360)) of a body at right
+ *  ascension `alpha` and declination `delta` to the four angles, for latitude
+ *  `phi` and right ascension of the MC `ramc`. `asc`/`dsc` are null when the
+ *  body is circumpolar. */
+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;
+export interface PrimaryDirection {
+    body: string;
+    angle: "MC" | "IC" | "ASC" | "DSC";
+    arc: number;
+    years: number;
+    jd: number;
+}
+/** Direct primary directions of the bodies to the four angles within
+ *  `maxYears`, by the given time key, sorted by years. */
+export declare function primaryDirections(engine: Engine, natalJd: number, lat: number, lonEast: number, bodies?: BodyId[], key?: string, maxYears?: number, yearLength?: number): PrimaryDirection[];

package/dist/src/directions.js

@@ -0,0 +1,69 @@
+/**
+ * astroengine directions -- primary directions to the angles.
+ *
+ * Primary (mundane) directions carry a planet, by the diurnal rotation of the
+ * sphere, to one of the four angles; the arc of rotation, converted by a time
+ * key, gives the age of the direction. This covers the well-defined subset:
+ * direct directions of a body to the MC, IC, Ascendant, and Descendant.
+ *
+ * For a body at right ascension alpha and declination delta, latitude phi, and
+ * right ascension of the MC (ramc): arc to MC = alpha - ramc; to IC = that
+ * - 180; to the Ascendant = alpha - AD - ramc - 90; to the Descendant =
+ * alpha + AD - ramc + 90, where AD = asin(tan phi * tan delta) is the
+ * ascensional difference. A circumpolar body (|tan phi * tan delta| > 1) has no
+ * oblique ascension, so its Ascendant/Descendant directions are undefined. Time
+ * keys: Ptolemy 1 deg = 1 year, Naibod 0.9856473 deg = 1 year. Mirrors the
+ * Python reference (astroengine/directions.py); the golden fixtures pin them.
+ */
+import { angles } from "./houses.js";
+const RAD = Math.PI / 180;
+const DEG = 180 / Math.PI;
+/** Degrees of arc that equal one year of life, per time key. */
+export const KEYS = { ptolemy: 1.0, naibod: 0.9856473 };
+export const TRADITIONAL = ["sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn"];
+const YEAR_DAYS = 365.2422;
+const mod360 = (x) => ((x % 360) + 360) % 360;
+/** Direct primary-direction arcs (degrees, [0, 360)) of a body at right
+ *  ascension `alpha` and declination `delta` to the four angles, for latitude
+ *  `phi` and right ascension of the MC `ramc`. `asc`/`dsc` are null when the
+ *  body is circumpolar. */
+export function directionArcs(alpha, delta, ramc, phi) {
+    const arcMc = mod360(alpha - ramc);
+    const arcIc = mod360(alpha - ramc - 180);
+    const t = Math.tan(phi * RAD) * Math.tan(delta * RAD);
+    if (Math.abs(t) > 1)
+        return { mc: arcMc, ic: arcIc, asc: null, dsc: null };
+    const ad = Math.asin(t) * DEG;
+    return {
+        mc: arcMc, ic: arcIc,
+        asc: mod360(alpha - ad - ramc - 90),
+        dsc: mod360(alpha + ad - ramc + 90),
+    };
+}
+/** Years of life corresponding to an arc of direction under a time key. */
+export function directionYears(arc, key = "naibod") {
+    return arc / KEYS[key];
+}
+/** 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) {
+    const armc = angles(engine.data, natalJd, lat, lonEast)[2];
+    const ramc = armc * DEG;
+    const out = [];
+    const ANGLES = ["mc", "ic", "asc", "dsc"];
+    for (const b of bodies) {
+        const p = engine.position(b, natalJd);
+        const arcs = directionArcs(p.ra, p.dec, ramc, lat);
+        for (const angle of ANGLES) {
+            const arc = arcs[angle];
+            if (arc === null)
+                continue;
+            const years = directionYears(arc, key);
+            if (years <= maxYears) {
+                out.push({ body: b, angle: angle.toUpperCase(), arc, years, jd: natalJd + years * yearLength });
+            }
+        }
+    }
+    out.sort((a, b) => a.years - b.years);
+    return out;
+}

package/dist/src/firdaria.d.ts

@@ -0,0 +1,49 @@
+/**
+ * astroengine firdaria -- the Persian/medieval system of planetary time-lord
+ * periods (firdariyyat).
+ *
+ * Life divides into nine periods totalling 75 years: the seven planets in the
+ * firdaria order, then the two lunar nodes. A day chart begins with the Sun, a
+ * night chart with the Moon; both follow the same cycle (Sun, Venus, Mercury,
+ * Moon, Saturn, Jupiter, Mars) and close with the North and South Nodes. Each
+ * planetary period splits into seven equal sub-periods led by the seven planets
+ * from that period's lord; node periods have no sub-divisions. Pure time
+ * arithmetic on the natal moment and the chart's sect. Mirrors the Python
+ * reference (astroengine/firdaria.py); the golden fixtures pin the two together.
+ */
+import { Engine } from "./chart.js";
+/** The firdaria cycle of the seven planets. */
+export declare const FIRDARIA_ORDER: readonly ["sun", "venus", "mercury", "moon", "saturn", "jupiter", "mars"];
+/** Period length in years for each of the seven planets. */
+export declare const FIRDARIA_YEARS: Record<(typeof FIRDARIA_ORDER)[number], number>;
+/** The two nodes close the sequence with no sub-periods (70 + 5 = 75 years). */
+export declare const NODE_PERIODS: ReadonlyArray<readonly [string, number]>;
+/** The nine major firdaria periods in order, as `[lord, years]` pairs. */
+export declare function firdariaSequence(day: boolean): Array<[string, number]>;
+export interface FirdariaSub {
+    lord: string;
+    start: number;
+    end: number;
+}
+export interface FirdariaPeriod {
+    lord: string;
+    years: number;
+    start: number;
+    end: number;
+    sub: FirdariaSub[];
+}
+/** The full firdaria timeline from birth. */
+export declare function firdaria(day: boolean, natalJd: number, yearLength?: number): FirdariaPeriod[];
+/** The major and sub firdar lord active at `targetJd`; both null outside the
+ *  75-year span. */
+export declare function firdariaActive(day: boolean, natalJd: number, targetJd: number, yearLength?: number): {
+    major: string | null;
+    sub: string | null;
+};
+/** The active firdar at `targetJd`, taking the chart's sect from the natal
+ *  moment and place. */
+export declare function firdariaAt(engine: Engine, natalJd: number, targetJd: number, lat: number, lonEast: number, yearLength?: number): {
+    day: boolean;
+    major: string | null;
+    sub: string | null;
+};

package/dist/src/firdaria.js

@@ -0,0 +1,62 @@
+import { TROPICAL_YEAR, isDayChart } from "./derived.js";
+/** The firdaria cycle of the seven planets. */
+export const FIRDARIA_ORDER = [
+    "sun", "venus", "mercury", "moon", "saturn", "jupiter", "mars",
+];
+/** Period length in years for each of the seven planets. */
+export const FIRDARIA_YEARS = {
+    sun: 10, venus: 8, mercury: 13, moon: 9, saturn: 11, jupiter: 12, mars: 7,
+};
+/** The two nodes close the sequence with no sub-periods (70 + 5 = 75 years). */
+export const NODE_PERIODS = [
+    ["north_node", 3], ["south_node", 2],
+];
+/** The nine major firdaria periods in order, as `[lord, years]` pairs. */
+export function firdariaSequence(day) {
+    const start = day ? 0 : FIRDARIA_ORDER.indexOf("moon");
+    const planets = [];
+    for (let i = 0; i < 7; i++) {
+        const lord = FIRDARIA_ORDER[(start + i) % 7];
+        planets.push([lord, FIRDARIA_YEARS[lord]]);
+    }
+    return [...planets, ...NODE_PERIODS.map((p) => [p[0], p[1]])];
+}
+/** The full firdaria timeline from birth. */
+export function firdaria(day, natalJd, yearLength = TROPICAL_YEAR) {
+    const out = [];
+    let t = natalJd;
+    for (const [lord, years] of firdariaSequence(day)) {
+        const span = years * yearLength;
+        const major = { lord, years, start: t, end: t + span, sub: [] };
+        const li = FIRDARIA_ORDER.indexOf(lord);
+        if (li >= 0) {
+            const subSpan = span / 7;
+            let st = t;
+            for (let k = 0; k < 7; k++) {
+                const sl = FIRDARIA_ORDER[(li + k) % 7];
+                major.sub.push({ lord: sl, start: st, end: st + subSpan });
+                st += subSpan;
+            }
+        }
+        out.push(major);
+        t += span;
+    }
+    return out;
+}
+/** The major and sub firdar lord active at `targetJd`; both null outside the
+ *  75-year span. */
+export function firdariaActive(day, natalJd, targetJd, yearLength = TROPICAL_YEAR) {
+    for (const major of firdaria(day, natalJd, yearLength)) {
+        if (major.start <= targetJd && targetJd < major.end) {
+            const sub = major.sub.find((s) => s.start <= targetJd && targetJd < s.end);
+            return { major: major.lord, sub: sub ? sub.lord : null };
+        }
+    }
+    return { major: null, sub: null };
+}
+/** The active firdar at `targetJd`, taking the chart's sect from the natal
+ *  moment and place. */
+export function firdariaAt(engine, natalJd, targetJd, lat, lonEast, yearLength = TROPICAL_YEAR) {
+    const day = isDayChart(engine, natalJd, lat, lonEast);
+    return { day, ...firdariaActive(day, natalJd, targetJd, yearLength) };
+}

package/dist/src/index.d.ts

@@ -15,3 +15,12 @@ export * from "./astrocartography.js";
 export * from "./ephemeris.js";
 export * from "./features.js";
 export * from "./compiler.js";
+export * from "./lots.js";
+export * from "./profections.js";
+export * from "./firdaria.js";
+export * from "./releasing.js";
+export * from "./vedic.js";
+export * from "./directions.js";
+export * from "./vargas.js";
+export * from "./yogini.js";
+export * from "./yogas.js";

package/dist/src/index.js

@@ -15,3 +15,12 @@ export * from "./astrocartography.js";
 export * from "./ephemeris.js";
 export * from "./features.js";
 export * from "./compiler.js";
+export * from "./lots.js";
+export * from "./profections.js";
+export * from "./firdaria.js";
+export * from "./releasing.js";
+export * from "./vedic.js";
+export * from "./directions.js";
+export * from "./vargas.js";
+export * from "./yogini.js";
+export * from "./yogas.js";

package/dist/src/lots.d.ts

@@ -0,0 +1,18 @@
+import { Engine, Zodiac } from "./chart.js";
+/** The seven Hermetic lots, in their conventional order. */
+export declare const HERMETIC_LOTS: readonly ["fortune", "spirit", "eros", "necessity", "courage", "victory", "nemesis"];
+export type HermeticLot = (typeof HERMETIC_LOTS)[number];
+/** Lot of Fortune: Asc + Moon - Sun by day, Asc + Sun - Moon by night. */
+export declare function lotFortune(asc: number, sun: number, moon: number, day: boolean): number;
+/** Lot of Spirit (the reverse of Fortune): Asc + Sun - Moon by day. */
+export declare function lotSpirit(asc: number, sun: number, moon: number, day: boolean): number;
+/** The seven Hermetic lots from the Ascendant, sect, and the seven planets'
+ *  longitudes (degrees). Pure arithmetic. */
+export declare function hermeticLots(asc: number, day: boolean, sun: number, moon: number, mercury: number, venus: number, mars: number, jupiter: number, saturn: number): Record<HermeticLot, number>;
+export interface ChartLots extends Record<HermeticLot, number> {
+    /** True when the Sun is above the horizon (a diurnal chart). */
+    day: boolean;
+}
+/** The seven Hermetic lots of a chart: compute the Ascendant and sect, then the
+ *  lots from the seven planets' longitudes. */
+export declare function lots(engine: Engine, jdUt: number, lat: number, lonEast: number, zodiac?: Zodiac): ChartLots;

package/dist/src/lots.js

@@ -0,0 +1,52 @@
+/**
+ * astroengine lots -- Hellenistic lots (Arabic parts), sect-aware.
+ *
+ * A lot is an arc cast from the Ascendant equal to the arc between two chart
+ * points, reversing direction between a day and a night chart. Arithmetic on
+ * apparent longitudes already checked against Swiss Ephemeris. Mirrors the
+ * Python reference (astroengine/lots.py); the golden fixtures pin the two
+ * together. Fortune and Spirit are symmetric about the Ascendant, so
+ * `(fortune + spirit) === 2 * asc` (mod 360).
+ */
+import { mod } from "./core.js";
+import { isDayChart } from "./derived.js";
+/** The seven Hermetic lots, in their conventional order. */
+export const HERMETIC_LOTS = [
+    "fortune", "spirit", "eros", "necessity", "courage", "victory", "nemesis",
+];
+/** Asc + (a - b) by day, Asc + (b - a) by night, wrapped to [0, 360). */
+function lot(asc, a, b, day) {
+    return mod(asc + (day ? a - b : b - a), 360);
+}
+/** Lot of Fortune: Asc + Moon - Sun by day, Asc + Sun - Moon by night. */
+export function lotFortune(asc, sun, moon, day) {
+    return lot(asc, moon, sun, day);
+}
+/** Lot of Spirit (the reverse of Fortune): Asc + Sun - Moon by day. */
+export function lotSpirit(asc, sun, moon, day) {
+    return lot(asc, sun, moon, day);
+}
+/** The seven Hermetic lots from the Ascendant, sect, and the seven planets'
+ *  longitudes (degrees). Pure arithmetic. */
+export function hermeticLots(asc, day, sun, moon, mercury, venus, mars, jupiter, saturn) {
+    const fortune = lotFortune(asc, sun, moon, day);
+    const spirit = lotSpirit(asc, sun, moon, day);
+    return {
+        fortune,
+        spirit,
+        eros: lot(asc, venus, spirit, day),
+        necessity: lot(asc, fortune, mercury, day),
+        courage: lot(asc, fortune, mars, day),
+        victory: lot(asc, jupiter, spirit, day),
+        nemesis: lot(asc, fortune, saturn, day),
+    };
+}
+/** The seven Hermetic lots of a chart: compute the Ascendant and sect, then the
+ *  lots from the seven planets' longitudes. */
+export function lots(engine, jdUt, lat, lonEast, zodiac = "tropical") {
+    const asc = engine.chartAt(jdUt, lat, lonEast, { zodiac }).angles.asc;
+    const day = isDayChart(engine, jdUt, lat, lonEast);
+    const lon = (b) => engine.longitude(b, jdUt, { zodiac });
+    const h = hermeticLots(asc, day, lon("sun"), lon("moon"), lon("mercury"), lon("venus"), lon("mars"), lon("jupiter"), lon("saturn"));
+    return { day, ...h };
+}

package/dist/src/profections.d.ts

@@ -0,0 +1,27 @@
+import { Engine, Zodiac } from "./chart.js";
+/** Traditional (domicile) ruler of each sign, Aries..Pisces. */
+export declare const SIGN_RULERS: readonly ["mars", "venus", "mercury", "moon", "sun", "mercury", "venus", "mars", "jupiter", "saturn", "saturn", "jupiter"];
+/** Traditional (domicile) ruler of a sign index (0 = Aries). */
+export declare function signRuler(sign: number): string;
+export interface ProfectedSign {
+    sign: string;
+    sign_index: number;
+    /** 1-based whole-sign house from the natal Ascendant. */
+    house: number;
+    /** Traditional (domicile) lord of the profected sign. */
+    lord: string;
+}
+/** The whole-sign profection `steps` signs after the Ascendant sign. */
+export declare function profectedSign(ascSign: number, steps: number): ProfectedSign;
+export interface Profection {
+    age_years: number;
+    /** 1-based month within the profection year. */
+    month: number;
+    annual: ProfectedSign;
+    monthly: ProfectedSign;
+}
+/** Annual and monthly profection at `targetJd` for a natal Ascendant sign. */
+export declare function profection(ascSign: number, natalJd: number, targetJd: number, yearLength?: number): Profection;
+/** Profection from a natal chart: take the Ascendant sign from the natal chart,
+ *  then profect to `targetJd`. */
+export declare function profectionAt(engine: Engine, natalJd: number, targetJd: number, lat: number, lonEast: number, zodiac?: Zodiac, yearLength?: number): Profection;

package/dist/src/profections.js

@@ -0,0 +1,49 @@
+/**
+ * astroengine profections -- annual and monthly profections, a Hellenistic
+ * time-lord technique.
+ *
+ * The Ascendant advances one whole sign per year of life; the profected sign's
+ * traditional (domicile) ruler is the lord of the year. Within the year the
+ * monthly profection advances one further sign per 1/12 of the year. Pure
+ * arithmetic on a date difference and the natal Ascendant sign. Mirrors the
+ * Python reference (astroengine/profections.py); the golden fixtures pin the
+ * two together. Whole-sign frame: the sign N signs after the Ascendant is the
+ * (N+1)th house. The profection year is a fixed length (the tropical year by
+ * default); birthday-exact profections would key off the solar return.
+ */
+import { mod } from "./core.js";
+import { SIGNS } from "./chart.js";
+import { TROPICAL_YEAR } from "./derived.js";
+/** Traditional (domicile) ruler of each sign, Aries..Pisces. */
+export const SIGN_RULERS = [
+    "mars", "venus", "mercury", "moon", "sun", "mercury",
+    "venus", "mars", "jupiter", "saturn", "saturn", "jupiter",
+];
+/** Traditional (domicile) ruler of a sign index (0 = Aries). */
+export function signRuler(sign) {
+    return SIGN_RULERS[mod(sign, 12)];
+}
+/** The whole-sign profection `steps` signs after the Ascendant sign. */
+export function profectedSign(ascSign, steps) {
+    const sign = mod(ascSign + steps, 12);
+    return { sign: SIGNS[sign], sign_index: sign, house: mod(steps, 12) + 1, lord: signRuler(sign) };
+}
+/** Annual and monthly profection at `targetJd` for a natal Ascendant sign. */
+export function profection(ascSign, natalJd, targetJd, yearLength = TROPICAL_YEAR) {
+    const age = (targetJd - natalJd) / yearLength;
+    const years = Math.floor(age);
+    const month = Math.floor((age - years) * 12); // 0..11
+    return {
+        age_years: years,
+        month: month + 1,
+        annual: profectedSign(ascSign, years),
+        monthly: profectedSign(ascSign, years + month),
+    };
+}
+/** Profection from a natal chart: take the Ascendant sign from the natal chart,
+ *  then profect to `targetJd`. */
+export function profectionAt(engine, natalJd, targetJd, lat, lonEast, zodiac = "tropical", yearLength = TROPICAL_YEAR) {
+    const asc = engine.chartAt(natalJd, lat, lonEast, { zodiac }).angles.asc;
+    const ascSign = mod(Math.floor(asc / 30), 12);
+    return profection(ascSign, natalJd, targetJd, yearLength);
+}

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, 3, 9, 10, 12];
+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,52 @@
+/**
+ * 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, 3, 9, 10, 12];
+function vargaSign(rasi, div, n) {
+    switch (n) {
+        case 1: return rasi;
+        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 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 };
+}
+/** 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,26 @@
+/**
+ * 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[];
+/** 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,39 @@
+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;
+}
+/** 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);
+}

package/dist/src/yogini.d.ts

@@ -0,0 +1,54 @@
+/**
+ * astroengine yogini -- the Yogini dasha, a 36-year nakshatra-based dasha cycle.
+ *
+ * Eight yoginis rule in a fixed order with periods 1..8 years (totalling 36):
+ * Mangala (Moon) 1, Pingala (Sun) 2, Dhanya (Jupiter) 3, Bhramari (Mars) 4,
+ * Bhadrika (Mercury) 5, Ulka (Saturn) 6, Siddha (Venus) 7, Sankata (Rahu) 8.
+ * The starting yogini comes from the Moon's birth nakshatra: (nakshatra number
+ * + 3) mod 8, a remainder of 0 meaning the 8th. As in Vimshottari, the elapsed
+ * portion of the first period is the fraction of the nakshatra the Moon has
+ * traversed, and each period subdivides into eight proportional sub-periods.
+ * Mirrors the Python reference (astroengine/yogini.py); the golden fixtures pin
+ * the two together.
+ */
+import { Engine, Zodiac } from "./chart.js";
+export declare const YOGINIS: readonly ["Mangala", "Pingala", "Dhanya", "Bhramari", "Bhadrika", "Ulka", "Siddha", "Sankata"];
+export declare const YOGINI_LORDS: Record<(typeof YOGINIS)[number], string>;
+/** Period in years by yogini index (Mangala..Sankata), totalling 36. */
+export declare const YOGINI_YEARS: readonly [1, 2, 3, 4, 5, 6, 7, 8];
+/** 0-based starting yogini index from the Moon's nakshatra index (0-based):
+ *  (nakshatra number + 3) mod 8, a remainder of 0 mapping to the 8th. */
+export declare function startingYogini(nakIndex: number): number;
+export interface YoginiSub {
+    yogini: string;
+    lord: string;
+    start: number;
+    end: number;
+}
+export interface YoginiPeriod {
+    level: number;
+    yogini: string;
+    lord: string;
+    years: number;
+    start: number;
+    end: number;
+    sub: YoginiSub[];
+}
+export interface YoginiTimeline {
+    start_yogini: string;
+    balance_years: number;
+    dashas: YoginiPeriod[];
+}
+/** The Yogini dasha timeline from the Moon's sidereal longitude. */
+export declare function yoginiDashas(moonLon: number, natalJd: number, levels?: number, yearLength?: number, count?: number): YoginiTimeline;
+export interface YoginiActive {
+    maha: string;
+    antar: string | null;
+}
+/** The maha and antar yogini active at targetJd; null before the first period. */
+export declare function yoginiActive(moonLon: number, natalJd: number, targetJd: number, yearLength?: number): YoginiActive | null;
+/** Yogini dasha active at targetJd, from the natal Moon's nakshatra. */
+export declare function yoginiAt(engine: Engine, natalJd: number, targetJd: number, zodiac?: Zodiac, yearLength?: number): {
+    moon_nakshatra: string;
+    start_yogini: string;
+} & Partial<YoginiActive>;

package/dist/src/yogini.js

@@ -0,0 +1,63 @@
+import { nakshatra, NAK_SPAN, DASHA_YEAR } from "./vedic.js";
+export const YOGINIS = [
+    "Mangala", "Pingala", "Dhanya", "Bhramari", "Bhadrika", "Ulka", "Siddha", "Sankata",
+];
+export const YOGINI_LORDS = {
+    Mangala: "moon", Pingala: "sun", Dhanya: "jupiter", Bhramari: "mars",
+    Bhadrika: "mercury", Ulka: "saturn", Siddha: "venus", Sankata: "rahu",
+};
+/** Period in years by yogini index (Mangala..Sankata), totalling 36. */
+export const YOGINI_YEARS = [1, 2, 3, 4, 5, 6, 7, 8];
+const YOGINI_TOTAL = 36;
+/** 0-based starting yogini index from the Moon's nakshatra index (0-based):
+ *  (nakshatra number + 3) mod 8, a remainder of 0 mapping to the 8th. */
+export function startingYogini(nakIndex) {
+    const y = (nakIndex + 1 + 3) % 8; // nakshatra number is 1-based
+    return ((y - 1) % 8 + 8) % 8; // remainder 0 -> 8th (index 7)
+}
+/** The Yogini dasha timeline from the Moon's sidereal longitude. */
+export function yoginiDashas(moonLon, natalJd, levels = 2, yearLength = DASHA_YEAR, count = 8) {
+    const nak = nakshatra(moonLon);
+    const start = startingYogini(nak.index);
+    const elapsed = nak.pos / NAK_SPAN;
+    const y0 = YOGINI_YEARS[start];
+    let t = natalJd - elapsed * y0 * yearLength;
+    const dashas = [];
+    for (let k = 0; k < count; k++) {
+        const yi = (start + k) % 8;
+        const years = YOGINI_YEARS[yi];
+        const span = years * yearLength;
+        const maha = {
+            level: 1, yogini: YOGINIS[yi], lord: YOGINI_LORDS[YOGINIS[yi]],
+            years, start: t, end: t + span, sub: [],
+        };
+        if (levels >= 2) {
+            let st = t;
+            for (let j = 0; j < 8; j++) {
+                const sj = (yi + j) % 8;
+                const subSpan = (years * YOGINI_YEARS[sj] / YOGINI_TOTAL) * yearLength;
+                maha.sub.push({ yogini: YOGINIS[sj], lord: YOGINI_LORDS[YOGINIS[sj]], start: st, end: st + subSpan });
+                st += subSpan;
+            }
+        }
+        dashas.push(maha);
+        t += span;
+    }
+    return { start_yogini: YOGINIS[start], balance_years: (1 - elapsed) * y0, dashas };
+}
+/** The maha and antar yogini active at targetJd; null before the first period. */
+export function yoginiActive(moonLon, natalJd, targetJd, yearLength = DASHA_YEAR) {
+    const timeline = yoginiDashas(moonLon, natalJd, 2, yearLength, 24).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.yogini, antar: antar ? antar.yogini : null };
+}
+/** Yogini dasha active at targetJd, from the natal Moon's nakshatra. */
+export function yoginiAt(engine, natalJd, targetJd, zodiac = "sidereal:lahiri", yearLength = DASHA_YEAR) {
+    const moonLon = engine.longitude("moon", natalJd, { zodiac });
+    const nak = nakshatra(moonLon);
+    const active = yoginiActive(moonLon, natalJd, targetJd, yearLength) ?? {};
+    return { moon_nakshatra: nak.name, start_yogini: YOGINIS[startingYogini(nak.index)], ...active };
+}

package/package.json

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