ether-to-astro 1.0.0

package/tests/validation/compare/positions.ts

@@ -0,0 +1,104 @@
+import type { NormalizedBody } from '../utils/fixtureTypes.js';
+import type { ValidationReport } from '../utils/report.js';
+import { TOLERANCES } from '../utils/tolerances.js';
+
+function sortBodies(rows: NormalizedBody[]): NormalizedBody[] {
+  return [...rows].sort((a, b) => String(a.body).localeCompare(String(b.body)));
+}
+
+export function comparePositions(
+  fixtureName: string,
+  expected: NormalizedBody[],
+  actual: NormalizedBody[],
+  report: ValidationReport,
+  subsystem = 'positions'
+): void {
+  const expectedSorted = sortBodies(expected);
+  const actualSorted = sortBodies(actual);
+
+  if (expectedSorted.length !== actualSorted.length) {
+    report.addHard({
+      fixture: fixtureName,
+      subsystem,
+      expected: expectedSorted.length,
+      actual: actualSorted.length,
+      delta: actualSorted.length - expectedSorted.length,
+      tolerance: 0,
+      message: 'Body count mismatch',
+    });
+    return;
+  }
+
+  for (let i = 0; i < expectedSorted.length; i++) {
+    const e = expectedSorted[i];
+    const a = actualSorted[i];
+
+    if (e.body !== a.body) {
+      report.addHard({
+        fixture: fixtureName,
+        subsystem,
+        expected: e.body,
+        actual: a.body,
+        delta: null,
+        tolerance: 'exact',
+        message: 'Body mismatch at sorted index',
+      });
+      continue;
+    }
+
+    const lonDelta = Math.abs(e.longitude - a.longitude);
+    if (lonDelta > TOLERANCES.positionLongitudeDeg) {
+      report.addHard({
+        fixture: fixtureName,
+        subsystem,
+        expected: e.longitude,
+        actual: a.longitude,
+        delta: lonDelta,
+        tolerance: TOLERANCES.positionLongitudeDeg,
+        message: `${e.body} longitude delta exceeds tolerance`,
+      });
+    }
+
+    if (e.latitude != null && a.latitude != null) {
+      const latDelta = Math.abs(e.latitude - a.latitude);
+      if (latDelta > TOLERANCES.positionLatitudeDeg) {
+        report.addHard({
+          fixture: fixtureName,
+          subsystem,
+          expected: e.latitude,
+          actual: a.latitude,
+          delta: latDelta,
+          tolerance: TOLERANCES.positionLatitudeDeg,
+          message: `${e.body} latitude delta exceeds tolerance`,
+        });
+      }
+    }
+
+    if (e.speed != null && a.speed != null) {
+      const speedDelta = Math.abs(e.speed - a.speed);
+      if (speedDelta > TOLERANCES.positionSpeedDegPerDay) {
+        report.addHard({
+          fixture: fixtureName,
+          subsystem,
+          expected: e.speed,
+          actual: a.speed,
+          delta: speedDelta,
+          tolerance: TOLERANCES.positionSpeedDegPerDay,
+          message: `${e.body} speed delta exceeds tolerance`,
+        });
+      }
+    }
+
+    if (e.retrograde != null && a.retrograde != null && e.retrograde !== a.retrograde) {
+      report.addHard({
+        fixture: fixtureName,
+        subsystem,
+        expected: e.retrograde,
+        actual: a.retrograde,
+        delta: null,
+        tolerance: 'exact',
+        message: `${e.body} retrograde flag mismatch`,
+      });
+    }
+  }
+}

package/tests/validation/compare/riseSet.ts

@@ -0,0 +1,48 @@
+import type { NormalizedRiseSet } from '../utils/fixtureTypes.js';
+import type { ValidationReport } from '../utils/report.js';
+import { minutesBetweenIso, TOLERANCES } from '../utils/tolerances.js';
+
+export function compareRiseSet(
+  fixtureName: string,
+  expected: NormalizedRiseSet,
+  actual: NormalizedRiseSet,
+  report: ValidationReport
+): void {
+  const fields: Array<keyof Omit<NormalizedRiseSet, 'body'>> = [
+    'rise',
+    'set',
+    'upperMeridianTransit',
+    'lowerMeridianTransit',
+  ];
+
+  for (const field of fields) {
+    const e = expected[field];
+    const a = actual[field];
+    if (e == null && a == null) continue;
+    if ((e == null) !== (a == null)) {
+      report.addHard({
+        fixture: fixtureName,
+        subsystem: 'rise-set',
+        expected: e,
+        actual: a,
+        delta: null,
+        tolerance: 'exact',
+        message: `${field} presence mismatch`,
+      });
+      continue;
+    }
+
+    const delta = minutesBetweenIso(e as string, a as string);
+    if (delta > TOLERANCES.riseSetMinutes) {
+      report.addHard({
+        fixture: fixtureName,
+        subsystem: 'rise-set',
+        expected: e,
+        actual: a,
+        delta,
+        tolerance: TOLERANCES.riseSetMinutes,
+        message: `${field} timing exceeds tolerance`,
+      });
+    }
+  }
+}

package/tests/validation/compare/roots.ts

@@ -0,0 +1,90 @@
+import type { NormalizedRoot } from '../utils/fixtureTypes.js';
+import type { ValidationReport } from '../utils/report.js';
+import { minutesBetweenIso, TOLERANCES } from '../utils/tolerances.js';
+
+function dedupeRootsByMinutes(roots: NormalizedRoot[], minutes: number): NormalizedRoot[] {
+  const sorted = [...roots].sort((a, b) => a.jd - b.jd);
+  const deduped: NormalizedRoot[] = [];
+  for (const r of sorted) {
+    const last = deduped[deduped.length - 1];
+    if (!last || minutesBetweenIso(last.isoUtc, r.isoUtc) > minutes) {
+      deduped.push(r);
+    }
+  }
+  return deduped;
+}
+
+export function compareRoots(
+  fixtureName: string,
+  productionRoots: NormalizedRoot[],
+  oracleRoots: NormalizedRoot[],
+  report: ValidationReport,
+  details?: unknown
+): void {
+  const dedupeMinutes = TOLERANCES.dedupeMinutes;
+  const normalizedProduction = dedupeRootsByMinutes(productionRoots, dedupeMinutes);
+  const normalizedOracle = dedupeRootsByMinutes(oracleRoots, dedupeMinutes);
+
+  if (normalizedProduction.length !== normalizedOracle.length) {
+    report.addHard({
+      fixture: fixtureName,
+      subsystem: 'roots',
+      expected: normalizedOracle.length,
+      actual: normalizedProduction.length,
+      delta: normalizedProduction.length - normalizedOracle.length,
+      tolerance: 0,
+      message: 'Root count mismatch (production vs dense-scan oracle, deduped)',
+      details,
+    });
+  }
+
+  const n = Math.min(normalizedProduction.length, normalizedOracle.length);
+  for (let i = 0; i < n; i++) {
+    const prod = normalizedProduction[i];
+    const oracle = normalizedOracle[i];
+    const deltaMinutes = minutesBetweenIso(prod.isoUtc, oracle.isoUtc);
+
+    if (deltaMinutes > TOLERANCES.rootHardMinutes) {
+      report.addHard({
+        fixture: fixtureName,
+        subsystem: 'roots',
+        expected: oracle.isoUtc,
+        actual: prod.isoUtc,
+        delta: deltaMinutes,
+        tolerance: TOLERANCES.rootHardMinutes,
+        message: `Root ${i} timing exceeds hard threshold`,
+        details,
+      });
+      continue;
+    }
+
+    if (deltaMinutes > TOLERANCES.rootPreferredMinutes) {
+      report.addWarning({
+        fixture: fixtureName,
+        subsystem: 'roots',
+        expected: oracle.isoUtc,
+        actual: prod.isoUtc,
+        delta: deltaMinutes,
+        tolerance: TOLERANCES.rootPreferredMinutes,
+        message: `Root ${i} timing exceeds preferred threshold`,
+        details,
+      });
+    }
+  }
+
+  for (let i = 1; i < normalizedProduction.length; i++) {
+    if (normalizedProduction[i].jd < normalizedProduction[i - 1].jd) {
+      report.addHard({
+        fixture: fixtureName,
+        subsystem: 'roots',
+        expected: 'sorted ascending',
+        actual: normalizedProduction.map((r) => r.jd),
+        delta: null,
+        tolerance: 'exact',
+        message: 'Production roots are not sorted earliest-first',
+        details,
+      });
+      break;
+    }
+  }
+}

package/tests/validation/compare/transits.ts

@@ -0,0 +1,69 @@
+import type { NormalizedTransit } from '../utils/fixtureTypes.js';
+import type { ValidationReport } from '../utils/report.js';
+
+export function findTransit(
+  transits: NormalizedTransit[],
+  transitingPlanet: string,
+  natalPlanet: string,
+  aspect: string
+): NormalizedTransit | undefined {
+  return transits.find(
+    (t) =>
+      t.transitingPlanet === transitingPlanet &&
+      t.natalPlanet === natalPlanet &&
+      t.aspect === aspect
+  );
+}
+
+export function assertTransitStatus(
+  fixtureName: string,
+  transit: NormalizedTransit | undefined,
+  expectedStatus:
+    | 'within_preview'
+    | 'outside_preview'
+    | 'not_found'
+    | 'unsupported_body'
+    | 'undefined',
+  report: ValidationReport
+): void {
+  if (!transit) {
+    report.addHard({
+      fixture: fixtureName,
+      subsystem: 'transits',
+      expected: 'transit exists',
+      actual: 'not found',
+      delta: null,
+      tolerance: 'exact',
+      message: 'Expected transit was not found',
+    });
+    return;
+  }
+
+  const actual = transit.exactTimeStatus;
+  if (expectedStatus === 'undefined') {
+    if (actual !== undefined) {
+      report.addHard({
+        fixture: fixtureName,
+        subsystem: 'transits',
+        expected: undefined,
+        actual,
+        delta: null,
+        tolerance: 'exact',
+        message: 'Expected exactTimeStatus to be undefined',
+      });
+    }
+    return;
+  }
+
+  if (actual !== expectedStatus) {
+    report.addHard({
+      fixture: fixtureName,
+      subsystem: 'transits',
+      expected: expectedStatus,
+      actual,
+      delta: null,
+      tolerance: 'exact',
+      message: 'Exact-time status mismatch',
+    });
+  }
+}

package/tests/validation/fixtures/astrolog-parity/core.ts

@@ -0,0 +1,194 @@
+import { PLANETS } from '../../../../src/types.js';
+import type {
+  AstrologEdgeParityFixture,
+  AstrologHouseParityFixture,
+  AstrologPositionParityFixture,
+  AstrologTransitSnapshotFixture,
+} from '../../utils/fixtureTypes.js';
+
+const CORE_PARITY_PLANET_IDS = [
+  PLANETS.SUN,
+  PLANETS.MOON,
+  PLANETS.MERCURY,
+  PLANETS.VENUS,
+  PLANETS.MARS,
+  PLANETS.JUPITER,
+  PLANETS.SATURN,
+  PLANETS.URANUS,
+  PLANETS.NEPTUNE,
+  PLANETS.PLUTO,
+];
+
+export const astrologPositionParityFixtures: AstrologPositionParityFixture[] = [
+  {
+    name: 'positions-modern-baseline-noon',
+    isoUtc: '2024-03-26T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-modern-baseline-midnight',
+    isoUtc: '2024-03-26T00:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-leap-day-2024-02-29',
+    isoUtc: '2024-02-29T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-year-boundary-dec31',
+    isoUtc: '2024-12-31T23:59:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-spring-equinox-window',
+    isoUtc: '2024-03-20T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-autumn-equinox-window',
+    isoUtc: '2024-09-22T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-mercury-retrograde',
+    isoUtc: '2024-04-10T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-venus-retrograde',
+    isoUtc: '2023-08-10T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-mars-station-window',
+    isoUtc: '2024-12-08T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-pluto-or-uranus-station-window',
+    isoUtc: '2024-09-02T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-far-past-date',
+    isoUtc: '1905-06-15T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'positions-near-future-date',
+    isoUtc: '2035-05-10T12:00:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+];
+
+export const astrologHouseParityFixtures: AstrologHouseParityFixture[] = [
+  {
+    name: 'houses-whole-sign-midlat-north',
+    isoUtc: '2024-03-26T12:00:00Z',
+    latitude: 40.7128,
+    longitude: -74.006,
+    houseSystem: 'W',
+  },
+  {
+    name: 'houses-whole-sign-southern-hemisphere',
+    isoUtc: '2024-09-01T00:00:00Z',
+    latitude: -33.8688,
+    longitude: 151.2093,
+    houseSystem: 'W',
+  },
+  {
+    name: 'houses-whole-sign-date-line-ish-longitude',
+    isoUtc: '2024-06-01T12:00:00Z',
+    latitude: -18.1248,
+    longitude: 178.4501,
+    houseSystem: 'W',
+  },
+  {
+    name: 'houses-placidus-midlat-sanity',
+    isoUtc: '2024-03-26T12:00:00Z',
+    latitude: 51.5072,
+    longitude: -0.1276,
+    houseSystem: 'P',
+  },
+  {
+    name: 'houses-high-latitude-fallback',
+    isoUtc: '2024-12-21T00:00:00Z',
+    latitude: 78.2232,
+    longitude: 15.6267,
+    houseSystem: 'P',
+    expectFallbackToWholeSign: true,
+  },
+];
+
+export const astrologTransitSnapshotFixtures: AstrologTransitSnapshotFixture[] = [
+  {
+    name: 'transits-mercury-retrograde-snapshot',
+    currentIsoUtc: '2024-04-10T12:00:00Z',
+    transitingPlanetId: PLANETS.MERCURY,
+    natalPlanetId: PLANETS.VENUS,
+    natalOffsetDegrees: 92,
+    expectedAspect: 'square',
+    maxOrb: 8,
+  },
+  {
+    name: 'transits-moon-fast-motion-snapshot',
+    currentIsoUtc: '2024-03-26T12:00:00Z',
+    transitingPlanetId: PLANETS.MOON,
+    natalPlanetId: PLANETS.MARS,
+    natalOffsetDegrees: 120,
+    expectedAspect: 'trine',
+    maxOrb: 8,
+  },
+  {
+    name: 'transits-square-dual-target',
+    currentIsoUtc: '2024-03-15T00:00:00Z',
+    transitingPlanetId: PLANETS.MARS,
+    natalPlanetId: PLANETS.VENUS,
+    natalOffsetDegrees: 90,
+    expectedAspect: 'square',
+    maxOrb: 8,
+  },
+  {
+    name: 'transits-trine-or-sextile-dual-target',
+    currentIsoUtc: '2024-03-15T00:00:00Z',
+    transitingPlanetId: PLANETS.JUPITER,
+    natalPlanetId: PLANETS.SUN,
+    natalOffsetDegrees: 60,
+    expectedAspect: 'sextile',
+    maxOrb: 8,
+  },
+  {
+    name: 'transits-slow-mover-in-orb',
+    currentIsoUtc: '2024-10-01T00:00:00Z',
+    transitingPlanetId: PLANETS.PLUTO,
+    natalPlanetId: PLANETS.MARS,
+    natalOffsetDegrees: 180,
+    expectedAspect: 'opposition',
+    maxOrb: 8,
+  },
+];
+
+export const astrologEdgeParityFixtures: AstrologEdgeParityFixture[] = [
+  {
+    name: 'edge-longitude-wrap-near-zero',
+    isoUtc: '2024-03-20T03:06:00Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+  },
+  {
+    name: 'edge-dst-ambiguous-local-time',
+    isoUtc: '2024-11-03T08:30:00.000Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+    local: { year: 2024, month: 11, day: 3, hour: 1, minute: 30 },
+    timezone: 'America/Los_Angeles',
+    disambiguation: 'earlier',
+  },
+  {
+    name: 'edge-dst-nonexistent-local-time',
+    isoUtc: '2024-03-10T10:30:00.000Z',
+    planetIds: CORE_PARITY_PLANET_IDS,
+    local: { year: 2024, month: 3, day: 10, hour: 2, minute: 30 },
+    timezone: 'America/Los_Angeles',
+    disambiguation: 'compatible',
+  },
+];

package/tests/validation/fixtures/eclipses/core.ts

@@ -0,0 +1,14 @@
+import type { EclipseFixture } from '../../utils/fixtureTypes.js';
+
+export const eclipseFixtures: EclipseFixture[] = [
+  {
+    name: 'next-solar-eclipse-sanity',
+    startIsoUtc: '2024-03-26T00:00:00Z',
+    type: 'solar',
+  },
+  {
+    name: 'next-lunar-eclipse-sanity',
+    startIsoUtc: '2024-03-26T00:00:00Z',
+    type: 'lunar',
+  },
+];

package/tests/validation/fixtures/houses/core.ts

@@ -0,0 +1,47 @@
+import type { HouseFixture } from '../../utils/fixtureTypes.js';
+
+export const houseFixtures: HouseFixture[] = [
+  {
+    name: 'nyc-placidus',
+    isoUtc: '2024-03-26T12:00:00Z',
+    latitude: 40.7128,
+    longitude: -74.006,
+    houseSystem: 'P',
+    expected: {
+      system: 'P',
+      ascendant: 33.98295887285655,
+      mc: 288.8571573752222,
+      cusps: [
+        33.98295887285655, 65.33379924755742, 87.90228930026863, 108.85715737522219,
+        132.88655769961264, 166.17376459102024, 213.98295887285656, 245.3337992475574,
+        267.90228930026865, 288.8571573752222, 312.88655769961264, 346.1737645910202,
+      ],
+    },
+  },
+  {
+    name: 'svalbard-polar-fallback',
+    isoUtc: '2024-03-26T12:00:00Z',
+    latitude: 78.2232,
+    longitude: 15.6267,
+    houseSystem: 'P',
+    expected: {
+      system: 'W',
+      ascendant: 157.0869567445154,
+      mc: 21.69267914127279,
+      cusps: [150, 180, 210, 240, 270, 300, 330, 0, 30, 60, 90, 120],
+    },
+  },
+  {
+    name: 'sydney-whole-sign',
+    isoUtc: '2024-09-01T00:00:00Z',
+    latitude: -33.8688,
+    longitude: 151.2093,
+    houseSystem: 'W',
+    expected: {
+      system: 'W',
+      ascendant: 238.03867274058655,
+      mc: 129.421733545281,
+      cusps: [210, 240, 270, 300, 330, 0, 30, 60, 90, 120, 150, 180],
+    },
+  },
+];