rave-engine 1.0.0

package/src/birth/parseBirth.js

@@ -0,0 +1,76 @@
+const { DateTime } = require('luxon');
+
+/**
+ * BirthParseError carries an HTTP-ish status code so a thin adapter (e.g. an
+ * Express handler) can map it back to a 400 response. We keep a plain class
+ * here so the engine doesn't need to know about Express.
+ */
+class BirthParseError extends Error {
+  constructor(message, statusCode = 400) {
+    super(message);
+    this.name = 'BirthParseError';
+    this.statusCode = statusCode;
+  }
+}
+
+function parseYmdLoose(v) {
+  // Accept both ISO-padded and non-padded dates:
+  // - YYYY-MM-DD
+  // - YYYY-M-D
+  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(String(v || '').trim());
+  if (!m) return null;
+  const year = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return null;
+  if (month < 1 || month > 12) return null;
+  if (day < 1 || day > 31) return null;
+  return { year, month, day };
+}
+
+function parseHmsLoose(v) {
+  // Accept:
+  // - HH:mm
+  // - H:mm
+  // - HH:mm:ss
+  const m = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/.exec(String(v || '').trim());
+  if (!m) return null;
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  const second = m[3] === undefined ? 0 : Number(m[3]);
+  if (!Number.isFinite(hour) || !Number.isFinite(minute) || !Number.isFinite(second)) return null;
+  if (hour < 0 || hour > 23) return null;
+  if (minute < 0 || minute > 59) return null;
+  if (second < 0 || second > 59) return null;
+  return { hour, minute, second };
+}
+
+function parseBirthToUtc({ birthdate, birthtime, timezone }) {
+  if (!birthdate || !birthtime || !timezone) {
+    throw new BirthParseError('manual mode requires birthdate, birthtime, timezone');
+  }
+
+  // birthdate: YYYY-MM-DD (or YYYY-M-D), birthtime: HH:mm (or H:mm) or HH:mm:ss
+  //
+  // NOTE:
+  // Luxon `DateTime.fromISO()` is strict about ISO padding (e.g. it rejects "1972-8-2").
+  // We normalize by parsing components and building a DateTime from an object instead.
+  const dateParts = parseYmdLoose(birthdate);
+  const timeParts = parseHmsLoose(birthtime);
+  if (!dateParts || !timeParts) {
+    throw new BirthParseError(
+      'Invalid birthdate/birthtime format. Expected birthdate "YYYY-MM-DD" (or "YYYY-M-D") and birthtime "HH:mm" (or "H:mm") optionally with seconds "HH:mm:ss".'
+    );
+  }
+
+  const dt = DateTime.fromObject({ ...dateParts, ...timeParts }, { zone: timezone });
+  if (!dt.isValid) {
+    throw new BirthParseError(
+      `Invalid datetime/timezone: ${dt.invalidReason || 'unknown'} (birthdate=${birthdate}, birthtime=${birthtime}, timezone=${timezone})`
+    );
+  }
+
+  return dt.toUTC().toJSDate();
+}
+
+module.exports = { parseBirthToUtc, BirthParseError };

package/src/calc/astronomia.js

@@ -0,0 +1,163 @@
+// Pure-JS ephemeris backend, built on the MIT-licensed `astronomia` package.
+//
+// This is the DEFAULT backend for rave-engine: no native build, no `.se1` data
+// files, no AGPL. It reproduces the same apparent geocentric tropical ecliptic
+// longitudes that the Swiss Ephemeris (`SEFLG_SWIEPH`) produces — validated to
+// the exact gate/line in the golden vectors (see test/profile.test.js).
+//
+// All longitudes are returned in DEGREES in [0, 360).
+//
+// Correctness note (the #1 trap): Swiss Ephemeris `swe_calc_ut` takes UT and
+// adds ΔT internally; astronomia's planet/Sun/Moon functions take JDE = UT + ΔT.
+// We convert UT → JDE once per call via `deltat.deltaT`, and keep all Julian
+// Days the caller sees in UT (the engine's `_meta` JDs are UT).
+
+const A = require('astronomia');
+const data = require('astronomia/data').default;
+
+const { normalizeAngleDegrees } = require('./mandala');
+
+const R2D = 180 / Math.PI;
+
+// VSOP87 planet instances (heliocentric spherical, "B" series). Built once.
+const EARTH = new A.planetposition.Planet(data.vsop87Bearth);
+const PLANETS = {
+  mercury: new A.planetposition.Planet(data.vsop87Bmercury),
+  venus: new A.planetposition.Planet(data.vsop87Bvenus),
+  mars: new A.planetposition.Planet(data.vsop87Bmars),
+  jupiter: new A.planetposition.Planet(data.vsop87Bjupiter),
+  saturn: new A.planetposition.Planet(data.vsop87Bsaturn),
+  uranus: new A.planetposition.Planet(data.vsop87Buranus),
+  neptune: new A.planetposition.Planet(data.vsop87Bneptune),
+};
+
+// Bodies this backend can place directly. Earth, south_node are DERIVED by the
+// caller (Earth = Sun + 180°, South Node = North Node + 180°).
+const BODIES = [
+  'sun',
+  'moon',
+  'mercury',
+  'venus',
+  'mars',
+  'jupiter',
+  'saturn',
+  'uranus',
+  'neptune',
+  'pluto',
+  'north_node',
+];
+
+/**
+ * Julian Day (UT) from a JS Date. Mirrors swe.swe_julday(..., SE_GREG_CAL).
+ * @param {Date} dt
+ * @returns {number} JD in UT
+ */
+function julianDayUT(dt) {
+  const hour =
+    dt.getUTCHours() +
+    dt.getUTCMinutes() / 60 +
+    dt.getUTCSeconds() / 3600 +
+    dt.getUTCMilliseconds() / 3600000;
+  // CalendarGregorianToJD takes a fractional day.
+  return A.julian.CalendarGregorianToJD(
+    dt.getUTCFullYear(),
+    dt.getUTCMonth() + 1,
+    dt.getUTCDate() + hour / 24
+  );
+}
+
+function toJDE(jdUT) {
+  const cal = A.julian.JDToCalendar(jdUT);
+  const yearFrac = cal.year + (cal.month - 1) / 12;
+  return jdUT + A.deltat.deltaT(yearFrac) / 86400;
+}
+
+function trueObliquity(jde) {
+  // mean obliquity + nutation in obliquity (Δε)
+  return A.nutation.meanObliquity(jde) + A.nutation.nutation(jde)[1];
+}
+
+function sunLonDeg(jde) {
+  // apparent (of-date) ecliptic longitude: includes nutation + aberration + FK5
+  return A.solar.apparentVSOP87(EARTH, jde).lon * R2D;
+}
+
+function planetLonDeg(name, jde) {
+  // apparent geocentric equatorial (light-time, aberration, FK5, +Δψ, true ε)
+  const pos = A.elliptic.position(PLANETS[name], EARTH, jde);
+  const eps = trueObliquity(jde);
+  const ecl = new A.coord.Equatorial(pos.ra, pos.dec).toEcliptic(eps);
+  return ecl.lon * R2D;
+}
+
+function moonLonDeg(jde) {
+  // mean equinox of date, no nutation → add Δψ for apparent
+  const pos = A.moonposition.position(jde);
+  const dpsi = A.nutation.nutation(jde)[0];
+  return (pos.lon + dpsi) * R2D;
+}
+
+function northNodeLonDeg(jde) {
+  // TRUE lunar ascending node (oscillating), matching mainstream Human Design
+  // calculators. astronomia returns it referenced to the mean equinox of date;
+  // add Δψ for apparent.
+  const dpsi = A.nutation.nutation(jde)[0];
+  return (A.moonposition.trueNode(jde) + dpsi) * R2D;
+}
+
+function plutoLonDeg(jde) {
+  // pluto.astrometric returns J2000 astrometric equatorial (note: fields are
+  // _ra / _dec). Convert to J2000 ecliptic, precess J2000 → date, then add Δψ
+  // for apparent-of-date longitude.
+  //
+  // IMPORTANT: EclipticPrecessor epochs are JULIAN YEARS (e.g. 2000.0), not
+  // Julian Days — passing JD here silently produces nonsense.
+  const astro = A.pluto.astrometric(jde, EARTH);
+  const eclJ2000 = new A.coord.Equatorial(astro._ra, astro._dec).toEcliptic(
+    A.nutation.meanObliquity(2451545.0)
+  );
+  const epochTo = 2000 + (jde - 2451545.0) / 365.25;
+  const prec = new A.precess.EclipticPrecessor(2000, epochTo);
+  const moved = prec.precess(new A.coord.Ecliptic(eclJ2000.lon, eclJ2000.lat));
+  const dpsi = A.nutation.nutation(jde)[0];
+  return (moved.lon + dpsi) * R2D;
+}
+
+/**
+ * Apparent geocentric tropical ecliptic longitude of `body` at `jdUT`.
+ * @param {string} body one of BODIES
+ * @param {number} jdUT Julian Day in UT
+ * @returns {number} longitude in degrees [0, 360)
+ */
+function longitude(body, jdUT) {
+  const jde = toJDE(jdUT);
+  let deg;
+  switch (body) {
+    case 'sun':
+      deg = sunLonDeg(jde);
+      break;
+    case 'moon':
+      deg = moonLonDeg(jde);
+      break;
+    case 'pluto':
+      deg = plutoLonDeg(jde);
+      break;
+    case 'north_node':
+      deg = northNodeLonDeg(jde);
+      break;
+    default:
+      if (!PLANETS[body]) throw new Error(`astronomia backend: unknown body "${body}"`);
+      deg = planetLonDeg(body, jde);
+  }
+  return normalizeAngleDegrees(deg);
+}
+
+module.exports = {
+  name: 'astronomia',
+  BODIES,
+  julianDayUT,
+  longitude,
+  // exposed for reuse/debugging
+  toJDE,
+  trueObliquity,
+};

package/src/calc/ephemeris.js

@@ -0,0 +1,61 @@
+// Ephemeris backend selector.
+//
+// rave-engine is pure-JS by default: the `astronomia` backend needs no native
+// build and no data files. A high-precision `swisseph` backend is available
+// opt-in (EPHE_BACKEND=swisseph) when the native binding + ephemeris files are
+// installed — it is never required.
+//
+// Both backends implement the same interface:
+//   { name, BODIES, julianDayUT(dt), longitude(body, jdUT) }   // degrees [0,360)
+
+const astronomiaBackend = require('./astronomia');
+
+let _backend = null;
+
+function parseBool(v) {
+  if (v === undefined || v === null || v === '') return false;
+  return String(v).toLowerCase() === 'true' || String(v) === '1';
+}
+
+function tryLoadSwisseph() {
+  try {
+    // eslint-disable-next-line global-require
+    return require('./swisseph');
+  } catch (e) {
+    if (parseBool(process.env.EPHE_DEBUG) || parseBool(process.env.EPHE_STATUS)) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[rave-engine] EPHE_BACKEND=swisseph requested but unavailable (${e.message.split('\n')[0]}). Falling back to astronomia.`
+      );
+    }
+    return null;
+  }
+}
+
+/**
+ * Resolve the active ephemeris backend (memoized).
+ * Default: astronomia. Opt into swisseph with EPHE_BACKEND=swisseph.
+ */
+function getBackend() {
+  if (_backend) return _backend;
+  if (String(process.env.EPHE_BACKEND || '').toLowerCase() === 'swisseph') {
+    const sw = tryLoadSwisseph();
+    if (sw) {
+      _backend = sw;
+      return _backend;
+    }
+  }
+  _backend = astronomiaBackend;
+  return _backend;
+}
+
+/**
+ * @deprecated No-op. Kept for backward compatibility with callers that set the
+ * Swiss Ephemeris data path. The default astronomia backend needs no data files;
+ * the optional swisseph backend resolves EPHE_PATH itself.
+ */
+function ensureEphePath() {
+  /* intentionally empty */
+}
+
+module.exports = { getBackend, ensureEphePath };

package/src/calc/mandala.js

@@ -0,0 +1,66 @@
+// Mandala / hexagram mapping helpers.
+//
+// Ported from preliminaries/gk_hex_profile.py to keep math identical.
+
+const pi2 = Math.PI * 2;
+
+// The wheel has 64 slices, each slice can be further subdivided into lines/colors/tones.
+const hex_width = pi2 / 64;
+const line_width = hex_width / 6;
+const color_width = line_width / 6;
+const tone_width = color_width / 6;
+const base_width = tone_width / 5;
+
+// start counting at 55, but this requires an offset in radiance!
+const iching_map = [
+  55, 37, 63, 22, 36, 25, 17, 21, 51, 42, 3, 27, 24, 2, 23, 8,
+  20, 16, 35, 45, 12, 15, 52, 39, 53, 62, 56, 31, 33, 7, 4, 29,
+  59, 40, 64, 47, 6, 46, 18, 48, 57, 32, 50, 28, 44, 1, 43, 14,
+  34, 9, 5, 26, 11, 10, 58, 38, 54, 61, 60, 41, 19, 13, 49, 30,
+];
+
+const DEG_TO_RADIANS = Math.PI / 180;
+const LINE_SEGMENT = 1 / 6;
+
+function neutron_stream_pos(radians_position) {
+  // (2*line_width - 1*color_width - 1*tone_width) plus additional offset.
+  const offset = 2 * line_width - 1 * color_width - 1 * tone_width + 3 * base_width;
+  const offset_calc = (360 * DEG_TO_RADIANS) / 64 * 5 + offset;
+  return (((radians_position + offset_calc) / pi2) * 64) % 64;
+}
+
+function map_on_hexagram(fractal_line) {
+  const fractal_bin = Math.floor(fractal_line);
+  const hexagram = iching_map[fractal_bin];
+
+  const remainder = fractal_line - fractal_bin;
+  const line = Math.floor(remainder / LINE_SEGMENT) + 1;
+
+  const color_bucket = remainder - LINE_SEGMENT * Math.floor(remainder / LINE_SEGMENT);
+  const color = Math.floor(color_bucket / LINE_SEGMENT) + 1;
+
+  return { hexagram, line, color };
+}
+
+function map_mandala_hexagram(radians_position) {
+  const bin_value = neutron_stream_pos(radians_position);
+  return map_on_hexagram(bin_value);
+}
+
+function normalizeAngleDegrees(angle) {
+  // [0, 360)
+  const out = angle % 360;
+  return out < 0 ? out + 360 : out;
+}
+
+function mapLongitudeDegrees(lonDeg) {
+  const lon = normalizeAngleDegrees(lonDeg);
+  return map_mandala_hexagram(lon * DEG_TO_RADIANS);
+}
+
+module.exports = {
+  mapLongitudeDegrees,
+  normalizeAngleDegrees,
+  // expose for debugging
+  iching_map,
+};

package/src/calc/profile.js

@@ -0,0 +1,288 @@
+const { mapLongitudeDegrees, normalizeAngleDegrees } = require('./mandala');
+const { getBackend, ensureEphePath } = require('./ephemeris');
+
+// Longitude speed is computed by central difference (only the sign is consumed,
+// for the `retrograde` flag, so this is extremely robust across backends).
+const SPEED_H = 0.5; // days
+
+function jdUtcFromDate(dt) {
+  return getBackend().julianDayUT(dt);
+}
+
+function signedAngleDiff(a, b) {
+  // minimal signed difference (a - b) in degrees within [-180, 180)
+  return ((a - b + 540) % 360) - 180;
+}
+
+function bodyLongitude(body, jdUt) {
+  return getBackend().longitude(body, jdUt);
+}
+
+function bodyLongitudeSpeed(body, jdUt) {
+  const hi = bodyLongitude(body, jdUt + SPEED_H);
+  const lo = bodyLongitude(body, jdUt - SPEED_H);
+  return signedAngleDiff(hi, lo) / (2 * SPEED_H);
+}
+
+function sunLongitudeDegrees(jdUt) {
+  return bodyLongitude('sun', jdUt);
+}
+
+/**
+ * Find the previous Julian Day (UT) at which the Sun's longitude was
+ * `deltaDegrees` behind its value at `jdUt`. Used to locate the Human Design
+ * "design" moment (88° of solar arc before birth).
+ *
+ * @param {number} jdUt
+ * @param {number} deltaDegrees
+ * @param {*} [_flags] deprecated/ignored (kept for backward compatibility)
+ */
+function findPreviousSolarLongitude(jdUt, deltaDegrees, _flags) {
+  const currentSun = sunLongitudeDegrees(jdUt);
+  const target = normalizeAngleDegrees(currentSun - deltaDegrees);
+
+  let highJd = jdUt;
+  const step = 1.0; // days
+  let lowJd = highJd - step;
+
+  let lowDiff = signedAngleDiff(sunLongitudeDegrees(lowJd), target);
+
+  let iterations = 0;
+  const maxIterations = 365;
+
+  // Walk back until we bracket the crossing.
+  while (lowDiff > 0 && iterations < maxIterations) {
+    lowJd -= step;
+    lowDiff = signedAngleDiff(sunLongitudeDegrees(lowJd), target);
+    iterations += 1;
+  }
+
+  if (lowDiff > 0) {
+    throw new Error('Failed to bracket previous solar longitude');
+  }
+
+  // Binary search for the crossing.
+  for (let i = 0; i < 50; i += 1) {
+    const mid = 0.5 * (lowJd + highJd);
+    const midDiff = signedAngleDiff(sunLongitudeDegrees(mid), target);
+    if (midDiff > 0) {
+      highJd = mid;
+    } else {
+      lowJd = mid;
+    }
+  }
+
+  return 0.5 * (lowJd + highJd);
+}
+
+function getBody(jdUt, body) {
+  return {
+    longitude: bodyLongitude(body, jdUt),
+    longitudeSpeed: bodyLongitudeSpeed(body, jdUt),
+  };
+}
+
+function deriveOpposite(planet) {
+  // Earth = Sun + 180°, South Node = North Node + 180°. Speed carries over.
+  return {
+    longitude: normalizeAngleDegrees(planet.longitude + 180),
+    longitudeSpeed: planet.longitudeSpeed,
+  };
+}
+
+function mapPlanetToGKLine(planet) {
+  const { hexagram, line } = mapLongitudeDegrees(planet.longitude);
+  return { gk: hexagram, line };
+}
+
+function mapPlanetToGateLineColor(planet) {
+  const { hexagram, line, color } = mapLongitudeDegrees(planet.longitude);
+  return {
+    gate: hexagram,
+    hexagram,
+    line,
+    color,
+    longitude: planet.longitude,
+    longitude_speed: planet.longitudeSpeed,
+    retrograde: planet.longitudeSpeed < 0,
+  };
+}
+
+// The two stream moments shared by every computation below.
+function streamMoments({ birthUtc }) {
+  const jdPersonality = jdUtcFromDate(birthUtc);
+  const jdDesign = findPreviousSolarLongitude(jdPersonality, 88.0);
+  return { jdPersonality, jdDesign };
+}
+
+function computeProfileSpheres({ birthUtc }) {
+  const { jdPersonality, jdDesign } = streamMoments({ birthUtc });
+
+  // Personality bodies
+  const pSun = getBody(jdPersonality, 'sun');
+  const pMercury = getBody(jdPersonality, 'mercury');
+  const pVenus = getBody(jdPersonality, 'venus');
+  const pMars = getBody(jdPersonality, 'mars');
+  const pJupiter = getBody(jdPersonality, 'jupiter');
+
+  // Design bodies
+  const dSun = getBody(jdDesign, 'sun');
+  const dMoon = getBody(jdDesign, 'moon');
+  const dVenus = getBody(jdDesign, 'venus');
+  const dMars = getBody(jdDesign, 'mars');
+  const dJupiter = getBody(jdDesign, 'jupiter');
+  const dSaturn = getBody(jdDesign, 'saturn');
+  const dUranus = getBody(jdDesign, 'uranus');
+
+  // Earth is opposite Sun in HD.
+  const pEarth = deriveOpposite(pSun);
+  const dEarth = deriveOpposite(dSun);
+
+  // Sphere → body map (parity with event-horizon-api):
+  // - p_sun = Life's Work,  p_earth = Evolution
+  // - d_sun = Radiance,     d_earth = Purpose
+  // - p_venus = IQ,  p_mars = EQ,  p_jupiter = Pearl,  p_mercury = Relating
+  // - d_moon = Attraction, d_venus = SQ, d_mars = Core, d_jupiter = Culture
+  // - d_saturn = Core Stability, d_uranus = Creativity
+  return {
+    lifeswork: mapPlanetToGKLine(pSun),
+    evolution: mapPlanetToGKLine(pEarth),
+    radiance: mapPlanetToGKLine(dSun),
+    purpose: mapPlanetToGKLine(dEarth),
+
+    iq: mapPlanetToGKLine(pVenus),
+    eq: mapPlanetToGKLine(pMars),
+    pearl: mapPlanetToGKLine(pJupiter),
+    relating: mapPlanetToGKLine(pMercury),
+
+    attraction: mapPlanetToGKLine(dMoon),
+    sq: mapPlanetToGKLine(dVenus),
+    core: mapPlanetToGKLine(dMars),
+    culture: mapPlanetToGKLine(dJupiter),
+    stability: mapPlanetToGKLine(dSaturn),
+    creativity: mapPlanetToGKLine(dUranus),
+
+    _meta: {
+      jd_personality: jdPersonality,
+      jd_design: jdDesign,
+    },
+  };
+}
+
+function computeEngineTest({ birthUtc }) {
+  const { jdPersonality, jdDesign } = streamMoments({ birthUtc });
+
+  // Personality bodies
+  const pSun = getBody(jdPersonality, 'sun');
+  const pMercury = getBody(jdPersonality, 'mercury');
+  const pVenus = getBody(jdPersonality, 'venus');
+  const pMars = getBody(jdPersonality, 'mars');
+  const pJupiter = getBody(jdPersonality, 'jupiter');
+
+  // Design bodies
+  const dSun = getBody(jdDesign, 'sun');
+  const dMoon = getBody(jdDesign, 'moon');
+  const dVenus = getBody(jdDesign, 'venus');
+  const dMars = getBody(jdDesign, 'mars');
+  const dJupiter = getBody(jdDesign, 'jupiter');
+  const dSaturn = getBody(jdDesign, 'saturn');
+  const dUranus = getBody(jdDesign, 'uranus');
+
+  const pEarth = deriveOpposite(pSun);
+  const dEarth = deriveOpposite(dSun);
+
+  return {
+    p_: {
+      sun: mapPlanetToGateLineColor(pSun),
+      earth: mapPlanetToGateLineColor(pEarth),
+      mercury: mapPlanetToGateLineColor(pMercury),
+      venus: mapPlanetToGateLineColor(pVenus),
+      mars: mapPlanetToGateLineColor(pMars),
+      jupiter: mapPlanetToGateLineColor(pJupiter),
+    },
+    d_: {
+      sun: mapPlanetToGateLineColor(dSun),
+      earth: mapPlanetToGateLineColor(dEarth),
+      moon: mapPlanetToGateLineColor(dMoon),
+      venus: mapPlanetToGateLineColor(dVenus),
+      mars: mapPlanetToGateLineColor(dMars),
+      jupiter: mapPlanetToGateLineColor(dJupiter),
+      saturn: mapPlanetToGateLineColor(dSaturn),
+      uranus: mapPlanetToGateLineColor(dUranus),
+    },
+    spheres: computeProfileSpheres({ birthUtc }),
+    _meta: {
+      jd_personality: jdPersonality,
+      jd_design: jdDesign,
+    },
+  };
+}
+
+// Full Human Design activation set: all 13 bodies in BOTH streams (26 gates),
+// used to derive the bodygraph (centers / channels). Earth and South Node are
+// derived from Sun / North Node.
+const HD_BODIES = [
+  'sun',
+  'earth',
+  'moon',
+  'north_node',
+  'south_node',
+  'mercury',
+  'venus',
+  'mars',
+  'jupiter',
+  'saturn',
+  'uranus',
+  'neptune',
+  'pluto',
+];
+
+function activationAt(jdUt, body) {
+  let planet;
+  if (body === 'earth') planet = deriveOpposite(getBody(jdUt, 'sun'));
+  else if (body === 'south_node') planet = deriveOpposite(getBody(jdUt, 'north_node'));
+  else planet = getBody(jdUt, body);
+
+  const { hexagram, line, color } = mapLongitudeDegrees(planet.longitude);
+  return {
+    body,
+    gate: hexagram,
+    line,
+    color,
+    longitude: planet.longitude,
+    retrograde: planet.longitudeSpeed < 0,
+  };
+}
+
+/**
+ * Compute the 26 Human Design activations (13 bodies × personality + design).
+ * @param {{ birthUtc: Date }} args
+ * @returns {{
+ *   personality: Array<object>,
+ *   design: Array<object>,
+ *   _meta: { jd_personality: number, jd_design: number }
+ * }}
+ */
+function computeActivations({ birthUtc }) {
+  const { jdPersonality, jdDesign } = streamMoments({ birthUtc });
+  const personality = HD_BODIES.map((b) => ({ stream: 'personality', ...activationAt(jdPersonality, b) }));
+  const design = HD_BODIES.map((b) => ({ stream: 'design', ...activationAt(jdDesign, b) }));
+  return {
+    personality,
+    design,
+    _meta: { jd_personality: jdPersonality, jd_design: jdDesign },
+  };
+}
+
+module.exports = {
+  computeProfileSpheres,
+  computeEngineTest,
+  computeActivations,
+  jdUtcFromDate,
+  // Exported for reuse in global transit scanning (design stream).
+  findPreviousSolarLongitude,
+  signedAngleDiff,
+  // Kept exported for backward compatibility (now a no-op).
+  ensureEphePath,
+  HD_BODIES,
+};