ether-to-astro 1.2.0 → 1.3.0

package/tests/validation/fixtures/service-transits/core.ts

@@ -0,0 +1,89 @@
+import { PLANETS } from '../../../../src/types.js';
+import type { ServiceTransitFixture } from '../../utils/fixtureTypes.js';
+
+export const serviceTransitFixtures: ServiceTransitFixture[] = [
+  {
+    name: 'tokyo-local-noon-sign-carry-snapshot',
+    natalChart: {
+      name: 'Tokyo Boundary Chart',
+      latitude: 35.6762,
+      longitude: 139.6503,
+      timezone: 'Asia/Tokyo',
+      julianDayIsoUtc: '1990-06-12T03:00:00Z',
+      houseSystem: 'P',
+      planetOffsets: [
+        {
+          transitingPlanetId: PLANETS.SUN,
+          natalPlanetId: PLANETS.SUN,
+          natalOffsetDegrees: 0,
+        },
+      ],
+    },
+    input: {
+      date: '2024-03-20',
+      mode: 'snapshot',
+      categories: ['personal'],
+    },
+    startupDefaults: {
+      preferredTimezone: 'UTC',
+    },
+    expected: {
+      mode: 'snapshot',
+      timezone: 'UTC',
+      calculationTimezone: 'Asia/Tokyo',
+      reportingTimezone: 'UTC',
+      windowStart: '2024-03-20',
+      windowEnd: '2024-03-20',
+      expectTransit: {
+        transitingPlanet: 'Sun',
+        natalPlanet: 'Sun',
+        aspect: 'conjunction',
+        transitSign: 'Aries',
+        transitDegree: 0,
+        natalSign: 'Aries',
+        natalDegree: 0,
+      },
+    },
+  },
+  {
+    name: 'los-angeles-to-tokyo-forecast-grouping',
+    natalChart: {
+      name: 'Pacific Forecast Chart',
+      latitude: 37.7749,
+      longitude: -122.4194,
+      timezone: 'America/Los_Angeles',
+      julianDayIsoUtc: '1990-06-12T21:35:00Z',
+      houseSystem: 'P',
+      planetOffsets: [
+        {
+          transitingPlanetId: PLANETS.SUN,
+          natalPlanetId: PLANETS.SUN,
+          natalOffsetDegrees: 0,
+        },
+      ],
+    },
+    input: {
+      date: '2024-03-26',
+      mode: 'forecast',
+      days_ahead: 1,
+      categories: ['personal'],
+    },
+    startupDefaults: {
+      preferredTimezone: 'Asia/Tokyo',
+    },
+    expected: {
+      mode: 'forecast',
+      timezone: 'Asia/Tokyo',
+      calculationTimezone: 'America/Los_Angeles',
+      reportingTimezone: 'Asia/Tokyo',
+      windowStart: '2024-03-27',
+      windowEnd: '2024-03-28',
+      forecastDays: 2,
+      expectTransit: {
+        transitingPlanet: 'Sun',
+        natalPlanet: 'Sun',
+        aspect: 'conjunction',
+      },
+    },
+  },
+];

package/tests/validation/utils/fixtureTypes.ts

@@ -1,4 +1,10 @@
-import type { PlanetName } from '../../../src/types.js';
+import type {
+  GetElectionalContextInput,
+  GetRisingSignWindowsInput,
+  GetTransitsInput,
+} from '../../../src/astro-service/service-types.js';
+import type { McpStartupDefaults } from '../../../src/entrypoint.js';
+import type { HouseSystem, PlanetName } from '../../../src/types.js';
 
 export interface NormalizedBody {
   body: PlanetName | string;
@@ -44,6 +50,70 @@ export interface NormalizedEclipse {
   maxTime: string;
 }
 
+export interface NormalizedElectionalContext {
+  houseSystem: string;
+  classification: 'day' | 'night';
+  isDayChart: boolean;
+  sunAltitudeDegrees: number;
+  rawSunAltitudeDegrees: number;
+  sunAltitudeDisplaysZero: boolean;
+  warnings: string[];
+  hasApplyingAspects: boolean;
+  applyingAspectCount: number;
+  hasMoonApplyingAspects: boolean;
+  moonApplyingAspectCount: number;
+  hasRulerBasics: boolean;
+}
+
+export interface NormalizedRisingSignWindow {
+  sign: string;
+  start: string;
+  end: string;
+  durationMs: number;
+}
+
+export interface NormalizedRisingSignWindowResult {
+  date: string;
+  timezone: string;
+  mode: 'approximate' | 'exact';
+  windows: NormalizedRisingSignWindow[];
+}
+
+export interface NormalizedServiceTransit {
+  transitingPlanet: string;
+  natalPlanet: string;
+  aspect: string;
+  orb: number;
+  exactTime?: string;
+  exactTimeStatus?: 'within_preview' | 'outside_preview' | 'not_found' | 'unsupported_body';
+  isApplying: boolean;
+  transitSign?: string;
+  transitDegree?: number;
+  transitHouse?: number;
+  natalSign?: string;
+  natalDegree?: number;
+  natalHouse?: number;
+}
+
+export interface NormalizedServiceTransitForecastDay {
+  date: string;
+  transits: NormalizedServiceTransit[];
+}
+
+export interface NormalizedServiceTransitResult {
+  mode?: 'snapshot' | 'best_hit' | 'forecast';
+  modeSource?: 'legacy_default' | 'explicit';
+  date?: string;
+  timezone: string;
+  calculationTimezone?: string;
+  reportingTimezone?: string;
+  daysAhead?: number;
+  windowStart?: string;
+  windowEnd?: string;
+  transits?: NormalizedServiceTransit[];
+  forecast?: NormalizedServiceTransitForecastDay[];
+}
+
 export interface PositionFixture {
   name: string;
   isoUtc: string;
@@ -144,3 +214,71 @@ export interface AstrologEdgeParityFixture {
   timezone?: string;
   disambiguation?: 'compatible' | 'earlier' | 'later' | 'reject';
 }
+
+export interface ElectionalFixture {
+  name: string;
+  input: GetElectionalContextInput;
+  expected: {
+    classification: 'day' | 'night';
+    isDayChart: boolean;
+    houseSystem?: string;
+    rawSunAltitudeSign?: 'positive' | 'negative' | 'zero';
+    sunAltitudeDisplaysZero?: boolean;
+    warningsContain?: string[];
+    hasApplyingAspects?: boolean;
+    hasMoonApplyingAspects?: boolean;
+    hasRulerBasics?: boolean;
+  };
+}
+
+export interface RisingSignWindowsFixture {
+  name: string;
+  input: GetRisingSignWindowsInput;
+  expectedTotalDurationMinutes: number;
+  minWindows?: number;
+  expectOffsetChange?: boolean;
+}
+
+export interface RisingSignModeComparisonFixture {
+  name: string;
+  baseInput: Omit<GetRisingSignWindowsInput, 'mode'>;
+}
+
+export interface ServiceTransitNatalFixture {
+  name: string;
+  latitude: number;
+  longitude: number;
+  timezone: string;
+  julianDayIsoUtc: string;
+  houseSystem?: HouseSystem;
+  planetOffsets: Array<{
+    transitingPlanetId: number;
+    natalPlanetId: number;
+    natalOffsetDegrees: number;
+  }>;
+}
+
+export interface ServiceTransitFixture {
+  name: string;
+  natalChart: ServiceTransitNatalFixture;
+  input: GetTransitsInput;
+  startupDefaults?: McpStartupDefaults;
+  expected: {
+    mode: 'snapshot' | 'best_hit' | 'forecast';
+    timezone: string;
+    calculationTimezone: string;
+    reportingTimezone: string;
+    windowStart?: string;
+    windowEnd?: string;
+    forecastDays?: number;
+    expectTransit: {
+      transitingPlanet: string;
+      natalPlanet: string;
+      aspect: string;
+      transitSign?: string;
+      transitDegree?: number;
+      natalSign?: string;
+      natalDegree?: number;
+    };
+  };
+}

package/tests/validation/validation.spec.ts

@@ -4,9 +4,15 @@ import { localToUTC } from '../../src/time-utils.js';
 import { PLANETS, type PlanetPosition } from '../../src/types.js';
 import { getAstrologHouses, getAstrologPositions, probeAstrolog } from './adapters/astrolog.js';
 import { InternalValidationAdapter } from './adapters/internal.js';
+import { compareElectionalContext } from './compare/electional.js';
 import { compareHouses } from './compare/houses.js';
 import { comparePositions } from './compare/positions.js';
+import {
+  compareRisingSignModePrecision,
+  compareRisingSignWindows,
+} from './compare/rising-sign-windows.js';
 import { compareRoots } from './compare/roots.js';
+import { compareServiceTransitFixture } from './compare/service-transits.js';
 import { assertTransitStatus, findTransit } from './compare/transits.js';
 import {
   astrologEdgeParityFixtures,
@@ -15,10 +21,16 @@ import {
   astrologTransitSnapshotFixtures,
 } from './fixtures/astrolog-parity/core.js';
 import { eclipseFixtures } from './fixtures/eclipses/core.js';
+import { electionalFixtures } from './fixtures/electional/core.js';
 import { houseFixtures } from './fixtures/houses/core.js';
 import { positionFixtures } from './fixtures/positions/core.js';
 import { riseSetFixtures } from './fixtures/rise-set/core.js';
+import {
+  risingSignModeComparisonFixtures,
+  risingSignWindowFixtures,
+} from './fixtures/rising-sign-windows/core.js';
 import { rootFixtures } from './fixtures/roots/core.js';
+import { serviceTransitFixtures } from './fixtures/service-transits/core.js';
 import { transitFixtures } from './fixtures/transits/core.js';
 import { dstFixtures } from './fixtures/transits/dst.js';
 import { denseScanRootOracleWithDebug } from './utils/denseRootOracle.js';
@@ -826,6 +838,76 @@ describe('Astro Validation Harness', () => {
     });
   });
 
+  describe('H. Electional context invariants', () => {
+    it('covers sect classification, near-horizon warnings, fallback semantics, and optional fields', () => {
+      const report = new ValidationReport();
+
+      for (const fixture of electionalFixtures) {
+        const actual = adapter.getElectionalContext(fixture.input);
+        compareElectionalContext(fixture, actual, report);
+      }
+
+      aggregateReport.hardFailures.push(...report.hardFailures);
+      aggregateReport.warnings.push(...report.warnings);
+      assertNoHardFailures(report);
+    });
+  });
+
+  describe('I. Rising-sign window invariants', () => {
+    it('validates contiguous local-day coverage, DST offsets, and deterministic repeats', () => {
+      const report = new ValidationReport();
+
+      for (const fixture of risingSignWindowFixtures) {
+        const actual = adapter.getRisingSignWindows(fixture.input);
+        const repeated = adapter.getRisingSignWindows(fixture.input);
+        compareRisingSignWindows(fixture, actual, repeated, report);
+      }
+
+      aggregateReport.hardFailures.push(...report.hardFailures);
+      aggregateReport.warnings.push(...report.warnings);
+      assertNoHardFailures(report);
+    });
+
+    it('checks that exact mode is at least as precise as approximate mode for the same day', () => {
+      const report = new ValidationReport();
+
+      for (const fixture of risingSignModeComparisonFixtures) {
+        const approximate = adapter.getRisingSignWindows({
+          ...fixture.baseInput,
+          mode: 'approximate',
+        });
+        const exact = adapter.getRisingSignWindows({
+          ...fixture.baseInput,
+          mode: 'exact',
+        });
+        compareRisingSignModePrecision(fixture, approximate, exact, adapter, report);
+      }
+
+      aggregateReport.hardFailures.push(...report.hardFailures);
+      aggregateReport.warnings.push(...report.warnings);
+      assertNoHardFailures(report);
+    });
+  });
+
+  describe('J. Service-level transit serialization invariants', () => {
+    it('covers enriched placement fields, explicit timezones, forecast grouping, and sign carry', () => {
+      const report = new ValidationReport();
+
+      for (const fixture of serviceTransitFixtures) {
+        const actual = adapter.getServiceTransits({
+          natalChart: fixture.natalChart,
+          transitInput: fixture.input,
+          startupDefaults: fixture.startupDefaults,
+        });
+        compareServiceTransitFixture(fixture, actual, report);
+      }
+
+      aggregateReport.hardFailures.push(...report.hardFailures);
+      aggregateReport.warnings.push(...report.warnings);
+      assertNoHardFailures(report);
+    });
+  });
+
   describe('DST scenario fixtures', () => {
     it('covers ambiguous and nonexistent local times under reject policy', () => {
       for (const fixture of dstFixtures) {