astrology-insights 2.2.0 → 2.3.0

package/dist/core/constants.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Panchang constants — astronomical degrees, names, and lookup tables.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RASHIS = exports.KARANA_NAMES_FIXED = exports.KARANA_NAMES_REPEATING = exports.YOGA_NAMES = exports.NAKSHATRAS = exports.TITHI_NAMES = exports.normalizeAngle = exports.DEGREES_PER_RASHI = exports.DEGREES_PER_YOGA = exports.DEGREES_PER_PADA = exports.DEGREES_PER_NAKSHATRA = exports.DEGREES_PER_TITHI = void 0;
+// ---------------------------------------------------------------------------
+// Degree constants
+// ---------------------------------------------------------------------------
+exports.DEGREES_PER_TITHI = 12;
+exports.DEGREES_PER_NAKSHATRA = 13.333333;
+exports.DEGREES_PER_PADA = 3.333333;
+exports.DEGREES_PER_YOGA = 13.333333;
+exports.DEGREES_PER_RASHI = 30;
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+function normalizeAngle(angle) {
+    let normalized = angle % 360;
+    if (normalized < 0) {
+        normalized += 360;
+    }
+    return normalized;
+}
+exports.normalizeAngle = normalizeAngle;
+// ---------------------------------------------------------------------------
+// Tithi names (30 total: 15 Shukla + 15 Krishna)
+// Index 0-14 = Shukla Paksha; index 15-29 = Krishna Paksha
+// The 15th tithi of each paksha is Purnima / Amavasya respectively.
+// ---------------------------------------------------------------------------
+exports.TITHI_NAMES = [
+    // Shukla Paksha (1–15)
+    'Shukla Pratipada',
+    'Shukla Dwitiya',
+    'Shukla Tritiya',
+    'Shukla Chaturthi',
+    'Shukla Panchami',
+    'Shukla Shashthi',
+    'Shukla Saptami',
+    'Shukla Ashtami',
+    'Shukla Navami',
+    'Shukla Dashami',
+    'Shukla Ekadashi',
+    'Shukla Dwadashi',
+    'Shukla Trayodashi',
+    'Shukla Chaturdashi',
+    'Purnima',
+    // Krishna Paksha (1–15)
+    'Krishna Pratipada',
+    'Krishna Dwitiya',
+    'Krishna Tritiya',
+    'Krishna Chaturthi',
+    'Krishna Panchami',
+    'Krishna Shashthi',
+    'Krishna Saptami',
+    'Krishna Ashtami',
+    'Krishna Navami',
+    'Krishna Dashami',
+    'Krishna Ekadashi',
+    'Krishna Dwadashi',
+    'Krishna Trayodashi',
+    'Krishna Chaturdashi',
+    'Amavasya',
+];
+// ---------------------------------------------------------------------------
+// Nakshatras (27)
+// ---------------------------------------------------------------------------
+exports.NAKSHATRAS = [
+    { name: 'Ashwini', lord: 'Ketu', deity: 'Ashwini Kumaras' },
+    { name: 'Bharani', lord: 'Venus', deity: 'Yama' },
+    { name: 'Krittika', lord: 'Sun', deity: 'Agni' },
+    { name: 'Rohini', lord: 'Moon', deity: 'Brahma' },
+    { name: 'Mrigashira', lord: 'Mars', deity: 'Soma' },
+    { name: 'Ardra', lord: 'Rahu', deity: 'Rudra' },
+    { name: 'Punarvasu', lord: 'Jupiter', deity: 'Aditi' },
+    { name: 'Pushya', lord: 'Saturn', deity: 'Brihaspati' },
+    { name: 'Ashlesha', lord: 'Mercury', deity: 'Nagas' },
+    { name: 'Magha', lord: 'Ketu', deity: 'Pitrs' },
+    { name: 'Purva Phalguni', lord: 'Venus', deity: 'Bhaga' },
+    { name: 'Uttara Phalguni', lord: 'Sun', deity: 'Aryaman' },
+    { name: 'Hasta', lord: 'Moon', deity: 'Savitar' },
+    { name: 'Chitra', lord: 'Mars', deity: 'Vishvakarma' },
+    { name: 'Swati', lord: 'Rahu', deity: 'Vayu' },
+    { name: 'Vishakha', lord: 'Jupiter', deity: 'Indragni' },
+    { name: 'Anuradha', lord: 'Saturn', deity: 'Mitra' },
+    { name: 'Jyeshtha', lord: 'Mercury', deity: 'Indra' },
+    { name: 'Mula', lord: 'Ketu', deity: 'Nirriti' },
+    { name: 'Purva Ashadha', lord: 'Venus', deity: 'Apah' },
+    { name: 'Uttara Ashadha', lord: 'Sun', deity: 'Vishvedevas' },
+    { name: 'Shravana', lord: 'Moon', deity: 'Vishnu' },
+    { name: 'Dhanishtha', lord: 'Mars', deity: 'Vasus' },
+    { name: 'Shatabhisha', lord: 'Rahu', deity: 'Varuna' },
+    { name: 'Purva Bhadrapada', lord: 'Jupiter', deity: 'Ajaikapat' },
+    { name: 'Uttara Bhadrapada', lord: 'Saturn', deity: 'Ahirbudhnya' },
+    { name: 'Revati', lord: 'Mercury', deity: 'Pushan' },
+];
+// ---------------------------------------------------------------------------
+// Yoga names (27)
+// ---------------------------------------------------------------------------
+exports.YOGA_NAMES = [
+    'Vishkumbha',
+    'Preeti',
+    'Ayushman',
+    'Saubhagya',
+    'Shobhana',
+    'Atiganda',
+    'Sukarman',
+    'Dhriti',
+    'Shoola',
+    'Ganda',
+    'Vriddhi',
+    'Dhruva',
+    'Vyaghata',
+    'Harshana',
+    'Vajra',
+    'Siddhi',
+    'Vyatipata',
+    'Variyan',
+    'Parigha',
+    'Shiva',
+    'Siddha',
+    'Sadhya',
+    'Shubha',
+    'Shukla',
+    'Brahma',
+    'Indra',
+    'Vaidhriti',
+];
+// ---------------------------------------------------------------------------
+// Karana names
+// ---------------------------------------------------------------------------
+/** 7 movable (repeating) karanas */
+exports.KARANA_NAMES_REPEATING = [
+    'Bava',
+    'Balava',
+    'Kaulava',
+    'Taitila',
+    'Garija',
+    'Vanija',
+    'Vishti',
+];
+/** 4 fixed karanas (occur once per lunar month at the end) */
+exports.KARANA_NAMES_FIXED = [
+    'Shakuni',
+    'Chatushpad',
+    'Naga',
+    'Kimstughna',
+];
+// ---------------------------------------------------------------------------
+// Rashis (12)
+// ---------------------------------------------------------------------------
+exports.RASHIS = [
+    { name: 'Aries', sanskritName: 'Mesha', lord: 'Mars', element: 'Fire' },
+    { name: 'Taurus', sanskritName: 'Vrishabha', lord: 'Venus', element: 'Earth' },
+    { name: 'Gemini', sanskritName: 'Mithuna', lord: 'Mercury', element: 'Air' },
+    { name: 'Cancer', sanskritName: 'Karka', lord: 'Moon', element: 'Water' },
+    { name: 'Leo', sanskritName: 'Simha', lord: 'Sun', element: 'Fire' },
+    { name: 'Virgo', sanskritName: 'Kanya', lord: 'Mercury', element: 'Earth' },
+    { name: 'Libra', sanskritName: 'Tula', lord: 'Venus', element: 'Air' },
+    { name: 'Scorpio', sanskritName: 'Vrishchika', lord: 'Mars', element: 'Water' },
+    { name: 'Sagittarius', sanskritName: 'Dhanu', lord: 'Jupiter', element: 'Fire' },
+    { name: 'Capricorn', sanskritName: 'Makara', lord: 'Saturn', element: 'Earth' },
+    { name: 'Aquarius', sanskritName: 'Kumbha', lord: 'Saturn', element: 'Air' },
+    { name: 'Pisces', sanskritName: 'Meena', lord: 'Jupiter', element: 'Water' },
+];

package/dist/core/karana.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateKarana = void 0;
+const constants_1 = require("./constants");
+const DEGREES_PER_KARANA = 6;
+function calculateKarana(sunLongitude, moonLongitude) {
+    const diff = (0, constants_1.normalizeAngle)(moonLongitude - sunLongitude);
+    const karanaIndex = Math.floor(diff / DEGREES_PER_KARANA);
+    const posInKarana = diff - (karanaIndex * DEGREES_PER_KARANA);
+    const progress = (posInKarana / DEGREES_PER_KARANA) * 100;
+    let name;
+    if (karanaIndex === 0) {
+        name = 'Kimstughna';
+    }
+    else if (karanaIndex >= 57) {
+        name = constants_1.KARANA_NAMES_FIXED[karanaIndex - 57];
+    }
+    else {
+        name = constants_1.KARANA_NAMES_REPEATING[(karanaIndex - 1) % 7];
+    }
+    return { name, number: karanaIndex + 1, progress: Math.round(progress * 10) / 10 };
+}
+exports.calculateKarana = calculateKarana;

package/dist/core/nakshatra.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateNakshatra = void 0;
+const constants_1 = require("./constants");
+function calculateNakshatra(moonLongitude) {
+    const lon = (0, constants_1.normalizeAngle)(moonLongitude);
+    const nakshatraIndex = Math.floor(lon / constants_1.DEGREES_PER_NAKSHATRA);
+    const posInNakshatra = lon - (nakshatraIndex * constants_1.DEGREES_PER_NAKSHATRA);
+    const pada = Math.min(Math.floor(posInNakshatra / constants_1.DEGREES_PER_PADA) + 1, 4);
+    const posInPada = posInNakshatra - ((pada - 1) * constants_1.DEGREES_PER_PADA);
+    const nk = constants_1.NAKSHATRAS[nakshatraIndex];
+    const progress = (posInNakshatra / constants_1.DEGREES_PER_NAKSHATRA) * 100;
+    const padaProgress = (posInPada / constants_1.DEGREES_PER_PADA) * 100;
+    return {
+        name: nk.name, number: nakshatraIndex + 1, pada,
+        lord: nk.lord, deity: nk.deity,
+        progress: Math.round(progress * 10) / 10,
+        padaProgress: Math.round(padaProgress * 10) / 10,
+    };
+}
+exports.calculateNakshatra = calculateNakshatra;

package/dist/core/rashi.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRashi = void 0;
+const constants_1 = require("./constants");
+function calculateRashi(longitude) {
+    const lon = (0, constants_1.normalizeAngle)(longitude);
+    const rashiIndex = Math.floor(lon / constants_1.DEGREES_PER_RASHI);
+    const degree = lon - (rashiIndex * constants_1.DEGREES_PER_RASHI);
+    const rashi = constants_1.RASHIS[rashiIndex];
+    return {
+        name: rashi.name,
+        lord: rashi.lord,
+        degree: Math.round(degree * 10) / 10,
+        number: rashiIndex + 1,
+    };
+}
+exports.calculateRashi = calculateRashi;

package/dist/core/tithi.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTithi = void 0;
+const constants_1 = require("./constants");
+// Bare tithi names (without paksha prefix) for both halves.
+// Index 0–14: Shukla Paksha tithis; index 15–29: Krishna Paksha tithis.
+// Purnima (index 14) and Amavasya (index 29) have no paksha prefix.
+const BARE_TITHI_NAMES = [
+    'Pratipada', 'Dwitiya', 'Tritiya', 'Chaturthi', 'Panchami',
+    'Shashthi', 'Saptami', 'Ashtami', 'Navami', 'Dashami',
+    'Ekadashi', 'Dwadashi', 'Trayodashi', 'Chaturdashi', 'Purnima',
+    'Pratipada', 'Dwitiya', 'Tritiya', 'Chaturthi', 'Panchami',
+    'Shashthi', 'Saptami', 'Ashtami', 'Navami', 'Dashami',
+    'Ekadashi', 'Dwadashi', 'Trayodashi', 'Chaturdashi', 'Amavasya',
+];
+function calculateTithi(sunLongitude, moonLongitude) {
+    const diff = (0, constants_1.normalizeAngle)(moonLongitude - sunLongitude);
+    const tithiIndex = Math.floor(diff / constants_1.DEGREES_PER_TITHI);
+    const progress = ((diff % constants_1.DEGREES_PER_TITHI) / constants_1.DEGREES_PER_TITHI) * 100;
+    const isShukla = tithiIndex < 15;
+    const paksha = isShukla ? 'Shukla' : 'Krishna';
+    const pakshaNumber = isShukla ? tithiIndex + 1 : tithiIndex - 15 + 1;
+    const baseName = BARE_TITHI_NAMES[tithiIndex];
+    // Purnima and Amavasya are standalone names; all others get paksha prefix.
+    const name = (baseName === 'Purnima' || baseName === 'Amavasya')
+        ? baseName
+        : `${paksha} ${baseName}`;
+    return {
+        name,
+        number: pakshaNumber,
+        tithiIndex: tithiIndex + 1,
+        paksha,
+        progress: Math.round(progress * 10) / 10,
+    };
+}
+exports.calculateTithi = calculateTithi;

package/dist/core/yoga.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateYoga = void 0;
+const constants_1 = require("./constants");
+function calculateYoga(sunLongitude, moonLongitude) {
+    const sum = (0, constants_1.normalizeAngle)(sunLongitude + moonLongitude);
+    const yogaIndex = Math.floor(sum / constants_1.DEGREES_PER_YOGA);
+    const posInYoga = sum - (yogaIndex * constants_1.DEGREES_PER_YOGA);
+    const progress = (posInYoga / constants_1.DEGREES_PER_YOGA) * 100;
+    return {
+        name: constants_1.YOGA_NAMES[yogaIndex],
+        number: yogaIndex + 1,
+        progress: Math.round(progress * 10) / 10,
+    };
+}
+exports.calculateYoga = calculateYoga;

package/dist/panchang/src/calculations/ephemeris.js

@@ -25,9 +25,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ephemeris = void 0;
 const swisseph = __importStar(require("swisseph"));
-const index_1 = { normalizeAngle: function(a) { var n = a % 360; if (n < 0) n += 360; return n; } };
+const index_1 = require("../utils/index");
 const planetary_1 = require("./planetary");
-const path = { join: function() { return "/"; } };
+const path = __importStar(require("path"));
 class Ephemeris {
     constructor(ephemeris_path) {
         this.planet_map = {
@@ -49,15 +49,15 @@ class Ephemeris {
         if (!ephemeris_path) {
             // Try multiple possible paths for the ephemeris files
             const possible_paths = [
-                "/",
-                "/",
-                "/",
-                "/" // CWD node_modules
+                path.join(__dirname, '../../ephe'),
+                path.join(__dirname, '../node_modules/swisseph/ephe'),
+                path.join(process.cwd(), 'ephe'),
+                path.join(process.cwd(), 'node_modules/swisseph/ephe') // CWD node_modules
             ];
             // Use the first existing path
             this.ephemeris_path = possible_paths.find(p => {
                 try {
-                    const fs = { existsSync: function() { return false; } };
+                    const fs = require('fs');
                     return fs.existsSync(p);
                 }
                 catch {

package/dist/panchang/src/calculations/planetary.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Planetary = exports.NAKSHATRAS = exports.RASHIS = void 0;
-const index_1 = { normalizeAngle: function(a) { var n = a % 360; if (n < 0) n += 360; return n; } };
+const index_1 = require("../utils/index");
 exports.RASHIS = [
     { name: "Mesha", element: "Fire", ruler: "Mars" },
     { name: "Vrishabha", element: "Earth", ruler: "Venus" },

package/dist/panchang/src/panchang-v2.js

@@ -180,6 +180,94 @@ function calculateFullPanchang(date, latitude, longitude, timezone) {
     const karana = (0, karana_1.calculateKarana)(sunLon, moonLon);
     const moonSign = (0, rashi_1.calculateRashi)(moonLon);
     const sunSign = (0, rashi_1.calculateRashi)(sunLon);
+    // ── Transition detection with binary search for exact time ──────────────
+    // Check sunrise vs sunset. If tithi/nakshatra/yoga/karana changed,
+    // binary-search for the exact transition moment.
+    function findTransitionTime(startDate, endDate, getValueFn, startValue, maxIterations = 14) {
+        let lo = startDate.getTime();
+        let hi = endDate.getTime();
+        for (let i = 0; i < maxIterations; i++) {
+            const mid = Math.floor((lo + hi) / 2);
+            const midDate = new Date(mid);
+            const lons = computeLongitudes(midDate, ayanamsa);
+            const val = getValueFn(midDate);
+            if (val === startValue) {
+                lo = mid;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        return new Date(hi);
+    }
+    function formatTransitionTime(dt, tz) {
+        try {
+            return dt.toLocaleTimeString('en-IN', {
+                timeZone: tz,
+                hour: '2-digit',
+                minute: '2-digit',
+                hour12: true,
+            });
+        }
+        catch {
+            const h = dt.getUTCHours();
+            const m = dt.getUTCMinutes();
+            return `${h % 12 || 12}:${m < 10 ? '0' + m : m} ${h < 12 ? 'AM' : 'PM'}`;
+        }
+    }
+    let tithi2 = null;
+    let nakshatra2 = null;
+    let yoga2 = null;
+    let karana2 = null;
+    let tithiTransitionTime = '';
+    let nakshatraTransitionTime = '';
+    let yogaTransitionTime = '';
+    let karanaTransitionTime = '';
+    if (sunset) {
+        try {
+            const sunsetLons = computeLongitudes(sunset, ayanamsa);
+            const tithiAtSunset = (0, tithi_1.calculateTithi)(sunsetLons.sunLon, sunsetLons.moonLon);
+            const nakshatraAtSunset = (0, nakshatra_1.calculateNakshatra)(sunsetLons.moonLon);
+            const yogaAtSunset = (0, yoga_1.calculateYoga)(sunsetLons.sunLon, sunsetLons.moonLon);
+            const karanaAtSunset = (0, karana_1.calculateKarana)(sunsetLons.sunLon, sunsetLons.moonLon);
+            const sunriseDate = sunrise ?? noonDate;
+            if (tithiAtSunset.number !== tithi.number) {
+                tithi2 = tithiAtSunset;
+                const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+                    const l = computeLongitudes(dt, ayanamsa);
+                    return (0, tithi_1.calculateTithi)(l.sunLon, l.moonLon).number;
+                }, tithi.number);
+                tithiTransitionTime = formatTransitionTime(transTime, timezone);
+            }
+            if (nakshatraAtSunset.number !== nakshatra.number) {
+                nakshatra2 = nakshatraAtSunset;
+                const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+                    const l = computeLongitudes(dt, ayanamsa);
+                    return (0, nakshatra_1.calculateNakshatra)(l.moonLon).number;
+                }, nakshatra.number);
+                nakshatraTransitionTime = formatTransitionTime(transTime, timezone);
+            }
+            if (yogaAtSunset.number !== yoga.number) {
+                yoga2 = yogaAtSunset;
+                const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+                    const l = computeLongitudes(dt, ayanamsa);
+                    return (0, yoga_1.calculateYoga)(l.sunLon, l.moonLon).number;
+                }, yoga.number);
+                yogaTransitionTime = formatTransitionTime(transTime, timezone);
+            }
+            if (karanaAtSunset.number !== karana.number) {
+                karana2 = karanaAtSunset;
+                const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+                    const l = computeLongitudes(dt, ayanamsa);
+                    return (0, karana_1.calculateKarana)(l.sunLon, l.moonLon).number;
+                }, karana.number);
+                karanaTransitionTime = formatTransitionTime(transTime, timezone);
+            }
+        }
+        catch {
+            // Transition detection failed, skip
+        }
+    }
     // Sun Nakshatra
     const sunNak = (0, nakshatra_1.calculateNakshatra)(sunLon);
     // Ayana: Uttarayana from Makara Sankranti (Sun enters Capricorn, ~270°) to Sun at ~90° (end of Gemini)
@@ -270,10 +358,22 @@ function calculateFullPanchang(date, latitude, longitude, timezone) {
         sunset: sunsetStr,
         moonrise: formatTimeHHMM(moonrise, timezone),
         moonset: formatTimeHHMM(moonset, timezone),
-        tithi: [{ name: tithi.name, number: tithi.number, startTime: '', endTime: '', progress: tithi.progress }],
-        nakshatra: [{ name: nakshatra.name, number: nakshatra.number, pada: nakshatra.pada, lord: nakshatra.lord, deity: nakshatra.deity, startTime: '', endTime: '', progress: nakshatra.progress }],
-        yoga: [{ name: yoga.name, number: yoga.number, startTime: '', endTime: '', progress: yoga.progress }],
-        karana: [{ name: karana.name, number: karana.number, startTime: '', endTime: '', progress: karana.progress }],
+        tithi: [
+            { name: tithi.name, number: tithi.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: tithiTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: tithi.progress },
+            ...(tithi2 ? [{ name: tithi2.name, number: tithi2.number, startTime: tithiTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: tithi2.progress }] : []),
+        ],
+        nakshatra: [
+            { name: nakshatra.name, number: nakshatra.number, pada: nakshatra.pada, lord: nakshatra.lord, deity: nakshatra.deity, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: nakshatraTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: nakshatra.progress },
+            ...(nakshatra2 ? [{ name: nakshatra2.name, number: nakshatra2.number, pada: nakshatra2.pada, lord: nakshatra2.lord, deity: nakshatra2.deity, startTime: nakshatraTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: nakshatra2.progress }] : []),
+        ],
+        yoga: [
+            { name: yoga.name, number: yoga.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: yogaTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: yoga.progress },
+            ...(yoga2 ? [{ name: yoga2.name, number: yoga2.number, startTime: yogaTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: yoga2.progress }] : []),
+        ],
+        karana: [
+            { name: karana.name, number: karana.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: karanaTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: karana.progress },
+            ...(karana2 ? [{ name: karana2.name, number: karana2.number, startTime: karanaTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: karana2.progress }] : []),
+        ],
         vara,
         moonSign,
         sunSign,

package/dist/panchang-v2.js

@@ -0,0 +1,396 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFullPanchang = void 0;
+const tithi_1 = require("./core/tithi");
+const nakshatra_1 = require("./core/nakshatra");
+const yoga_1 = require("./core/yoga");
+const karana_1 = require("./core/karana");
+const rashi_1 = require("./core/rashi");
+const constants_1 = require("./core/constants");
+const muhurat_1 = require("./timings/muhurat");
+const kalam_1 = require("./timings/kalam");
+const MOON_PHASES = [
+    'New Moon', 'Waxing Crescent', 'First Quarter', 'Waxing Gibbous',
+    'Full Moon', 'Waning Gibbous', 'Last Quarter', 'Waning Crescent',
+];
+function getMoonPhaseName(tithiIndex) {
+    // Derive phase from tithi number (more accurate than angular division)
+    // Tithi 0 = Shukla Pratipad (just after new moon)
+    // Tithi 14 = Purnima (full moon)
+    // Tithi 15 = Krishna Pratipad (just after full moon)
+    // Tithi 29 = Amavasya (new moon)
+    if (tithiIndex <= 0)
+        return 'New Moon';
+    if (tithiIndex <= 3)
+        return 'Waxing Crescent';
+    if (tithiIndex <= 6)
+        return 'First Quarter';
+    if (tithiIndex <= 10)
+        return 'Waxing Gibbous';
+    if (tithiIndex <= 14)
+        return 'Full Moon';
+    if (tithiIndex <= 18)
+        return 'Waning Gibbous';
+    if (tithiIndex <= 21)
+        return 'Last Quarter';
+    if (tithiIndex <= 25)
+        return 'Waning Crescent';
+    return 'New Moon';
+}
+const RITUS = [
+    { vedic: 'Vasanta', english: 'Spring' },
+    { vedic: 'Grishma', english: 'Summer' },
+    { vedic: 'Varsha', english: 'Monsoon' },
+    { vedic: 'Sharad', english: 'Autumn' },
+    { vedic: 'Hemanta', english: 'Pre-Winter' },
+    { vedic: 'Shishira', english: 'Winter' },
+];
+const SOLAR_MONTHS = [
+    'Mesha', 'Vrishabha', 'Mithuna', 'Karka', 'Simha', 'Kanya',
+    'Tula', 'Vrishchika', 'Dhanu', 'Makara', 'Kumbha', 'Meena',
+];
+const SAMVATSARS = [
+    'Prabhava', 'Vibhava', 'Shukla', 'Pramodoota', 'Prajothpatti',
+    'Angirasa', 'Srimukha', 'Bhava', 'Yuva', 'Dhata',
+    'Ishvara', 'Bahudhanya', 'Pramathi', 'Vikrama', 'Vrisha',
+    'Chitrabhanu', 'Svabhanu', 'Tarana', 'Parthiva', 'Vyaya',
+    'Sarvajit', 'Sarvadhari', 'Virodhi', 'Vikrita', 'Khara',
+    'Nandana', 'Vijaya', 'Jaya', 'Manmatha', 'Durmukhi',
+    'Hevilambi', 'Vilambi', 'Vikari', 'Sharvari', 'Plava',
+    'Shubhakrit', 'Shobhakrit', 'Krodhi', 'Vishvavasu', 'Parabhava',
+    'Plavanga', 'Kilaka', 'Saumya', 'Sadharana', 'Virodhikrit',
+    'Paridhaavi', 'Pramadicha', 'Ananda', 'Rakshasa', 'Nala',
+    'Pingala', 'Kalayukti', 'Siddharthi', 'Raudri', 'Durmathi',
+    'Dundubhi', 'Rudhirodgari', 'Raktakshi', 'Krodhana', 'Akshaya',
+];
+function calculateDurations(sunriseStr, sunsetStr) {
+    const [sh, sm] = sunriseStr.split(':').map(Number);
+    const [eh, em] = sunsetStr.split(':').map(Number);
+    const sunriseMin = sh * 60 + sm;
+    const sunsetMin = eh * 60 + em;
+    const dayMins = sunsetMin - sunriseMin;
+    const nightMins = 1440 - dayMins;
+    const midMins = sunriseMin + Math.floor(dayMins / 2);
+    const fmtDuration = (mins) => {
+        const h = Math.floor(mins / 60);
+        const m = mins % 60;
+        return `${h}h ${String(m).padStart(2, '0')}m`;
+    };
+    const fmtTime = (mins) => {
+        const h = mins % 1440;
+        const hh = Math.floor(h / 60);
+        const mm = h % 60;
+        return `${String(hh).padStart(2, '0')}:${String(mm).padStart(2, '0')}`;
+    };
+    return {
+        dinamana: fmtDuration(dayMins),
+        ratrimana: fmtDuration(nightMins),
+        madhyahna: fmtTime(midMins),
+    };
+}
+function formatTimeHHMM(date, timezone) {
+    if (!date)
+        return '';
+    return date.toLocaleTimeString('en-US', { timeZone: timezone, hour: '2-digit', minute: '2-digit', hour12: false });
+}
+function calculateFullPanchang(date, latitude, longitude, timezone) {
+    // Use noon local time as an initial reference for sunrise/sunset calculation.
+    // After computing sunrise, we re-compute planetary positions at sunrise
+    // to match Drik Panchang convention (prevailing tithi/nakshatra at sunrise).
+    const noonDate = typeof date === 'string'
+        ? new Date(date + 'T12:00:00')
+        : date;
+    const location = { latitude, longitude, timezone };
+    // Helper: compute sidereal sun/moon longitudes for a given Date
+    function computeLongitudes(dt, ayan) {
+        try {
+            const { Ephemeris } = require('./calculations/ephemeris');
+            const eph = new Ephemeris();
+            const sunT = eph.calculatePosition(dt, 'Sun');
+            const moonT = eph.calculatePosition(dt, 'Moon');
+            return {
+                sunLon: (0, constants_1.normalizeAngle)(sunT.longitude - ayan),
+                moonLon: (0, constants_1.normalizeAngle)(moonT.longitude - ayan),
+            };
+        }
+        catch {
+            // Fallback: Jean Meeus low-precision
+            const jd = dt.getTime() / 86400000 + 2440587.5;
+            const T = (jd - 2451545.0) / 36525;
+            const L0 = (0, constants_1.normalizeAngle)(280.46646 + 36000.76983 * T);
+            const M = (0, constants_1.normalizeAngle)(357.52911 + 35999.05029 * T);
+            const Mrad = M * Math.PI / 180;
+            const C = (1.914602 - 0.004817 * T) * Math.sin(Mrad)
+                + 0.019993 * Math.sin(2 * Mrad)
+                + 0.000289 * Math.sin(3 * Mrad);
+            const sLon = (0, constants_1.normalizeAngle)((0, constants_1.normalizeAngle)(L0 + C) - ayan);
+            const Lm = (0, constants_1.normalizeAngle)(218.3165 + 481267.8813 * T);
+            const Mm = (0, constants_1.normalizeAngle)(134.9634 + 477198.8676 * T);
+            const F = (0, constants_1.normalizeAngle)(93.2721 + 483202.0175 * T);
+            const MmRad = Mm * Math.PI / 180;
+            const FRad = F * Math.PI / 180;
+            const moonCorr = 6.289 * Math.sin(MmRad)
+                - 1.274 * Math.sin(MmRad - 2 * FRad)
+                + 0.658 * Math.sin(2 * FRad)
+                - 0.186 * Math.sin(Mrad)
+                - 0.114 * Math.sin(2 * FRad)
+                + 0.059 * Math.sin(2 * MmRad)
+                - 0.057 * Math.sin(MmRad - 2 * FRad + Mrad)
+                + 0.053 * Math.sin(MmRad + 2 * FRad)
+                + 0.046 * Math.sin(2 * FRad - Mrad)
+                + 0.041 * Math.sin(MmRad - Mrad);
+            const mLon = (0, constants_1.normalizeAngle)((0, constants_1.normalizeAngle)(Lm + moonCorr) - ayan);
+            return { sunLon: sLon, moonLon: mLon };
+        }
+    }
+    // Try to use Swiss Ephemeris, fall back to SunCalc-based calculations
+    let sunLon = 0, moonLon = 0;
+    let sunrise = null, sunset = null;
+    let moonrise = null, moonset = null;
+    let ayanamsa = 24.17; // Default Lahiri approximation for 2026
+    try {
+        const { Ephemeris } = require('./calculations/ephemeris');
+        const ephemeris = new Ephemeris();
+        ayanamsa = ephemeris.calculate_lahiri_ayanamsa(noonDate);
+    }
+    catch {
+        // Use default ayanamsa
+    }
+    // Get sunrise/sunset first
+    try {
+        const SunCalc = require('suncalc');
+        const times = SunCalc.getTimes(noonDate, latitude, longitude);
+        sunrise = times.sunrise;
+        sunset = times.sunset;
+        const moonTimes = SunCalc.getMoonTimes(noonDate, latitude, longitude);
+        moonrise = moonTimes.rise ?? null;
+        moonset = moonTimes.set ?? null;
+    }
+    catch {
+        // No SunCalc available
+    }
+    // Compute longitudes at SUNRISE (Drik Panchang convention: prevailing tithi at sunrise)
+    const sunriseDate = sunrise ?? noonDate;
+    const lons = computeLongitudes(sunriseDate, ayanamsa);
+    sunLon = lons.sunLon;
+    moonLon = lons.moonLon;
+    const tithi = (0, tithi_1.calculateTithi)(sunLon, moonLon);
+    const nakshatra = (0, nakshatra_1.calculateNakshatra)(moonLon);
+    const yoga = (0, yoga_1.calculateYoga)(sunLon, moonLon);
+    const karana = (0, karana_1.calculateKarana)(sunLon, moonLon);
+    const moonSign = (0, rashi_1.calculateRashi)(moonLon);
+    const sunSign = (0, rashi_1.calculateRashi)(sunLon);
+    // ── Transition detection with binary search for exact time ──────────────
+    // Check sunrise vs sunset. If tithi/nakshatra/yoga/karana changed,
+    // binary-search for the exact transition moment.
+    function findTransitionTime(startDate, endDate, getValueFn, startValue, maxIterations = 14) {
+        let lo = startDate.getTime();
+        let hi = endDate.getTime();
+        for (let i = 0; i < maxIterations; i++) {
+            const mid = Math.floor((lo + hi) / 2);
+            const midDate = new Date(mid);
+            const lons = computeLongitudes(midDate, ayanamsa);
+            const val = getValueFn(midDate);
+            if (val === startValue) {
+                lo = mid;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        return new Date(hi);
+    }
+    function formatTransitionTime(dt, tz) {
+        try {
+            return dt.toLocaleTimeString('en-IN', {
+                timeZone: tz,
+                hour: '2-digit',
+                minute: '2-digit',
+                hour12: true,
+            });
+        }
+        catch {
+            const h = dt.getUTCHours();
+            const m = dt.getUTCMinutes();
+            return `${h % 12 || 12}:${m < 10 ? '0' + m : m} ${h < 12 ? 'AM' : 'PM'}`;
+        }
+    }
+    let tithi2 = null;
+    let nakshatra2 = null;
+    let yoga2 = null;
+    let karana2 = null;
+    let tithiTransitionTime = '';
+    let nakshatraTransitionTime = '';
+    let yogaTransitionTime = '';
+    let karanaTransitionTime = '';
+    if (sunset) {
+        try {
+            const sunsetLons = computeLongitudes(sunset, ayanamsa);
+            const tithiAtSunset = (0, tithi_1.calculateTithi)(sunsetLons.sunLon, sunsetLons.moonLon);
+            const nakshatraAtSunset = (0, nakshatra_1.calculateNakshatra)(sunsetLons.moonLon);
+            const yogaAtSunset = (0, yoga_1.calculateYoga)(sunsetLons.sunLon, sunsetLons.moonLon);
+            const karanaAtSunset = (0, karana_1.calculateKarana)(sunsetLons.sunLon, sunsetLons.moonLon);
+            const sunriseDate = sunrise ?? noonDate;
+            if (tithiAtSunset.number !== tithi.number) {
+                tithi2 = tithiAtSunset;
+                const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+                    const l = computeLongitudes(dt, ayanamsa);
+                    return (0, tithi_1.calculateTithi)(l.sunLon, l.moonLon).number;
+                }, tithi.number);
+                tithiTransitionTime = formatTransitionTime(transTime, timezone);
+            }
+            if (nakshatraAtSunset.number !== nakshatra.number) {
+                nakshatra2 = nakshatraAtSunset;
+                const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+                    const l = computeLongitudes(dt, ayanamsa);
+                    return (0, nakshatra_1.calculateNakshatra)(l.moonLon).number;
+                }, nakshatra.number);
+                nakshatraTransitionTime = formatTransitionTime(transTime, timezone);
+            }
+            if (yogaAtSunset.number !== yoga.number) {
+                yoga2 = yogaAtSunset;
+                const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+                    const l = computeLongitudes(dt, ayanamsa);
+                    return (0, yoga_1.calculateYoga)(l.sunLon, l.moonLon).number;
+                }, yoga.number);
+                yogaTransitionTime = formatTransitionTime(transTime, timezone);
+            }
+            if (karanaAtSunset.number !== karana.number) {
+                karana2 = karanaAtSunset;
+                const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+                    const l = computeLongitudes(dt, ayanamsa);
+                    return (0, karana_1.calculateKarana)(l.sunLon, l.moonLon).number;
+                }, karana.number);
+                karanaTransitionTime = formatTransitionTime(transTime, timezone);
+            }
+        }
+        catch {
+            // Transition detection failed, skip
+        }
+    }
+    // Sun Nakshatra
+    const sunNak = (0, nakshatra_1.calculateNakshatra)(sunLon);
+    // Ayana: Uttarayana from Makara Sankranti (Sun enters Capricorn, ~270°) to Sun at ~90° (end of Gemini)
+    // Sidereal: 270°→360°→0°→90° = Uttarayana; 90°→270° = Dakshinayana
+    const ayana = (sunLon >= 270 || sunLon < 90) ? 'Uttarayana' : 'Dakshinayana';
+    // Ritu (season) based on Sun's sidereal sign
+    // Ritu mapping (North Indian): Pisces-Aries=Vasanta, Taurus-Gemini=Grishma, etc.
+    // Shift by -1 from sign number: sign 12(Pisces)→0, sign 1(Aries)→0, sign 2→1, etc.
+    const rituSignMap = {
+        12: 0, 1: 0,
+        2: 1, 3: 1,
+        4: 2, 5: 2,
+        6: 3, 7: 3,
+        8: 4, 9: 4,
+        10: 5, 11: 5, // Shishira (Capricorn, Aquarius)
+    };
+    const ritu = RITUS[rituSignMap[sunSign.number] ?? 0];
+    // Solar month
+    const solarMonth = SOLAR_MONTHS[sunSign.number - 1];
+    // Samvatsar (60-year cycle)
+    // Vikram new year = Chaitra Shukla Pratipad (day after Chaitra Amavasya)
+    // This falls when Sun is in Pisces (Meena) and Moon is new → Shukla Pratipad
+    // Approximation: if Sun is in Pisces (sign 12) and tithi is in Shukla Paksha,
+    // we're in the new Vikram year. Otherwise check if we've passed the spring new moon.
+    //
+    // More robust: The Vikram year changes when Chaitra Shukla Paksha begins.
+    // Chaitra = lunar month when Sun is in Pisces/Aries.
+    // If tithi is Shukla (waxing) and Sun is in Pisces → new year has started.
+    // If tithi is Krishna (waning) and Sun is in Pisces → still old year (Chaitra Krishna = Phalguna Amanta).
+    const gregYear = noonDate.getFullYear();
+    const sunInPisces = sunSign.number === 12; // Meena
+    const sunInAries = sunSign.number === 1; // Mesha
+    const isShukla = tithi.paksha === 'Shukla';
+    // New year starts when: Sun in Pisces + Shukla Paksha (Chaitra Shukla)
+    // OR Sun has moved past Pisces into Aries+ (definitely new year)
+    const newYearStarted = (sunInPisces && isShukla) ||
+        (sunSign.number >= 1 && sunSign.number <= 6); // Aries through Virgo = after spring
+    // But Jan-Feb is always before new year (Sun in Capricorn/Aquarius)
+    const month = noonDate.getMonth();
+    const isEarlyYear = month <= 1; // Jan, Feb always before Hindu new year
+    const vikramSamvat = (newYearStarted && !isEarlyYear) ? gregYear + 57 : gregYear + 56;
+    const shakaSamvat = (newYearStarted && !isEarlyYear) ? gregYear - 78 : gregYear - 79;
+    const samvatsarIndex = ((vikramSamvat - 51) % 60 + 60) % 60;
+    const samvatsar = SAMVATSARS[samvatsarIndex];
+    // Use the date string to determine weekday (timezone-independent)
+    const varaDateStr = typeof date === 'string' ? date : noonDate.toISOString().split('T')[0];
+    const varaDate = new Date(varaDateStr + 'T12:00:00Z'); // Noon UTC — safe for any timezone
+    const vara = {
+        name: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][varaDate.getUTCDay()],
+        number: varaDate.getUTCDay(),
+    };
+    const diff = (0, constants_1.normalizeAngle)(moonLon - sunLon);
+    // Use SunCalc for accurate illumination when available
+    let moonIllumination = Math.round(((1 - Math.cos(diff * Math.PI / 180)) / 2) * 100);
+    try {
+        const SunCalc = require('suncalc');
+        const illum = SunCalc.getMoonIllumination(noonDate);
+        moonIllumination = Math.round(illum.fraction * 100);
+    }
+    catch { }
+    ;
+    const sunriseStr = formatTimeHHMM(sunrise, timezone);
+    const sunsetStr = formatTimeHHMM(sunset, timezone);
+    const dateStr = noonDate.toISOString().split('T')[0];
+    // Calculate auspicious muhurats and inauspicious kalams
+    let auspiciousMuhurats = [];
+    let inauspiciousKalams = [];
+    if (sunriseStr && sunsetStr) {
+        try {
+            auspiciousMuhurats = (0, muhurat_1.calculateMuhurats)(sunriseStr, sunsetStr, dateStr, latitude, longitude, timezone);
+        }
+        catch {
+            // Timing calculation failed; return empty array
+        }
+        try {
+            inauspiciousKalams = (0, kalam_1.calculateKalams)(sunriseStr, sunsetStr, dateStr, latitude, longitude, timezone);
+        }
+        catch {
+            // Timing calculation failed; return empty array
+        }
+    }
+    // Dinamana / Ratrimana / Madhyahna
+    const durations = (sunriseStr && sunsetStr) ? calculateDurations(sunriseStr, sunsetStr) : { dinamana: '', ratrimana: '', madhyahna: '' };
+    return {
+        date: dateStr,
+        location: { lat: latitude, lon: longitude, timezone },
+        sunrise: sunriseStr,
+        sunset: sunsetStr,
+        moonrise: formatTimeHHMM(moonrise, timezone),
+        moonset: formatTimeHHMM(moonset, timezone),
+        tithi: [
+            { name: tithi.name, number: tithi.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: tithiTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: tithi.progress },
+            ...(tithi2 ? [{ name: tithi2.name, number: tithi2.number, startTime: tithiTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: tithi2.progress }] : []),
+        ],
+        nakshatra: [
+            { name: nakshatra.name, number: nakshatra.number, pada: nakshatra.pada, lord: nakshatra.lord, deity: nakshatra.deity, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: nakshatraTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: nakshatra.progress },
+            ...(nakshatra2 ? [{ name: nakshatra2.name, number: nakshatra2.number, pada: nakshatra2.pada, lord: nakshatra2.lord, deity: nakshatra2.deity, startTime: nakshatraTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: nakshatra2.progress }] : []),
+        ],
+        yoga: [
+            { name: yoga.name, number: yoga.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: yogaTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: yoga.progress },
+            ...(yoga2 ? [{ name: yoga2.name, number: yoga2.number, startTime: yogaTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: yoga2.progress }] : []),
+        ],
+        karana: [
+            { name: karana.name, number: karana.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: karanaTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: karana.progress },
+            ...(karana2 ? [{ name: karana2.name, number: karana2.number, startTime: karanaTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: karana2.progress }] : []),
+        ],
+        vara,
+        moonSign,
+        sunSign,
+        moonPhase: { name: getMoonPhaseName(tithi.tithiIndex - 1), illumination: moonIllumination },
+        paksha: tithi.paksha,
+        auspiciousMuhurats,
+        inauspiciousKalams,
+        sunNakshatra: { name: sunNak.name, number: sunNak.number, pada: sunNak.pada, lord: sunNak.lord, deity: sunNak.deity, startTime: '', endTime: '', progress: sunNak.progress },
+        ayana,
+        ritu,
+        solarMonth,
+        dinamana: durations.dinamana,
+        ratrimana: durations.ratrimana,
+        madhyahna: durations.madhyahna,
+        samvatsar,
+        vikramSamvat: vikramSamvat,
+        shakaSamvat: shakaSamvat,
+    };
+}
+exports.calculateFullPanchang = calculateFullPanchang;

package/dist/timings/kalam.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Kalam (inauspicious timing) calculations for Panchang v2.
+ * Wraps existing lib/ functions with typed interfaces.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateKalams = void 0;
+/**
+ * Strip seconds from "HH:mm:ss" -> "HH:mm", or return as-is if already "HH:mm".
+ */
+function toHHMM(time) {
+    const parts = time.split(':');
+    return `${parts[0]}:${parts[1]}`;
+}
+/**
+ * Parse ISO timestamp or "HH:mm:ss" to "HH:mm".
+ */
+function normalizeTime(time) {
+    // Handle ISO format like "2026-03-20T06:10:00.000+05:30"
+    if (time.includes('T')) {
+        const timePart = time.split('T')[1];
+        const parts = timePart.split(':');
+        return `${parts[0]}:${parts[1]}`;
+    }
+    return toHHMM(time);
+}
+/**
+ * Calculate all inauspicious kalams for a given date.
+ *
+ * @param sunrise - "HH:mm" format
+ * @param sunset  - "HH:mm" format
+ * @param date    - "yyyy-MM-dd" format
+ * @param lat     - latitude
+ * @param lon     - longitude
+ * @param tz      - IANA timezone
+ */
+function calculateKalams(sunrise, sunset, date, lat, lon, tz) {
+    const kalams = [];
+    // Ensure sunrise/sunset have seconds for lib functions that expect "HH:mm:ss"
+    const sunriseWithSec = sunrise.length === 5 ? sunrise + ':00' : sunrise;
+    const sunsetWithSec = sunset.length === 5 ? sunset + ':00' : sunset;
+    // 1. Rahu Kalam
+    try {
+        const calculateRahuKalam = require('../../../lib/rahuKalam');
+        const rahu = calculateRahuKalam(date, sunriseWithSec, sunsetWithSec, tz);
+        kalams.push({
+            name: 'Rahu Kalam',
+            startTime: toHHMM(rahu.start),
+            endTime: toHHMM(rahu.end),
+            description: 'Inauspicious period ruled by Rahu; avoid new ventures & travel',
+        });
+    }
+    catch {
+        // Skip if lib unavailable
+    }
+    // 2. Gulika Kalam (same segment-based calculation as Rahu)
+    try {
+        const calculateGulikaKalam = require('../../../lib/gulikaKalam');
+        const gulikaResult = calculateGulikaKalam(date, sunriseWithSec, sunsetWithSec, tz);
+        if (gulikaResult && gulikaResult.start) {
+            kalams.push({
+                name: 'Gulika Kalam',
+                startTime: toHHMM(gulikaResult.start),
+                endTime: toHHMM(gulikaResult.end),
+                description: 'Inauspicious period ruled by Saturn\'s son Gulika; avoid auspicious activities',
+            });
+        }
+    }
+    catch {
+        // Skip if lib unavailable
+    }
+    // 3. Yamaganda (Yamghant Kalam)
+    try {
+        const calculateYamghantKalam = require('../../../lib/yamghantKalam');
+        const yama = calculateYamghantKalam(date, sunriseWithSec, sunsetWithSec, tz);
+        kalams.push({
+            name: 'Yamaganda',
+            startTime: toHHMM(yama.start),
+            endTime: toHHMM(yama.end),
+            description: 'Inauspicious period ruled by Yama; avoid important activities',
+        });
+    }
+    catch {
+        // Skip if lib unavailable
+    }
+    // 4. Varjyam — nakshatra-based timing (placeholder with note)
+    kalams.push({
+        name: 'Varjyam',
+        startTime: '',
+        endTime: '',
+        description: 'Nakshatra-dependent inauspicious period (requires precise nakshatra transition times)',
+    });
+    // 5. Dur Muhurtam
+    try {
+        const calculateDurMuhurtam = require('../../../lib/durMuhurtam');
+        const durPeriods = calculateDurMuhurtam(date, sunriseWithSec, sunsetWithSec, tz);
+        durPeriods.forEach((period, index) => {
+            const startTime = normalizeTime(period.start);
+            const endTime = normalizeTime(period.end);
+            const label = durPeriods.length > 1 ? `Dur Muhurtam ${index + 1}` : 'Dur Muhurtam';
+            kalams.push({
+                name: label,
+                startTime,
+                endTime,
+                description: 'Inauspicious muhurta; avoid starting new activities during this period',
+            });
+        });
+    }
+    catch {
+        // Skip if lib unavailable
+    }
+    return kalams;
+}
+exports.calculateKalams = calculateKalams;

package/dist/timings/muhurat.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Muhurat (auspicious timing) calculations for Panchang v2.
+ * Wraps existing lib/ functions and adds computed muhurats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateMuhurats = void 0;
+/**
+ * Parse "HH:mm" or "HH:mm:ss" into total minutes from midnight.
+ */
+function parseTimeToMinutes(time) {
+    const parts = time.split(':').map(Number);
+    return parts[0] * 60 + parts[1];
+}
+/**
+ * Convert total minutes from midnight to "HH:mm" string.
+ * Handles wrap-around past midnight (mod 1440).
+ */
+function minutesToHHMM(minutes) {
+    let m = Math.round(minutes) % 1440;
+    if (m < 0)
+        m += 1440;
+    const h = Math.floor(m / 60);
+    const min = m % 60;
+    return `${h.toString().padStart(2, '0')}:${min.toString().padStart(2, '0')}`;
+}
+/**
+ * Strip seconds from "HH:mm:ss" -> "HH:mm", or return as-is if already "HH:mm".
+ */
+function toHHMM(time) {
+    const parts = time.split(':');
+    return `${parts[0]}:${parts[1]}`;
+}
+/**
+ * Calculate all auspicious muhurats for a given date.
+ *
+ * @param sunrise - "HH:mm" format
+ * @param sunset  - "HH:mm" format
+ * @param date    - "yyyy-MM-dd" format
+ * @param lat     - latitude
+ * @param lon     - longitude
+ * @param tz      - IANA timezone
+ */
+function calculateMuhurats(sunrise, sunset, date, lat, lon, tz) {
+    const sunriseMin = parseTimeToMinutes(sunrise);
+    const sunsetMin = parseTimeToMinutes(sunset);
+    const dayDuration = sunsetMin - sunriseMin; // minutes of daytime
+    const muhurtaDuration = dayDuration / 15; // one daytime muhurta
+    // Night duration (sunset to next sunrise, approximated as 24h - dayDuration)
+    const nightDuration = 1440 - dayDuration;
+    const muhurats = [];
+    // 1. Brahma Muhurta — 2 muhurtas before sunrise (1h 36min before, lasts 48 min)
+    const brahmaStart = sunriseMin - (muhurtaDuration * 2);
+    const brahmaEnd = sunriseMin - muhurtaDuration;
+    muhurats.push({
+        name: 'Brahma Muhurta',
+        startTime: minutesToHHMM(brahmaStart),
+        endTime: minutesToHHMM(brahmaEnd),
+        description: 'Most auspicious time for meditation & spiritual practice, 2 muhurtas before sunrise',
+    });
+    // 2. Pratah Sandhya — from ~1h12m (1.5 muhurtas) before sunrise to sunrise
+    // Drik Panchang uses: start = sunrise - (nightMuhurta * 1.5), end = sunrise
+    const nightMuhurta = nightDuration / 15;
+    const pratahStart = sunriseMin - (nightMuhurta * 1.5);
+    muhurats.push({
+        name: 'Pratah Sandhya',
+        startTime: minutesToHHMM(pratahStart),
+        endTime: minutesToHHMM(sunriseMin),
+        description: 'Morning twilight period, ideal for Sandhyavandanam',
+    });
+    // 3. Abhijit Muhurat — use existing lib function
+    try {
+        const calculateAbhijeetMuhurt = require('../../../lib/abhijeetMuhurt');
+        // The lib expects sunrise/sunset with seconds
+        const sunriseWithSec = sunrise.length === 5 ? sunrise + ':00' : sunrise;
+        const sunsetWithSec = sunset.length === 5 ? sunset + ':00' : sunset;
+        const abhijit = calculateAbhijeetMuhurt(date, sunriseWithSec, sunsetWithSec, lat, lon, tz);
+        muhurats.push({
+            name: 'Abhijit Muhurat',
+            startTime: toHHMM(abhijit.start),
+            endTime: toHHMM(abhijit.end),
+            description: 'Midday auspicious period ruled by Lord Vishnu, ideal for important tasks',
+        });
+    }
+    catch {
+        // Fallback: compute manually (muhurta #8, i.e. index 7-8 after sunrise)
+        const abhijitStart = sunriseMin + muhurtaDuration * 7;
+        const abhijitEnd = sunriseMin + muhurtaDuration * 9;
+        muhurats.push({
+            name: 'Abhijit Muhurat',
+            startTime: minutesToHHMM(abhijitStart),
+            endTime: minutesToHHMM(abhijitEnd),
+            description: 'Midday auspicious period ruled by Lord Vishnu, ideal for important tasks',
+        });
+    }
+    // 4. Vijaya Muhurat — the muhurta spanning the midpoint between Abhijit and sunset
+    // Drik Panchang: roughly the 11th muhurta (index 10) from sunrise
+    const vijayaStart = sunriseMin + muhurtaDuration * 10;
+    const vijayaEnd = sunriseMin + muhurtaDuration * 11;
+    muhurats.push({
+        name: 'Vijaya Muhurat',
+        startTime: minutesToHHMM(vijayaStart),
+        endTime: minutesToHHMM(vijayaEnd),
+        description: 'Afternoon auspicious period for victory & success in endeavors',
+    });
+    // 5. Godhuli Muhurat — starts ~1 min before sunset, lasts ~24 min (sunset-1 to sunset+23)
+    // Drik Panchang pattern: from ~sunset to sunset + half a nightMuhurta
+    muhurats.push({
+        name: 'Godhuli Muhurat',
+        startTime: minutesToHHMM(sunsetMin - 1),
+        endTime: minutesToHHMM(sunsetMin + 22),
+        description: 'Cow-dust time around sunset, auspicious for marriages & ceremonies',
+    });
+    // 6. Sayahna Sandhya — from sunset to sunset + 1.5 night muhurtas
+    // Mirrors Pratah Sandhya: Pratah = 1.5 night muhurtas before sunrise, Sayahna = 1.5 after sunset
+    const sayahnaEnd = sunsetMin + (nightMuhurta * 1.5);
+    muhurats.push({
+        name: 'Sayahna Sandhya',
+        startTime: minutesToHHMM(sunsetMin),
+        endTime: minutesToHHMM(sayahnaEnd),
+        description: 'Evening twilight period, ideal for evening prayers & Sandhyavandanam',
+    });
+    // 7. Nishita Muhurat — midnight +/- 24 min
+    // Midnight = midpoint between sunset and next sunrise
+    const midnightMin = sunsetMin + nightDuration / 2;
+    muhurats.push({
+        name: 'Nishita Muhurat',
+        startTime: minutesToHHMM(midnightMin - 24),
+        endTime: minutesToHHMM(midnightMin + 24),
+        description: 'Midnight auspicious period, sacred for worship of Lord Shiva',
+    });
+    return muhurats;
+}
+exports.calculateMuhurats = calculateMuhurats;

package/dist/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Shared types for Panchang v2 calculations.
+ * NOTE: The existing types/panchang.ts is preserved as-is — do NOT import from here
+ * in files that already import from '../types/panchang'.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astrology-insights",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Comprehensive Vedic astrology engine for Node.js — Panchang, birth charts (Kundli), Vimshottari Dasha, divisional charts, dosha analysis, and planetary remedies. Swiss Ephemeris precision, validated against Drik Panchang.",
   "main": "index.js",
   "react-native": "index.rn.js",
@@ -60,6 +60,7 @@
   },
   "homepage": "https://github.com/adarshsrii/astrology#readme",
   "dependencies": {
+    "date-fns": "^4.1.0",
     "date-fns-tz": "^3.2.0",
     "luxon": "^3.5.0",
     "suncalc": "^1.9.0",

package/panchang/src/panchang-v2.ts

@@ -190,6 +190,107 @@ export function calculateFullPanchang(
   const moonSign = calculateRashi(moonLon);
   const sunSign = calculateRashi(sunLon);
 
+  // ── Transition detection with binary search for exact time ──────────────
+  // Check sunrise vs sunset. If tithi/nakshatra/yoga/karana changed,
+  // binary-search for the exact transition moment.
+
+  function findTransitionTime(
+    startDate: Date,
+    endDate: Date,
+    getValueFn: (dt: Date) => number,
+    startValue: number,
+    maxIterations: number = 14, // ~1 minute precision over 12 hours
+  ): Date {
+    let lo = startDate.getTime();
+    let hi = endDate.getTime();
+    for (let i = 0; i < maxIterations; i++) {
+      const mid = Math.floor((lo + hi) / 2);
+      const midDate = new Date(mid);
+      const lons = computeLongitudes(midDate, ayanamsa);
+      const val = getValueFn(midDate);
+      if (val === startValue) {
+        lo = mid;
+      } else {
+        hi = mid;
+      }
+    }
+    return new Date(hi);
+  }
+
+  function formatTransitionTime(dt: Date, tz: string): string {
+    try {
+      return dt.toLocaleTimeString('en-IN', {
+        timeZone: tz,
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: true,
+      });
+    } catch {
+      const h = dt.getUTCHours();
+      const m = dt.getUTCMinutes();
+      return `${h % 12 || 12}:${m < 10 ? '0' + m : m} ${h < 12 ? 'AM' : 'PM'}`;
+    }
+  }
+
+  let tithi2: any = null;
+  let nakshatra2: any = null;
+  let yoga2: any = null;
+  let karana2: any = null;
+  let tithiTransitionTime = '';
+  let nakshatraTransitionTime = '';
+  let yogaTransitionTime = '';
+  let karanaTransitionTime = '';
+
+  if (sunset) {
+    try {
+      const sunsetLons = computeLongitudes(sunset, ayanamsa);
+      const tithiAtSunset = calculateTithi(sunsetLons.sunLon, sunsetLons.moonLon);
+      const nakshatraAtSunset = calculateNakshatra(sunsetLons.moonLon);
+      const yogaAtSunset = calculateYoga(sunsetLons.sunLon, sunsetLons.moonLon);
+      const karanaAtSunset = calculateKarana(sunsetLons.sunLon, sunsetLons.moonLon);
+
+      const sunriseDate = sunrise ?? noonDate;
+
+      if (tithiAtSunset.number !== tithi.number) {
+        tithi2 = tithiAtSunset;
+        const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+          const l = computeLongitudes(dt, ayanamsa);
+          return calculateTithi(l.sunLon, l.moonLon).number;
+        }, tithi.number);
+        tithiTransitionTime = formatTransitionTime(transTime, timezone);
+      }
+
+      if (nakshatraAtSunset.number !== nakshatra.number) {
+        nakshatra2 = nakshatraAtSunset;
+        const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+          const l = computeLongitudes(dt, ayanamsa);
+          return calculateNakshatra(l.moonLon).number;
+        }, nakshatra.number);
+        nakshatraTransitionTime = formatTransitionTime(transTime, timezone);
+      }
+
+      if (yogaAtSunset.number !== yoga.number) {
+        yoga2 = yogaAtSunset;
+        const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+          const l = computeLongitudes(dt, ayanamsa);
+          return calculateYoga(l.sunLon, l.moonLon).number;
+        }, yoga.number);
+        yogaTransitionTime = formatTransitionTime(transTime, timezone);
+      }
+
+      if (karanaAtSunset.number !== karana.number) {
+        karana2 = karanaAtSunset;
+        const transTime = findTransitionTime(sunriseDate, sunset, (dt) => {
+          const l = computeLongitudes(dt, ayanamsa);
+          return calculateKarana(l.sunLon, l.moonLon).number;
+        }, karana.number);
+        karanaTransitionTime = formatTransitionTime(transTime, timezone);
+      }
+    } catch {
+      // Transition detection failed, skip
+    }
+  }
+
   // Sun Nakshatra
   const sunNak = calculateNakshatra(sunLon);
 
@@ -290,10 +391,22 @@ export function calculateFullPanchang(
     sunset: sunsetStr,
     moonrise: formatTimeHHMM(moonrise, timezone),
     moonset: formatTimeHHMM(moonset, timezone),
-    tithi: [{ name: tithi.name, number: tithi.number, startTime: '', endTime: '', progress: tithi.progress }],
-    nakshatra: [{ name: nakshatra.name, number: nakshatra.number, pada: nakshatra.pada, lord: nakshatra.lord, deity: nakshatra.deity, startTime: '', endTime: '', progress: nakshatra.progress }],
-    yoga: [{ name: yoga.name, number: yoga.number, startTime: '', endTime: '', progress: yoga.progress }],
-    karana: [{ name: karana.name, number: karana.number, startTime: '', endTime: '', progress: karana.progress }],
+    tithi: [
+      { name: tithi.name, number: tithi.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: tithiTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: tithi.progress },
+      ...(tithi2 ? [{ name: tithi2.name, number: tithi2.number, startTime: tithiTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: tithi2.progress }] : []),
+    ],
+    nakshatra: [
+      { name: nakshatra.name, number: nakshatra.number, pada: nakshatra.pada, lord: nakshatra.lord, deity: nakshatra.deity, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: nakshatraTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: nakshatra.progress },
+      ...(nakshatra2 ? [{ name: nakshatra2.name, number: nakshatra2.number, pada: nakshatra2.pada, lord: nakshatra2.lord, deity: nakshatra2.deity, startTime: nakshatraTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: nakshatra2.progress }] : []),
+    ],
+    yoga: [
+      { name: yoga.name, number: yoga.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: yogaTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: yoga.progress },
+      ...(yoga2 ? [{ name: yoga2.name, number: yoga2.number, startTime: yogaTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: yoga2.progress }] : []),
+    ],
+    karana: [
+      { name: karana.name, number: karana.number, startTime: formatTransitionTime(sunrise ?? noonDate, timezone), endTime: karanaTransitionTime || formatTransitionTime(sunset ?? noonDate, timezone), progress: karana.progress },
+      ...(karana2 ? [{ name: karana2.name, number: karana2.number, startTime: karanaTransitionTime, endTime: formatTransitionTime(sunset ?? noonDate, timezone), progress: karana2.progress }] : []),
+    ],
     vara,
     moonSign,
     sunSign,