@typescriptify/sweph 1.0.0

package/tests/c-style/orbital.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { sweClose } from '../../src/sweph';
+import { sweNodAps, sweNodApsUt, sweGetOrbitalElements, sweOrbitMaxMinTrueDistance } from '../../src/swecl';
+import { SE_MARS, SE_EARTH, SEFLG_MOSEPH } from '../../src/constants';
+
+describe('Orbital Elements (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  describe('sweNodAps', () => {
+    it('Mars ascending node should be valid', () => {
+      const r = sweNodAps(swed, J2000, SE_MARS, SEFLG_MOSEPH, 0);
+      assert.ok(r.xnasc[0] >= 0 && r.xnasc[0] < 360);
+    });
+
+    it('Mars descending node should differ from ascending', () => {
+      const r = sweNodAps(swed, J2000, SE_MARS, SEFLG_MOSEPH, 0);
+      assert.ok(Math.abs(r.xnasc[0] - r.xndsc[0]) > 90);
+    });
+  });
+
+  describe('sweNodApsUt', () => {
+    it('should produce valid ascending node', () => {
+      const r = sweNodApsUt(swed, J2000, SE_MARS, SEFLG_MOSEPH, 0);
+      assert.ok(r.xnasc[0] >= 0);
+    });
+  });
+
+  describe('sweGetOrbitalElements', () => {
+    it('Mars semi-axis should be ~1.5237 AU', () => {
+      const r = sweGetOrbitalElements(swed, J2000, SE_MARS, SEFLG_MOSEPH);
+      near(r.dret[0], 1.5237, 0.01);
+    });
+
+    it('Mars eccentricity should be ~0.0933', () => {
+      const r = sweGetOrbitalElements(swed, J2000, SE_MARS, SEFLG_MOSEPH);
+      near(r.dret[1], 0.0933, 0.01);
+    });
+
+    it('Mars inclination should be ~1.85 deg', () => {
+      const r = sweGetOrbitalElements(swed, J2000, SE_MARS, SEFLG_MOSEPH);
+      near(r.dret[2], 1.85, 0.2);
+    });
+
+    it('Earth semi-axis should be ~1.0 AU', () => {
+      const r = sweGetOrbitalElements(swed, J2000, SE_EARTH, SEFLG_MOSEPH);
+      near(r.dret[0], 1.0, 0.01);
+    });
+
+    it('Earth eccentricity should be ~0.0167', () => {
+      const r = sweGetOrbitalElements(swed, J2000, SE_EARTH, SEFLG_MOSEPH);
+      near(r.dret[1], 0.0167, 0.01);
+    });
+  });
+
+  describe('sweOrbitMaxMinTrueDistance', () => {
+    it('Mars dmin should be ~0.37 AU', () => {
+      const r = sweOrbitMaxMinTrueDistance(swed, J2000, SE_MARS, SEFLG_MOSEPH);
+      near(r.dmin, 0.37, 0.1);
+    });
+
+    it('Mars dmax should be ~2.68 AU', () => {
+      const r = sweOrbitMaxMinTrueDistance(swed, J2000, SE_MARS, SEFLG_MOSEPH);
+      near(r.dmax, 2.68, 0.1);
+    });
+
+    it('dmin < dtrue < dmax', () => {
+      const r = sweOrbitMaxMinTrueDistance(swed, J2000, SE_MARS, SEFLG_MOSEPH);
+      assert.ok(r.dmin < r.dtrue);
+      assert.ok(r.dtrue < r.dmax);
+    });
+  });
+});

package/tests/c-style/phenomena.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000, LONDON_ARR } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { sweClose } from '../../src/sweph';
+import { swePheno, swePhenoUt, sweGauquelinSector } from '../../src/swecl';
+import { SE_SUN, SE_MARS, SEFLG_MOSEPH } from '../../src/constants';
+
+describe('Phenomena (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  describe('swePheno', () => {
+    it('Mars phase angle should be 0-180', () => {
+      const r = swePheno(swed, J2000, SE_MARS, SEFLG_MOSEPH, null);
+      assert.ok(r.attr[0] >= 0 && r.attr[0] < 180, `phase=${r.attr[0]}`);
+    });
+
+    it('Mars should have elongation > 0', () => {
+      const r = swePheno(swed, J2000, SE_MARS, SEFLG_MOSEPH, null);
+      assert.ok(r.attr[2] >= 0, `elongation=${r.attr[2]}`);
+    });
+  });
+
+  describe('swePhenoUt', () => {
+    it('should return valid phase angle', () => {
+      const r = swePhenoUt(swed, J2000, SE_MARS, SEFLG_MOSEPH, null);
+      assert.ok(r.attr[0] >= 0);
+    });
+  });
+
+  describe('sweGauquelinSector', () => {
+    it('Sun sector should be 1-36', () => {
+      const r = sweGauquelinSector(swed, J2000, SE_SUN, null, SEFLG_MOSEPH, 0,
+        LONDON_ARR, 1013.25, 10, null);
+      assert.ok(r.retval >= 0);
+      assert.ok(r.dgsect > 0 && r.dgsect <= 36, `sector=${r.dgsect}`);
+    });
+  });
+});

package/tests/c-style/planetocentric.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { sweCalc, sweCalcPctr, sweClose } from '../../src/sweph';
+import { SE_MARS, SE_EARTH, SEFLG_MOSEPH } from '../../src/constants';
+
+describe('Planetocentric (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  it('Mars from Earth should match geocentric Mars', () => {
+    const geo = sweCalc(swed, J2000, SE_MARS, SEFLG_MOSEPH);
+    const pctr = sweCalcPctr(swed, J2000, SE_MARS, SE_EARTH, SEFLG_MOSEPH);
+    assert.ok(pctr.xx[0] >= 0 && pctr.xx[0] < 360);
+    near(pctr.xx[0], geo.xx[0], 0.1);
+  });
+
+  it('should produce valid longitude and latitude', () => {
+    const pctr = sweCalcPctr(swed, J2000, SE_MARS, SE_EARTH, SEFLG_MOSEPH);
+    assert.ok(pctr.xx[0] >= 0 && pctr.xx[0] < 360);
+    assert.ok(pctr.xx[1] >= -90 && pctr.xx[1] <= 90);
+  });
+});

package/tests/c-style/planets.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { sweCalc, sweCalcUt, sweSetTopo, sweClose } from '../../src/sweph';
+import {
+  SE_SUN, SE_MOON, SE_MERCURY, SE_VENUS, SE_MARS, SE_JUPITER, SE_SATURN,
+  SE_URANUS, SE_NEPTUNE, SE_PLUTO, SE_MEAN_NODE, SE_TRUE_NODE,
+  SE_OSCU_APOG, SE_EARTH,
+  SEFLG_MOSEPH, SEFLG_SPEED, SEFLG_EQUATORIAL, SEFLG_HELCTR, SEFLG_TOPOCTR,
+} from '../../src/constants';
+
+describe('Planet Positions (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  describe('Sun', () => {
+    it('should have longitude ~280.37 at J2000', () => {
+      const r = sweCalc(swed, J2000, SE_SUN, SEFLG_MOSEPH | SEFLG_SPEED);
+      near(r.xx[0], 280.37, 0.1);
+    });
+
+    it('should have speed ~1.0 deg/day', () => {
+      const r = sweCalc(swed, J2000, SE_SUN, SEFLG_MOSEPH | SEFLG_SPEED);
+      near(r.xx[3], 1.0, 0.1);
+    });
+  });
+
+  describe('Moon', () => {
+    it('should have valid longitude at J2000', () => {
+      const r = sweCalc(swed, J2000, SE_MOON, SEFLG_MOSEPH | SEFLG_SPEED);
+      assert.ok(r.xx[0] >= 0 && r.xx[0] < 360);
+    });
+
+    it('should have speed ~13 deg/day', () => {
+      const r = sweCalc(swed, J2000, SE_MOON, SEFLG_MOSEPH | SEFLG_SPEED);
+      near(r.xx[3], 13.0, 2.0);
+    });
+  });
+
+  describe('All planets', () => {
+    const planets = [
+      { id: SE_MERCURY, name: 'Mercury' },
+      { id: SE_VENUS, name: 'Venus' },
+      { id: SE_MARS, name: 'Mars' },
+      { id: SE_JUPITER, name: 'Jupiter' },
+      { id: SE_SATURN, name: 'Saturn' },
+      { id: SE_URANUS, name: 'Uranus' },
+      { id: SE_NEPTUNE, name: 'Neptune' },
+      { id: SE_PLUTO, name: 'Pluto' },
+    ];
+
+    for (const { id, name } of planets) {
+      it(`${name} should have valid longitude`, () => {
+        const r = sweCalc(swed, J2000, id, SEFLG_MOSEPH | SEFLG_SPEED);
+        assert.ok(r.xx[0] >= 0 && r.xx[0] < 360, `${name} lon=${r.xx[0]}`);
+        assert.ok(r.xx[2] > 0, `${name} distance should be positive`);
+      });
+    }
+  });
+
+  describe('sweCalcUt', () => {
+    it('should calculate Mars via UT', () => {
+      const r = sweCalcUt(swed, J2000, SE_MARS, SEFLG_MOSEPH | SEFLG_SPEED);
+      assert.ok(r.xx[0] >= 0 && r.xx[0] < 360);
+    });
+  });
+
+  describe('Nodes and apsides', () => {
+    it('Mean node should have valid longitude', () => {
+      const r = sweCalc(swed, J2000, SE_MEAN_NODE, SEFLG_MOSEPH | SEFLG_SPEED);
+      assert.ok(r.xx[0] >= 0 && r.xx[0] < 360);
+    });
+
+    it('True node should have valid longitude', () => {
+      const r = sweCalc(swed, J2000, SE_TRUE_NODE, SEFLG_MOSEPH | SEFLG_SPEED);
+      assert.ok(r.xx[0] >= 0 && r.xx[0] < 360);
+    });
+
+    it('Osculating apogee should have valid longitude', () => {
+      const r = sweCalc(swed, J2000, SE_OSCU_APOG, SEFLG_MOSEPH);
+      assert.ok(r.xx[0] >= 0 && r.xx[0] < 360);
+    });
+  });
+
+  describe('Equatorial coordinates', () => {
+    it('Sun RA should be valid at J2000', () => {
+      const r = sweCalc(swed, J2000, SE_SUN, SEFLG_MOSEPH | SEFLG_EQUATORIAL);
+      assert.ok(r.xx[0] >= 0 && r.xx[0] < 360, `RA=${r.xx[0]}`);
+    });
+  });
+
+  describe('Heliocentric', () => {
+    it('Mars heliocentric should have valid longitude', () => {
+      const r = sweCalc(swed, J2000, SE_MARS, SEFLG_MOSEPH | SEFLG_HELCTR);
+      assert.ok(r.xx[0] >= 0 && r.xx[0] < 360);
+    });
+
+    it('Earth heliocentric should have valid longitude', () => {
+      const r = sweCalc(swed, J2000, SE_EARTH, SEFLG_MOSEPH | SEFLG_HELCTR);
+      assert.ok(r.xx[0] >= 0 && r.xx[0] < 360);
+    });
+  });
+
+  describe('Topocentric', () => {
+    it('Sun should differ slightly from geocentric', () => {
+      const geo = sweCalc(swed, J2000, SE_SUN, SEFLG_MOSEPH | SEFLG_SPEED);
+      sweSetTopo(swed, -0.1278, 51.5074, 0);
+      const topo = sweCalc(swed, J2000, SE_SUN, SEFLG_MOSEPH | SEFLG_TOPOCTR | SEFLG_SPEED);
+      assert.ok(topo.xx[0] >= 0 && topo.xx[0] < 360);
+      // Topocentric should differ slightly from geocentric
+      assert.ok(Math.abs(topo.xx[0] - geo.xx[0]) < 1, 'Topo should be close to geo');
+    });
+  });
+});

package/tests/c-style/rise-set.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000, LONDON_ARR } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { sweCalc, sweClose } from '../../src/sweph';
+import { sweRiseTrans, sweAzalt, sweAzaltRev, sweRefrac, sweRefracExtended } from '../../src/swecl';
+import {
+  SE_SUN, SEFLG_MOSEPH, SEFLG_SPEED,
+  SE_CALC_RISE, SE_CALC_SET,
+  SE_ECL2HOR, SE_EQU2HOR, SE_TRUE_TO_APP,
+} from '../../src/constants';
+
+describe('Rise/Set/Transit (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  describe('sweRiseTrans', () => {
+    it('Sun rise should be after J2000', () => {
+      const r = sweRiseTrans(swed, J2000, SE_SUN, null, SEFLG_MOSEPH,
+        SE_CALC_RISE, LONDON_ARR, 1013.25, 10, null);
+      assert.ok(r.retval >= 0);
+      assert.ok(r.tret > 0, 'rise time should be positive');
+    });
+
+    it('Sun set should be after J2000', () => {
+      const r = sweRiseTrans(swed, J2000, SE_SUN, null, SEFLG_MOSEPH,
+        SE_CALC_SET, LONDON_ARR, 1013.25, 10, null);
+      assert.ok(r.retval >= 0);
+      assert.ok(r.tret > J2000, 'set time should be after J2000');
+    });
+  });
+
+  describe('sweAzalt', () => {
+    it('should compute Sun azimuth at J2000', () => {
+      const sun = sweCalc(swed, J2000, SE_SUN, SEFLG_MOSEPH | SEFLG_SPEED);
+      const xaz = [0, 0, 0];
+      sweAzalt(swed, J2000, SE_ECL2HOR, LONDON_ARR, 1013.25, 10,
+        [sun.xx[0], sun.xx[1], sun.xx[2]], xaz);
+      assert.ok(xaz[0] >= 0 && xaz[0] < 360, `azimuth=${xaz[0]}`);
+    });
+  });
+
+  describe('sweAzaltRev', () => {
+    it('should reverse azalt back to coordinates', () => {
+      const sun = sweCalc(swed, J2000, SE_SUN, SEFLG_MOSEPH | SEFLG_SPEED);
+      const xaz = [0, 0, 0];
+      sweAzalt(swed, J2000, SE_ECL2HOR, LONDON_ARR, 1013.25, 10,
+        [sun.xx[0], sun.xx[1], sun.xx[2]], xaz);
+      const xout = [0, 0, 0];
+      sweAzaltRev(swed, J2000, SE_EQU2HOR, LONDON_ARR, [xaz[0], xaz[2]], xout);
+      assert.ok(xout[0] >= 0 && xout[0] < 360);
+    });
+  });
+
+  describe('sweRefrac', () => {
+    it('true-to-apparent should increase altitude', () => {
+      const ref = sweRefrac(10, 1013.25, 10, SE_TRUE_TO_APP);
+      assert.ok(ref > 10, `refracted=${ref}`);
+    });
+  });
+
+  describe('sweRefracExtended', () => {
+    it('should return positive value', () => {
+      const dret = [0, 0, 0, 0];
+      const ref = sweRefracExtended(10, 0, 1013.25, 10, 0.0065, SE_TRUE_TO_APP, dret);
+      assert.ok(ref > 0);
+    });
+  });
+});

package/tests/helpers.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared test helpers, constants, and assertions.
+ */
+import { strict as assert } from 'node:assert';
+
+/** Assert that `a` is within `tol` of `b`. */
+export function near(a: number, b: number, tol: number): void {
+  assert.ok(
+    Math.abs(a - b) < tol,
+    `Expected ${a} to be within ${tol} of ${b} (diff: ${Math.abs(a - b)})`,
+  );
+}
+
+/** J2000.0 epoch — 2000 Jan 1.5 UT */
+export const J2000 = 2451545.0;
+
+/** London geographic position */
+export const LONDON = { longitude: -0.1278, latitude: 51.5074, altitude: 0 };
+
+/** London as [lon, lat, alt] array for C-style functions */
+export const LONDON_ARR: [number, number, number] = [-0.1278, 51.5074, 0];

package/tests/modern/ayanamsa.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_SIDM_LAHIRI, SE_SIDM_TRUE_CITRA, SE_SIDM_FAGAN_BRADLEY } from '../../src/constants';
+
+describe('Ayanamsa (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('Lahiri', () => {
+    it('should be ~23.86 at J2000', () => {
+      swe.setSiderealMode(SE_SIDM_LAHIRI);
+      const aya = swe.getAyanamsa(J2000);
+      near(aya, 23.86, 0.1);
+    });
+  });
+
+  describe('True Citra', () => {
+    it('should be ~23.84 at J2000', () => {
+      swe.setSiderealMode(SE_SIDM_TRUE_CITRA);
+      const aya = swe.getAyanamsa(J2000);
+      near(aya, 23.84, 0.2);
+    });
+  });
+
+  describe('getAyanamsaName', () => {
+    it('should return Lahiri', () => {
+      assert.strictEqual(swe.getAyanamsaName(SE_SIDM_LAHIRI), 'Lahiri');
+    });
+
+    it('should return Fagan/Bradley', () => {
+      assert.strictEqual(swe.getAyanamsaName(SE_SIDM_FAGAN_BRADLEY), 'Fagan/Bradley');
+    });
+  });
+
+  describe('Constructor siderealMode', () => {
+    it('should accept siderealMode in options', () => {
+      const swe2 = new SwissEph({ siderealMode: SE_SIDM_LAHIRI });
+      const aya = swe2.getAyanamsa(J2000);
+      near(aya, 23.86, 0.1);
+      swe2.close();
+    });
+  });
+});

package/tests/modern/calc.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_SUN, SE_MOON, SE_MERCURY, SE_VENUS, SE_MARS, SE_JUPITER, SE_SATURN,
+  SE_URANUS, SE_NEPTUNE, SE_PLUTO, SE_EARTH, SE_MEAN_NODE, SE_TRUE_NODE,
+  SEFLG_EQUATORIAL, SEFLG_HELCTR,
+} from '../../src/constants';
+
+describe('Calculation (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('Sun', () => {
+    it('should have longitude ~280.37 at J2000', () => {
+      const sun = swe.calc(J2000, SE_SUN);
+      near(sun.longitude, 280.37, 0.1);
+    });
+
+    it('should have speed ~1.0 deg/day', () => {
+      const sun = swe.calc(J2000, SE_SUN);
+      near(sun.longitudeSpeed, 1.0, 0.1);
+    });
+
+    it('should have nonzero distance', () => {
+      const sun = swe.calc(J2000, SE_SUN);
+      assert.ok(sun.distance > 0);
+    });
+  });
+
+  describe('Moon', () => {
+    it('should have valid longitude', () => {
+      const moon = swe.calc(J2000, SE_MOON);
+      assert.ok(moon.longitude >= 0 && moon.longitude < 360);
+    });
+
+    it('should have speed ~13 deg/day', () => {
+      const moon = swe.calc(J2000, SE_MOON);
+      near(moon.longitudeSpeed, 13.0, 2.0);
+    });
+  });
+
+  describe('All planets', () => {
+    const planets = [
+      { id: SE_MERCURY, name: 'Mercury' },
+      { id: SE_VENUS, name: 'Venus' },
+      { id: SE_MARS, name: 'Mars' },
+      { id: SE_JUPITER, name: 'Jupiter' },
+      { id: SE_SATURN, name: 'Saturn' },
+      { id: SE_URANUS, name: 'Uranus' },
+      { id: SE_NEPTUNE, name: 'Neptune' },
+      { id: SE_PLUTO, name: 'Pluto' },
+    ];
+
+    for (const { id, name } of planets) {
+      it(`${name} should have valid longitude`, () => {
+        const r = swe.calc(J2000, id);
+        assert.ok(r.longitude >= 0 && r.longitude < 360, `${name}=${r.longitude}`);
+      });
+    }
+  });
+
+  describe('Equatorial', () => {
+    it('Sun RA should be valid', () => {
+      const r = swe.calc(J2000, SE_SUN, SEFLG_EQUATORIAL);
+      assert.ok(r.longitude >= 0 && r.longitude < 360);
+    });
+  });
+
+  describe('Heliocentric', () => {
+    it('Mars heliocentric should be valid', () => {
+      const r = swe.calc(J2000, SE_MARS, SEFLG_HELCTR);
+      assert.ok(r.longitude >= 0 && r.longitude < 360);
+    });
+  });
+
+  describe('calcPlanetocentric', () => {
+    it('Mars from Earth should match geocentric', () => {
+      const geo = swe.calc(J2000, SE_MARS);
+      const pctr = swe.calcPlanetocentric(J2000, SE_MARS, SE_EARTH);
+      near(pctr.longitude, geo.longitude, 0.01);
+    });
+  });
+
+  describe('fixedStar', () => {
+    it('Spica should have longitude ~203.84', () => {
+      const r = swe.fixedStar('Spica', J2000);
+      near(r.longitude, 203.84, 0.5);
+    });
+
+    it('should include star name', () => {
+      const r = swe.fixedStar('Spica', J2000);
+      assert.ok(r.starName.includes('Spica'));
+    });
+  });
+
+  describe('fixedStar2', () => {
+    it('should match fixedStar', () => {
+      const r1 = swe.fixedStar('Spica', J2000);
+      const r2 = swe.fixedStar2('Spica', J2000);
+      near(r2.longitude, r1.longitude, 0.001);
+    });
+  });
+
+  describe('fixedStarMagnitude', () => {
+    it('Spica should have magnitude ~0.98', () => {
+      const mag = swe.fixedStarMagnitude('Spica');
+      near(mag, 0.98, 0.1);
+    });
+  });
+});

package/tests/modern/config.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { J2000, LONDON } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_SUN, SEFLG_TOPOCTR } from '../../src/constants';
+
+describe('Configuration (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('setTopo', () => {
+    it('should set topocentric position without error', () => {
+      swe.setTopo(LONDON);
+    });
+
+    it('topocentric calc should work after setTopo', () => {
+      swe.setTopo(LONDON);
+      const r = swe.calc(J2000, SE_SUN, SEFLG_TOPOCTR);
+      assert.ok(r.longitude >= 0 && r.longitude < 360);
+    });
+  });
+
+  describe('setDeltaTUserDefined', () => {
+    it('should not throw', () => {
+      swe.setDeltaTUserDefined(0.001);
+    });
+  });
+
+  describe('setInterpolateNutation', () => {
+    it('should not throw', () => {
+      swe.setInterpolateNutation(true);
+      swe.setInterpolateNutation(false);
+    });
+  });
+
+  describe('close', () => {
+    it('should not crash on double close', () => {
+      const s = new SwissEph();
+      s.close();
+      // Second close should not throw
+      s.close();
+    });
+  });
+});

package/tests/modern/crossings.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { SwissEph } from '../../src/SwissEph';
+import { SE_MARS } from '../../src/constants';
+
+describe('Crossings (modern)', () => {
+  let swe: SwissEph;
+
+  before(() => { swe = new SwissEph(); });
+  after(() => { swe.close(); });
+
+  describe('sunCrossing', () => {
+    it('vernal equinox 2000 should be Mar 20', () => {
+      const start = SwissEph.julianDay(2000, 3, 1, 0);
+      const r = swe.sunCrossing(0, start);
+      const d = SwissEph.fromJulianDay(r.jd);
+      assert.strictEqual(d.month, 3);
+      assert.strictEqual(d.day, 20);
+    });
+  });
+
+  describe('moonCrossing', () => {
+    it('should find Moon crossing 0 deg after J2000', () => {
+      const r = swe.moonCrossing(0, J2000);
+      assert.ok(r.jd > J2000);
+    });
+  });
+
+  describe('moonNodeCrossing', () => {
+    it('should find next node crossing', () => {
+      const r = swe.moonNodeCrossing(J2000);
+      assert.ok(r.jd > J2000);
+      assert.ok(typeof r.longitude === 'number');
+      assert.ok(typeof r.latitude === 'number');
+    });
+  });
+
+  describe('helioCrossing', () => {
+    it('Mars should cross 0 deg helio', () => {
+      const r = swe.helioCrossing(SE_MARS, 0, J2000);
+      assert.ok(r.jd > J2000);
+    });
+  });
+});