Panchang Core — Advanced Vedic Astrology Engine for PHP

Introduction

Authentic Vedic Panchanga calculation engine with JME native ephemeris precision.

System Setup

Configuring PHP FFI and JME native ephemeris data files.

1. Enable FFI Extension

sudo apt install php8.3-ffi

sudo dnf install php-ffi

2. Configure php.ini

Add or uncomment high-privilege FFI settings in your php.ini:

extension=ffi
ffi.enable=1

3. Verify Setup

php -r "echo extension_loaded('ffi') ? 'FFI loaded' : 'FFI not loaded';"
php -r "echo ini_get('ffi.enable') ? 'FFI enabled' : 'FFI not enabled';"

📂 JPL Kernel Files

The default moshier mode works without external kernel files. For strict JPL mode, download a supported .bsp kernel from the native JME release page:

Installation

composer require jayeshmepani/panchang-core

Quick Start

<?php

require 'vendor/autoload.php';

use JayeshMepani\PanchangCore\Traits\CliBootstrap;
use Carbon\CarbonImmutable;

// Initialize standalone environment (loads config & sets up DI)
CliBootstrap::init(__DIR__);

// Create fully wired PanchangService
$panchang = CliBootstrap::makePanchangService();

// Calculate panchanga
$date = CarbonImmutable::parse('2026-03-24');
$details = $panchang->getDayDetails(
    date: $date,
    lat: 23.2472446,
    lon: 69.668339,
    tz: 'Asia/Kolkata'
);

echo "Sunrise Tithi: " . $details['Tithi_At_Sunrise']['name'] . "\n";
echo "Current Tithi: " . $details['Current_Tithi_At_Input_Now']['name'] . "\n";
echo "Nakshatra: " . $details['Nakshatra']['name'] . "\n";

🪐 Ayanamsa Authority

The Ayanamsa defines the starting point of the sidereal zodiac. For Panchanga calculations, this is a fixed religious and legal anchor.

System Core Policy

// The engine automatically applies Lahiri to Sun/Moon longitudes
$details = $panchang->getDayDetails($date, $lat, $lon, $tz);

echo "Ayanamsa Index: " . $details['Ayanamsa']; // "LAHIRI (Chitra Paksha)"
echo "Ayanamsa Value: " . $details['Ayanamsa_Degree']; // e.g. 24.1234
echo "Current Tithi: " . $details['Current_Tithi_At_Input_Now']['name']; // Guaranteed Lahiri-aligned

Engine Conventions

Current calculation settings used by the package for Panchanga, sunrise, moonrise, eclipses, and Nirnay rules.

Configuration

Global settings and formatting preferences available in config/panchang.php.

Default Calculation Options

The defaults array configures localization, calendar-system selection, and formatting representations.

Festival Calculation Settings

The festivals array provides defaults for region and tradition if not explicitly supplied.

Cache Settings

The cache array controls package cache behavior in Laravel applications.

// Example: Sunrise at 6:14 AM
// Event at 5:30 AM belongs to NEXT Panchang day
$details = $panchang->getDayDetails($date, $lat, $lon, $tz);
// Times before sunrise in output are dated to next civil date

// Time-only (for display)
$varjyam_start = $details['Varjyam']['varjyam_start']; // "03:31:48 AM"

// Full ISO timestamp (for storage/database)
$varjyam_start_iso = $details['Varjyam']['varjyam_start_iso']; // "28/03/2026 03:31:48 AM"

// ALWAYS use _iso fields when:
// - Storing in database
// - Displaying to users
// - Comparing across timezones

// Check how many windows exist
$windowCount = $details['Varjyam']['window_count']; // 0, 1, or 2

// Access all windows
foreach ($details['Varjyam']['windows'] as $window) {
    echo $window['window_start_iso'] . " - " . $window['window_end_iso'];
    echo $window['visible_start_iso'] . " - " . $window['visible_end_iso'];
}

// Top-level keys maintain backward compatibility
$details['Varjyam']['varjyam_start']; // First window start
$details['Varjyam']['varjyam_end'];   // First window end

// Amrita_Kaal uses the same window payload shape
$details['Amrita_Kaal']['windows'][0]['window_start_iso'];
$details['Amrita_Kaal']['windows'][0]['window_end_iso'];

// Returns both base and effective windows
$pradosha = $details['Pradosha_Kaal'];
$base_start = $pradosha['base_pradosha_start_iso'];
$base_end = $pradosha['base_pradosha_end_iso'];       // Sunset + 6 fixed ghaṭīs
$effective_start = $pradosha['pradosha_start_iso'];
$effective_end = $pradosha['pradosha_end_iso'];       // Trayodashi overlap

$badTimes   = $details['Rahu_Kaal_Gulika_Yamaganda'];
$abhijit    = $details['Abhijit_Muhurta'];
$praharas   = $details['Prahara_Full_Day'];
$daylight   = $details['Daylight_Fivefold_Division']; // Morning, Forenoon, Midday, Afternoon, Evening
$brahma     = $details['Brahma_Muhurta'];
$dur        = $details['Dur_Muhurta_Full_Day'];
$nishita    = $details['Nishita_Muhurta'];            // Night midpoint
$vijaya     = $details['Vijaya_Muhurta'];             // 11th of 15 day muhurtas
$godhuli    = $details['Godhuli_Muhurta'];            // Evening twilight
$sandhya    = $details['Sandhya'];                    // Morning, Noon, Evening
$gowri      = $details['Gowri_Panchangam'];           // Tamil 8-part division
$kalaVela   = $details['Kala_Vela'];                  // Kala, Mrityu, etc.
$karmakala  = $details['Karmakala_Windows'];
$varjyam    = $details['Varjyam'];
$amrita     = $details['Amrita_Kaal'];
$pradosha   = $details['Pradosha_Kaal'];

$specialYogas = $snapshot['Special_Yogas'];
$anandadi     = $snapshot['Anandadi_Yoga'];
$amritadi     = $snapshot['Amritadi_Yoga'];
$panchak      = $snapshot['Panchak'];
$maitreya     = $snapshot['Maitreya_Yoga'];
$gajachchhaya = $snapshot['Gajachchhaya_Yoga'];
$nakShool     = $snapshot['Nakshatra_Shool'];
$dishaShool   = $snapshot['Disha_Shool'];
$rahuVaasa    = $snapshot['Rahu_Vaasa'];
$chandraVaasa = $snapshot['Chandra_Vaasa'];
$shivaVaasa   = $snapshot['Shiva_Vaasa'];
$agniVaasa    = $snapshot['Agni_Vaasa'];
$yoginiVaasa  = $snapshot['Yogini_Vaasa'];
$ekadashi     = $snapshot['Ekadashi_Observance'];

Nakshatra

Enum: JayeshMepani\PanchangCore\Core\Enums\Nakshatra

use JayeshMepani\PanchangCore\Core\Enums\Nakshatra;

// Get nakshatra from moon longitude
$nakshatra = Nakshatra::fromLongitude(125.3); // Magha

echo $nakshatra->getName();          // "Magha"
echo $nakshatra->getDeity();         // "Pitris"
echo $nakshatra->getRulingPlanet();  // "Ketu"
echo $nakshatra->getSymbol();        // "Royal Throne"

// Get pada (quarter)
$pada = Nakshatra::getPada(125.3);    // 2
echo "Pada: $pada\n";                // Pada: 2

// Get longitude range
$range = Nakshatra::Ashwini->getLongitudeRange();
echo $range['start'] . "° - " . $range['end'] . "°\n"; // 0° - 13.333°

Tithi

Enum: JayeshMepani\PanchangCore\Core\Enums\Tithi

use JayeshMepani\PanchangCore\Core\Enums\Paksha;
use JayeshMepani\PanchangCore\Core\Enums\Tithi;

// Get tithi by index (1-30)
$tithi = Tithi::from(12); // enum case: ShuklaDwadashi

echo $tithi->getName();            // "Twelfth Lunar Day of Bright Half"
echo $tithi->getName('hi');        // "शुक्ल द्वादशी"
echo $tithi->getName('gu');        // "સુદ બારસ"
echo $tithi->getPaksha()->name;    // "Shukla"
echo $tithi->getPaksha()->getName(); // "Bright Half (waxing)"

// Check paksha
if ($tithi->getPaksha() === Paksha::Shukla) {
    echo "Waxing moon phase\n";    // Waxing moon phase
}

// Get normalized index (1-15 for both pakshas)
echo $tithi->getNormalizedIndex(); // 12

Paksha

Enum: JayeshMepani\PanchangCore\Core\Enums\Paksha

use JayeshMepani\PanchangCore\Core\Enums\Paksha;

$paksha = Paksha::Shukla;
echo $paksha->getName();        // "Bright Half (waxing)"
echo $paksha->getName('hi');    // "शुक्ल"
echo $paksha->getName('gu');    // "શુક્લ"
echo $paksha->getDescription(); // "Waxing moon fortnight (bright half)"

echo Paksha::Shukla->getRawName();  // "Shukla"
echo Paksha::Krishna->getRawName(); // "Krishna"

Yoga

Enum: JayeshMepani\PanchangCore\Core\Enums\Yoga

use JayeshMepani\PanchangCore\Core\Enums\Yoga;

$yoga = Yoga::fromLongitudes(10.0, 20.0); // Ayushman

echo $yoga->getName();                    // "Ayushman"
echo $yoga->getName('hi');                // "आयुष्मान"
echo $yoga->getName('gu');                // "આયુષ્માન"

$remaining = Yoga::getFractionRemaining(10.0, 20.0);
echo round($remaining, 2);                // 0.75

Karana

Enum: JayeshMepani\PanchangCore\Core\Enums\Karana

use JayeshMepani\PanchangCore\Core\Enums\Karana;

$karana = Karana::fromTithi(12, 0.25); // Bava

echo $karana->getName();               // "Bava"
echo $karana->getName('hi');           // "बव"
echo $karana->getName('gu');           // "બવ"

[$name, $index] = Karana::getFromLongitudes(10.0, 80.0);
echo $name;                            // "Taitila"
echo $index;                           // 12

Vara

Enum: JayeshMepani\PanchangCore\Core\Enums\Vara

use JayeshMepani\PanchangCore\Core\Enums\Vara;

$vara = Vara::fromDayOfWeek(2); // Tuesday

echo $vara->getName();          // "Tuesday"
echo $vara->getName('hi');      // "मंगलवार"
echo $vara->getName('gu');      // "મંગળવાર"
echo $vara->getRulingPlanet();  // "Maṅgala (Mars)"

Core Enums

Basic enumeration types used throughout the package.

CalendarType

Enum: JayeshMepani\PanchangCore\Core\Enums\CalendarType

use JayeshMepani\PanchangCore\Core\Enums\CalendarType;

$amanta = CalendarType::Amanta;
echo $amanta->getLocalizedName('hi'); // "अमांत"

PanchangService

Service: JayeshMepani\PanchangCore\Panchanga\PanchangService

$selected = $panchang->getSelectedDetails(
    $date,
    $lat,
    $lon,
    $tz,
    ['Panchanga', 'Muhurta_Full_Day', 'Dharma_Sindhu'],
    calculationAt: CarbonImmutable::now($tz)
);

$tithi = $selected['Panchanga']['Current_Tithi_At_Input_Now']['name'];

$fields = $panchang->getFields($date, $lat, $lon, $tz, [
    'Panchanga.Current_Tithi_At_Input_Now.name',
    'Abhijit_Muhurta.abhijit_start',
    'Sunrise',
]);

FestivalService

Service: JayeshMepani\PanchangCore\Festivals\FestivalService

$today = $panchang->getFestivalSnapshot(CarbonImmutable::parse('2026-03-24'), 23.247, 69.668, 'Asia/Kolkata');
$tomorrow = $panchang->getFestivalSnapshot(CarbonImmutable::parse('2026-03-25'), 23.247, 69.668, 'Asia/Kolkata');

$festivals = $festivalService->resolveFestivalsForDate(
    CarbonImmutable::parse('2026-03-24'),
    $today,
    $tomorrow
);

foreach ($festivals as $festival) {
    echo $festival['name'] . "\n";
}

OutputGeneratorService

Service: JayeshMepani\PanchangCore\Panchanga\OutputGeneratorService

AstronomyService

Service: JayeshMepani\PanchangCore\Astronomy\AstronomyService

SunService

Service: JayeshMepani\PanchangCore\Astronomy\SunService

PanchangaEngine

Service: JayeshMepani\PanchangCore\Panchanga\PanchangaEngine

$tithi = $engine->calculateTithi(350.5, 125.3);
echo $tithi['name']; // "Twelfth Lunar Day of Bright Half"
                

CliBootstrap

Trait: JayeshMepani\PanchangCore\Traits\CliBootstrap

require __DIR__ . '/vendor/autoload.php';

CliBootstrap::init(__DIR__);
$panchangService = CliBootstrap::makePanchangService();

CliBootstrap::init(__DIR__);

$panchangService = CliBootstrap::makePanchangService();

MuhurtaService

Service: JayeshMepani\PanchangCore\Panchanga\MuhurtaService

EclipseService

Service: JayeshMepani\PanchangCore\Astronomy\EclipseService

BhadraEngine

Service: JayeshMepani\PanchangCore\Festivals\Utils\BhadraEngine

ElectionalEvaluator

Service: JayeshMepani\PanchangCore\Panchanga\ElectionalEvaluator

KalaNirnayaEngine

Service: JayeshMepani\PanchangCore\Panchanga\KalaNirnayaEngine

VimshottariDasha

Enum: JayeshMepani\PanchangCore\Core\Enums\VimshottariDasha

JSON Response Schema

Complete reference of keys returned by the getDayDetails() "God Object".

Auspicious & Inauspicious Windows

Directional and Transition Outputs

CLI Tooling & Scripts

Built-in scripts for rapid data generation, batch processing, and data export.

Available Scripts

Usage Examples

cd scripts
php panchang_today.php

cd scripts
php panchang_festivals.php 2026

cd scripts
php panchang_festivals.php 2026 festivals
php panchang_festivals.php 2026 vrats

Yearly festival JSON files generated by the CLI now emit the compact by_date branch only. The dedicated vrat file also pulls repeated weekly weekday vrats into a shared recurring_weekday_vrats block instead of repeating them on every date. Use the selective runtime APIs when you also need a flat list.

cd scripts
php panchang_month_output.php 2026 5 > month_2026_05.json

Localization and Calendar Types

Use environment variables to control output format:

PANCHANG_LOCALE=hi PANCHANG_CALENDAR_TYPE=purnimanta php panchang_today.php

Supported locales: en, hi, gu. Calendar types: amanta, purnimanta.

Configuration

Complete reference for config/panchang.php.

Batch Processing

Efficiently generating large JSON datasets for applications.

use JayeshMepani\PanchangCore\Panchanga\OutputGeneratorService;

$generator = app(OutputGeneratorService::class);

// 1. Export 10 years of eclipses
$eclipses = $generator->generateEclipses(2025, 2035, 23.24, 69.66, 'Asia/Kolkata');

// 2. Export full year of festivals
$festivals = $generator->generateFestivals(2026, 23.24, 69.66, 'Asia/Kolkata');

// 3. One massive unified export
$all = $generator->generateAll(2026, 2026, 2030, 23.24, 69.66, 'Asia/Kolkata');

Localization

Multilingual support for English, Hindi, and Gujarati.

Switching Locales at Runtime

// Using environment variables (Global)
putenv('PANCHANG_LOCALE=gu');

// The output of any service will now use Gujarati script
$details = Panchang::getDayDetails($date, $lat, $lon, $tz);
echo $details['Current_Tithi_At_Input_Now']['name']; // "વદ તેરસ"

Direct Localization Usage

Use the Localization class directly for custom translations:

use JayeshMepani\PanchangCore\Core\Localization;

// Get translated Nakshatra name
$nakshatraName = Localization::translate('Nakshatra', 0, 'hi'); // "अश्विनी"

// Get translated Tithi
$tithiName = Localization::translate('Tithi', 15, 'gu'); // "પૂનમ"

// Available categories: Nakshatra, Vara, Tithi, Rasi, Yoga, Karana, Choghadiya, Muhurta, Masa, Paksha, Ritu, Ayana, Planet, Samvatsara, Vrata, Eclipse, Festival

Supported Languages

• en — English
• hi — Hindi (Devanagari script)
• gu — Gujarati (Gujarati script)

The Localization class contains comprehensive translations for all panchang elements, including festival names, planetary names, and astrological terms.

Usage Patterns (How do I...?)

Practical code snippets for specific needs. Prefer selective APIs when you do not need the full daily, monthly, festival, or eclipse payload.

$tithi = Panchang::getCurrentTithi(
    date: $date,
    lat: $lat,
    lon: $lon,
    tz: $tz,
    calculationAt: CarbonImmutable::now($tz)
);

echo "Current Tithi is: " . $tithi['name'];
// Example output: Current Tithi is: Twelfth Lunar Day of Bright Half

$fields = Panchang::getFields($date, $lat, $lon, $tz, [
    'Panchanga.Current_Tithi_At_Input_Now.name',
    'Panchanga.Current_Nakshatra_At_Input_Now.name',
    'Abhijit_Muhurta.abhijit_start',
    'Abhijit_Muhurta.abhijit_end',
]);

echo $fields['Panchanga']['Current_Tithi_At_Input_Now']['name'];
// Example output: Twelfth Lunar Day of Bright Half

echo $fields['Abhijit_Muhurta']['abhijit_start'];
// Example output: 12:23:28 PM

$panchanga = Panchang::getPanchanga(
    date: $date,
    lat: $lat,
    lon: $lon,
    tz: $tz,
    calculationAt: CarbonImmutable::now($tz)
);

$tithi = $panchanga['Current_Tithi_At_Input_Now'];
$nakshatra = $panchanga['Current_Nakshatra_At_Input_Now'];
$yoga = $panchanga['Current_Yoga_At_Input_Now'];
$karana = $panchanga['Current_Karana_At_Input_Now'];
$vara = $panchanga['Vara'];

echo $tithi['name'];     // Example output: "Twelfth Lunar Day of Bright Half"
echo $nakshatra['name']; // Example output: "Magha"
echo $yoga['name'];      // Example output: "Ayushman"
echo $karana['name'];    // Example output: "Bava"
echo $vara['name'];      // Example output: "Tuesday"

$selected = Panchang::getSelectedDetails($date, $lat, $lon, $tz, [
    'Panchanga',
    'Muhurta_Full_Day',
    'Abhijit_Muhurta',
    'Dharma_Sindhu',
], calculationAt: CarbonImmutable::now($tz));

$muhurtas = $selected['Muhurta_Full_Day'];
$dharmaSindhu = $selected['Dharma_Sindhu'];

echo count($muhurtas); // Example output: 30
echo $selected['Abhijit_Muhurta']['abhijit_start']; // Example output: "12:23:28 PM"

$eval = Panchang::getDailyMuhurtaEvaluation($date, $lat, $lon, $tz, CarbonImmutable::now());
if ($eval['evaluation_results']['bhadra']['is_active']) {
    echo "Bhadra is active!";
}

echo $eval['evaluation_results']['bhadra']['is_active'] ? 'yes' : 'no';
// Example output: no

$details = Panchang::getSelectedDetails($date, $lat, $lon, $tz, ['Panchanga']);

echo "Starts: " . $details['Panchanga']['Nakshatra']['start_iso'];
// Example output: Starts: 23/05/2026 07:28:11 AM

echo "Ends: " . $details['Panchanga']['Nakshatra']['end_iso'];
// Example output: Ends: 24/05/2026 05:48:42 AM

$calendar = Panchang::getMonthFields(
    year: 2026,
    month: 6,
    lat: $lat,
    lon: $lon,
    tz: $tz,
    fields: ['tithi']
);

$firstDay = $calendar['2026-06-01'];
echo $firstDay['tithi_display']['display'];
// Example output: 16

print_r(array_keys($firstDay));
// Example output: ['date', 'day', 'tithi', 'tithi_display', 'tithi_windows']

$calendar = Panchang::getMonthFields(
    year: 2026,
    month: 6,
    lat: $lat,
    lon: $lon,
    tz: $tz,
    fields: ['tithi', 'nakshatra', 'festivals'],
    options: ['festival_scope' => 'month']
);

$festivals = $calendar['2026-06-01']['festivals'];
// Example output: []

print_r(array_keys($calendar['2026-06-01']));
// Example output: ['date', 'day', 'tithi', 'tithi_display', 'tithi_windows', 'nakshatra', 'nakshatra_windows', 'nakshatra_padas', 'festivals', 'daily_observances', 'sankranti']

$periods = Panchang::getCalendarPeriodWindowsRange(
    fromYear: 2026,
    fromMonth: 4,
    toYear: 2026,
    toMonth: 6,
    lat: $lat,
    lon: $lon,
    tz: $tz,
    fields: ['ayana', 'ritu', 'amanta_month', 'purnimanta_month']
);

echo $periods['ayana_windows'][0]['name'];
// Example output: Southward Course

print_r($periods['amanta_month_windows'][2]);
// Example output:
// [
//   'name' => 'Jyeshtha (Intercalary)',
//   'start_iso' => '17/05/2026 01:30:56 AM',
//   'end_iso' => '15/06/2026 08:24:04 AM',
//   'index' => 2,
// ]

print_r($periods['purnimanta_month_windows'][2]);
// Example output:
// [
//   'name' => 'Jyeshtha (Intercalary)',
//   'start_iso' => '01/05/2026 10:51:36 PM',
//   'end_iso' => '31/05/2026 02:13:37 PM',
//   'index' => 2,
// ]

$generator = app(\JayeshMepani\PanchangCore\Panchanga\OutputGeneratorService::class);

$flat = $generator->generateFestivalFlat(
    year: 2026,
    lat: $lat,
    lon: $lon,
    tz: $tz
);

foreach ($flat['flat'] as $entry) {
    echo $entry['date'] . ': ' . $entry['festival']['name'] . PHP_EOL;
    // Example output: 2026-01-14: Makara Sankranti
}

$generator = app(\JayeshMepani\PanchangCore\Panchanga\OutputGeneratorService::class);

$eclipses = $generator->generateEclipseFlat(
    startYear: 2026,
    endYear: 2032,
    lat: $lat,
    lon: $lon,
    tz: $tz
);

$count = count($eclipses['flat']);
echo $count;
// Example output: 18

$details = Panchang::getDayDetails($date, $lat, $lon, $tz);

$allMuhurtas = $details['Muhurta_Full_Day'];
$allLagnas = $details['Lagna_Full_Day'];
$allDailySections = $details;

echo count($allMuhurtas); // Example output: 30
echo count($allLagnas);   // Example output: 13
echo $details['Panchanga']['Current_Tithi_At_Input_Now']['name'];
// Example output: Twelfth Lunar Day of Bright Half

Constants & Enums

Available options for calculation parameters.

Laravel Integration

Complete guide for using Panchang Core in Laravel applications.

composer require jayeshmepani/panchang-core

Configuration

Publish the configuration file:

php artisan vendor:publish --provider="JayeshMepani\PanchangCore\PanchangServiceProvider" --tag="panchang-config"

This creates config/panchang.php:

return [
    'ephe_path' => env('PANCHANG_EPHE_PATH', __DIR__ . '/../ephe'),
    'defaults' => [
        'locale' => env('PANCHANG_LOCALE', 'en'),
        'calendar_type' => env('PANCHANG_CALENDAR_TYPE', 'amanta'),
        'measurement_system' => 'indian_metric',
        'date_time_format' => 'indian_12h',
        'time_notation' => '12h',
        'coordinate_format' => 'decimal',
        'angle_unit' => 'degree',
        'duration_format' => 'mixed',
    ],
    'festivals' => [
        'default_tradition' => 'Smarta',
        'default_region' => 'North',
        'supported_traditions' => ['Smarta', 'Vaishnava'],
        'supported_regions' => ['North', 'South', 'Bengal', 'Maharashtra', 'Tamil', 'Gujarat'],
    ],
    'cache' => [
        'enabled' => true,
        'ttl' => 86400,
        'prefix' => 'panchang_',
    ],
];

Using the Facade

use JayeshMepani\PanchangCore\Facades\Panchang;
use Carbon\CarbonImmutable;

// Get complete panchanga
$details = Panchang::getDayDetails(
    date: CarbonImmutable::parse('2026-03-24'),
    lat: 23.2472,
    lon: 69.6683,
    tz: 'Asia/Kolkata'
);

echo $details['Tithi_At_Sunrise']['name']; // "Twelfth Lunar Day of Bright Half"
echo $details['Nakshatra']['name'];        // "Magha"

Service Container

Or inject via constructor:

use JayeshMepani\PanchangCore\Panchanga\PanchangService;

class PanchangController extends Controller
{
    public function __construct(
        private PanchangService $panchang
    ) {}

    public function show()
    {
        $details = $this->panchang->getDayDetails(
            date: CarbonImmutable::now(),
            lat: 28.6139,
            lon: 77.2090,
            tz: 'Asia/Kolkata'
        );

        return view('panchang', compact('details'));
    }
}

Return Value Structures

Complete data structures returned by main methods.

getDayDetails() Return Structure

[
  'Display_Settings' => [...],
  'Units' => [...],
  'Tithi' => ['index' => 12, 'name' => 'Twelfth Lunar Day of Bright Half', 'paksha' => 'Shukla'],
  'Tithi_At_Sunrise' => ['index' => 12, 'name' => 'Twelfth Lunar Day of Bright Half', 'paksha' => 'Shukla'],
  'Current_Tithi_At_Input_Now' => ['index' => 13, 'name' => 'Thirteenth Lunar Day of Bright Half', 'paksha' => 'Shukla'],
  'Nakshatra' => ['index' => 10, 'name' => 'Magha', 'pada' => 2, 'lord' => 'Ketu'],
  'Nakshatra_At_Sunrise' => ['index' => 10, 'name' => 'Magha', 'pada' => 2, 'lord' => 'Ketu'],
  'Current_Nakshatra_At_Input_Now' => ['index' => 11, 'name' => 'Purva Phalguni', 'pada' => 1, 'lord' => 'Venus'],
  'Yoga' => ['index' => 9, 'name' => 'Shula'],
  'Current_Yoga_At_Input_Now' => ['index' => 10, 'name' => 'Ganda'],
  'Karana' => ['index' => 23, 'name' => 'Bava'],
  'Karana_At_Sunrise' => ['index' => 23, 'name' => 'Bava'],
  'Current_Karana_At_Input_Now' => ['index' => 24, 'name' => 'Balava'],
  'Vara' => ['index' => 2, 'name' => 'Tuesday', 'lord' => 'Mars'],
  'Hindu_Calendar' => [
    'Month_Amanta' => 'Chaitra',
    'Month_Purnimanta' => 'Chaitra',
    'Is_Adhika' => false,
    'Is_Kshaya' => false,
    'Amanta_Index' => 1,
    'Purnimanta_Index' => 1,
  ],
  'Moon_Phase_At_Sunrise' => [
    'key' => 'waxing_gibbous',
    'name' => 'Waxing Gibbous',
    'visibility' => 'Late afternoon and most of night',
    'illumination_fraction' => 0.73,
    'phase_angle_degrees' => 117.4,
    'synodic_age_days' => 9.62,
  ],
  'Current_Moon_Phase_At_Input_Now' => [
    'key' => 'waxing_gibbous',
    'name' => 'Waxing Gibbous',
    'visibility' => 'Late afternoon and most of night',
    'illumination_fraction' => 0.76,
    'phase_angle_degrees' => 121.1,
    'synodic_age_days' => 9.93,
  ],
  'Rahu_Kaal_Gulika_Yamaganda' => [...],
  'Abhijit_Muhurta' => [
    'abhijit_start' => '12:24:00 PM',
    'abhijit_end' => '01:12:00 PM',
    'daylight_midpoint' => '12:48:00 PM',
  ],
  'Brahma_Muhurta' => [
    'calculation_convention' => 'dynamic_night_muhurta',
    'fixed_48_minute_convention' => [...],
  ],
  'Hora_Full_Day' => [...],
  'Chogadiya_Full_Day' => [...],
  'Muhurta_Full_Day' => [...],
  'Prahara_Full_Day' => [...],
  'Lagna_Full_Day' => [
    [
      'sign_name' => 'Taurus',
      'start_iso' => '...',
      'end_iso' => '...',
      'visible_start_iso' => '...',
      'visible_end_iso' => '...',
      'is_partial_start' => true,
      'is_partial_end' => false,
    ],
  ],
  'Dur_Muhurta_Full_Day' => [...],
  'Daylight_Fivefold_Division' => [...],
  'Nishita_Muhurta' => [...],
  'Vijaya_Muhurta' => [...],
  'Godhuli_Muhurta' => [...],
  'Sandhya' => [...],
  'Gowri_Panchangam' => [...],
  'Kala_Vela' => [...],
  'Karmakala_Windows' => [...],
  'Varjyam' => ['is_available' => true, 'window_count' => 1, 'windows' => [[
    'type' => 'varjyam',
    'offset_ghati' => 14,
    'duration_ghati' => 4,
    'visible_start_iso' => '...',
    'visible_end_iso' => '...',
  ]]],
  'Amrita_Kaal' => ['is_available' => true, 'window_count' => 1, 'windows' => [[
    'type' => 'amrita_kaal',
    'offset_ghati' => 38,
    'duration_ghati' => 4,
    'visible_start_iso' => '...',
    'visible_end_iso' => '...',
  ]]],
  'Pradosha_Kaal' => [...],
  'Bhadra' => [...],
  'Dharma_Sindhu' => [...],
  'Festivals' => [...],
  'Daily_Observances' => [...],
  'Special_Yogas' => [...],
  'Anandadi_Yoga' => [...],
  'Amritadi_Yoga' => [...],
  'Nitya_Yoga_Observations' => ['yoga_index' => 17, 'yoga_name' => 'Vyatipata', 'is_kranti_dosha' => true],
  'Panchak' => [...],
  'Maitreya_Yoga' => [...],
  'Gajachchhaya_Yoga' => [...],
  'Nakshatra_Shool' => [...],
  'Disha_Shool' => [...],
  'Yatra_Screening' => ['current_at_input_now' => ['blocked_directions' => [...], 'direction_grid' => [...]]],
  'Rahu_Vaasa' => [...],
  'Chandra_Vaasa' => [
    'rule_system' => 'moon_rashi_direction_4_direction',
    'direction_key' => 'West',
    'nakshatra_pada_vaasa' => [...],
  ],
  'Shiva_Vaasa' => [...],
  'Agni_Vaasa' => [...],
  'Yogini_Vaasa' => [...],
  'Ekadashi_Observance' => [...],
  // Ekadashi_Observance can include:
  // fasting_guidance.profile
  // fasting_guidance.guidance_keys
  // fasting_guidance.guidance
  // fasting_guidance.source_refs
  'Vara_Tithi_Doshas' => ['active_keys' => ['dagdha'], 'all' => [...]],
  'Tithi_Observance_Analysis' => ['rule_system' => 'smarta_udaya_tithi_structural_analysis', 'current_at_input_now' => ['status' => 'Shuddha'], 'at_sunrise' => ['status' => 'Shuddha']],
  'Vrata_Parana' => ['supported_families' => [['family_key' => 'sankashti_chaturthi']], 'current_at_input_now' => ['family_key' => 'sankashti_chaturthi']],
  'Day_Night_Measures' => ['dinamana' => ['ghati' => 33], 'ratrimana' => ['ghati' => 26]],
  'Nakshatra_Tyajya' => ['is_equivalent_to_varjyam' => true],
  'Transitions' => [...],
  'Resolution_Context' => [...],
]

getFestivalSnapshot() Return Structure

[
  'Festivals' => [
    [
      'name' => 'Holika Dahan',
      'description' => 'Holika bonfire ritual',
      'deity' => 'Vishnu/Prahlada',
      'fasting' => false,
      'regions' => ['Pan-India'],
      'aliases' => [],
      'observance_note' => null,
      'calculation_basis' => [
        'type' => 'tithi',
        'type_name' => 'tithi',
        'basis' => 'tithi',
        'basis_name' => 'tithi',
        'tithi' => [...],
        'paksha' => 'Shukla',
        'paksha_name' => 'Shukla',
        'month' => [
          'calendar_type' => 'amanta',
          'value' => 'Phalguna',
          'name' => 'Phalguna',
        ],
        'karmakala_type' => 'pradosha',
        'karmakala_type_name' => 'pradosha',
      ],
      'resolution' => [...],
      'rules_applied' => [...],
    ],
  ],
  'Tithi' => [...],
  'Vara' => [...],
  'Nakshatra' => [...],
  'Yoga' => [...],
  'Karana' => [...],
  'Sunrise' => '06:14:00 AM',
  'Sunset' => '06:52:00 PM',
  'Moonrise' => '10:12:35 PM',
  'Moonset' => '09:00:37 AM',
  'Moonrise_Date' => '2026-04-05',
  'Moonset_Date' => '2026-04-06',
  'Moonrise_ISO' => '05/04/2026 10:12:35 PM',
  'Moonset_ISO' => '06/04/2026 09:00:37 AM',
  'Moonset_Day_Relation' => 'next_day',
  'Special_Yogas' => [...],
  'Anandadi_Yoga' => [...],
  'Amritadi_Yoga' => [...],
  'Nitya_Yoga_Observations' => [...],
  'Panchak' => [...],
  'Maitreya_Yoga' => [...],
  'Gajachchhaya_Yoga' => [...],
  'Nakshatra_Shool' => [...],
  'Disha_Shool' => [...],
  'Yatra_Screening' => [...],
  'Rahu_Vaasa' => [...],
  'Chandra_Vaasa' => [...],
  'Shiva_Vaasa' => [...],
  'Agni_Vaasa' => [...],
  'Yogini_Vaasa' => [...],
  'Ekadashi_Observance' => [...],
  'Vara_Tithi_Doshas' => [...],
  'Tithi_Observance_Analysis' => [...],
  'Vrata_Parana' => [...],
  'Day_Night_Measures' => [...],
  'Nakshatra_Tyajya' => [...],
  'Resolution_Context' => [...],
]

Festival metadata keeps canonical values for code and localized companion fields for display. The calculation_basis.month block follows the active calendar_type only; it does not emit both amanta and purnimanta months in the same localized output.

getMonthCalendar() Return Structure

[
  '2026-04-01' => [
    'date' => '2026-04-01',
    'day' => 1,
    'tithi' => [...],
    'tithi_display' => [
      'display' => '14',
      'indexes' => [14],
      'phase_indexes' => [14],
      'names' => ['Fourteenth Lunar Day of Bright Half'],
      'has_multiple_tithis' => false,
      'has_kshaya_tithi' => false,
      'kshaya_tithi' => null,
    ],
    'tithi_windows' => [...],
    'nakshatra' => [...],
    'nakshatra_windows' => [...],
    'nakshatra_padas' => [...],
    'yoga' => [...],
    'yoga_windows' => [...],
    'karana' => [...],
    'karana_windows' => [...],
    'vara' => [...],
    'sun_sign' => [...],
    'moon_sign' => [...],
    'moon_phase' => [
      'key' => 'waxing_gibbous',
      'name' => 'Waxing Gibbous',
      'visibility' => 'Late afternoon and most of night',
      'illumination_band' => '51%-99%',
      'illumination_fraction' => 0.73,
      'illumination_percent' => 73.0,
      'phase_angle_degrees' => 117.4,
      'synodic_age_days' => 9.62,
    ],
    'sunrise' => '06:43:00 AM',
    'sunset' => '07:11:00 PM',
    'moonrise' => '...',
    'moonset' => '...',
    'moonrise_date' => '2026-04-01',
    'moonset_date' => '2026-04-02',
    'moonrise_iso' => '01/04/2026 06:26:00 PM',
    'moonset_iso' => '02/04/2026 06:05:00 AM',
    'moonset_day_relation' => 'next_day',
    'moon_visibility' => [
      'starts_at' => '...',
      'starts_on' => '2026-04-01',
      'starts_iso' => '...',
      'ends_at' => '...',
      'ends_on' => '2026-04-02',
      'ends_iso' => '...',
      'ends_day_relation' => 'next_day',
    ],
    'hindu_calendar' => [...],
    'festivals' => [...],
    'daily_observances' => [...],
    'sankranti' => null,
  ],
]

Month calendar note: tithi remains the sunrise-based day label for compatibility, while tithi_display is the calendar-cell helper for UI use. On kshaya/skip days it can expose compact values such as 30/1 together with structured kshaya_tithi metadata.

Moon visibility note: month output preserves compact moonrise and moonset display fields, but also includes date-qualified fields because a moonset can occur after midnight on the next civil date.

Moon phase note: moon_phase is a visual phase classification derived from exact Sun-Moon elongation and illuminated fraction. It is intentionally separate from Tithi.

Real-World Examples

Complete working examples for common use cases.

1. Daily Panchang Display

// Show today's panchang
$today = Panchang::getDayDetails(
    date: CarbonImmutable::now(),
    lat: $userLat,
    lon: $userLon,
    tz: $userTz
);

echo "Current Tithi: " . $today['Current_Tithi_At_Input_Now']['name'];
echo "Nakshatra: " . $today['Nakshatra']['name'];

2. Festival Calendar

// Get festivals for entire month
$monthFestivals = [];
for ($day = 1; $day <= 31; $day++) {
    $date = CarbonImmutable::create(2026, 10, $day);
    $fest = Panchang::getFestivalSnapshot($date, $lat, $lon, $tz);
    
    if (!empty($fest['Festivals'])) {
        $monthFestivals[$day] = $fest['Festivals'];
    }
}

3. Tradition-Specific Resolution

// Smarta-style date resolution (date-scoped festivals)
$smarta = Panchang::getDayDetails(
    CarbonImmutable::parse('2026-09-06'),
    28.61, 77.20, 'Asia/Kolkata'
)['Festivals'];

// Next-day festival context (for comparison)
$vaishnava = Panchang::getDayDetails(
    CarbonImmutable::parse('2026-09-07'),
    28.61, 77.20, 'Asia/Kolkata'
)['Festivals'];

4. Planetary Positions for a Timestamp

// Get planetary positions and ascendant for a timestamp/location
$timestampData = [
    'year' => 1990, 'month' => 5, 'day' => 15,
    'hour' => 14, 'minute' => 30, 'second' => 0,
    'tz' => 'Asia/Kolkata', 'lat' => 28.61, 'lon' => 77.20
];

$planets = $astronomy->getPlanets($timestampData);
$ascendant = $astronomy->getAscendant($timestampData);

echo "Sun: " . $planets['Sun'] . "°\n";
echo "Ascendant: " . $ascendant . "°";

5. Comprehensive Full-Day Data

// Get all advanced time divisions for a date
$details = Panchang::getDayDetails($date, $lat, $lon, $tz);

$currentTithi = $details['Current_Tithi_At_Input_Now']; // Runtime tithi
$sunriseTithi = $details['Tithi_At_Sunrise'];           // Sunrise tithi
$currentKarana = $details['Current_Karana_At_Input_Now'];
$sunriseKarana = $details['Karana_At_Sunrise'];
$lagnas   = $details['Lagna_Full_Day'];     // Exact Sign entry times
$horas    = $details['Hora_Full_Day'];       // 24 planetary rulers
$praharas = $details['Prahara_Full_Day'];    // 8 canonical periods
$muhurtas = $details['Muhurta_Full_Day'];    // 30 named Muhurtas
$brahma   = $details['Brahma_Muhurta'];      // Dynamic night-muhurta convention
$badTimes = $details['Rahu_Kaal_Gulika_Yamaganda']; // Rahu, Gulika, Yamaganda
$durs     = $details['Dur_Muhurta_Full_Day']; // Inauspicious Muhurtas
$sandhya  = $details['Sandhya'];              // Morning / Noon / Evening
$gowri    = $details['Gowri_Panchangam'];     // Day + night Gowri divisions
$karmakala = $details['Karmakala_Windows'];   // Named daily windows

6. Transit-Only Muhurta Evaluation

$evaluation = Panchang::getDailyMuhurtaEvaluation(
    date: CarbonImmutable::now()->startOfDay(),
    lat: $lat,
    lon: $lon,
    tz: $tz,    currentAt: CarbonImmutable::now($tz)
);

$verdict = $evaluation['rejection_report']['overall_verdict'];
$bhadraActive = $evaluation['evaluation_results']['bhadra']['is_active'];
$varjyamActive = $evaluation['evaluation_results']['varjyam']['is_active'];

7. Raw JSON Exporter

Use this when you want the complete all-in-one package output in a single JSON file:

php scripts/panchang_raw_output.php > output.json

This writes meta, festivals_2026, eclipses_2026_2032, todays_complete_details, and muhurta_evaluation in one file.

Additional standalone exporters are available in scripts/:

php scripts/panchang_today.php
php scripts/panchang_month_output.php 2026 5 > month_2026_05.json
php scripts/panchang_eclipses.php 2026 2032
php scripts/panchang_festivals.php 2026

panchang_today.php writes today_panchang.json automatically and prints status text only. panchang_month_output.php prints JSON to stdout only, so choose the filename with shell redirection. Without arguments it generates the current month. panchang_eclipses.php writes eclipses_YYYY_YYYY.json automatically and prints status text only. panchang_festivals.php writes festivals_YYYY.json automatically and prints status lines; do not redirect its stdout as raw JSON.

Use PANCHANG_LOCALE=en|hi|gu and PANCHANG_CALENDAR_TYPE=amanta|purnimanta to generate localized/calendar-type variants. For a dedicated output directory, move implicit-output files after generation and redirect stdout-only scripts directly:

cd scripts
dir="output/amanta/gu"
mkdir -p "$dir"

PANCHANG_CALENDAR_TYPE=amanta PANCHANG_LOCALE=gu php panchang_today.php > /tmp/today.log
mv -f today_panchang.json "$dir/today.json"

PANCHANG_CALENDAR_TYPE=amanta PANCHANG_LOCALE=gu php panchang_festivals.php 2026 > /tmp/festivals.log
mv -f festivals_2026.json "$dir/festivals_2026.json"

PANCHANG_CALENDAR_TYPE=amanta PANCHANG_LOCALE=gu php panchang_month_output.php 2026 5 > "$dir/month_2026_05.json"

PANCHANG_CALENDAR_TYPE=amanta PANCHANG_LOCALE=gu php panchang_eclipses.php 2026 2032 > /tmp/eclipses.log
mv -f eclipses_2026_2032.json "$dir/eclipses_2026_2032.json"

Accuracy & Date Range

Technical specifications of the JME native ephemeris astronomical engine.

Error Handling

Understanding and handling errors.

Common Exceptions

Best Practices

try {
    $details = Panchang::getDayDetails(
        date: $date,
        lat: $lat, // Validate: -90 to 90
        lon: $lon, // Validate: -180 to 180
        tz: $tz    // Validate: timezone_exists($tz)
    );
} catch (RuntimeException $e) {
    Log::error('Panchang calculation failed', [
        'error' => $e->getMessage(),
        'location' => compact('lat', 'lon', 'tz')
    ]);

    return response()->json([
        'error' => 'Unable to calculate panchang for this location'
    ], 500);
}

FAQ & Troubleshooting

Common questions and solutions.

Release and Upgrade Notes

Current release history and compatibility notes from v1.0.0 through the latest v10.4.1 release.

Published Releases

1. 10.4.1
   Ashwin Month Alias Restoration and Festival Catalog Output FixLatest Release

   Patch release restoring Ashvina-season festival and vrat emission after the English month display spelling was normalized to Ashwin. Month matching now treats Ashwin, Ashwina, and Ashvina as the same canonical lunar month for rule selection, recovering Navaratri, Deepavali-family observances, Ashvina Ekadashi vrats, Ahoi Ashtami, Karva Chauth, and related output while keeping the v10.4.0 dynamic timing behavior intact.

2. 10.4.0
   Dynamic Day-Night Kala Timing, Pradosha and Parana Chronometry, and Localization Refinement

   Minor release aligning key Panchang timing windows with dynamic day and night divisions where the Nirnay-style rules require them. This release adds generated night fivefold and full ten-kāla outputs, moves Pradosha and related night timing from fixed offsets to rātrimāna-based windows, refines dynamic ghadi reporting in Ekadashi parāṇa and allied rule metadata, and tightens English, Hindi, and Gujarati user-facing localization across nakshatra, month, festival-rule, and observance output.

3. 10.3.1
   Govardhan Puja and Bali Pratipada Decision Correction

   Patch release correcting the Govardhan Puja / Bali Pratipada / Annakut selection path. The decision now requires sayahna-vyapini Pratipada, protects against Sthula Chandra Darshana risk when Pratipada is too short after sunrise, keeps Bestu Varas separate, and updates localized decision labels in English, Hindi, and Gujarati. The 2026 Bhuj generated output shifts Govardhan Puja and Bali Pratipada from November 10 to November 9 without changing festival or vrat identity totals.

4. 10.3.0
   Chandra Darshana Visibility Architecture, Hindola Higher-Tithi Preference, and Eclipse Sutak Corrections

   Minor release completing the Chandra Darshana modern crescent-visibility engine: the visibility gate now applies across all three resolution branches (short Pratipada, Dwitiya fallback, Kshaya); modern astronomical metrics (lag, elongation, illumination) are always embedded in visibility_assessment.modern_visibility for auditing; yesterday's sunset/moonset data is injected into Resolution_Context; the Dwitiya branch gains a double-observation guard using yesterday's visibility; and Hindola Festival gains a prefer_higher_tithi_option to resolve Dwitiya over Pratipada when both qualify. Eclipse Sutak relaxed-start times are corrected for 8 of 9 events. New Gujarati localization strings are added for all new Chandra Darshana reason keys.

5. 10.2.0
   Calendar Period Windows, Mahadiksha Guidance, and Vrat Rule Expansion

   Minor release adding generated calendar-period windows for today, month, and raw outputs; exposing sidereal and Sayana ayana/ritu windows; adding day-detail Mahadiksha guidance; refreshing festival/vrat rule metadata and localization; adding generic Vratni Purnima coverage; and regenerating Amanta/Purnimanta JSON across English, Hindi, and Gujarati. The latest generated output reports 324 festival identities and 122 vrat identities.

6. 10.1.0
   Nirnay Rule Expansion, Eclipse Ritual Refinements, and Multilingual Output Refresh

   Minor release refreshing festival and vrat rule coverage, calendar-specific Nag Panchami handling, eclipse ritual guidance, and generated Amanta/Purnimanta JSON output across English, Hindi, and Gujarati.

7. 10.0.8
   Ekadashi Alias Expansion and Formal Naming Cleanup

   Patch release expanding canonical alias coverage across the Ekadashi family and aligning the festival registry, identity documentation, and localization layer with the refreshed identity set.

8. 10.0.7
   Phuldolotsava Rule Refinement, Purnimanta Month Corrections, and Calendar-Aware Paksha Support

   Patch release refining Phuldolotsava (Satsangi Jeevan Dolotsav) with accurate Krishna Pratipada + Uttara Phalguni vyapini rules and structured metadata, introducing paksha_amanta / paksha_purnimanta support, correcting month_purnimanta values across multiple avatar and tithi observances, exposing richer rule metadata, and updating localization. All outputs regenerated.

9. 10.0.6
   Festival Catalog and Localization Refresh

   Patch release refreshing the public festival and vrat catalog, tightening overlapping alias and rule handling in the current registry, and keeping the updated user-facing labels aligned across supported languages.

10. 10.0.4
    Festival Identity and Rule Alignment

    Patch release consolidating Siddhivinayaka Chaturthi into the Vinayaka Chaturthi alias set, separating Kurma Jayanti from Vaishakha Purnima convention handling, aligning Skanda Sashti with its evening decision path, and localizing the new user-facing festival-rule labels.

11. 10.0.3
    Adhika and Kshaya Maas Boundary Correction

    Patch release correcting rare lunar month-boundary handling for Adhika Maas, Kshaya Maas, and returning Nija Maas across both Amanta and Purnimanta systems. Keeps skipped months out of the active month label, preserves intercalary Jyeshtha timing in 2026, and aligns rare 2123–2124 Pausha-Kshaya sequencing with expected public Panchang behavior.

12. 10.0.2
    Dynamic Sandhya Timing Alignment

    Patch release aligning Pratah and Sayahna Sandhya timing with the dynamic rātrimāna-ghaṭī convention used by published Panchang output. Pratah Sandhya now ends at sunrise, Sayahna Sandhya begins at sunset, and both use three dynamic night-ghaṭīs based on actual local rātrimāna.

13. 10.0.1
    Ekadashi Parana Timing Correction

    Patch release correcting Ekadashi parana timing. Enforces the first-six-ghaṭī morning cap when Dvādaśī continues past Madhyāhna, applies restricted nakṣatra-pada blocking only when active at parana opening, and reopens the remaining Dvādaśī window if an active restriction consumes the early cap.

14. 10.0.0
    Relaxed Eclipse-Sutak Timing Correction

    Major release with a corrected relaxed food restriction window during visible eclipses. The window for children, elderly people and the unwell now starts one full local prahara before eclipse contact. Regular Sutak timing is unchanged. All eclipse and raw outputs have been refreshed.

15. 9.8.0
    Dynamic Dinamāna/Rātrimāna Periods and Raksha Bandhan Rule Correction

    Corrects day and night period handling so proportional windows use actual local dinamāna and rātrimāna, while ghaṭī remains a fixed elapsed-time unit. Adds dedicated Raksha Bandhan Nirnay selection with a dynamic three-day-muhūrta Udaya Purnima threshold, improves karmakāla windows, and refreshes generated festival and vrat output.

16. 9.7.0
    Classical Muhurta Quality Correction and Nārada-Aligned Durmuhūrta Schedule

    Aligns the 30 muhūrtas with classical sources: corrects base tyājya labels (Indragni and Īśa now Inauspicious; Arka and Vāyu now Auspicious). Introduces clear separation between fixed base quality and weekday-specific Durmuhūrta using the Nārada verse. Adds quality and index fields to muhūrta table output and provides authoritative weekday Durmuhūrta indexes.

17. 9.6.0
    Sun and Moon Position Accuracy Fix

    Fixes a double annual aberration error in JPL ephemeris calculations for Sun and Moon. Applies the NO_ABERRATION flag consistently in key astronomy services and traits for correct apparent positions. All 2026 data regenerated with improved precision.

18. 9.5.0
    Chandra Darshana Visibility and Satsangi Jeevan Observance Expansion

    Adds support for Chandra Darshana (the first visible waxing crescent), expands Swaminarayan tradition festivals and vrats, provides improved Ekadashi fasting guidance, includes a dedicated decision tree document, and regenerates all 2026 localized outputs.

19. 9.4.0
    Ekadashi Parana Classification and Preferred Window Output

    Expands Ekadashi observance output with explicit Tithyavasara versus Harivasara classification, preferred first-six-ghatika daytime parana windows when Dwadashi runs past Madhyahna, localized user-facing parana labels, and regenerated daily, festival, vrat, and raw artifacts.

20. 9.3.0
    Eclipse Ritual Gating and Festival Truth Table Refinements

    Refines local eclipse ritual visibility and sutak handling, corrects Panchak weekday locking to JD-based resolution, and updates major festival decision tables including Diwali, Ram Navami, Hari Jayanti, Vamana Jayanti, Samaveda Upakarma, and Phuldolotsava.

21. 9.2.0
    General Panchang Rule Outputs and Localization Hardening

    Expands the public non-natal daily rule-engine surface with Panchak subtype locking, Nitya Yoga flags, Tithi and vrata observance analysis, Yatra screening, Nakshatra Tyajya, and localized user-facing output cleanup.

22. 9.1.0
    Calendar Period Selective API and Purnimanta Intercalary Fix

    Minor release adding a dedicated selective API for Hindu calendar period windows and correcting intercalary month labeling in Purnimanta month-window output.

23. 9.0.0
    Verified Nirnay Rules, Panchang Conventions, and Localized Output Contract

    Major release aligning festival, vrat, eclipse, sunrise, moonrise, Ekadashi-parana, and generated JSON behavior with verified engine conventions and localized user-facing output.

24. 8.4.0
    Exact Month-Range Selective APIs

    Minor release adding true exact month-range selective generation for month calendars, festivals, vrats, and eclipses so consumers can request only the bounded span they need.

25. 8.3.0
    Selective Festival/Vrat Outputs and Compact Vrat JSON

    Minor release adding dedicated yearly festival-only and vrat-only generation paths, switching generated yearly observance files to by-date output, compacting repeated weekday vrats into a shared recurring block, and extending the selective model to exact month-range generation for months, festivals, vrats, and eclipses.

26. 8.2.1
    Localization Corrections and Output Cleanup

    Patch release focused on user-facing localization corrections, generated output cleanup, and documentation sync across daily, month, and raw Panchang outputs.

27. 8.2.0
    High-Precision Eclipse Obscuration and JPL Mapping Refinements

    Significant improvement to eclipse accuracy. This version introduces a new geometric engine for area-based obscuration, corrects JME/JPL data structure mappings for solar and lunar diameters, and adds specific support for annular eclipse phases.

28. 8.1.0
    Selective APIs and Modular Output Generation

    Backward-compatible feature release adding selective daily, month, today, festival, and eclipse APIs so consumers can calculate and return only the branches they need.

29. 8.0.0
    Moon Phase, Kshaya Tithi, and Calendar Output Refresh

    Major release focused on clearer calendar output, richer month-view data, better English-facing labels, and first-class moon phase information for daily and monthly Panchang use.

30. 7.0.2
    Brahma Muhurta Calculation Fix

    Fixes a before-sunrise Brahma Muhurta calculation issue that could stop daily Panchang JSON generation.

31. 7.0.1
    Regional Localization and Festival calculation improvements

    A backward-compatible update modifying 2 core PHP files to consolidate festival definitions (such as Shakambhari Purnima and Pradosh Vrat) and standardise Hindi/Gujarati translation formatting.

32. 7.0.0
    Panchang Accuracy, Festival Expansion, and Output Improvements

    Major release focused on improving Panchang clarity, Muhurta accuracy, festival coverage, eclipse handling, and overall timing precision.

33. 6.0.2
    Today Output Field Corrections

    Clarifies current-time versus sunrise-based output fields and corrects daily Panchang details after the v6 migration.

34. 6.0.1
    JPL Fail-Fast and Eclipse Logic Refinements

    Hardens JME/JPL configuration handling and refines eclipse visibility logic.

35. 6.0.0
    JME Native Ephemeris Migration

    Migrates the astronomical backend to the project-owned JME native ephemeris FFI path. Validate deployment FFI configuration before upgrading production environments.

36. 5.0.0
    Yoga, Shoola, Vaasa and Moon Visibility Expansion

    Expands day-level output with special yogas, direction checks, Vaasa signals, and moon visibility fields.

37. 4.1.1
    PHP 8.3+ Syntax Modernization and Documentation Polish

    Modernizes syntax and documentation while keeping the v4 public model intact.

38. 4.1.0
    Festival Registry Refine and Minor Fixes

    Refines festival registry behavior and resolves smaller v4 follow-up issues.

39. 4.0.0
    Universal Panchanga: Architectural Maturity and Global Reach

    Major compatibility release. See the dedicated v4.0.0 compatibility notes below.

40. 3.0.0
    Lahiri-only, Sankranti Fix and Quality Hardening

    Standardizes the calculation model around Lahiri ayanamsa and tightens Sankranti behavior.

41. 2.0.1
    Purge of Activity-Based Muhurta Logic

    Removes activity-specific Muhurta assumptions in favor of calculation-first daily windows.

42. 2.0.0
    Expanded Karmakala Support, Transit-Only Muhurta Cleanup and Output Normalization

    Introduces wider Karmakala support and normalizes Muhurta output structures.

43. 1.2.0
    Festival Registry Refactor, True Hindu Month Resolution and Precision Output Cleanup

    Refactors festival rules and improves month-resolution precision.

44. 1.1.0
    Precision Calendar Fixes and Raw JSON Exporter

    Adds raw JSON export support and fixes precision calendar output details.

45. 1.0.0
    Initial Release

    Initial public Panchang Core package release.

v10.4.1 Upgrade & Release Notes

This patch release restores Ashvina-season festival and vrat output after the English display month spelling changed to Ashwin, without changing the v10.4.0 dynamic timing model.

Upgrade Actions

• Regenerate cached festival, vrat, month, today, and raw JSON after upgrading from v10.4.0.
• Rebaseline snapshots that compare exact festival counts, vrat counts, Ashvina/Ashwin month observances, or generated festival/vrat identity sets.

v10.4.0 Upgrade & Release Notes

This release upgrades core Panchang chronometry to dynamic day and night division logic where the rule system depends on dinamāna and rātrimāna, expands generated kala output, and refreshes multilingual user-facing labeling.

Upgrade Actions

• Regenerate cached today, month, raw, festival, vrat, and localized JSON output after upgrading.
• Rebaseline snapshots or downstream comparisons that assert on Pradosha windows, night-kāla fields, parāṇa ghadi metadata, or localized user-facing strings.

v10.3.1 Upgrade & Release Notes

This patch release corrects the Govardhan Puja / Bali Pratipada / Annakut decision path and regenerates the public JSON outputs without changing identity totals.

Upgrade Actions

• Regenerate cached festival, month, today, raw, and localized JSON output after upgrading.
• Rebaseline tests or snapshots that assert on Govardhan Puja, Bali Pratipada, Annakut, or Deepotsav-family observance dates.

v10.3.0 Upgrade & Release Notes

This release completes the Chandra Darshana visibility engine, introduces the higher-tithi festival preference system, corrects eclipse Sutak relaxed-start times, and regenerates the public JSON outputs.

Upgrade Actions

• Regenerate cached eclipse, today, month, raw, festival, and vrat output after upgrading.
• Rebaseline tests or snapshots that assert on visibility_assessment structure, eclipse relaxed_start times, or Chandra Darshana winning_reason_key values.
• Review any code that destructures visibility_assessment as a flat string-keyed map — it now contains a nested modern_visibility object.

v10.2.0 Upgrade & Release Notes

This release expands generated calendar-period output, adds day-detail Mahadiksha guidance, refreshes festival and vrat metadata, and regenerates the public JSON outputs.

Upgrade Actions

• Regenerate cached today, month, raw, festival, vrat, and eclipse output after upgrading.
• Rebaseline tests or snapshots that compare generated JSON structure, identity totals, calendar-period windows, or day-detail ritual guidance fields.
• Review UI code that assumes day-detail output only contains sidereal ayana/ritu fields; Sayana ayana/ritu and Mahadiksha guidance may now be available.

v10.1.0 Upgrade & Release Notes

This release refreshes festival and vrat rule coverage, improves eclipse ritual output, and regenerates the public Amanta/Purnimanta JSON outputs across English, Hindi, and Gujarati.

Upgrade Actions

• Regenerate cached festival, vrat, month, eclipse, today, and raw yearly output after upgrading.
• Rebaseline snapshots that compare exact festival dates, vrat dates, aliases, localized names, or eclipse ritual fields.
• Review applications that display Nag Panchami, Sankashti, Chandra Darshana, Deepotsav, or eclipse-sutak guidance from cached JSON.

v10.0.8 Upgrade & Release Notes

This release expands the canonical alias set for the 26 named Ekadashis and keeps the festival registry, documentation, and localization layer aligned with the current Ekadashi identity set.

Upgrade Actions

• Regenerate cached festival, vrat, month, or raw yearly output if your application displays Ekadashi aliases or localized festival names.
• Rebaseline snapshots or tests that assert on Ekadashi alias lists, localized festival names, or user-facing festival identity strings.
• Prefer the refreshed canonical Ekadashi alias set in UI display, search, and documentation surfaces.

v10.0.7 Upgrade & Release Notes

This release improves precision for Satsangi tradition observances and adds first-class support for calendar-specific paksha and month definitions in the festival registry.

Upgrade Actions

• Regenerate any cached yearly festival, vrat, month, or raw outputs.
• Rebaseline tests/snapshots that assert on Phuldolotsava date, name, tithi, or nakshatra rules, or on purnimanta month names for avatar observances.
• Review Dhuleti vs Phuldolotsava distinction if your application treats Holi-cluster observances specially.

v10.0.6 Upgrade & Release Notes

This release updates the festival module more broadly: some observances were added, some overlapping identities were merged or cleaned up, several decision rules were corrected, and the related user-facing labels were aligned across supported languages.

Upgrade Actions

• Regenerate cached festival, vrat, month, and raw output if you store canonical observance names, total counts, aliases, descriptions, or decision labels.
• Rebaseline tests or snapshots that compare exact festival totals, vrat totals, resolved observance names, aliases, or user-facing festival decision strings.
• Expect generated observance output to reflect refreshed canonical identities and corrected touched festival decisions.

v10.0.4 Upgrade & Release Notes

Festival identity and rule handling is now cleaner across the Ganesh Chaturthi family, Kurma Jayanti, Vaishakha Purnima, and Skanda Sashti, with the related user-facing labels localized consistently.

Upgrade Actions

• Regenerate cached festival, month, and raw output if you store canonical festival identity names, total festival counts, or detailed decision reasons.
• Rebaseline tests or snapshots that compare exact festival identity totals, Ganesh Chaturthi family aliases, or festival decision notes.
• Expect Vinayaka Chaturthi and Ganesh Chaturthi to stay aligned on the same resolved Bhadrapada observance date.
• Expect Kurma Jayanti, Vaishakha Purnima, and Skanda Sashti outputs to reflect their corrected public rule wording.

v10.0.3 Upgrade & Release Notes

Rare Adhika, Kshaya, and Nija month transitions now keep the active month sequence aligned in both Amanta and Purnimanta output.

Upgrade Actions

• Regenerate cached month, daily, festival, vrat, and raw output if you store lunar month names or month-status flags.
• Rebaseline tests or snapshots that compare exact Amanta or Purnimanta month labels near Adhika or Kshaya transitions.
• Expect corrected output especially around Adhika Jyeshtha in 2026 and the Pausha Kshaya sequence in 2123–2124.

v10.0.2 Upgrade & Release Notes

Sandhya timing now follows the dynamic rātrimāna-ghaṭī convention used by published Panchang output.

Upgrade Actions

• Update direct calls to calculateSandhya() to pass $nextSunrise between $sunset and $solarNoon.
• Regenerate cached daily, today, month, and raw output if you store Sandhya timings.
• Rebaseline tests or snapshots that compare exact Pratah or Sayahna Sandhya start/end times.

v10.0.1 Upgrade & Release Notes

Ekadashi parana timing now strictly follows the first-six-ghaṭī cap when Dvādaśī extends beyond Madhyāhna, while nakṣatra blocking is limited to restrictions active at parana opening.

Upgrade Actions

• Regenerate cached Ekadashi observance, vrat, festival, and raw yearly output if you store parana timings.
• Rebaseline tests or snapshots that compare exact parana start/end windows.
• Expect corrected parana results especially on Dvādaśī days that extend past Madhyāhna or begin under Anuradha 1, Shravana 2-3, or Revati 4 restrictions.

v10.0.0 Upgrade & Breaking Changes

The relaxed food window during visible eclipses now starts one full local prahara before the eclipse contact, instead of the beginning of the previous time segment.

Practical Example

For the solar eclipse visible from Bhuj on 2 August 2027:

• v9.8.0 showed the relaxed window starting around 9:39 AM (based on the previous segment).
• v10.0.0 now correctly shows it starting around 12:21 PM — one full local daytime prahara before the eclipse begins.

The calculation uses the actual length of the prahara in which the eclipse contact occurs, rather than simply taking the start of the segment before it.

Upgrade Actions

• Regenerate any eclipse data or combined raw output files you maintain.
• Review and update any tests or comparisons that rely on the previous relaxed Sutak start times.
• Keep pregnancy-related precautions separate — the relaxed window is intended only for children, elderly people, and the unwell.
• Use the regular Sutak timing for general use, and the relaxed timing only for the specific vulnerable groups mentioned.

v9.8.0 Upgrade & Release Notes

Dynamic day/night period correction across festival, vrat, and daily timing logic with dedicated Raksha Bandhan Nirnay handling.

Highlights

• Dynamic Day/Night Periods: Daytime muhūrtas, nighttime muhūrtas, fivefold day periods, Abhijit, Vijaya, and Niśītha now follow actual local sunrise, sunset, and next sunrise boundaries.
• Fixed-Offset Ritual Windows Preserved: Aruṇodaya, Sandhyā, Pradoṣa, and fixed ghaṭī durations remain sunrise/sunset anchored fixed elapsed-time intervals where tradition requires that treatment.
• Raksha Bandhan Nirnay: The package now distinguishes Udaya Purnima selection from previous-day fallback and exposes the basis used for the decision.
• Ekadashi Parana Refinement: Preferred parana guidance now uses dynamic day midpoint for Madhyāhna while keeping first-six-ghaṭī preference as a fixed elapsed-time rule.
• Generated Count Alignment: Generated observance output is refreshed for the corrected 326 festival and 90 vrat identity set.

Upgrade Notes

• Rebaseline generated festival and vrat snapshots because corrected dynamic period rules can shift or remove observances that were previously selected by overly broad static windows.
• Review Raksha Bandhan displays and aliases: Shravana Purnima now carries the Raksha Bandhan/Rakshabandhan/Rakshabandh aliases and uses Aparāhna-based Nirnay selection.
• Do not treat normalized day/night divisions as classical ghaṭīs. Classical ghaṭī remains 24 minutes; proportional divisions are derived from local dinamāna or rātrimāna.

v9.7.0 Upgrade & Release Notes

Classical muhūrta base quality alignment with Vṛddha Vasiṣṭha/Nārada tradition and correct weekday Durmuhūrta schedule.

Highlights

• Corrected Base Muhūrta Qualities: Day tyājya (Inauspicious) are now Rudra, Ahi, Pitṛ, Indrāgni, Nirṛti, and Bhaga. Night krūra are Īśa, Ajapāda, Yama, and Vahni. Indrāgni and Īśa are properly marked Inauspicious; Arka and Vāyu are Auspicious.
• Clear Separation of Layers: Fixed base quality (from Muhūrtādhyāya) is now independent of weekday Durmuhūrta (Nārada verse). The engine applies both layers correctly.
• Accurate Weekday Durmuhūrta Schedule: Sunday Aryamā (14th), Monday Nirṛti + Brahmā, Tuesday Pitṛ + Agni, Wednesday Vidhātṛ/Abhijit (8th), and so on — using traditional numbering as explained in the sources.
• Nārada Verse Support: The Durmuhūrta implementation now directly follows the well-known śloka beginning “अर्यमा राक्षसब्राह्मौ...” with correct 1-based positions documented.
• Documentation Improvements: MASTER.md and the new MUHURTA_TEXT_SOURCES.md now contain clear, user-friendly explanations of the thirty muhūrtas, their qualities, and the distinction between base and weekday rules.

Upgrade Notes

• If you consume the full muhūrta table, expect two new fields (quality and index) on each row. Existing fields remain unchanged.
• Weekday Durmuhūrta results may differ on certain days compared to previous versions because the schedule now matches classical sources.
• New methods on the Muhurta enum make it easy to inspect base quality or retrieve the Durmuhūrta indexes for a given vara without parsing tables.
• No changes to other panchāṅga limbs (tithi, nakṣatra, yoga, etc.) or festival/vrat logic.

v9.6.0 Upgrade & Release Notes

Precision improvements to Sun and Moon astronomical calculations with aberration fix and regenerated data.

Highlights

• JME Aberration Correction: Added the NO_ABERRATION flag consistently in four key files (AstronomyService, TransitEngine, and two helper traits) to produce correct single-aberration apparent positions for the Sun and Moon.
• Four files updated: AstronomyService, TransitEngine, PanchangAstronomyHelpersTrait, and PanchangBirthMonthHelpersTrait now all use the corrected calculation flags.
• Verified accuracy: Positions now align with published 2026 equinox and solstice instants.
• Data regeneration: All output files (today, month, festivals, vrats, eclipses, raw) have been updated with the improved precision.

Upgrade Notes

• Regenerate any stored or cached JSON data for 2026+ to benefit from the corrected Sun/Moon positions.
• This is a pure accuracy improvement. No changes to API structure or field names.
• Users working in strict JPL mode with high-precision requirements (eclipses, exact festival timings, etc.) will see the most noticeable benefits.
• The fix has been applied uniformly so all calculation paths (daily panchang, festival resolution, birth month helpers, transit angles) are consistent.

v9.4.0 Upgrade & Release Notes

Feature release focused on richer Ekadashi observance output, clearer parana classification, and localized user-facing parana terminology.

Added and Improved

• Parana basis classification: Ekadashi output now distinguishes ordinary Tithyavasara parana from nakshatra-restricted Harivasara resolution.
• Preferred daytime window: When Dwadashi continues past Madhyahna, the public payload now exposes the traditional first-six-ghatika Pratah Kala preference as an explicit rule and preferred parana window set.
• Richer preferred-window fields: Ekadashi parana now includes preferred start/end fields in addition to the full allowed window set, making client rendering simpler for common observance views.
• Localized parana terminology: The newly added parana classifications and daytime-preference rule labels are now localized in English, Hindi, and Gujarati output.

Fixed

• Public Ekadashi parity: The exposed Ekadashi observance payload now reflects the newer Nirnay decision tree already encoded in the engine instead of stopping at only the basic allowed-window view.
• Preferred-window semantics: Clients can now distinguish the full valid parana span from the traditionally preferred early-day portion when the Dwadashi duration is long enough to require that distinction.

Upgrade Notes

• Regenerate stored today, festival, vrat, month, and raw yearly JSON after upgrading.
• If your application displays Ekadashi parana, prefer the new preferred_parana_windows branch when present and fall back to parana_windows only when no preferred window is published.
• If your application shows user-facing parana labels, consume the localized classification and rule-label fields instead of deriving display text from raw keys.

v9.3.0 Upgrade & Release Notes

Feature release focused on stronger eclipse ritual gating, corrected Panchak weekday resolution, and verified festival-rule refinements in the Nirnay layer.

Added and Improved

• Eclipse scriptural classification: Eclipse output now includes explicit scriptural instruction text for Grastodaya, Grastasta, ordinary visible eclipses, and not-applicable cases.
• Nishita JD fields: Nishita Muhurta output now carries Julian-day start and end values in addition to formatted timestamps.
• Additional localized period labels: Localization coverage now includes period labels such as Abhijit, Pratah Kal, Arunodaya, Sangava, Vijaya Kaal, and Nishitha.

Fixed

• Lunar eclipse ritual visibility: Local ritual visibility now rejects penumbral-only lunar cases and requires a minimum visible duration before marking an eclipse as visible for ritual purposes.
• Solar eclipse ritual visibility: Solar ritual visibility now also enforces a minimum visible duration before local visibility and sutak are considered applicable.
• Sutak boundaries: Sutak now fails closed when local prahara boundaries cannot be resolved, and returned sutak duration reflects the actual computed interval instead of a fixed nominal hour count.
• Panchak weekday locking: Panchak subtype determination now uses JD-based weekday resolution instead of parsing localized formatted timestamps.

Festival Rule Refinements

• Diwali truth table: Added explicit Pradosha-based day-selection truth-table handling when Amavasya spans competing evenings.
• Ram Navami: Added explicit handling for Vriddhi, Kshaya, and Ashtami-viddha rejection around Navami selection.
• Swaminarayan Jayanti (Hari-Nom): Rule profile now follows sunrise-vyapini Navami with first-day preference for Vriddhi/Kshaya handling, while keeping the incarnation remembrance context distinct.
• Vamana Jayanti: Primary observance window now uses Abhijit rather than Madhyahna while retaining Shravana Nakshatra preference.
• Govardhan Puja: Morning observance basis is now modeled through Pratah Kal instead of raw sunrise.
• Samaveda Upakarma: Rule emphasis now follows a primarily Hasta-Nakshatra-based profile with sunrise observance handling.
• Phuldolotsava: Tithi and month mapping now follow the corrected Holi-cluster tithi placement in the staged rules.

Upgrade Notes

• Regenerate eclipse, today, festival, and raw yearly artifacts after upgrading.
• If your application compares exact ritual visibility or sutak fields, rebaseline expected output for short local eclipses and penumbral lunar cases.
• If your application depends on Panchak weekday display fields in Hindi or Gujarati output, no client change is needed; the correction is internal and output-only.
• If you cached festival observance dates for the affected festival families, regenerate those caches after upgrading.

v9.2.0 Upgrade & Release Notes

Feature release focused on expanding the public non-natal daily rule-engine surface, tightening Panchak and travel logic, and hardening localized user-facing generated output.

Added

• New public daily rule outputs: Added Nitya_Yoga_Observations, Vara_Tithi_Doshas, Tithi_Observance_Analysis, Vrata_Parana, Yatra_Screening, Day_Night_Measures, and Nakshatra_Tyajya to full day details and selectable daily APIs.
• Panchak subtype classification: Public Panchak output now includes entry-weekday subtype classification for Roga Panchaka, Raja Panchaka, Agni Panchaka, Chora Panchaka, Mrityu Panchaka, and Shubha Panchaka / no named five-dosha subtype, with related keys tied to the cycle-entry weekday.
• Day and night traditional duration metrics: Added explicit Dinamana and Ratrimana style payloads with seconds, minutes, hours, ghati, and pala.
• Supported non-Ekadashi parana families: Added structured parana-family output for supported non-Ekadashi observances including Sankashti Chaturthi, Pradosha Vrat, Masik Shivaratri, and Skanda Shashthi.

Improved

• Panchak window metadata: Panchak windows now expose localized start_weekday, localized current_running_weekday, subtype key, and the explicit entry_weekday lock semantics. The current-day payload also exposes current_weekday_type and current_weekday_type_key when the calculation time is inside an active Panchak window.
• Yatra screening: Directional travel screening now exposes a full direction grid, blocked-direction determination, and urgent-travel exception guidance in the public output.
• Tithi observance analysis: Structural sunrise-based tithi observance analysis is now exposed explicitly as a non-festival-specific engine with Shuddha, Viddha, Kshaya, and Vriddhi-style state reporting.
• Nitya Yoga flags: Public output now exposes explicit Vyatipata / Vaidhriti style Kranti-dosha flagging and general Nitya-yoga avoidance scope.

Localization and Output Cleanup

• User-facing leak audit: English generated JSON is clean of Hindi/Gujarati display text, and Hindi/Gujarati generated JSON is clean of English display text for audited user-facing fields.
• Localized new sections: Newly added or modified user-facing fields in the rule-engine outputs are localized across English, Hindi, and Gujarati, including Panchak weekday labels, dosha display labels, parana labels, and shared fallback phrases.
• Translation-first English labels: Where practical, newly added English-facing labels now use translation rather than transliteration.

Upgrade Notes

• Use canonical keys such as weekday_type_key, dosha_key, family_key, and related machine fields for program logic. Treat localized display fields as presentation text.
• Tithi_Observance_Analysis is a structural sunrise-tithi engine, not a complete festival-specific decision engine. Festival-specific overrides still belong to the observance rule families.
• Vrata_Parana is intentionally limited to the supported non-Ekadashi families in this release. Do not assume universal parana coverage for every vrata family.

v9.1.0 Upgrade & Release Notes

Backward-compatible feature release focused on selective Hindu calendar period windows and a Purnimanta intercalary month-window correction.

Added

• Dedicated calendar-period selective API: Added getCalendarPeriodWindowsRange() for month-range period windows without generating full daily month rows.
• Selectable calendar period fields: Consumers can request only the period branches they need: ayana, ritu, vikram_samvat, gujarati_samvat, saka_samvat, kali_samvat, samvatsara, samvatsara_north, amanta_month, and purnimanta_month.
• Lean output contract: Period windows expose only name, start_iso, and end_iso. Amanta and Purnimanta month windows additionally expose index.

Fixed

• Purnimanta intercalary month windows: Purnimanta month-window labels now preserve the intercalary suffix where applicable. For example, the 2026 repeated Jyeshtha period is returned as Jyeshtha (Intercalary) followed by normal Jyeshtha.

Upgrade Notes

• Use getCalendarPeriodWindowsRange() when your API or UI needs only period windows such as Ayana, Ritu, Samvat, or lunar month ranges.
• Use getMonthFields() or getMonthRangeFields() when you need daily calendar cells. Calendar-period windows are intentionally separate from daily month rows.
• If you cached Purnimanta month-window output generated before v9.1.0, regenerate it for ranges containing adhik months.

v9.0.0 Upgrade & Release Notes

Major release focused on verified Hindu Panchang conventions, Nirnay-rule festival decisions, eclipse ritual thresholds, Ekadashi parana restrictions, localized generated output, and regenerated 2026-2032 JSON artifacts.

Verified Engine Conventions

• Ayanamsa: Panchanga limb calculations continue to use Lahiri / Chitra Paksha via JME_SIDEREAL_LAHIRI; the package does not switch Panchanga limbs to dynamic True Citra.
• Sunrise and sunset: Rise/set calculations use visible upper limb with standard atmospheric refraction, standard pressure, and standard temperature.
• Panchanga Moon: Tithi, Nakshatra, Yoga, Karana, moon sign, and transition searches use geocentric sidereal Sun/Moon longitudes. Moonrise/moonset remains topocentric for the observer location.
• Moonrise/moonset daily semantics: The civil-day moon visibility interval starts only from a moonrise inside that civil date. If no moonrise occurs inside the date, both moonrise and moonset are returned as null for that daily output.
• Panchang day boundary: Daily Panchang decisions continue to use sunrise-to-next-sunrise boundaries, with runtime/current-at-input fields exposed separately where applicable.
• Prahar and Brahma Muhurta: Prahars are variable day/night quarters, and Brahma Muhurta follows the dynamic night-muhurta convention.

Nirnay and Festival Rule Improvements

• Vaishnava Ekadashi: Dashami-vedha handling uses the 55-ghatika threshold from the previous sunrise for Nirnay-style Vaishnava decisions.
• Hari Vasara and Parana: Parana starts after the first quarter of Dwadashi and now exposes restricted and allowed windows. Gujarati/Nirnay month-paksha restrictions block Ashadha Shukla Anuradha pada 1, Bhadrapada Shukla Shravana padas 2-3, and Kartika Shukla Revati pada 4. The public payload now also distinguishes ordinary Tithyavasara parana from nakshatra-restricted Harivasara style resolution and exposes the first-six-ghaṭikā daytime preference when Dwadashi continues past Madhyahna.
• Festival karmakala engine: Pradosha, Nishitha, Madhyahna, Aparahna, Sangava, Arunodaya, and Vijaya Kaal decisions use window overlap and coverage metadata instead of only single-point matching.
• Holika Dahan: Bhadra Mukha/Madhya rejection, Bhadra Puchha preference, lunar-eclipse exception logic, and Purnima-in-Pradosha requirements are implemented in the decision engine.
• Major truth tables: Janmashtami, Mahashivaratri, Vijayadashami, and Govatsa Dwadashi now use dedicated decision branches with tie-breakers and fallback handling encoded in the engine.
• Deepotsav sequence: Vagh Baras, Dhanteras, Naraka Chaturdashi Abhyanga Snan, Kali Chaudas, Diwali/Kali Puja, Govardhan/Annakut, and Bhai Beej expose sequence metadata; location-sensitive observances are marked accordingly.
• Specific corrected observances: Pausha Purnima Vrat uses the labeled sunrise-based vrat day, Mahavir Jayanti uses Chaitra Shukla Trayodashi at sunrise, Samavedi Shravani consolidates to the best annual Hasta/Aparahna observance, and Phuldolotsava is marked as a Swaminarayan/BAPS sect-specific tithi observance.

Eclipse and Ritual Visibility Updates

• Ritual minimums: Lunar ritual minimum is umbral magnitude >= 0.0625; solar ritual minimum is local/eclipse disk magnitude >= 0.083333....
• Sutak gating: Sutak is not applicable when the eclipse is not ritually visible at the configured location.
• Dynamic sutak windows: Lunar sutak uses a 3-prahar lookback and solar sutak uses a 4-prahar lookback, anchored to local variable prahar divisions.
• Ritual classification: Eclipse output includes local visibility classification, Grast Uday/Grast Ast status, telescope-only status, and post-eclipse bath/fresh-food guidance where applicable.

Localization and Documentation

• Hindi/Gujarati output cleanup: User-facing generated JSON was scanned for cross-language leakage. English output is clean of Hindi/Gujarati display text, Hindi output is clean of English/Gujarati display text, and Gujarati output is clean of English/Hindi display text for audited user-facing fields.
• Localized aliases and decision reasons: Added missing display translations for Deepotsav aliases, Purnima vrat aliases, Phuldol labels, deity composites, festival descriptions, karmakala names, and rule-decision reasons.
• Traditional source docs: The traditional-source documentation now includes the current engine convention matrix, verified Nirnay decisions promoted to code, and the expanded traditional/source-family reference list.

Upgrade Notes

• Do not compare v9 generated yearly JSON against v8 by expecting identical dates or identical localized strings. Rebaseline festival, vrat, eclipse, and daily output snapshots after upgrading.
• Use canonical IDs, keys, or *_key fields for application logic. Treat localized display fields as presentation text that can change when translations are corrected.
• Review any client logic that assumes visible, sutak.applicable, or meets_ritual_minimum can be interpreted independently. In v9 ritual eclipse handling is intentionally gated by local visibility and magnitude threshold.
• Review any UI copy or tests that assume civil-day moonset appears without a same-day moonrise. The daily output intentionally returns a visibility interval beginning with a moonrise inside the date.

v8.4.0 Upgrade & Release Notes

Minor release focused on exact month-range selective generation across month calendars, festivals, vrats, and eclipses.

Added and Improved

• Exact month-range selective month generation: Consumers can now request only the months they need instead of looping externally and assembling the range themselves.
• Exact month-range selective festival and vrat generation: Festival and vrat range requests now calculate only the requested bounded window rather than generating full surrounding years and filtering afterward.
• Exact month-range selective eclipse generation: Eclipse range requests now support direct date-range generation instead of relying only on year-bucket generation.
• Range-aware observance consolidation: Multi-year range output now preserves yearly observances correctly without collapsing independent observances from different years together.

Upgrade Notes

• Use the new range-selective APIs when your application needs a bounded span such as October 2026 through August 2028.
• The new range APIs are designed to avoid full-year overcompute. They calculate the requested span, with only minimal boundary support needed for correct observance resolution.
• Existing yearly and single-month APIs remain available for current integrations.

v8.3.0 Upgrade & Release Notes

Minor release focused on true selective yearly observance generation and smaller dedicated vrat JSON artifacts.

Added and Improved

• Dedicated yearly selective outputs: Added true festival-only and vrat-only yearly generation paths instead of building the combined yearly observance payload first and slicing it afterward.
• Compact generated artifacts: Yearly generated observance files now stay focused on date-indexed consumption for app and API use.
• Smaller vrat payloads: Repeated weekday vrats such as Monday, Friday, and Saturday fasts are stored once under a recurring block and no longer inflate the dated vrat list.
• Consistent raw output: The yearly festival branch embedded in raw output now follows the same compact by-date contract as the standalone generated festival file.

Upgrade Notes

• If your app was reading the generated yearly flat branch from festival or vrat JSON files, switch to the selective runtime APIs for flat output or update the client to consume the dated contract.
• If your app displays weekday-recurring vrats from the dedicated vrat file, read them from recurring_weekday_vrats instead of expecting them to be repeated inside by_date.
• Regenerate stored yearly observance files after upgrading so the compact structure is applied consistently.

v8.2.1 Upgrade & Release Notes

Patch release focused on localized label corrections, generated output cleanup, and documentation alignment.

Localization and Output Corrections

• User-facing labels: Corrected localized display labels in generated output so month and daily calendar data read naturally in supported languages.
• Composed labels: Corrected generated Nakshatra Pada labels in localized month output so runtime-composed names match the selected locale cleanly.
• Output consistency: Refreshed generated JSON so corrected localized labels appear consistently across daily, month, festival, eclipse, and raw output files.
• Documentation sync: Updated release notes and related documentation to match the current output behavior.

v8.2.0 Upgrade & Release Notes

High-precision update focused on eclipse obscuration accuracy and JME/JPL data structure alignment.

Eclipse Precision Improvements

• New Geometric Engine: Implemented calculateSolarObscuration() using the standard geometric formula for the intersection of two circles to provide authentic area-based coverage metrics.
• JME/JPL Data Mapping: Corrected the interpretation of the JME attr[] array. Sun and Moon diameters are now correctly converted from arcseconds to degrees before calculating the overlap.
• Annular Eclipse Support: Added specific handling for annular phases where the Moon is entirely within the Sun's disk, ensuring area coverage reflects the ratio of the Moon's disk area to the Sun's disk area.
• DE440 Validation: Verified contact times and magnitudes against NASA and PIB benchmarks for high-precision DE440/JPL mode configurations.
• Numerical Stability: Added guards for trigonometric domain limits to prevent NaN results during extreme partial eclipse phases.

v8.1.0 Upgrade & Release Notes

Backward-compatible feature release focused on selective APIs and modular output generation.

Added Selective APIs

• Daily selective details: Added getSelectedDetails() to calculate only requested day-detail sections instead of building the full getDayDetails() payload.
• Daily convenience methods: Added getBasicDetails(), getPanchanga(), getSpecialYogas(), getMuhurtaFullDay(), getAbhijitMuhurta(), getVarjyam(), getDharmaSindhu(), and getSection().
• Panchanga limb methods: Added getTithi(), getCurrentTithi(), getNakshatra(), getCurrentNakshatra(), getYoga(), getCurrentYoga(), getKarana(), getCurrentKarana(), and getVara().
• Dot-path field picker: Added getFields() for returning only specific nested values such as Panchanga.Current_Tithi_At_Input_Now.name.
• Month field groups: Added getMonthFields() with selectable groups for tithi, nakshatra, yoga, karana, vara, sun, moon, hindu_calendar, and festivals.
• Today output branches: Added generateTodaySelected() for selecting todays_complete_details and/or muhurta_evaluation.
• Festival output branches: Added generateFestivalsSelected(), generateFestivalByDate(), and generateFestivalFlat().
• Eclipse output branches: Added generateEclipsesSelected(), generateEclipseByYear(), and generateEclipseFlat().
• Month output branches: Added generateMonthSelected() and generateMonthCalendarFields().

Behavior and Parity

• Selective daily sections are designed to avoid calculating unrelated heavy branches while still running shared base dependencies when required.
• Selective values were tested against the original full outputs for exact equality, including JSON-equivalent structure and values.
• Month selected output preserves the same canonical field order as getMonthCalendar() when all groups are requested.
• Festival resolution is skipped in month field generation unless the festivals group is requested.

Documentation

• Added selective API reference entries for all new service and output-generator methods.
• Updated usage patterns to prefer selective APIs for small reads and added sample output comments.
• Updated examples to match current localized English/Hindi/Gujarati display strings from Localization.php.

v8.0.0 Upgrade & Release Notes

Major release focused on clearer calendar output, richer month-view data, better English-facing labels, and first-class moon phase information for daily and monthly Panchang use.

Added Features & Improvements

• Moon Phase Output:
  • Added moon phase information to daily Panchang and month calendar output.
  • Moon phase output now includes visual phase name, visibility guidance, illumination range, illumination percentage, and lunar age.
  • Moon phase is now treated as its own first-class output instead of being left for client apps to infer.
• Month Calendar Improvements:
  • Added compact Tithi display support for month cells.
  • Added explicit metadata for skipped or compressed Tithi cases.
  • Added richer timing information for intra-day Nakshatra, Yoga, Karana, and related transitions so calendar UIs can show day-level changes more accurately.
• English Output Refresh:
  • Improved English-facing labels so user-facing output feels more natural in apps and websites.
  • Kept traditional Panchang terms where transliteration remains the clearer and more accurate choice.

Fixed Issues

• Corrected compact month-calendar Tithi display for skipped-Tithi cases such as 30/1.
• Corrected English label consistency across generated outputs.
• Corrected related generated output paths so the refreshed labels and richer calendar fields appear consistently.

v7.0.2 Upgrade & Release Notes

A backward-compatible patch release that fixes a Brahma Muhurta calculation issue during daily Panchang generation.

Fixes

• Fixed a Brahma Muhurta calculation issue that could cause daily Panchang generation to fail before sunrise.
• The previous sunset is now matched to the actual sunrise being used, preventing invalid night-duration calculations during JSON regeneration.

v7.0.1 Upgrade & Release Notes

A backward-compatible update modifying 2 core PHP files (Localization.php and FestivalService.php) to refine regional translation formatting and consolidate festival calculation rules.

Core Updates

• Localization Formatting (Localization.php):
  • Standardised Hindi standard names, descriptions, deities, and sources to use native Devanagri numerals (१, २, ३...) while keeping dynamic format parameters intact.
  • Standardised Gujarati translation names and descriptions to use native Gujarati numerals (૧, ૨, ૩...).
  • Added missing Hindi (पोंगल) and Gujarati (પોંગલ) translations for Pongal.
  • Ensured clean, unique translation key registration across all supported locales.
• Festival Calculations (FestivalService.php):
  • Consolidated Shakambhari Purnima under Pausha Purnima.
  • Refactored Pradosh Vrat to resolve dynamically based on the weekday (e.g., calculating names like Shani Pradosh Vrat, weekday-specific descriptions, and deities dynamically) instead of hardcoding multiple redundant entries.
  • Clarified public observance totals as 326 unique festival identities and 90 unique vrat identities.

v7.0.0 Upgrade & Release Notes

Major release focused on improving Panchang clarity, Muhurta accuracy, festival coverage, eclipse handling, and overall timing precision. Several areas now follow more precise Panchang conventions, and many outputs have clearer meanings and improved consistency.

Added Features & Improvements

• Panchanga & Muhurta Improvements:
  • Clear sunrise-versus-current Panchanga values for Tithi, Karana, and Yoga.
  • Dedicated current-time transition information so it is easier to identify what is active at the calculation time.
  • Dynamic Brahma Muhurta output while still preserving the traditional fixed 48-minute reference.
  • Independent Varjyam and Amrita Kaal windows with clearer and more accurate timing boundaries.
  • Improved Lagna day coverage with partial interval handling.
  • Clearer Panchaka Rahita output separating sunrise calculations from current-time calculations.
  • Richer Panchanga transition details for Tithi, Nakshatra, Nakshatra Pada, Yoga, and Karana.
• Eclipse Improvements:
  • Added separate global and local eclipse classifications.
  • Improved location-aware eclipse visibility handling.
  • Improved eclipse visibility consistency across different locations.
• Festival Expansion:
  • Expanded built-in observance coverage to 326 unique festival identities and 90 unique vrat identities with broader regional and traditional observance support.
  • Added support for many regional festival naming conventions and aliases.
  • Improved handling for regional observances such as Uttarayan, Pongal, Maghi, Til Sankranti, Khichdi, Ghughuti, Sakraat, Thiruvadhirai, Arudra Darshanam, and many more.
  • Improved handling for weekday-specific Pradosh observances.
  • Added smarter festival deduplication so aliases no longer appear as separate duplicate festivals.
  • Expanded festival translations and localization coverage.
  • Added additional Mahavidya worship descriptions for Magha Gupt Navaratri observances.

Fixed Issues

• Panchanga & Muhurta:
  • Corrected Amrita Kaal timing behavior.
  • Corrected Varjyam and Amrita Kaal output windows.
  • Corrected Brahma Muhurta convention handling.
  • Corrected Friday Dur Muhurta mapping.
  • Corrected Friday Rahu Vaasa direction.
  • Corrected Chandra Vaasa meaning to match directional Panchang convention.
  • Corrected Panchaka Rahita current-time behavior.
  • Corrected generated month output defaults so current month handling behaves correctly when no month is provided.
• Eclipse Handling:
  • Corrected local eclipse visibility behavior.
  • Improved local eclipse-type handling for location-specific outputs.
  • Improved eclipse ordering and visibility consistency.
• Festival Handling:
  • Improved festival alias handling and canonical naming behavior.
  • Removed duplicate regional festival outputs caused by overlapping aliases.
  • Improved festival name preference logic so more specific naming conventions are preserved when mutual aliases exist.
  • Refined festival descriptions and deity associations.
  • Merged overlapping or deprecated festival representations into cleaner canonical festival entries.

Documentation

• README is now shorter and focused on practical usage.
• HTML documentation includes updated v7.0.0 release and upgrade notes.
• API documentation has been refreshed for the updated output behavior.
• Documentation now explains sunrise-versus-current Panchanga semantics more clearly.
• Documentation now explains global-versus-local eclipse classification behavior.

Summary: This release provides clearer Panchanga timing behavior, more accurate Muhurta calculations, better eclipse visibility handling, broader regional festival support, cleaner festival naming and deduplication, richer transition and timing information, improved localization coverage, and more consistent and predictable outputs. The package now delivers a more complete and region-aware Panchanga experience while maintaining compatibility with traditional Panchang conventions.

v6.x Upgrade Notes

• Current_Tithi_At_Input_Now and Current_Karana_At_Input_Now should be used when the app needs the value active at the requested calculation time.
• Tithi and Karana remain sunrise-based compatibility fields. Prefer Tithi_At_Sunrise and Karana_At_Sunrise when sunrise semantics must be explicit.
• Moon_Phase_At_Sunrise, Current_Moon_Phase_At_Input_Now, and month-level moon_phase use exact Sun-Moon elongation and illuminated fraction. They are visual moon-phase outputs, not festival-resolution fields.
• tithi_display is the month-cell helper for UI rendering. Use it when a date can legitimately display a compact double-Tithi form such as 30/1.
• Brahma_Muhurta now exposes the dynamic night-muhurta convention by default and preserves the fixed 48-minute convention under fixed_48_minute_convention.
• Amrita_Kaal is calculated independently from nakshatra-specific Amrita ghati offsets. It is not derived from Varjyam end time.
• Day_Types.apparent_solar_noon and Abhijit_Muhurta.daylight_midpoint intentionally name two different concepts.

v5.x Upgrade Notes

• Day output includes expanded Vaasa, Shoola, moon visibility, and special yoga structures.
• Consumers should avoid strict allowlists that reject new top-level output keys.
• Mobile and static-site exports should use the generated JSON files as versioned payloads, because new fields are intentionally additive.

v4.0.0 Compatibility Notes

These notes remain important when upgrading from v3.x or older integrations.

1. Default Configuration Changes

2. Method Signature Changes

All enum getName() methods now accept an optional $locale parameter:

// v3.x
$name = Nakshatra::Ashwini->getName(); // "Ashwini"

// v4.0.0
$name = Nakshatra::Ashwini->getName();              // Uses configured locale
$name = Nakshatra::Ashwini->getName('hi');         // "अश्विनी"
$name = Nakshatra::Ashwini->getName('gu');         // "અશ્વિની"

3. Time Field Structure Changes

Sunrise, Sunset, Moonrise, and Moonset in the Panchanga output now return objects instead of strings:

// v3.x (string)
$details['Panchanga']['Sunrise']; // "06:14:00 AM"

// v4.0.0 (object)
$details['Panchanga']['Sunrise']; // ['jd' => 2461234.5, 'iso' => '2026-04-16T06:14:00+05:30', 'display' => '06:14:00 AM', 'timestamp' => 1234567890]
$details['Panchanga']['Sunrise']['display'];  // "06:14:00 AM"
$details['Panchanga']['Sunrise']['jd'];        // Julian Day
$details['Panchanga']['Sunrise']['iso'];        // ISO timestamp
$details['Panchanga']['Sunrise']['timestamp'];  // Unix timestamp

4. Enum Value Changes

5. Removed Methods

The following methods have been removed:

• Masa::getEnglishApproximation() - removed
• Masa::getRulingNakshatra() - removed
• Ritu::getEnglishName() - removed
• Ritu::getMonths() - removed
• Karana::getType() - removed
• Karana::isVishti() - removed

6. PHP 8.3+ Requirement

This package targets PHP 8.3+ and the current Composer platform config is pinned accordingly.

7. Calendar Type Parameter

Methods like getDayDetails() support an optional calendarType parameter. If omitted, the default remains CalendarType::Amanta:

// v3.x
$details = $panchang->getDayDetails($date, $lat, $lon, $tz);

// Explicit enum
$details = $panchang->getDayDetails($date, $lat, $lon, $tz, 0.0, null, CalendarType::Amanta);

// Or use string
$details = $panchang->getDayDetails($date, $lat, $lon, $tz, 0.0, null, 'amanta');
$details = $panchang->getDayDetails($date, $lat, $lon, $tz, 0.0, null, 'purnimanta');

License

Complete Public API Surface (Live from src)

This section is a direct reflection snapshot of all public methods and public constants currently declared in src/.

Use this as the definitive signature reference when integrating the package.

## JayeshMepani\PanchangCore\Astronomy\AstronomyService
- __construct(JmeEph\FFI\JmeEphFFI $jme): void
- configure(string $ephePath = ""): void
- getAscendant(array $birth): float
- getAyanamsa(float $jd): float
- getPlanets(array $birth): array
- setAyanamsa(float $jd): void
- toJulianDayUtc(array $birth): float

## JayeshMepani\PanchangCore\Astronomy\EclipseService
- __construct(JmeEph\FFI\JmeEphFFI $jme): void
- configure(string $ephePath = ""): void
- getEclipsesForYear(int $year, float $lat, float $lon, string $tz): array

## JayeshMepani\PanchangCore\Astronomy\SunService
- __construct(JmeEph\FFI\JmeEphFFI $jme): void
- configure(string $ephePath = ""): void
- getBirthDatetime(array $birth): Carbon\CarbonImmutable
- getIntervalAndStart(array $birth): array
- getMoonriseMoonset(array $birth): array
- getSolarTransits(array $birth): array
- getSunriseSunset(array $birth): array
- getTwilightTimes(array $birth): array
- isDayBirth(array $birth): bool
- jdToCarbonPublic(float $jd, string $timezone): Carbon\CarbonImmutable

## JayeshMepani\PanchangCore\Core\AstroCore
- countSigns(int $targetSign, int $startSign, bool $forward = true): int
- formatAngle(float $angle): string|float
- formatCoordinate(float $coordinate): string|float
- formatDateTime(Carbon\CarbonImmutable $time): string
- formatDuration(float $minutes): string|float
- formatTime(Carbon\CarbonImmutable $time): string
- getAngularDistance(float $a, float $b): float
- getConfig(string $key, mixed $default = null): mixed
- getHouseNumFromLagna(int $signIdx, int $ascSignIdx): int
- getSign(float $lon): int
- getSignLon(float $lon): float
- getTimeDiffMinutesPrecise(DateTimeInterface $target, DateTimeInterface $reference): float
- normalize(float $x): float
- toDms(float $deg): string

## JayeshMepani\PanchangCore\Core\Constants\ClassicalTimeConstants
const SECONDS_PER_DAY
const MINUTES_PER_DAY
const SECONDS_PER_HOUR
const MINUTES_PER_HOUR
const SECONDS_PER_MINUTE
const GHATIKA_IN_MINUTES
const GHATIKA_PER_DAY
const PALA_IN_SECONDS
const MUHURTA_IN_MINUTES
const MUHURTA_PER_DAY
const ARUNODAYA_MINUTES
const ARUNODAYA_PER_DAY
const PRADOSHA_GHATIKAS
const PRADOSHA_MINUTES
const PRADOSHA_PER_DAY
const BRAHMA_MUHURTA_MINUTES
const BRAHMA_MUHURTA_OFFSET_MINUTES
const PRATAH_SANDHYA_BEFORE_SUNRISE_GHATIKAS
const PRATAH_SANDHYA_AFTER_SUNRISE_GHATIKAS
const MADHYAHNA_SANDHYA_HALF_GHATIKAS
const SAYAM_SANDHYA_BEFORE_SUNSET_GHATIKAS
const SAYAM_SANDHYA_AFTER_SUNSET_GHATIKAS
const DEGREES_PER_SIGN
const DEGREES_PER_NAKSHATRA
const DEGREES_PER_TITHI
const TITHIS_PER_PAKSHA
const NAKSHATRAS_TOTAL
const SIGNS_TOTAL
const CIRCLE_DEGREES
const JD_EPSILON
const BINARY_SEARCH_ITERATIONS
const DEGREE_EPSILON
const JUPITER_CYCLE_YEARS
const KALI_ERA_OFFSET
const VIKRAMA_ERA_OFFSET
const SHAKA_ERA_OFFSET
const BHADRA_TITHIS
const EKADASHI_TITHI
const CHATURDASHI_TITHI
const PURNIMA_TITHI
const SCORE_TITHI_AT_KARMAKALA
const SCORE_TITHI_AT_SUNRISE
const SCORE_TITHI_DURING_DAY
const SCORE_TITHI_DURING_NIGHT
const SCORE_WEEKDAY_MATCH
const SCORE_NAKSHATRA_MATCH
const SCORE_VRIDDHI_FIRST_DAY
const SCORE_KSHAYA_PENALTY

## JayeshMepani\PanchangCore\Core\Enums\CalendarType
const Amanta
const Purnimanta
- cases(): array
- from(string|int $value): static
- getLocalizedName(string $locale = null): string
- isAmanta(): bool
- isPurnimanta(): bool
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Choghadiya
const Udveg
const Chal
const Labh
const Amrit
const Kaal
const Shubh
const Rog
- cases(): array
- from(string|int $value): static
- fromTime(float $jdSunrise, float $jdSunset, float $jdCurrent, JayeshMepani\PanchangCore\Core\Enums\Vara $vara): self
- getDaySequence(JayeshMepani\PanchangCore\Core\Enums\Vara $vara): array
- getName(string $locale = null): string
- getNature(): string
- getNightSequence(JayeshMepani\PanchangCore\Core\Enums\Vara $vara): array
- isAuspicious(): bool
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Hora
const Sun
const Venus
const Mercury
const Moon
const Saturn
const Jupiter
const Mars
- cases(): array
- from(string|int $value): static
- getName(string $locale = null): string
- getSequence(JayeshMepani\PanchangCore\Core\Enums\Vara $vara): array
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Karana
const Bava
const Balava
const Kaulava
const Taitila
const Gara
const Vanija
const Vishti
const Shakuni
const Chatushpada
const Naga
const Kintughna
- cases(): array
- from(string|int $value): static
- fromTithi(int $tithiIndex, float $fraction): self
- getFromLongitudes(float $sunLon, float $moonLon): array
- getName(string $locale = null): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Masa
const Chaitra
const Vaishakha
const Jyeshtha
const Ashadha
const Shravana
const Bhadrapada
const Ashvina
const Kartika
const Margashirsha
const Pausha
const Magha
const Phalguna
- cases(): array
- from(string|int $value): static
- fromAmantaIndex(int $index): self
- fromIndex(int $index): self
- fromSunLongitude(float $sunLon): self
- getName(string $locale = null): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Muhurta
const Rudra
const Ahi
const Mitra
const Pitri
const Vasu
const Udaka
const Vishvedeva
const Vidhatr
const Brahma
const Indra
const Indragni
const Nirriti
const Toyapa
const Aryaman
const Bhaga
const Isha
const Ajapada
const Ahirbudhnya
const Pusha
const Ashvini
const Yama
const Vahni
const Dhatr
const Chandra
const Aditi
const Ijya
const Vishnu
const Arka
const Tvashtr
const Vayu
- cases(): array
- from(string|int $value): static
- getDaySequence(): array
- getName(string $locale = null): string
- getNightSequence(): array
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Nakshatra
const Ashwini
const Bharani
const Krittika
const Rohini
const Mrigashira
const Ardra
const Punarvasu
const Pushya
const Ashlesha
const Magha
const PurvaPhalguni
const UttaraPhalguni
const Hasta
const Chitra
const Swati
const Vishakha
const Anuradha
const Jyeshtha
const Mula
const PurvaAshadha
const UttaraAshadha
const Shravana
const Dhanishta
const Shatabhisha
const PurvaBhadrapada
const UttaraBhadrapada
const Revati
- cases(): array
- from(string|int $value): static
- fromLongitude(float $longitude): self
- getDeity(): string
- getLongitudeRange(): array
- getName(string $locale = null): string
- getPada(float $longitude): int
- getRulingPlanet(): string
- getSymbol(): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Paksha
const Shukla
const Krishna
- cases(): array
- containsTithi(int $tithiIndex): bool
- from(string|int $value): static
- getDescription(): string
- getName(string $locale = null): string
- getRawName(): string
- getTithiRange(): array
- isKrishna(): bool
- isShukla(): bool
- normalizeTithi(int $tithiIndex): int
- opposite(): self
- toAbsoluteTithi(int $normalizedTithi): int
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Rasi
const Mesha
const Vrishabha
const Mithuna
const Karka
const Simha
const Kanya
const Tula
const Vrischika
const Dhanu
const Makara
const Kumbha
const Meena
- cases(): array
- from(string|int $value): static
- fromLongitude(float $longitude): self
- getElement(): string
- getEnglishName(): string
- getLongitudeRange(): array
- getName(string $locale = null): string
- getRulingPlanet(): string
- getSymbol(): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Ritu
const Vasanta
const Grishma
const Varsha
const Sharad
const Hemanta
const Shishira
- cases(): array
- from(string|int $value): static
- fromMonth(int $monthIndex): self
- fromSunLongitude(float $sunLon): self
- getName(string $locale = null): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Samvatsara
const Prabhava
const Vibhava
const Shukla
const Pramoda
const Prajapati
const Angirasa
const Srimukha
const Bhava
const Yuva
const Dhata
const Ishvara
const Bahudhanya
const Pramathi
const Vikrama
const Vrisha
const Chitrabhanu
const Svabhanu
const Tarana
const Parthiva
const Vyaya
const Sarvajit
const Sarvadhari
const Virodhi
const Vikriti
const Khara
const Nandana
const Vijaya
const Jaya
const Manmatha
const Durmukhi
const Hevilambi
const Vilambi
const Vikari
const Sharvari
const Plava
const Shubhakritu
const Shobhakritu
const Krodhi
const Vishvavasu
const Parabhava
const Plavanga
const Kilaka
const Saumya
const Sadharana
const Virodhikritu
const Paritapi
const Pramadi
const Ananda
const Rakshasa
const Nala
const Pingala
const Kalayukti
const Siddharthi
const Raudri
const Durmati
const Dundubhi
const Rudhirodgari
const Raktakshi
const Krodhana
const Akshaya
- cases(): array
- from(string|int $value): static
- fromGregorianYear(int $gregorianYear): self
- fromYear(int $year): self
- getName(string $locale = null): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Tithi
const ShuklaPratipada
const ShuklaDwitiya
const ShuklaTritiya
const ShuklaChaturthi
const ShuklaPanchami
const ShuklaShashthi
const ShuklaSaptami
const ShuklaAshtami
const ShuklaNavami
const ShuklaDashami
const ShuklaEkadashi
const ShuklaDwadashi
const ShuklaTrayodashi
const ShuklaChaturdashi
const Purnima
const KrishnaPratipada
const KrishnaDwitiya
const KrishnaTritiya
const KrishnaChaturthi
const KrishnaPanchami
const KrishnaShashthi
const KrishnaSaptami
const KrishnaAshtami
const KrishnaNavami
const KrishnaDashami
const KrishnaEkadashi
const KrishnaDwadashi
const KrishnaTrayodashi
const KrishnaChaturdashi
const Amavasya
- cases(): array
- from(string|int $value): static
- fromLongitudes(float $sunLon, float $moonLon): self
- getFractionRemaining(float $sunLon, float $moonLon): float
- getName(string $locale = null): string
- getNormalizedIndex(): int
- getPaksha(): JayeshMepani\PanchangCore\Core\Enums\Paksha
- isChaturdashi(): bool
- isEkadashi(): bool
- isPurnimaOrAmavasya(): bool
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Vara
const Sunday
const Monday
const Tuesday
const Wednesday
const Thursday
const Friday
const Saturday
- cases(): array
- from(string|int $value): static
- fromDayOfWeek(int $dayOfWeek): self
- fromJulianDay(float $jd): self
- getEnglishName(): string
- getName(string $locale = null): string
- getRulingPlanet(): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\VimshottariDasha
const Sun
const Moon
const Mars
const Rahu
const Jupiter
const Saturn
const Mercury
const Ketu
const Venus
- cases(): array
- from(string|int $value): static
- fromNakshatra(JayeshMepani\PanchangCore\Core\Enums\Nakshatra $nakshatra): self
- getDashaYears(): int
- getName(string $locale = null): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Enums\Yoga
const Vishkumbha
const Priti
const Ayushman
const Saubhagya
const Shobhana
const Atiganda
const Sukarma
const Dhriti
const Shula
const Ganda
const Vriddhi
const Dhruva
const Vyaghata
const Harshana
const Vajra
const Siddhi
const Vyatipata
const Variyana
const Parigha
const Shiva
const Siddha
const Sadhya
const Shubha
const Shukla
const Brahma
const Indra
const Vaidhriti
- cases(): array
- from(string|int $value): static
- fromLongitudes(float $sunLon, float $moonLon): self
- getFractionRemaining(float $sunLon, float $moonLon): float
- getName(string $locale = null): string
- tryFrom(string|int $value): static

## JayeshMepani\PanchangCore\Core\Localization
- translate(string $type, string|int $key, string $locale = null): string

## JayeshMepani\PanchangCore\Facades\Panchang

## JayeshMepani\PanchangCore\Festivals\FestivalFamilyOrchestrator
const FESTIVAL_FAMILIES
const EXCEPTION_LOGIC
- resolveFestivalFamily(string $familyName, array $baseDate, array $panchangData, string $tradition = null, string $region = null): array

## JayeshMepani\PanchangCore\Festivals\FestivalRuleEngine
- annotateMonthAnomalies(array $dateToDetails): array
- resolveMajorFestival(string $festivalName, array $rule, Carbon\CarbonImmutable $date, array $today, array $tomorrow): array
- resolveNakshatraBasedFestival(string $festivalName, array $rule, Carbon\CarbonImmutable $date, array $today, array $tomorrow): array

## JayeshMepani\PanchangCore\Festivals\FestivalService
const TITHI_VRATAS
const FESTIVALS
const MONTHS
- __construct(JayeshMepani\PanchangCore\Festivals\FestivalRuleEngine $ruleEngine): void
- buildFestivalPayload(string $name, array $rules, array $resolved = null): array
- getDailyObservances(array $panchangDetails): array
- getFestivalsForYear(int $year, string $pakshaSystem = "Amanta"): array
- resolveFestivalsForDate(Carbon\CarbonImmutable $date, array $todayDetails, array $tomorrowDetails, array $yesterdayDetails = null, callable $fetchHistoricalSnapshot = null, bool $includeExtraWinners = false): array
- usesClassicalResolver(array $rules): bool

## JayeshMepani\PanchangCore\Festivals\Utils\BhadraEngine
- calculateBhadra(float $sunriseJd, float $vishtiStartJd, float $vishtiEndJd, int $moonRasiIndex, int $tithiIndex, string $paksha): array

## JayeshMepani\PanchangCore\PanchangServiceProvider
- boot(): void
- register(): void

## JayeshMepani\PanchangCore\Panchanga\ElectionalEvaluator
- calculateAbhijitCancellation(float $sunrise, float $sunset, int $varaNumber, float $currentTime): array
- calculateAmritaKaal(int $varaNumber, float $sunrise, float $sunset, float $nextSunrise, float $currentTime): array
- calculateBhadra(int $moonSignIdx): array
- calculateDagdhaTithi(int $tithiNumber, int $moonSignIdx): array
- calculateDagdhaYoga(int $varaNumber, int $tithiNumber): array
- calculatePanchakaDosha(int $tithiNumber, int $varaNumber, int $nakshatraNumber, int $lagnaNumber): array
- calculateRiktaTithi(int $tithiNumber, bool $isKrishnaPaksha): array
- calculateTransitMoorthy(string $nakshatraName): array
- calculateVarjyam(int $nakshatraNumber, float $nakshatraStartTime, float $nakshatraDurationMinutes): array
- generateRejectionReport(array $evaluationResults): array

## JayeshMepani\PanchangCore\Panchanga\ElectionalRuleBook
const UNIVERSAL_BAD_TITHIS
const UNIVERSAL_BAD_CHOGADIYA
const UNIVERSAL_GOOD_CHOGADIYA
const UNIVERSAL_GOOD_HORAS
const UNIVERSAL_BAD_YOGAS
const UNIVERSAL_GOOD_KARANAS
const UNIVERSAL_BAD_KARANAS
const COMBUSTION_ORBS
const COMBUSTION_ORBS_RETRO
const VARA_TITHI_YOGAS

## JayeshMepani\PanchangCore\Panchanga\KalaNirnayaEngine
const GHATI_IN_MINUTES
const PALA_IN_SECONDS
const GHATIKA_PER_DAY
const ARUNODAYA_GHATIKAS
const ARUNODAYA_MINUTES
const SANKRANTI_PUNYA_KAAL
const TITHI_NAMES
const FESTIVAL_RULES
- __construct(float $latitude, float $longitude): void
- calculatePunyaKaal(string $sankrantiName, float $sankrantiJd, float $sunriseJd, float $sunsetJd, float $nextSunriseJd): array
- configure(string $ephePath = ""): void
- determineEkadashi(float $ekadashiStartJd, float $ekadashiEndJd, float $dashamiEndJd, float $dvadashiStartJd, float $sunriseJd, float $nextSunriseJd, string $tradition = "Vaishnava"): array
- determineViddhaTithi(int $tithiNumber, float $tithiStartJd, float $tithiEndJd, float $sunriseDay1Jd, float $sunriseDay2Jd, float $prevTithiEndJd): array
- generateKalaNirnayaReport(int $tithiNumber, float $tithiStartJd, float $tithiEndJd, float $prevTithiEndJd, float $sunriseJd, float $sunsetJd, float $nextSunriseJd): array
- resolveFestivalDate(string $festivalName, float $tithiStartJd, float $tithiEndJd, float $sunriseJd, float $sunsetJd, float $nextSunriseJd): array

## JayeshMepani\PanchangCore\Panchanga\MuhurtaService
- __construct(JayeshMepani\PanchangCore\Muhurta\Planetary\HoraCalculator $horaCalculator, JayeshMepani\PanchangCore\Muhurta\Planetary\ChogadiyaCalculator $chogadiyaCalculator, JayeshMepani\PanchangCore\Muhurta\Classical\DailyPeriodsCalculator $dailyPeriodsCalculator, JayeshMepani\PanchangCore\Muhurta\Classical\InauspiciousPeriodsCalculator $inauspiciousPeriodsCalculator, JayeshMepani\PanchangCore\Muhurta\Regional\GowriPanchangamCalculator $gowriPanchangamCalculator, JayeshMepani\PanchangCore\Muhurta\Lagna\LagnaTableCalculator $lagnaTableCalculator): void
- calculateAbhijitMuhurta(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset): array
- calculateAmritaKaal(Carbon\CarbonImmutable $sunrise, array $varjyam): array
- calculateBadTimes(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, int $varaIdx): array
- calculateBrahmaMuhurta(Carbon\CarbonImmutable $previousSunset, Carbon\CarbonImmutable $sunrise): array
- calculateChogadiya(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, Carbon\CarbonImmutable $current, int $varaIdx): array
- calculateChogadiyaTable(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, int $varaIdx): array
- calculateDaylightFivefoldDivision(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset): array
- calculateDurMuhurta(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, int $varaIdx): array
- calculateGodhuliMuhurta(Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise): array
- calculateGowriPanchangam(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, int $varaIdx): array
- calculateHora(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, Carbon\CarbonImmutable $current, int $varaIdx): array
- calculateHoraTable(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, int $varaIdx): array
- calculateKalaVela(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, int $varaIdx): array
- calculateLagna(Carbon\CarbonImmutable $current, Carbon\CarbonImmutable $sunrise, float $sunriseSunLongitude, float $ayanamsaDeg, float $lat, float $lon, JmeEph\FFI\JmeEphFFI $jme): array
- calculateLagnaTable(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, float $sunriseSunLongitude, float $ayanamsaDeg, float $lat, float $lon, JmeEph\FFI\JmeEphFFI $jme): array
- calculateMuhurtaTable(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise): array
- calculateNakshatraPeriodWindows(string $type, Carbon\CarbonImmutable $timezoneReference, int $nakshatraIndex, float $nakshatraStartJd, float $nakshatraEndJd, float $scopeStartJd, float $scopeEndJd): array
- calculateNishitaMuhurta(Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise): array
- calculatePradoshaKaal(Carbon\CarbonImmutable $sunset, int $tithiNum): array
- calculatePrahara(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise): array
- calculateSandhya(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, Carbon\CarbonImmutable $solarNoon): array
- calculateVarjyam(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset, Carbon\CarbonImmutable $nextSunrise, int $nakshatraIndex, float $nakshatraStartJd, float $nakshatraEndJd): array
- calculateVijayaMuhurta(Carbon\CarbonImmutable $sunrise, Carbon\CarbonImmutable $sunset): array

## JayeshMepani\PanchangCore\Panchanga\OutputGeneratorService
- __construct(JayeshMepani\PanchangCore\Panchanga\PanchangService $panchangService, JayeshMepani\PanchangCore\Astronomy\EclipseService $eclipseService): void
- generateAll(int $festivalYear, int $eclipseStartYear, int $eclipseEndYear, float $lat, float $lon, string $tz, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- generateEclipseByYear(int $startYear, int $endYear, float $lat, float $lon, string $tz): array
- generateEclipseFlat(int $startYear, int $endYear, float $lat, float $lon, string $tz): array
- generateEclipses(int $startYear, int $endYear, float $lat, float $lon, string $tz): array
- generateEclipsesSelected(int $startYear, int $endYear, float $lat, float $lon, string $tz, array $sections): array
- generateFestivalByDate(int $year, float $lat, float $lon, string $tz, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- generateFestivalFlat(int $year, float $lat, float $lon, string $tz, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- generateFestivals(int $year, float $lat, float $lon, string $tz, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- generateFestivalsSelected(int $year, float $lat, float $lon, string $tz, array $sections, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- generateMonthCalendarFields(int $year, int $month, float $lat, float $lon, string $tz, array $calendarFields, float $elevation = 0, array $options = [], Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- generateMonthSelected(int $year, int $month, float $lat, float $lon, string $tz, array $sections, array $calendarFields, float $elevation = 0, array $options = [], Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- generateTodayPanchang(float $lat, float $lon, string $tz, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- generateTodaySelected(float $lat, float $lon, string $tz, array $sections, array $detailSections = ["Basic_Details"], float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array

## JayeshMepani\PanchangCore\Panchanga\PanchangService
- __construct(JmeEph\FFI\JmeEphFFI $jme, JayeshMepani\PanchangCore\Astronomy\SunService $sunService, JayeshMepani\PanchangCore\Astronomy\AstronomyService $astronomy, JayeshMepani\PanchangCore\Panchanga\PanchangaEngine $panchanga, JayeshMepani\PanchangCore\Panchanga\MuhurtaService $muhurta, JayeshMepani\PanchangCore\Festivals\FestivalService $festivalService, JayeshMepani\PanchangCore\Festivals\Utils\BhadraEngine $bhadraEngine, mixed $unusedTransitEngine = null, mixed $unusedIntervalTracker = null, JayeshMepani\PanchangCore\Panchanga\Residences\VaasaCalculator|null $vaasaCalculator = null, JayeshMepani\PanchangCore\Panchanga\Residences\ShoolaCalculator|null $shoolaCalculator = null, JayeshMepani\PanchangCore\Panchanga\Yogas\SpecialYogaCalculator|null $specialYogaCalculator = null, JayeshMepani\PanchangCore\Panchanga\Doshas\PanchakCalculator|null $panchakCalculator = null, JayeshMepani\PanchangCore\Panchanga\Doshas\BhadraCalculator|null $bhadraCalculator = null, mixed $unusedVarjyamWindowCalculator = null, JayeshMepani\PanchangCore\Panchanga\Vrata\EkadashiParanaCalculator|null $ekadashiParanaCalculator = null, mixed ...$unusedExtractedCalculators): void
- configure(string $ephePath = ""): void
- getAbhijitMuhurta(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getBasicDetails(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getCurrentKarana(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, Carbon\CarbonImmutable $calculationAt = null, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getCurrentNakshatra(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, Carbon\CarbonImmutable $calculationAt = null, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getCurrentTithi(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, Carbon\CarbonImmutable $calculationAt = null, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getCurrentYoga(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, Carbon\CarbonImmutable $calculationAt = null, float $elevation = 0, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getDailyMuhurtaEvaluation(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, Carbon\CarbonImmutable $currentAt = null, float $elevation = 0, array $options = []): array
- getDayDetails(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getDharmaSindhu(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getElectionalSnapshot(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, array $options = []): array
- getFestivalSnapshot(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- getFestivalYearCalendar(int $year, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- getFields(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, array $fields, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getKarana(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getMonthFields(int $year, int $month, float $lat, float $lon, string $tz, array $fields, float $elevation = 0, array $options = [], Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- getMonthCalendar(int $year, int $month, float $lat, float $lon, string $tz, float $elevation = 0, array $options = [], Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta): array
- getMuhurtaFullDay(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getNakshatra(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getPanchanga(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getSection(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, string $section, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getSelectedDetails(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, array $sections, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getSpecialYogas(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getTithi(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getVara(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getVarjyam(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array
- getYoga(Carbon\CarbonImmutable $date, float $lat, float $lon, string $tz, float $elevation = 0, Carbon\CarbonImmutable $calculationAt = null, JayeshMepani\PanchangCore\Core\Enums\CalendarType|string $calendarType = JayeshMepani\PanchangCore\Core\Enums\CalendarType::Amanta, array $options = []): array

## JayeshMepani\PanchangCore\Panchanga\PanchangaEngine
- calculateKundaLagna(float $ascLon): array
- calculatePanchakaRahita(int $tithiNum, int $varaNum, int $nakNum, int $lagnaNum): array
- calculateTithi(float $sunLon, float $moonLon): array
- calculateVara(array $birth, JayeshMepani\PanchangCore\Astronomy\SunService $sunService): array
- calculateYoga(float $sunLon, float $moonLon): array
- getAyana(float $sunLon): string
- getGujaratiSamvat(int $vikramSamvat, int $monthIndex): int
- getHinduMonth(float $sunLon, float $moonLon, string $paksha = "Shukla"): array
- getKaliSamvat(int $vikramSamvat): int
- getKarana(float $sunLon, float $moonLon): array
- getNakshatraInfo(float $longitude): array
- getPanchanga(float $sunLon, float $moonLon, array $birth, JayeshMepani\PanchangCore\Astronomy\SunService $sunService, JayeshMepani\PanchangCore\Astronomy\AstronomyService $astronomy): array
- getRitu(float $sunLon): string
- getSamvat(int $year, int $month): array
- getSamvatsara(int $vikramSamvat): string
- getSamvatsaraNorth(int $vikramSamvat): string
- isVishtiKarana(float $sunLon, float $moonLon): bool

## JayeshMepani\PanchangCore\Traits\CliBootstrap
- init(string $baseDir): void
- makeEclipseService(): JayeshMepani\PanchangCore\Astronomy\EclipseService
- makeOutputGenerator(JayeshMepani\PanchangCore\Panchanga\PanchangService $panchang): JayeshMepani\PanchangCore\Panchanga\OutputGeneratorService
- makePanchangService(): JayeshMepani\PanchangCore\Panchanga\PanchangService

Quick Reference