ether-to-astro 1.2.0 → 1.3.0

package/tests/property/service-transits.property.test.ts

@@ -0,0 +1,154 @@
+import fc from 'fast-check';
+import { beforeAll, describe, expect, it } from 'vitest';
+import type { GetTransitsInput } from '../../src/astro-service/service-types.js';
+import { ASPECTS, PLANETS, ZODIAC_SIGNS } from '../../src/types.js';
+import type { InternalValidationAdapter } from '../validation/adapters/internal.js';
+import type { ServiceTransitNatalFixture } from '../validation/utils/fixtureTypes.js';
+import {
+  dateOnlyArb,
+  longitudeArb,
+  nonPolarLatitudeArb,
+  timezoneArb,
+} from './helpers/arbitraries.js';
+import { propertyConfig } from './helpers/config.js';
+import { getInternalValidationAdapter } from './helpers/runtime.js';
+
+const SERVICE_TRANSIT_PLANET_IDS = [
+  PLANETS.SUN,
+  PLANETS.MOON,
+  PLANETS.MERCURY,
+  PLANETS.VENUS,
+  PLANETS.MARS,
+  PLANETS.JUPITER,
+  PLANETS.SATURN,
+] as const;
+
+const serviceTransitOffsetArb = fc
+  .record({
+    transitingPlanetId: fc.constantFrom(...SERVICE_TRANSIT_PLANET_IDS),
+    natalPlanetId: fc.constantFrom(...SERVICE_TRANSIT_PLANET_IDS),
+    aspectAngle: fc.constantFrom(...ASPECTS.map((aspect) => aspect.angle)),
+    deviation: fc.double({
+      min: -1.5,
+      max: 1.5,
+      noNaN: true,
+      noDefaultInfinity: true,
+    }),
+  })
+  .map(({ transitingPlanetId, natalPlanetId, aspectAngle, deviation }) => ({
+    transitingPlanetId,
+    natalPlanetId,
+    natalOffsetDegrees: (aspectAngle + deviation + 360) % 360,
+  }));
+
+const serviceTransitFixtureArb = fc
+  .record({
+    latitude: nonPolarLatitudeArb,
+    longitude: longitudeArb,
+    timezone: timezoneArb,
+    houseSystem: fc.constantFrom('P' as const, 'W' as const),
+    planetOffsets: fc.array(serviceTransitOffsetArb, { minLength: 2, maxLength: 4 }),
+  })
+  .map(
+    ({ latitude, longitude, timezone, houseSystem, planetOffsets }): ServiceTransitNatalFixture => ({
+      name: 'Property Transit Fixture',
+      latitude,
+      longitude,
+      timezone,
+      julianDayIsoUtc: '1990-06-12T21:35:00Z',
+      houseSystem,
+      planetOffsets,
+    })
+  );
+
+describe('Property: service-level transit serialization', () => {
+  let adapter: InternalValidationAdapter;
+
+  beforeAll(async () => {
+    adapter = await getInternalValidationAdapter();
+  });
+
+  it('keeps snapshot transit payloads enriched and astrologically valid', async () => {
+    await fc.assert(
+      fc.property(serviceTransitFixtureArb, dateOnlyArb, timezoneArb, (natalChart, date, reportingTimezone) => {
+        const result = adapter.getServiceTransits({
+          natalChart,
+          transitInput: {
+            date,
+            mode: 'snapshot',
+          } satisfies GetTransitsInput,
+          startupDefaults: {
+            preferredTimezone: reportingTimezone,
+          },
+        });
+
+        expect(result.timezone).toBe(reportingTimezone);
+        expect(result.calculationTimezone).toBe(natalChart.timezone);
+        expect(result.reportingTimezone).toBe(reportingTimezone);
+
+        fc.pre((result.transits?.length ?? 0) > 0);
+        for (const transit of result.transits ?? []) {
+          expect(transit.transitSign).toBeDefined();
+          expect(transit.natalSign).toBeDefined();
+          expect(transit.transitDegree).toBeDefined();
+          expect(transit.natalDegree).toBeDefined();
+          expect(transit.transitHouse).toBeDefined();
+          expect(transit.natalHouse).toBeDefined();
+          expect(ZODIAC_SIGNS).toContain(transit.transitSign);
+          expect(ZODIAC_SIGNS).toContain(transit.natalSign);
+          expect(transit.transitDegree).toBeGreaterThanOrEqual(0);
+          expect(transit.transitDegree).toBeLessThan(30);
+          expect(transit.natalDegree).toBeGreaterThanOrEqual(0);
+          expect(transit.natalDegree).toBeLessThan(30);
+          expect(transit.transitHouse).toBeGreaterThanOrEqual(1);
+          expect(transit.transitHouse).toBeLessThanOrEqual(12);
+          expect(transit.natalHouse).toBeGreaterThanOrEqual(1);
+          expect(transit.natalHouse).toBeLessThanOrEqual(12);
+        }
+      }),
+      propertyConfig({ heavy: true })
+    );
+  });
+
+  it('keeps forecast grouping and timezone metadata stable', async () => {
+    await fc.assert(
+      fc.property(
+        serviceTransitFixtureArb,
+        dateOnlyArb,
+        timezoneArb,
+        fc.integer({ min: 0, max: 3 }),
+        (natalChart, date, reportingTimezone, daysAhead) => {
+          const result = adapter.getServiceTransits({
+            natalChart,
+            transitInput: {
+              date,
+              mode: 'forecast',
+              days_ahead: daysAhead,
+            } satisfies GetTransitsInput,
+            startupDefaults: {
+              preferredTimezone: reportingTimezone,
+            },
+          });
+
+          expect(result.mode).toBe('forecast');
+          expect(result.timezone).toBe(reportingTimezone);
+          expect(result.calculationTimezone).toBe(natalChart.timezone);
+          expect(result.reportingTimezone).toBe(reportingTimezone);
+          expect(result.forecast).toHaveLength(daysAhead + 1);
+
+          for (const day of result.forecast ?? []) {
+            expect(day.date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+            for (const transit of day.transits) {
+              expect(transit.transitSign).toBeDefined();
+              expect(transit.natalSign).toBeDefined();
+              expect(transit.transitDegree).toBeGreaterThanOrEqual(0);
+              expect(transit.transitDegree).toBeLessThan(30);
+            }
+          }
+        }
+      ),
+      propertyConfig({ heavy: true })
+    );
+  });
+});
+

package/tests/property/time-utils.property.test.ts

@@ -0,0 +1,91 @@
+import fc from 'fast-check';
+import { describe, expect, it } from 'vitest';
+import {
+  formatLocalTimestampWithOffset,
+  getTimezoneOffset,
+  localToUTC,
+  utcToLocal,
+} from '../../src/time-utils.js';
+import { propertyConfig } from './helpers/config.js';
+import {
+  NON_HOUR_OFFSET_TIMEZONES,
+  timezoneArb,
+  utcDateArb,
+  validLocalDateTimeArb,
+  nonHourLocalDateTimeArb,
+} from './helpers/arbitraries.js';
+
+const DST_REJECT_FIXTURES = [
+  {
+    timezone: 'America/Los_Angeles',
+    local: { year: 2024, month: 3, day: 10, hour: 2, minute: 30, second: 0 },
+  },
+  {
+    timezone: 'America/New_York',
+    local: { year: 2024, month: 3, day: 10, hour: 2, minute: 30, second: 0 },
+  },
+  {
+    timezone: 'America/Los_Angeles',
+    local: { year: 2024, month: 11, day: 3, hour: 1, minute: 30, second: 0 },
+  },
+  {
+    timezone: 'America/New_York',
+    local: { year: 2024, month: 11, day: 3, hour: 1, minute: 30, second: 0 },
+  },
+] as const;
+
+function formatExpectedOffset(offsetMinutes: number): string {
+  const sign = offsetMinutes >= 0 ? '+' : '-';
+  const absoluteOffset = Math.abs(offsetMinutes);
+  const hours = String(Math.floor(absoluteOffset / 60)).padStart(2, '0');
+  const minutes = String(absoluteOffset % 60).padStart(2, '0');
+  return `${sign}${hours}:${minutes}`;
+}
+
+describe('Property: time utils', () => {
+  it('round-trips valid local datetimes through UTC for representative zones', async () => {
+    await fc.assert(
+      fc.property(validLocalDateTimeArb, ({ timezone, local }) => {
+        const utc = localToUTC(local, timezone, 'reject');
+        expect(utcToLocal(utc, timezone)).toEqual(local);
+      }),
+      propertyConfig()
+    );
+  });
+
+  it('keeps formatted offsets aligned with getTimezoneOffset()', async () => {
+    await fc.assert(
+      fc.property(utcDateArb, timezoneArb, (instant, timezone) => {
+        const offsetMinutes = getTimezoneOffset(instant, timezone);
+        expect(Number.isInteger(offsetMinutes)).toBe(true);
+
+        const formatted = formatLocalTimestampWithOffset(instant, timezone);
+        expect(formatted.slice(-6)).toBe(formatExpectedOffset(offsetMinutes));
+      }),
+      propertyConfig()
+    );
+  });
+
+  it('preserves non-hour offset zones through round-trip conversion', async () => {
+    await fc.assert(
+      fc.property(nonHourLocalDateTimeArb, ({ timezone, local }) => {
+        expect(NON_HOUR_OFFSET_TIMEZONES).toContain(timezone);
+
+        const utc = localToUTC(local, timezone, 'reject');
+        expect(utcToLocal(utc, timezone)).toEqual(local);
+        expect(getTimezoneOffset(utc, timezone) % 60).not.toBe(0);
+      }),
+      propertyConfig()
+    );
+  });
+
+  it('rejects curated ambiguous and nonexistent DST-edge local times', async () => {
+    await fc.assert(
+      fc.property(fc.constantFrom(...DST_REJECT_FIXTURES), ({ timezone, local }) => {
+        expect(() => localToUTC(local, timezone, 'reject')).toThrow(RangeError);
+      }),
+      propertyConfig()
+    );
+  });
+});
+

package/tests/property/transits.property.test.ts

@@ -0,0 +1,113 @@
+import fc from 'fast-check';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { deduplicateTransits } from '../../src/transits.js';
+import { ASPECTS, PLANETS } from '../../src/types.js';
+import type { Transit } from '../../src/types.js';
+import type { InternalValidationAdapter } from '../validation/adapters/internal.js';
+import { dateOnlyArb, utcDateArb } from './helpers/arbitraries.js';
+import { propertyConfig } from './helpers/config.js';
+import { getInternalValidationAdapter } from './helpers/runtime.js';
+
+const PLANET_NAMES = [
+  'Sun',
+  'Moon',
+  'Mercury',
+  'Venus',
+  'Mars',
+  'Jupiter',
+  'Saturn',
+] as const;
+
+const ASPECT_ORB_BY_NAME = new Map(ASPECTS.map((aspect) => [aspect.name, aspect.orb]));
+const PLANET_IDS = [PLANETS.SUN, PLANETS.MOON, PLANETS.MERCURY, PLANETS.VENUS, PLANETS.MARS] as const;
+
+const transitArb: fc.Arbitrary<Transit> = fc.record({
+  transitingPlanet: fc.constantFrom(...PLANET_NAMES),
+  natalPlanet: fc.constantFrom(...PLANET_NAMES),
+  aspect: fc.constantFrom(...ASPECTS.map((aspect) => aspect.name)),
+  orb: fc.double({ min: 0, max: 8, noNaN: true, noDefaultInfinity: true }),
+  exactTime: fc.option(utcDateArb, { nil: undefined }),
+  exactTimeStatus: fc.option(
+    fc.constantFrom('within_preview', 'outside_preview', 'not_found', 'unsupported_body'),
+    { nil: undefined }
+  ),
+  isApplying: fc.boolean(),
+  transitLongitude: fc.double({ min: 0, max: 359.999, noNaN: true, noDefaultInfinity: true }),
+  natalLongitude: fc.double({ min: 0, max: 359.999, noNaN: true, noDefaultInfinity: true }),
+});
+
+const transitOffsetArb = fc.record({
+  transitingPlanetId: fc.constantFrom(...PLANET_IDS),
+  natalPlanetId: fc.constantFrom(...PLANET_IDS),
+  date: dateOnlyArb,
+  aspectAngle: fc.constantFrom(...ASPECTS.map((aspect) => aspect.angle)),
+  deviation: fc.double({ min: -1.5, max: 1.5, noNaN: true, noDefaultInfinity: true }),
+});
+
+function canonicalizeDeduped(transits: Transit[]) {
+  return deduplicateTransits(transits)
+    .map((transit) => ({
+      key: `${transit.transitingPlanet}-${transit.natalPlanet}-${transit.aspect}`,
+      orb: transit.orb,
+      exactTime: transit.exactTime?.toISOString(),
+      exactTimeStatus: transit.exactTimeStatus,
+      transitLongitude: transit.transitLongitude,
+      natalLongitude: transit.natalLongitude,
+      isApplying: transit.isApplying,
+    }))
+    .sort((left, right) => left.key.localeCompare(right.key));
+}
+
+describe('Property: transit engine', () => {
+  let adapter: InternalValidationAdapter;
+
+  beforeAll(async () => {
+    adapter = await getInternalValidationAdapter();
+  });
+
+  it('keeps deduplication idempotent and order-independent', async () => {
+    await fc.assert(
+      fc.property(fc.array(transitArb, { minLength: 1, maxLength: 20 }), (transits) => {
+        const firstPass = canonicalizeDeduped(transits);
+        const secondPass = canonicalizeDeduped(deduplicateTransits(transits));
+        const reversedPass = canonicalizeDeduped([...transits].reverse());
+
+        expect(secondPass).toEqual(firstPass);
+        expect(reversedPass).toEqual(firstPass);
+        expect(new Set(firstPass.map((transit) => transit.key)).size).toBe(firstPass.length);
+      }),
+      propertyConfig()
+    );
+  });
+
+  it('keeps live transits within configured aspect orbs and exact-time status rules', async () => {
+    await fc.assert(
+      fc.property(transitOffsetArb, ({ transitingPlanetId, natalPlanetId, date, aspectAngle, deviation }) => {
+        const transits = adapter.getTransitsFromOffsets({
+          currentIsoUtc: `${date}T12:00:00Z`,
+          transitingPlanetId,
+          natalPlanetId,
+          natalOffsetDegrees: (aspectAngle + deviation + 360) % 360,
+        });
+
+        fc.pre(transits.length > 0);
+        for (const transit of transits) {
+          expect(transit.orb).toBeLessThanOrEqual(ASPECT_ORB_BY_NAME.get(transit.aspect) ?? Number.POSITIVE_INFINITY);
+
+          if (transit.exactTime) {
+            expect(transit.exactTimeStatus).toBe('within_preview');
+          }
+
+          if (
+            transit.exactTimeStatus === 'outside_preview' ||
+            transit.exactTimeStatus === 'not_found' ||
+            transit.exactTimeStatus === 'unsupported_body'
+          ) {
+            expect(transit.exactTime).toBeUndefined();
+          }
+        }
+      }),
+      propertyConfig({ heavy: true })
+    );
+  });
+});

package/tests/unit/astro-service/chart-output-service.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ChartOutputService } from '../../../src/astro-service/chart-output-service.js';
+import type { NatalChart, PlanetPosition } from '../../../src/types.js';
+
+function makePlanet(planet: PlanetPosition['planet'], longitude: number): PlanetPosition {
+  return {
+    planetId: 0,
+    planet,
+    longitude,
+    latitude: 0,
+    distance: 1,
+    speed: 1,
+    sign: 'Aries',
+    degree: longitude % 30,
+    isRetrograde: false,
+  };
+}
+
+function makeNatalChart(): NatalChart {
+  return {
+    name: 'Test User',
+    birthDate: { year: 1990, month: 6, day: 12, hour: 14, minute: 35 },
+    location: { latitude: 37.7749, longitude: -122.4194, timezone: 'America/Los_Angeles' },
+    planets: [makePlanet('Sun', 10), makePlanet('Moon', 20)],
+    julianDay: 2451545,
+    houseSystem: 'P',
+    utcDateTime: { year: 1990, month: 6, day: 12, hour: 21, minute: 35 },
+  };
+}
+
+function makeChartOutputService() {
+  const chartRenderer = {
+    generateNatalChart: vi.fn(async (_chart, _theme, format) => {
+      if (format === 'svg') return '<svg>ok</svg>';
+      return Buffer.from([1, 2, 3]);
+    }),
+    generateTransitChart: vi.fn(async (_chart, _date, _theme, format) => {
+      if (format === 'svg') return '<svg>transit</svg>';
+      return Buffer.from([4, 5, 6]);
+    }),
+  };
+  const now = vi.fn(() => new Date('2024-03-26T12:00:00Z'));
+  const writeFile = vi.fn(async () => {});
+
+  const chartOutputService = new ChartOutputService({
+    chartRenderer: chartRenderer as any,
+    now,
+    writeFile,
+  });
+
+  return { chartOutputService, chartRenderer, now, writeFile };
+}
+
+describe('When using the extracted ChartOutputService', () => {
+  it('Given inline render requests, then it preserves SVG and binary output serialization', async () => {
+    const { chartOutputService } = makeChartOutputService();
+
+    const inlineSvg = await chartOutputService.generateNatalChart(makeNatalChart(), { format: 'svg' });
+    expect(inlineSvg).toMatchObject({
+      format: 'svg',
+      text: 'Natal Chart for Test User:',
+      svg: '<svg>ok</svg>',
+    });
+
+    const inlinePng = await chartOutputService.generateNatalChart(makeNatalChart(), { format: 'png' });
+    expect(inlinePng).toMatchObject({
+      format: 'png',
+      image: {
+        data: Buffer.from([1, 2, 3]).toString('base64'),
+        mimeType: 'image/png',
+      },
+    });
+  });
+
+  it('Given transit chart output paths and dates, then it preserves saved-file and label behavior', async () => {
+    const { chartOutputService, writeFile } = makeChartOutputService();
+
+    const saved = await chartOutputService.generateTransitChart(makeNatalChart(), {
+      format: 'webp',
+      output_path: '/tmp/test.webp',
+      date: '2024-03-26',
+    });
+
+    expect(writeFile).toHaveBeenCalledWith('/tmp/test.webp', Buffer.from([4, 5, 6]));
+    expect(saved.text).toContain('Transit Chart for Test User');
+    expect(saved.text).toContain('/tmp/test.webp');
+  });
+
+  it('Given transit SVG output, then it preserves the inline SVG branch', async () => {
+    const { chartOutputService } = makeChartOutputService();
+
+    const result = await chartOutputService.generateTransitChart(makeNatalChart(), {
+      format: 'svg',
+      date: '2024-03-26',
+    });
+
+    expect(result).toMatchObject({
+      format: 'svg',
+      svg: '<svg>transit</svg>',
+    });
+  });
+});

package/tests/unit/astro-service/electional-service.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ElectionalService } from '../../../src/astro-service/electional-service.js';
+import type { PlanetPosition } from '../../../src/types.js';
+
+function makePlanet(planet: PlanetPosition['planet'], longitude: number): PlanetPosition {
+  return {
+    planetId: 0,
+    planet,
+    longitude,
+    latitude: 0,
+    distance: 1,
+    speed: 1,
+    sign: 'Aries',
+    degree: longitude % 30,
+    isRetrograde: false,
+  };
+}
+
+function makeElectionalService() {
+  const ephem = {
+    dateToJulianDay: vi.fn((date: Date) => date.getTime() / 86400000 + 2440587.5),
+    calculateAspectAngle: vi.fn((a: number, b: number) => {
+      const diff = Math.abs(a - b);
+      return diff > 180 ? 360 - diff : diff;
+    }),
+    getHorizontalCoordinates: vi.fn(() => ({
+      azimuth: 180,
+      trueAltitude: 25,
+      apparentAltitude: 25,
+    })),
+    getAllPlanets: vi.fn(() => [
+      { ...makePlanet('Sun', 0), sign: 'Aries', speed: 1 },
+      { ...makePlanet('Moon', 58), sign: 'Taurus', speed: 13 },
+      { ...makePlanet('Mercury', 120), sign: 'Leo', speed: 1.2 },
+      { ...makePlanet('Venus', 180), sign: 'Libra', speed: 1.1 },
+      { ...makePlanet('Mars', 240), sign: 'Sagittarius', speed: 0.7 },
+      { ...makePlanet('Jupiter', 300), sign: 'Aquarius', speed: 0.2 },
+      { ...makePlanet('Saturn', 315), sign: 'Aquarius', speed: 0.05, isRetrograde: true },
+      { ...makePlanet('Uranus', 30), sign: 'Taurus', speed: 0.03 },
+      { ...makePlanet('Neptune', 330), sign: 'Pisces', speed: 0.02 },
+      { ...makePlanet('Pluto', 270), sign: 'Capricorn', speed: 0.01 },
+    ]),
+  };
+  const houseCalc = {
+    calculateHouses: vi.fn(() => ({
+      ascendant: 270,
+      mc: 204,
+      cusps: [0, 270, 300, 330, 0, 30, 60, 90, 120, 150, 204, 240, 260],
+      system: 'W' as const,
+    })),
+  };
+
+  const electionalService = new ElectionalService({
+    ephem: ephem as any,
+    houseCalc: houseCalc as any,
+  });
+
+  return { electionalService, ephem, houseCalc };
+}
+
+describe('When using the extracted ElectionalService', () => {
+  it('Given deterministic inputs, then it preserves electional context payloads and optional summaries', () => {
+    const { electionalService } = makeElectionalService();
+
+    const result = electionalService.getElectionalContext({
+      date: '2026-03-28',
+      time: '09:30',
+      timezone: 'America/Los_Angeles',
+      latitude: 37.7749,
+      longitude: -122.4194,
+      include_ruler_basics: true,
+    });
+
+    expect(result.data).toMatchObject({
+      input: {
+        date: '2026-03-28',
+        time: '09:30',
+        timezone: 'America/Los_Angeles',
+        house_system: 'W',
+      },
+      ascendant: {
+        sign: 'Capricorn',
+      },
+      sect: {
+        is_day_chart: true,
+        classification: 'day',
+        sun_altitude_degrees: 25,
+      },
+      moon: {
+        sign: 'Taurus',
+        phase_name: 'crescent',
+        is_void_of_course: null,
+      },
+      ruler_basics: {
+        asc_sign_ruler: {
+          body: 'Saturn',
+          sign: 'Aquarius',
+          is_retrograde: true,
+        },
+      },
+    });
+    expect((result.data as any).applying_aspects).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          from_body: 'Sun',
+          to_body: 'Moon',
+          aspect: 'sextile',
+          applying: true,
+        }),
+      ])
+    );
+    expect((result.data as any).meta.warnings).toContain(
+      'House calculation fell back from P to W for this location.'
+    );
+    expect(result.text).toContain('Applying Aspects:');
+  });
+
+  it('Given DST-overlap or invalid orb inputs, then it preserves strict validation semantics', () => {
+    const { electionalService } = makeElectionalService();
+
+    expect(() =>
+      electionalService.getElectionalContext({
+        date: '2026-11-01',
+        time: '01:30',
+        timezone: 'America/Los_Angeles',
+        latitude: 37.7749,
+        longitude: -122.4194,
+      })
+    ).toThrow(/ambiguous or nonexistent due to a DST transition/);
+
+    expect(() =>
+      electionalService.getElectionalContext({
+        date: '2026-03-28',
+        time: '09:30',
+        timezone: 'UTC',
+        latitude: 37.7749,
+        longitude: -122.4194,
+        orb_degrees: 11,
+      })
+    ).toThrow(/Invalid orb_degrees/);
+  });
+
+  it('Given applying-aspect toggles and invalid clock input, then it preserves the raw electional contract', () => {
+    const { electionalService, ephem } = makeElectionalService();
+    ephem.getAllPlanets.mockReturnValue([
+      { ...makePlanet('Sun', 0), sign: 'Aries', speed: 1 },
+      { ...makePlanet('Moon', 120), sign: 'Leo', speed: 1 },
+      { ...makePlanet('Mercury', 210), sign: 'Scorpio', speed: 1 },
+      { ...makePlanet('Venus', 300), sign: 'Aquarius', speed: 1 },
+      { ...makePlanet('Mars', 45), sign: 'Taurus', speed: 1 },
+      { ...makePlanet('Jupiter', 90), sign: 'Cancer', speed: 0.1 },
+      { ...makePlanet('Saturn', 180), sign: 'Libra', speed: 0.1 },
+      { ...makePlanet('Uranus', 240), sign: 'Sagittarius', speed: 0.1 },
+      { ...makePlanet('Neptune', 270), sign: 'Capricorn', speed: 0.1 },
+      { ...makePlanet('Pluto', 330), sign: 'Pisces', speed: 0.1 },
+    ]);
+
+    const result = electionalService.getElectionalContext({
+      date: '2026-03-28',
+      time: '09:30:15',
+      timezone: 'UTC',
+      latitude: 40.7,
+      longitude: -74,
+      include_planetary_applications: false,
+    });
+
+    expect((result.data as any).applying_aspects).toBeUndefined();
+    expect((result.data as any).moon.applying_aspects).toBeUndefined();
+    expect((result.data as any).ruler_basics).toBeUndefined();
+    expect(result.text).not.toContain('Applying Aspects:');
+
+    expect(() =>
+      electionalService.getElectionalContext({
+        date: '2026-03-28',
+        time: '25:61',
+        timezone: 'UTC',
+        latitude: 40.7,
+        longitude: -74,
+      })
+    ).toThrow(/Invalid clock time/);
+  });
+});