caelus 0.12.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, nine 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": 9,
+    "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

@@ -0,0 +1,42 @@
+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;
+/** 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";
+    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,119 @@
+/**
+ * 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];
+}
+/** 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) {
+    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,14 @@ 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";
+export * from "./ashtottari.js";
+export * from "./rajayoga.js";

package/dist/src/index.js

@@ -15,3 +15,14 @@ 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";
+export * from "./ashtottari.js";
+export * from "./rajayoga.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/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[];