@cosmosos/mcp-ephemeris 0.1.0

package/dist/index.js

@@ -0,0 +1,1808 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'module';
+const require = __createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// ../ephemeris/src/astrocartography.ts
+var DEG = Math.PI / 180;
+var RAD = 180 / Math.PI;
+function norm360(x) {
+  return (x % 360 + 360) % 360;
+}
+function wrap180(x) {
+  const v = norm360(x + 180) - 180;
+  return v;
+}
+var DEFAULTS = { latMin: -66, latMax: 66, latStep: 1.5 };
+function eclipticToEquatorial(lonDeg, latDeg, oblDeg) {
+  const l = lonDeg * DEG;
+  const b = latDeg * DEG;
+  const e = oblDeg * DEG;
+  const sinl = Math.sin(l);
+  const ra = Math.atan2(
+    sinl * Math.cos(e) - Math.tan(b) * Math.sin(e),
+    Math.cos(l)
+  );
+  const dec = Math.asin(
+    Math.sin(b) * Math.cos(e) + Math.cos(b) * Math.sin(e) * sinl
+  );
+  return { ra: norm360(ra * RAD), dec: dec * RAD };
+}
+function bodyLines(body, gstDeg, opts = {}) {
+  const { latMin, latMax, latStep } = { ...DEFAULTS, ...opts };
+  const { ra, dec } = body;
+  if (!Number.isFinite(ra) || !Number.isFinite(dec)) {
+    return { key: body.key, mcLng: NaN, icLng: NaN, asc: [], dsc: [] };
+  }
+  const mcLng = wrap180(ra - gstDeg);
+  const icLng = wrap180(mcLng + 180);
+  const asc = [];
+  const dsc = [];
+  const tanDec = Math.tan(dec * DEG);
+  for (let lat = latMax; lat >= latMin - 1e-9; lat -= latStep) {
+    const cosH = -Math.tan(lat * DEG) * tanDec;
+    if (cosH < -1 || cosH > 1) continue;
+    const H = Math.acos(cosH) * RAD;
+    asc.push({ lat, lng: wrap180(ra - H - gstDeg) });
+    dsc.push({ lat, lng: wrap180(ra + H - gstDeg) });
+  }
+  return { key: body.key, mcLng, icLng, asc, dsc };
+}
+function computeAcgLines(bodies, gstDeg, opts = {}) {
+  return bodies.map((b) => bodyLines(b, gstDeg, opts));
+}
+var MERIDIAN_LAT = 85;
+function bodyPolys(l) {
+  return [
+    { key: l.key, angle: "MC", pts: [{ x: l.mcLng, y: MERIDIAN_LAT }, { x: l.mcLng, y: -MERIDIAN_LAT }] },
+    { key: l.key, angle: "IC", pts: [{ x: l.icLng, y: MERIDIAN_LAT }, { x: l.icLng, y: -MERIDIAN_LAT }] },
+    { key: l.key, angle: "AC", pts: l.asc.map((p) => ({ x: p.lng, y: p.lat })) },
+    { key: l.key, angle: "DC", pts: l.dsc.map((p) => ({ x: p.lng, y: p.lat })) }
+  ];
+}
+function segIntersect(a, b, c, d) {
+  const rx = b.x - a.x, ry = b.y - a.y;
+  const sx = d.x - c.x, sy = d.y - c.y;
+  const den = rx * sy - ry * sx;
+  if (!(Math.abs(den) >= 1e-12)) return null;
+  const t = ((c.x - a.x) * sy - (c.y - a.y) * sx) / den;
+  const u = ((c.x - a.x) * ry - (c.y - a.y) * rx) / den;
+  if (!(t >= 0 && t <= 1 && u >= 0 && u <= 1)) return null;
+  return { x: a.x + t * rx, y: a.y + t * ry };
+}
+function splitSegments(pts) {
+  const segs = [];
+  let cur = [];
+  let prev = null;
+  for (const p of pts) {
+    if (prev && Math.abs(p.x - prev.x) > 180) {
+      if (cur.length) segs.push(cur);
+      cur = [];
+    }
+    cur.push(p);
+    prev = p;
+  }
+  if (cur.length) segs.push(cur);
+  return segs;
+}
+function findParans(lines, dedupDeg = 1.5) {
+  const polysByBody = lines.map(bodyPolys);
+  const out = [];
+  for (let i = 0; i < polysByBody.length; i++) {
+    for (let j = i + 1; j < polysByBody.length; j++) {
+      for (const la of polysByBody[i]) {
+        for (const lb of polysByBody[j]) {
+          const segsA = splitSegments(la.pts);
+          const segsB = splitSegments(lb.pts);
+          for (const sa of segsA) {
+            for (let k = 0; k < sa.length - 1; k++) {
+              for (const sb of segsB) {
+                for (let m = 0; m < sb.length - 1; m++) {
+                  const x = segIntersect(sa[k], sa[k + 1], sb[m], sb[m + 1]);
+                  if (!x) continue;
+                  out.push({
+                    aKey: la.key,
+                    bKey: lb.key,
+                    aAngle: la.angle,
+                    bAngle: lb.angle,
+                    lat: x.y,
+                    lng: x.x
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const kept = [];
+  for (const p of out) {
+    const dup = kept.some(
+      (q) => q.aKey === p.aKey && q.bKey === p.bKey && q.aAngle === p.aAngle && q.bAngle === p.bAngle && Math.abs(q.lat - p.lat) < dedupDeg && Math.abs(q.lng - p.lng) < dedupDeg
+    );
+    if (!dup) kept.push(p);
+  }
+  return kept;
+}
+
+// ../ephemeris/src/numerology.ts
+function computeLifePath(localBirthDate) {
+  function reduceToDigit(n) {
+    while (n > 9) {
+      n = String(n).split("").reduce((s, c) => s + Number(c), 0);
+    }
+    return n;
+  }
+  function reducePreserveMasters(n) {
+    while (n > 9 && n !== 11 && n !== 22 && n !== 33) {
+      n = String(n).split("").reduce((s, c) => s + Number(c), 0);
+    }
+    return n;
+  }
+  try {
+    const m = (localBirthDate || "").match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!m) return 0;
+    const year = Number(m[1]);
+    const month = Number(m[2]);
+    const day = Number(m[3]);
+    return reducePreserveMasters(reduceToDigit(day) + reduceToDigit(month) + reduceToDigit(year));
+  } catch {
+    return 0;
+  }
+}
+
+// ../ephemeris/src/engine-core.ts
+var PI = Math.PI;
+var R = PI / 180;
+var D = 180 / PI;
+function n360(x) {
+  return (x % 360 + 360) % 360;
+}
+function nutLon(T) {
+  const O = (125.04 - 1934.136 * T) * R;
+  const L = (280.4665 + 36000.7698 * T) * R;
+  const Lp = (218.3165 + 481267.8813 * T) * R;
+  return (-17.2 * Math.sin(O) - 1.32 * Math.sin(2 * L) - 0.23 * Math.sin(2 * Lp) + 0.21 * Math.sin(2 * O)) / 3600;
+}
+function obl(T) {
+  return 23.439291 - 0.013004 * T - 164e-9 * T * T + 504e-9 * T * T * T;
+}
+function solveKepler(Mdeg, e) {
+  const M = Mdeg * R;
+  let E = M + e * Math.sin(M);
+  for (let i = 0; i < 200; i++) {
+    const dE = (M - E + e * Math.sin(E)) / (1 - e * Math.cos(E));
+    E += dE;
+    if (Math.abs(dE) < 1e-12) break;
+  }
+  return E;
+}
+
+// ../ephemeris/src/vsop.ts
+var PE = {
+  earth: { L0: 100.46646, L1: 36000.76983, p0: 102.937, p1: 1198, e0: 0.01671, e1: -42e-6, a: 1, i: 0, Om: 0 },
+  mercury: { L0: 252.2503, L1: 149472.675, p0: 77.456, p1: 5719, e0: 0.20563, e1: 204e-7, a: 0.3871, i: 7.005, Om: 48.331 },
+  venus: { L0: 181.9798, L1: 58517.816, p0: 131.564, p1: 175, e0: 677e-5, e1: -478e-7, a: 0.72334, i: 3.395, Om: 76.68 },
+  mars: { L0: 355.4333, L1: 19140.299, p0: 336.06, p1: 15843, e0: 0.0934, e1: 905e-7, a: 1.52371, i: 1.85, Om: 49.558 },
+  jupiter: { L0: 34.3515, L1: 3034.906, p0: 14.331, p1: 7759, e0: 0.04839, e1: 163e-6, a: 5.20289, i: 1.303, Om: 100.464 },
+  saturn: { L0: 50.0775, L1: 1222.114, p0: 93.057, p1: 12722, e0: 0.05551, e1: -347e-6, a: 9.53668, i: 2.489, Om: 113.665 },
+  uranus: { L0: 314.055, L1: 428.467, p0: 173.005, p1: 4207, e0: 0.0463, e1: -273e-7, a: 19.1892, i: 0.773, Om: 74.006 },
+  neptune: { L0: 304.349, L1: 218.486, p0: 48.123, p1: 5766, e0: 899e-5, e1: 64e-7, a: 30.0699, i: 1.77, Om: 131.784 },
+  pluto: { L0: 238.929, L1: 145.208, p0: 224.067, p1: 4223, e0: 0.24883, e1: 6e-5, a: 39.4821, i: 17.16, Om: 110.303 },
+  chiron: { L0: 209.39, L1: 26098.35, p0: 339.47, p1: 5765, e0: 0.3789, e1: 0, a: 13.648, i: 6.93, Om: 209.21 }
+};
+var OUTER_PLANETS = ["mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto", "chiron"];
+function helioPos3D(key, T) {
+  const e = PE[key];
+  if (!e) return { x: 0, y: 0, z: 0, lon: 0, r: 0 };
+  const L = n360(e.L0 + e.L1 * T);
+  const peri = n360(e.p0 + e.p1 * T / 3600);
+  const ecc = e.e0 + e.e1 * T;
+  const M = n360(L - peri);
+  const E = solveKepler(M, ecc);
+  const v = 2 * Math.atan2(
+    Math.sqrt(1 + ecc) * Math.sin(E / 2),
+    Math.sqrt(1 - ecc) * Math.cos(E / 2)
+  ) * D;
+  const hLon = n360(v + peri);
+  const r = e.a * (1 - ecc * Math.cos(E));
+  const inc = e.i * R;
+  const Om = e.Om * R;
+  const lon = hLon * R;
+  return {
+    x: r * (Math.cos(Om) * Math.cos(lon - Om) - Math.sin(Om) * Math.sin(lon - Om) * Math.cos(inc)),
+    y: r * (Math.sin(Om) * Math.cos(lon - Om) + Math.cos(Om) * Math.sin(lon - Om) * Math.cos(inc)),
+    z: r * Math.sin(lon - Om) * Math.sin(inc),
+    lon: hLon,
+    r
+  };
+}
+function helioToGeoLon(p, e) {
+  const xg = p.x - e.x;
+  const yg = p.y - e.y;
+  return n360(Math.atan2(yg, xg) * D);
+}
+function helioToGeoLonLat(p, e) {
+  const xg = p.x - e.x;
+  const yg = p.y - e.y;
+  const zg = p.z - e.z;
+  return {
+    lon: n360(Math.atan2(yg, xg) * D),
+    lat: Math.atan2(zg, Math.hypot(xg, yg)) * D
+  };
+}
+function isRetrograde(key, JD) {
+  if (!(key in PE)) return false;
+  const T1 = (JD - 0.5 - 2451545) / 36525;
+  const T2 = (JD + 0.5 - 2451545) / 36525;
+  const e1 = helioPos3D("earth", T1), e2 = helioPos3D("earth", T2);
+  const p1 = helioPos3D(key, T1), p2 = helioPos3D(key, T2);
+  const g1 = helioToGeoLon(p1, e1);
+  const g2 = helioToGeoLon(p2, e2);
+  let diff = g2 - g1;
+  if (diff > 180) diff -= 360;
+  if (diff < -180) diff += 360;
+  return diff < 0;
+}
+
+// ../ephemeris/src/solar-lunar.ts
+function sunGeo(T) {
+  const L0 = n360(280.46646 + 36000.76983 * T + 3032e-7 * T * T);
+  const M = n360(357.52911 + 35999.05029 * T - 1537e-7 * T * T);
+  const Mr = M * R;
+  const e = 0.016708634 - 42037e-9 * T - 1267e-10 * T * T;
+  const C = (1.914602 - 4817e-6 * T - 14e-6 * T * T) * Math.sin(Mr) + (0.019993 - 101e-6 * T) * Math.sin(2 * Mr) + 289e-6 * Math.sin(3 * Mr);
+  const lon = n360(L0 + C + nutLon(T) - 5694e-6);
+  const r = 1.000001018 * (1 - e * e) / (1 + e * Math.cos(Mr + C * R));
+  return { lon, r };
+}
+function moonGeo(T) {
+  const Lp = n360(218.3165 + 481267.8813 * T + nutLon(T));
+  const D2 = (297.8502 + 445267.1115 * T) * R;
+  const M = (357.5291 + 35999.0503 * T) * R;
+  const Mp = (134.9634 + 477198.8676 * T) * R;
+  const F = (93.272 + 483202.0175 * T) * R;
+  return n360(
+    Lp + 6.289 * Math.sin(Mp) + 1.274 * Math.sin(2 * D2 - Mp) + 0.658 * Math.sin(2 * D2) + 0.214 * Math.sin(2 * Mp) - 0.186 * Math.sin(M) - 0.114 * Math.sin(2 * F) + 0.059 * Math.sin(2 * D2 - 2 * Mp) + 0.057 * Math.sin(2 * D2 - M - Mp) + 0.053 * Math.sin(2 * D2 + Mp) + 0.046 * Math.sin(2 * D2 - M) - 0.041 * Math.sin(M - Mp) - 0.035 * Math.sin(D2) - 0.03 * Math.sin(M + Mp) + 0.015 * Math.sin(2 * D2 - 2 * F)
+  );
+}
+function lunarNode(T) {
+  return n360(125.0446 - 1934.1363 * T + 21e-4 * T * T);
+}
+function moonLat(T) {
+  const F = (93.2721 + 483202.0175 * T) * R;
+  const Mp = (134.9634 + 477198.8676 * T) * R;
+  const D2 = (297.8502 + 445267.1115 * T) * R;
+  const M = (357.5291 + 35999.0503 * T) * R;
+  return 5.128189 * Math.sin(F) + 0.280606 * Math.sin(Mp + F) + 0.277693 * Math.sin(Mp - F) + 0.173238 * Math.sin(2 * D2 - F) + 0.055413 * Math.sin(2 * D2 + F - Mp) + 0.046272 * Math.sin(2 * D2 - F - Mp) + 0.032573 * Math.sin(2 * D2 + F) + 0.017198 * Math.sin(2 * Mp + F) + 9267e-6 * Math.sin(2 * D2 + Mp - F) + 8823e-6 * Math.sin(2 * Mp - F) + 8247e-6 * Math.sin(2 * D2 - M - F);
+}
+var MOON_PHASES_FR = {
+  moon_new: { phase: "Nouvelle Lune", description: "Temps des semences et des intentions nouvelles" },
+  moon_waxc: { phase: "Premier croissant", description: "Croissance, construction, prise d'\xE9lan" },
+  moon_firstq: { phase: "Premier quartier", description: "D\xE9cisions, action, d\xE9passement des obstacles" },
+  moon_waxg: { phase: "Gibbeuse croissante", description: "Perfectionnement, ajustements, pers\xE9v\xE9rance" },
+  moon_full: { phase: "Pleine Lune", description: "Culmination, r\xE9v\xE9lation, intensit\xE9 \xE9motionnelle" },
+  moon_wang: { phase: "Gibbeuse d\xE9croissante", description: "Gratitude, partage, diffusion" },
+  moon_lastq: { phase: "Dernier quartier", description: "L\xE2cher-prise, r\xE9visions, ajustements" },
+  moon_wanc: { phase: "Dernier croissant", description: "Repos, introspection, purification" }
+};
+function moonPhase(JD) {
+  const T = (JD - 2451545) / 36525;
+  const sl = sunGeo(T).lon;
+  const ml = moonGeo(T);
+  const el = n360(ml - sl);
+  let k, emoji;
+  if (el < 11.25) {
+    k = "moon_new";
+    emoji = "\u{1F311}";
+  } else if (el < 78.75) {
+    k = "moon_waxc";
+    emoji = "\u{1F312}";
+  } else if (el < 101.25) {
+    k = "moon_firstq";
+    emoji = "\u{1F313}";
+  } else if (el < 168.75) {
+    k = "moon_waxg";
+    emoji = "\u{1F314}";
+  } else if (el < 191.25) {
+    k = "moon_full";
+    emoji = "\u{1F315}";
+  } else if (el < 258.75) {
+    k = "moon_wang";
+    emoji = "\u{1F316}";
+  } else if (el < 281.25) {
+    k = "moon_lastq";
+    emoji = "\u{1F317}";
+  } else if (el < 348.75) {
+    k = "moon_wanc";
+    emoji = "\u{1F318}";
+  } else {
+    k = "moon_new";
+    emoji = "\u{1F311}";
+  }
+  const info = MOON_PHASES_FR[k];
+  const illumination = (1 - Math.cos(el * R)) / 2;
+  return {
+    key: k,
+    phase: info.phase,
+    emoji,
+    illumination: Math.round(illumination * 100) / 100,
+    description: info.description
+  };
+}
+
+// ../ephemeris/src/houses.ts
+function gmst(JD) {
+  const T = (JD - 2451545) / 36525;
+  return n360(280.46061837 + 360.98564736629 * (JD - 2451545) + 387933e-9 * T * T - T * T * T / 3871e4);
+}
+function lst(JD, lng) {
+  return n360(gmst(JD) + lng);
+}
+function gmstDeg(JD) {
+  return gmst(JD);
+}
+function calcASC(RAMC, lat, ob) {
+  const t = RAMC * R, l = lat * R, e = ob * R;
+  return n360(Math.atan2(Math.cos(t), -(Math.sin(t) * Math.cos(e) + Math.tan(l) * Math.sin(e))) * D);
+}
+function calcMC(RAMC, ob) {
+  const t = RAMC * R, e = ob * R;
+  return n360(Math.atan2(Math.sin(t), Math.cos(t) * Math.cos(e)) * D);
+}
+function placidusHouses(RAMC, lat, ob) {
+  const asc = calcASC(RAMC, lat, ob);
+  const mc = calcMC(RAMC, ob);
+  const c = new Array(12).fill(0);
+  c[0] = asc;
+  c[9] = mc;
+  c[3] = n360(mc + 180);
+  c[6] = n360(asc + 180);
+  const ee = ob * R;
+  const ll = lat * R;
+  function eclOfRA(ra) {
+    const r = ra * R;
+    return n360(Math.atan2(Math.sin(r), Math.cos(r) * Math.cos(ee)) * D);
+  }
+  function pCusp(offset, k) {
+    let ra = n360(RAMC + offset);
+    for (let it = 0; it < 50; it++) {
+      const lon = eclOfRA(ra) * R;
+      const decl = Math.asin(Math.sin(ee) * Math.sin(lon));
+      const x = Math.tan(ll) * Math.tan(decl);
+      if (Math.abs(x) >= 1) throw new Error("placidus: cuspide circumpolaire");
+      const next = n360(RAMC + offset + k * Math.asin(x) * D);
+      const step = Math.abs(n360(next - ra + 180) - 180);
+      ra = next;
+      if (step < 1e-4) break;
+    }
+    return eclOfRA(ra);
+  }
+  try {
+    c[10] = pCusp(30, 1 / 3);
+    c[11] = pCusp(60, 2 / 3);
+    c[1] = pCusp(120, 2 / 3);
+    c[2] = pCusp(150, 1 / 3);
+  } catch {
+    const d1 = n360(asc - mc);
+    const d2 = n360(mc + 180 - asc);
+    c[10] = n360(mc + d1 / 3);
+    c[11] = n360(mc + 2 * d1 / 3);
+    c[1] = n360(asc + d2 / 3);
+    c[2] = n360(asc + 2 * d2 / 3);
+  }
+  c[4] = n360(c[10] + 180);
+  c[5] = n360(c[11] + 180);
+  c[7] = n360(c[1] + 180);
+  c[8] = n360(c[2] + 180);
+  return c;
+}
+function equalHouses(asc) {
+  return Array.from({ length: 12 }, (_, i) => n360(asc + i * 30));
+}
+function wholeSignHouses(asc) {
+  const base = Math.floor(asc / 30) * 30;
+  return Array.from({ length: 12 }, (_, i) => n360(base + i * 30));
+}
+function kochHouses(RAMC, lat, ob) {
+  return placidusHouses(RAMC, lat, ob);
+}
+function calculateHousesByCoords(system, JD, lat, lng) {
+  const T = (JD - 2451545) / 36525;
+  const ob = obl(T);
+  const RA = lst(JD, lng);
+  const asc = calcASC(RA, lat, ob);
+  const mc = calcMC(RA, ob);
+  let cusps;
+  switch (system) {
+    case "equal":
+      cusps = equalHouses(asc);
+      break;
+    case "whole_sign":
+      cusps = wholeSignHouses(asc);
+      break;
+    case "koch":
+      cusps = kochHouses(RA, lat, ob);
+      break;
+    case "placidus":
+    default:
+      cusps = placidusHouses(RA, lat, ob);
+  }
+  return { cusps, asc, mc, vertex: null, system };
+}
+function houseOfLongitude(lon, cusps) {
+  for (let i = 0; i < 12; i++) {
+    const n = (i + 1) % 12;
+    const s = cusps[i], e = cusps[n];
+    if (e < s) {
+      if (lon >= s || lon < e) return i + 1;
+    } else {
+      if (lon >= s && lon < e) return i + 1;
+    }
+  }
+  return 1;
+}
+
+// ../ephemeris/src/aspects.ts
+var ASPECT_TYPES = [
+  { type: "conjunction", nameFr: "Conjonction", angle: 0, orb: 8, tone: "n", symbol: "\u260C" },
+  { type: "sextile", nameFr: "Sextile", angle: 60, orb: 6, tone: "h", symbol: "\u26B9" },
+  { type: "square", nameFr: "Carr\xE9", angle: 90, orb: 7, tone: "t", symbol: "\u25A1" },
+  { type: "trine", nameFr: "Trigone", angle: 120, orb: 8, tone: "h", symbol: "\u25B3" },
+  { type: "opposition", nameFr: "Opposition", angle: 180, orb: 8, tone: "t", symbol: "\u260D" },
+  { type: "quincunx", nameFr: "Quinconce", angle: 150, orb: 3, tone: "t", symbol: "\u26BB" }
+];
+var MINOR_ASPECT_TYPES = [
+  { type: "semisextile", nameFr: "Semi-sextile", angle: 30, orb: 2, tone: "n", symbol: "\u26BA" },
+  { type: "semisquare", nameFr: "Semi-carr\xE9", angle: 45, orb: 2, tone: "t", symbol: "\u2220" },
+  { type: "sesquiquadrate", nameFr: "Sesqui-carr\xE9", angle: 135, orb: 2, tone: "t", symbol: "\u26BC" },
+  { type: "quintile", nameFr: "Quintile", angle: 72, orb: 2, tone: "n", symbol: "Q" }
+];
+var NATAL_ASPECT_TYPES = [...ASPECT_TYPES, ...MINOR_ASPECT_TYPES];
+function calculateAspects(pos) {
+  const skip = /* @__PURE__ */ new Set([
+    "northNode",
+    "southNode",
+    "fortune",
+    "ceres",
+    "pallas",
+    "juno",
+    "vesta",
+    "lilithTrue"
+  ]);
+  const keys = Object.keys(pos).filter((k) => !skip.has(k));
+  const out = [];
+  for (let i = 0; i < keys.length - 1; i++) {
+    for (let j = i + 1; j < keys.length; j++) {
+      const k1 = keys[i], k2 = keys[j];
+      let d = Math.abs(pos[k1].longitude - pos[k2].longitude);
+      if (d > 180) d = 360 - d;
+      for (const a of NATAL_ASPECT_TYPES) {
+        const isLum = k1 === "sun" || k1 === "moon" || k2 === "sun" || k2 === "moon";
+        const maxOrb = a.orb + (isLum ? 2 : 0);
+        const o = Math.abs(d - a.angle);
+        if (o <= maxOrb) {
+          out.push({
+            p1: k1,
+            p2: k2,
+            type: a.type,
+            typeFr: a.nameFr,
+            angle: a.angle,
+            orb: o,
+            exact: o < 1,
+            symbol: a.symbol,
+            tone: a.tone
+          });
+        }
+      }
+    }
+  }
+  return out.sort((a, b) => a.orb - b.orb);
+}
+
+// ../ephemeris/src/lots.ts
+function partOfFortune(sunLon, moonLon, asc, isNight) {
+  return isNight ? n360(asc + sunLon - moonLon) : n360(asc + moonLon - sunLon);
+}
+function computeHermeticLots(asc, planets, isNight, fortune) {
+  const lon = (k) => planets[k]?.longitude ?? 0;
+  const lot = (a, b) => n360(isNight ? asc + b - a : asc + a - b);
+  const spirit = lot(lon("sun"), lon("moon"));
+  return {
+    fortune,
+    spirit,
+    eros: lot(lon("venus"), spirit),
+    necessity: lot(fortune, lon("mercury")),
+    courage: lot(fortune, lon("mars")),
+    victory: lot(lon("jupiter"), spirit),
+    nemesis: lot(fortune, lon("saturn"))
+  };
+}
+
+// ../ephemeris/src/astro-engine.ts
+function allPositions(JD) {
+  const T = (JD - 2451545) / 36525;
+  const pos = {};
+  const sun = sunGeo(T);
+  pos["sun"] = {
+    key: "sun",
+    longitude: sun.lon,
+    signIdx: Math.floor(sun.lon / 30),
+    degree: sun.lon % 30
+  };
+  const ml = moonGeo(T);
+  pos["moon"] = {
+    key: "moon",
+    longitude: ml,
+    signIdx: Math.floor(ml / 30),
+    degree: ml % 30
+  };
+  const earthH = helioPos3D("earth", T);
+  OUTER_PLANETS.forEach((k) => {
+    const pH = helioPos3D(k, T);
+    const lon = helioToGeoLon(pH, earthH);
+    pos[k] = {
+      key: k,
+      longitude: lon,
+      signIdx: Math.floor(lon / 30),
+      degree: lon % 30
+    };
+  });
+  const nn = lunarNode(T);
+  pos["northNode"] = {
+    key: "northNode",
+    longitude: nn,
+    signIdx: Math.floor(nn / 30),
+    degree: nn % 30,
+    retrograde: true
+  };
+  const sn = n360(nn + 180);
+  pos["southNode"] = {
+    key: "southNode",
+    longitude: sn,
+    signIdx: Math.floor(sn / 30),
+    degree: sn % 30,
+    retrograde: true
+  };
+  return pos;
+}
+var ACG_BODY_KEYS = [
+  "sun",
+  "moon",
+  "mercury",
+  "venus",
+  "mars",
+  "jupiter",
+  "saturn",
+  "uranus",
+  "neptune",
+  "pluto"
+];
+function equatorialPositions(JD) {
+  const T = (JD - 2451545) / 36525;
+  const eps = obl(T);
+  const out = {};
+  out["sun"] = eclipticToEquatorial(sunGeo(T).lon, 0, eps);
+  out["moon"] = eclipticToEquatorial(moonGeo(T), moonLat(T), eps);
+  const earthH = helioPos3D("earth", T);
+  for (const k of ["mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"]) {
+    const g = helioToGeoLonLat(helioPos3D(k, T), earthH);
+    out[k] = eclipticToEquatorial(g.lon, g.lat, eps);
+  }
+  out["northNode"] = eclipticToEquatorial(lunarNode(T), 0, eps);
+  return out;
+}
+function ayanamsa(JD) {
+  const T = (JD - 2451545) / 36525;
+  const y = 2e3 + T * 100;
+  return 22.46 + 1.3748 * (y - 1900) / 100 - 572e-6 * (y - 1900) * (y - 1900) / 1e6;
+}
+function toSidereal(lon, JD) {
+  return n360(lon - ayanamsa(JD));
+}
+function computeChartFromJD(JD, latitude, longitude, opts = {}) {
+  const zodiac = opts.zodiac ?? "tropical";
+  const houseSystem = opts.houseSystem ?? "placidus";
+  const T = (JD - 2451545) / 36525;
+  let planets = allPositions(JD);
+  if (zodiac === "sidereal") {
+    const adjusted = {};
+    for (const k of Object.keys(planets)) {
+      const slon = toSidereal(planets[k].longitude, JD);
+      adjusted[k] = {
+        ...planets[k],
+        longitude: slon,
+        signIdx: Math.floor(slon / 30),
+        degree: slon % 30
+      };
+    }
+    planets = adjusted;
+  }
+  const houses = calculateHousesByCoords(houseSystem, JD, latitude, longitude);
+  if (zodiac === "sidereal") {
+    houses.cusps = houses.cusps.map((c) => toSidereal(c, JD));
+    houses.asc = toSidereal(houses.asc, JD);
+    houses.mc = toSidereal(houses.mc, JD);
+  }
+  for (const k of Object.keys(planets)) {
+    planets[k].house = houseOfLongitude(planets[k].longitude, houses.cusps);
+  }
+  const retrogrades = [];
+  ["mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"].forEach((k) => {
+    const r = isRetrograde(k, JD);
+    if (planets[k]) planets[k].retrograde = r;
+    if (r) retrogrades.push(k);
+  });
+  const aspects = calculateAspects(planets);
+  const sunLon = planets["sun"].longitude;
+  const moonLon = planets["moon"].longitude;
+  const sunAbove = (sunLon - houses.asc + 360) % 360 >= 180;
+  const pofLon = partOfFortune(sunLon, moonLon, houses.asc, !sunAbove);
+  planets["fortune"] = {
+    key: "fortune",
+    longitude: pofLon,
+    signIdx: Math.floor(pofLon / 30),
+    degree: pofLon % 30,
+    house: houseOfLongitude(pofLon, houses.cusps)
+  };
+  const phase = moonPhase(JD);
+  const numerology = 0;
+  const lots = computeHermeticLots(houses.asc, planets, !sunAbove, pofLon);
+  return {
+    planets,
+    houses,
+    aspects,
+    retrogrades,
+    moonPhase: phase,
+    numerology,
+    zodiac,
+    houseSystem,
+    JD,
+    T,
+    ayanamsa: zodiac === "sidereal" ? ayanamsa(JD) : 0,
+    lots,
+    source: "meeus"
+  };
+}
+function computeCurrentSky(lat, lng, opts = {}) {
+  const JD = Date.now() / 864e5 + 24405875e-1;
+  return computeChartFromJD(JD, lat, lng, opts);
+}
+
+// ../ephemeris/src/swiss-engine.ts
+import { createRequire } from "module";
+import { join } from "path";
+var _swe = null;
+var _swissephLoadError = null;
+function loadSwisseph() {
+  if (_swe !== null) return _swe !== false;
+  try {
+    const req = typeof __require === "function" ? __require : createRequire(join(process.cwd(), "package.json"));
+    _swe = req("swisseph");
+    const path = process.env["SWISSEPH_PATH"] ?? "/usr/local/share/swisseph";
+    if (typeof _swe.swe_set_ephe_path === "function") {
+      try {
+        _swe.swe_set_ephe_path(path);
+      } catch {
+      }
+    }
+    return true;
+  } catch (err) {
+    _swe = false;
+    _swissephLoadError = err instanceof Error ? err.message : String(err);
+    return false;
+  }
+}
+function getSwissephLoadError() {
+  return _swissephLoadError;
+}
+function ensureSwissephLoaded() {
+  return loadSwisseph();
+}
+var _sidModeSet = false;
+function ayanamsaSwiss(JD) {
+  if (!loadSwisseph()) throw new Error("swisseph not loaded");
+  if (!_sidModeSet) {
+    _swe.swe_set_sid_mode(_swe.SE_SIDM_LAHIRI, 0, 0);
+    _sidModeSet = true;
+  }
+  const r = _swe.swe_get_ayanamsa_ut(JD);
+  return typeof r === "number" ? r : r && r.ayanamsa !== void 0 ? r.ayanamsa : r;
+}
+function toSiderealSwiss(lon, JD) {
+  return n360(lon - ayanamsaSwiss(JD));
+}
+var _PLANET_IPL = null;
+var FILE_BASED_BODIES = /* @__PURE__ */ new Set([
+  "chiron",
+  "ceres",
+  "pallas",
+  "juno",
+  "vesta"
+]);
+var OPTIONAL_BODIES = /* @__PURE__ */ new Set([
+  "chiron",
+  "ceres",
+  "pallas",
+  "juno",
+  "vesta",
+  "lilithTrue"
+]);
+var _omittedBodiesLogged = /* @__PURE__ */ new Set();
+function logBodyOmission(key, reason) {
+  if (_omittedBodiesLogged.has(key)) return;
+  _omittedBodiesLogged.add(key);
+  console.warn(`[swiss-engine] corps \xAB ${key} \xBB omis (\xE9ph\xE9m\xE9rides .se1 absentes ?) : ${reason}`);
+}
+function getPlanetIpl() {
+  if (_PLANET_IPL) return _PLANET_IPL;
+  if (!loadSwisseph()) throw new Error("swisseph not loaded");
+  _PLANET_IPL = {
+    sun: _swe.SE_SUN,
+    moon: _swe.SE_MOON,
+    mercury: _swe.SE_MERCURY,
+    venus: _swe.SE_VENUS,
+    mars: _swe.SE_MARS,
+    jupiter: _swe.SE_JUPITER,
+    saturn: _swe.SE_SATURN,
+    uranus: _swe.SE_URANUS,
+    neptune: _swe.SE_NEPTUNE,
+    pluto: _swe.SE_PLUTO,
+    // Nœud lunaire moyen (cohérent avec astro-engine actuel).
+    // Pour passer en nœud vrai : SE_TRUE_NODE.
+    northNode: _swe.SE_MEAN_NODE,
+    // LILITH-V1 : Mean Apogee = "Lilith astrologique" mean (lisse,
+    // standard depuis Dane Rudhyar). Alternative `SE_OSCU_APOG = 13`
+    // (osculating) — instantanée, oscille beaucoup, peu utilisée en
+    // thème natal. Mean = bon défaut.
+    lilith: _swe.SE_MEAN_APOG,
+    // ASTEROIDS-V1 : Chiron + les 4 astéroïdes « féminins/archétypaux »
+    // standards. Codes IPL natifs Swiss Ephemeris (mode fichier requis).
+    chiron: _swe.SE_CHIRON,
+    ceres: _swe.SE_CERES,
+    pallas: _swe.SE_PALLAS,
+    juno: _swe.SE_JUNO,
+    vesta: _swe.SE_VESTA,
+    // Lilith vraie = apogée lunaire osculateur (instantané).
+    lilithTrue: _swe.SE_OSCU_APOG
+  };
+  return _PLANET_IPL;
+}
+var HOUSE_SYSTEM_CHAR = {
+  placidus: "P",
+  koch: "K",
+  equal: "E",
+  whole_sign: "W"
+};
+function allPositionsSwiss(JD) {
+  if (!loadSwisseph()) throw new Error("swisseph not loaded");
+  const ipl = getPlanetIpl();
+  const out = {};
+  for (const [key, code] of Object.entries(ipl)) {
+    const flag = (FILE_BASED_BODIES.has(key) ? _swe.SEFLG_SWIEPH : _swe.SEFLG_MOSEPH) | _swe.SEFLG_SPEED;
+    let r;
+    try {
+      r = _swe.swe_calc_ut(JD, code, flag);
+    } catch (err) {
+      r = { error: err instanceof Error ? err.message : String(err) };
+    }
+    const errored = r && typeof r === "object" && "error" in r && r.error;
+    const lon = errored ? NaN : n360(r.longitude);
+    if (errored || !Number.isFinite(lon)) {
+      if (OPTIONAL_BODIES.has(key)) {
+        logBodyOmission(key, errored ? String(r.error) : "longitude non finie");
+        continue;
+      }
+      throw new Error(`swe_calc_ut failed for ${key} (ipl=${code}): ${errored ? r.error : "longitude non finie"}`);
+    }
+    out[key] = {
+      key,
+      longitude: lon,
+      signIdx: Math.floor(lon / 30),
+      degree: lon % 30,
+      retrograde: typeof r.longitudeSpeed === "number" ? r.longitudeSpeed < 0 : false
+    };
+  }
+  if (out["northNode"]) {
+    const sn = n360(out["northNode"].longitude + 180);
+    out["southNode"] = {
+      key: "southNode",
+      longitude: sn,
+      signIdx: Math.floor(sn / 30),
+      degree: sn % 30,
+      // SOUTH-NODE-RETRO-FIX : le Nœud Sud partage l'axe nodal — il a
+      // donc le même mouvement que le Nœud Nord. Sans cette ligne il
+      // s'affichait « Direct » alors que le Nœud Nord est rétrograde.
+      retrograde: out["northNode"].retrograde ?? false
+    };
+  }
+  return out;
+}
+function equatorialPositionsSwiss(JD) {
+  if (!loadSwisseph()) throw new Error("swisseph not loaded");
+  const flag = _swe.SEFLG_MOSEPH | _swe.SEFLG_EQUATORIAL;
+  const ipl = getPlanetIpl();
+  const out = {};
+  for (const key of ["sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto", "northNode"]) {
+    const code = ipl[key];
+    if (typeof code !== "number") continue;
+    const r = _swe.swe_calc_ut(JD, code, flag);
+    if (r && typeof r === "object" && "error" in r && r.error) {
+      throw new Error(`swe_calc_ut (equatorial) failed for ${key}: ${r.error}`);
+    }
+    const ra = r.rectAscension ?? r.longitude;
+    const dec = r.declination ?? r.latitude;
+    if (!Number.isFinite(ra) || !Number.isFinite(dec)) {
+      throw new Error(
+        `swe_calc_ut (equatorial) a renvoy\xE9 des coordonn\xE9es non finies pour ${key} (ra=${ra}, dec=${dec}) \u2014 champs attendus rectAscension/declination.`
+      );
+    }
+    out[key] = { ra: n360(ra), dec };
+  }
+  return out;
+}
+function calculateHousesSwiss(system, JD, lat, lng) {
+  if (!loadSwisseph()) throw new Error("swisseph not loaded");
+  const hsys = HOUSE_SYSTEM_CHAR[system] ?? "P";
+  const r = _swe.swe_houses(JD, lat, lng, hsys);
+  if (r && typeof r === "object" && "error" in r && r.error) {
+    throw new Error(`swe_houses failed: ${r.error}`);
+  }
+  const cusps = r.house.map(n360);
+  const vertex = typeof r.vertex === "number" ? n360(r.vertex) : null;
+  return {
+    cusps,
+    asc: n360(r.ascendant),
+    mc: n360(r.mc),
+    vertex,
+    system
+  };
+}
+function moonPhaseFromLongitudes(sunLon, moonLon) {
+  const el = n360(moonLon - sunLon);
+  let key, emoji;
+  if (el < 11.25) {
+    key = "moon_new";
+    emoji = "\u{1F311}";
+  } else if (el < 78.75) {
+    key = "moon_waxc";
+    emoji = "\u{1F312}";
+  } else if (el < 101.25) {
+    key = "moon_firstq";
+    emoji = "\u{1F313}";
+  } else if (el < 168.75) {
+    key = "moon_waxg";
+    emoji = "\u{1F314}";
+  } else if (el < 191.25) {
+    key = "moon_full";
+    emoji = "\u{1F315}";
+  } else if (el < 258.75) {
+    key = "moon_wang";
+    emoji = "\u{1F316}";
+  } else if (el < 281.25) {
+    key = "moon_lastq";
+    emoji = "\u{1F317}";
+  } else if (el < 348.75) {
+    key = "moon_wanc";
+    emoji = "\u{1F318}";
+  } else {
+    key = "moon_new";
+    emoji = "\u{1F311}";
+  }
+  const FR = {
+    moon_new: { phase: "Nouvelle Lune", description: "Temps des semences et des intentions nouvelles" },
+    moon_waxc: { phase: "Premier croissant", description: "Croissance, construction, prise d'\xE9lan" },
+    moon_firstq: { phase: "Premier quartier", description: "D\xE9cisions, action, d\xE9passement des obstacles" },
+    moon_waxg: { phase: "Gibbeuse croissante", description: "Perfectionnement, ajustements, pers\xE9v\xE9rance" },
+    moon_full: { phase: "Pleine Lune", description: "Culmination, r\xE9v\xE9lation, intensit\xE9 \xE9motionnelle" },
+    moon_wang: { phase: "Gibbeuse d\xE9croissante", description: "Gratitude, partage, diffusion" },
+    moon_lastq: { phase: "Dernier quartier", description: "L\xE2cher-prise, r\xE9visions, ajustements" },
+    moon_wanc: { phase: "Dernier croissant", description: "Repos, introspection, purification" }
+  };
+  const info = FR[key];
+  const illumination = (1 - Math.cos(el * Math.PI / 180)) / 2;
+  return {
+    key,
+    phase: info.phase,
+    emoji,
+    illumination: Math.round(illumination * 100) / 100,
+    description: info.description
+  };
+}
+function computeChartFromJDSwiss(JD, latitude, longitude, opts = {}) {
+  const zodiac = opts.zodiac ?? "tropical";
+  const houseSystem = opts.houseSystem ?? "placidus";
+  const T = (JD - 2451545) / 36525;
+  let planets = allPositionsSwiss(JD);
+  if (zodiac === "sidereal") {
+    const adjusted = {};
+    for (const k of Object.keys(planets)) {
+      const slon = toSiderealSwiss(planets[k].longitude, JD);
+      adjusted[k] = {
+        ...planets[k],
+        longitude: slon,
+        signIdx: Math.floor(slon / 30),
+        degree: slon % 30
+      };
+    }
+    planets = adjusted;
+  }
+  const houses = calculateHousesSwiss(houseSystem, JD, latitude, longitude);
+  if (zodiac === "sidereal") {
+    houses.cusps = houses.cusps.map((c) => toSiderealSwiss(c, JD));
+    houses.asc = toSiderealSwiss(houses.asc, JD);
+    houses.mc = toSiderealSwiss(houses.mc, JD);
+    if (houses.vertex != null) houses.vertex = toSiderealSwiss(houses.vertex, JD);
+  }
+  for (const k of Object.keys(planets)) {
+    planets[k].house = houseOfLongitude(planets[k].longitude, houses.cusps);
+  }
+  const retrogrades = [];
+  for (const k of ["mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto", "chiron", "ceres", "pallas", "juno", "vesta"]) {
+    if (planets[k]?.retrograde) retrogrades.push(k);
+  }
+  const aspects = calculateAspects(planets);
+  const sunLon = planets["sun"].longitude;
+  const moonLon = planets["moon"].longitude;
+  const sunAbove = (sunLon - houses.asc + 360) % 360 >= 180;
+  const pofLon = partOfFortune(sunLon, moonLon, houses.asc, !sunAbove);
+  planets["fortune"] = {
+    key: "fortune",
+    longitude: pofLon,
+    signIdx: Math.floor(pofLon / 30),
+    degree: pofLon % 30,
+    house: houseOfLongitude(pofLon, houses.cusps)
+  };
+  const lots = computeHermeticLots(houses.asc, planets, !sunAbove, pofLon);
+  const phase = moonPhaseFromLongitudes(sunLon, moonLon);
+  void moonPhase;
+  return {
+    planets,
+    houses,
+    aspects,
+    retrogrades,
+    moonPhase: phase,
+    numerology: 0,
+    // dérivée plus tard à partir de localBirthDate
+    zodiac,
+    houseSystem,
+    JD,
+    T,
+    ayanamsa: zodiac === "sidereal" ? ayanamsaSwiss(JD) : 0,
+    lots,
+    // C2-FIX : ChartResult.source est désormais "meeus" | "swiss" — on
+    // rapporte le vrai moteur. getEngineDiagnostic() reste la source
+    // détaillée pour /admin/ephemeris/health.
+    source: "swiss"
+  };
+}
+function computeCurrentSkySwiss(lat, lng, opts = {}) {
+  const JD = Date.now() / 864e5 + 24405875e-1;
+  return computeChartFromJDSwiss(JD, lat, lng, opts);
+}
+function moonPhaseSwiss(JD) {
+  if (!loadSwisseph()) throw new Error("swisseph not loaded");
+  const ipl = getPlanetIpl();
+  const sun = _swe.swe_calc_ut(JD, ipl.sun, _swe.SEFLG_MOSEPH);
+  const moon = _swe.swe_calc_ut(JD, ipl.moon, _swe.SEFLG_MOSEPH);
+  return moonPhaseFromLongitudes(n360(sun.longitude), n360(moon.longitude));
+}
+
+// ../ephemeris/src/engine-router.ts
+var _activeEngine = null;
+var _resolutionLog = null;
+function resolveEngine() {
+  if (_activeEngine) return _activeEngine;
+  const requested = (process.env["ASTRO_ENGINE"] ?? "swisseph").toLowerCase().trim();
+  if (requested === "astracore") {
+    _activeEngine = "astracore";
+    _resolutionLog = "ASTRO_ENGINE=astracore (explicite)";
+    return _activeEngine;
+  }
+  if (ensureSwissephLoaded()) {
+    _activeEngine = "swisseph";
+    _resolutionLog = `ASTRO_ENGINE=${requested} \u2192 swisseph charg\xE9 OK`;
+    return _activeEngine;
+  }
+  const err = getSwissephLoadError();
+  const isProd = (process.env["NODE_ENV"] ?? "").toLowerCase() === "production";
+  const allowFallback = (process.env["ASTRO_ALLOW_FALLBACK"] ?? "").toLowerCase() === "true";
+  if (isProd && !allowFallback) {
+    const msg = `[ephemeris/router] FATAL: ASTRO_ENGINE=${requested} mais swisseph indisponible (${err ?? "raison inconnue"}). Le fallback AstraCore n'applique pas \u0394T et servirait des th\xE8mes faux. Refus du fallback silencieux en production. Corrige le build/volume swisseph, ou pose ASTRO_ALLOW_FALLBACK=true pour accepter explicitement AstraCore.`;
+    console.error(msg);
+    throw new Error(msg);
+  }
+  _activeEngine = "astracore";
+  _resolutionLog = `ASTRO_ENGINE=${requested} demand\xE9 mais swisseph indisponible (${err ?? "raison inconnue"}) \u2014 fallback sur astracore` + (allowFallback ? " (ASTRO_ALLOW_FALLBACK=true)" : " (hors production)");
+  console.warn(`[ephemeris/router] ${_resolutionLog}`);
+  return _activeEngine;
+}
+function getActiveEngine() {
+  return resolveEngine();
+}
+function computeChartFromJD2(JD, latitude, longitude, opts = {}) {
+  if (resolveEngine() === "swisseph") {
+    return computeChartFromJDSwiss(JD, latitude, longitude, opts);
+  }
+  return computeChartFromJD(JD, latitude, longitude, opts);
+}
+function computeCurrentSky2(lat, lng, opts = {}) {
+  if (resolveEngine() === "swisseph") {
+    return computeCurrentSkySwiss(lat, lng, opts);
+  }
+  return computeCurrentSky(lat, lng, opts);
+}
+function allPositions2(JD) {
+  return resolveEngine() === "swisseph" ? allPositionsSwiss(JD) : allPositions(JD);
+}
+function moonPhase2(JD) {
+  return resolveEngine() === "swisseph" ? moonPhaseSwiss(JD) : moonPhase(JD);
+}
+function equatorialPositions2(JD) {
+  return resolveEngine() === "swisseph" ? equatorialPositionsSwiss(JD) : equatorialPositions(JD);
+}
+function computeAstrocartography(JD, opts = {}) {
+  const eq = equatorialPositions2(JD);
+  const gst = gmstDeg(JD);
+  const allow = new Set(opts.bodyKeys ?? ACG_BODY_KEYS);
+  const bodies = Object.entries(eq).filter(([key]) => allow.has(key)).map(([key, c]) => ({ key, ra: c.ra, dec: c.dec }));
+  const lineOpts = opts.latStep ? { latStep: opts.latStep } : {};
+  const lines = computeAcgLines(bodies, gst, lineOpts);
+  const parans = findParans(lines);
+  return { jd: JD, gst, bodies, lines, parans };
+}
+
+// ../ephemeris/src/types.ts
+var CityNotFoundError = class extends Error {
+  constructor(query, suggestions = []) {
+    super(
+      suggestions.length > 0 ? `City "${query}" not found. Did you mean: ${suggestions.join(", ")}?` : `City "${query}" not found.`
+    );
+    this.query = query;
+    this.suggestions = suggestions;
+    this.name = "CityNotFoundError";
+  }
+  query;
+  suggestions;
+};
+
+// ../ephemeris/src/time-utc.service.ts
+import { DateTime } from "luxon";
+var TimezoneError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "TimezoneError";
+  }
+  code;
+  details;
+};
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var TIME_RE = /^\d{2}:\d{2}(:\d{2})?$/;
+function assertValidDate(date) {
+  if (!DATE_RE.test(date)) {
+    throw new TimezoneError(
+      `Birth date must be YYYY-MM-DD, got "${date}"`,
+      "INVALID_DATE",
+      { date }
+    );
+  }
+}
+function assertValidTime(time) {
+  if (!TIME_RE.test(time)) {
+    throw new TimezoneError(
+      `Birth time must be HH:MM or HH:MM:SS, got "${time}"`,
+      "INVALID_TIME",
+      { time }
+    );
+  }
+}
+function assertValidIanaTz(ianaTz) {
+  if (NUMERIC_OFFSET_RE.test(ianaTz)) {
+    throw new TimezoneError(
+      `Numeric offset "${ianaTz}" not accepted \u2014 use an IANA timezone like "Europe/Paris" instead. Fixed offsets lose DST history.`,
+      "INVALID_IANA_TZ",
+      { ianaTz }
+    );
+  }
+  if (!DateTime.local().setZone(ianaTz).isValid) {
+    throw new TimezoneError(
+      `Unknown IANA timezone "${ianaTz}". Expected e.g. "Europe/Paris".`,
+      "INVALID_IANA_TZ",
+      { ianaTz }
+    );
+  }
+}
+var NUMERIC_OFFSET_RE = /^(UTC|GMT|UT)?[+-]\d{1,2}(:?\d{2})?$/i;
+function localToUTC(localDate, localTime, ianaTz, opts = {}) {
+  assertValidDate(localDate);
+  assertValidTime(localTime);
+  assertValidIanaTz(ianaTz);
+  const onAmbiguous = opts.onAmbiguous ?? "earliest";
+  const onNonExistent = opts.onNonExistent ?? "shiftLater";
+  const [hStr, mStr, sStr] = localTime.split(":");
+  const hour = Number(hStr);
+  const minute = Number(mStr);
+  const second = sStr ? Number(sStr) : 0;
+  const [yStr, moStr, dStr] = localDate.split("-");
+  const year = Number(yStr);
+  const month = Number(moStr);
+  const day = Number(dStr);
+  const dt = DateTime.fromObject(
+    { year, month, day, hour, minute, second },
+    { zone: ianaTz }
+  );
+  if (!dt.isValid) {
+    throw new TimezoneError(
+      `Luxon rejected ${localDate} ${localTime} @ ${ianaTz}: ${dt.invalidReason} \u2014 ${dt.invalidExplanation}`,
+      "INVALID_DATE",
+      { localDate, localTime, ianaTz }
+    );
+  }
+  if (typeof opts.longitude === "number" && !Number.isInteger(dt.offset)) {
+    const lmtOffsetMinutes = opts.longitude * 4;
+    const utc = DateTime.fromObject({ year, month, day, hour, minute, second }, { zone: "utc" }).minus({ milliseconds: Math.round(lmtOffsetMinutes * 6e4) });
+    const utcMs = utc.toMillis();
+    return {
+      jdUT: utcMs / 864e5 + 24405875e-1,
+      offsetMinutes: lmtOffsetMinutes,
+      utcISO: utc.toUTC().toISO() ?? "",
+      resolution: "valid"
+      // aucune bascule DST possible en ère LMT
+    };
+  }
+  let resolution = "valid";
+  if (dt.hour !== hour || dt.minute !== minute) {
+    if (onNonExistent === "throw") {
+      throw new TimezoneError(
+        `Time ${localTime} on ${localDate} does not exist in ${ianaTz} (DST spring-forward).`,
+        "NONEXISTENT_TIME",
+        { localDate, localTime, ianaTz, shiftedTo: dt.toISO() }
+      );
+    }
+    resolution = "nonexistent";
+  }
+  if (resolution === "valid") {
+    const before = dt.minus({ minutes: 30 });
+    const after = dt.plus({ minutes: 30 });
+    if (before.offset !== dt.offset || after.offset !== dt.offset) {
+      const alt = dt.plus({ hours: 1 });
+      const altAsWall = DateTime.fromObject(
+        { year: alt.year, month: alt.month, day: alt.day, hour: alt.hour, minute: alt.minute, second: alt.second },
+        { zone: ianaTz }
+      );
+      if (altAsWall.toMillis() !== alt.toMillis()) {
+        if (onAmbiguous === "throw") {
+          throw new TimezoneError(
+            `Time ${localTime} on ${localDate} is ambiguous in ${ianaTz} (DST fall-back). Ask the user which occurrence.`,
+            "AMBIGUOUS_TIME",
+            { localDate, localTime, ianaTz }
+          );
+        }
+        if (onAmbiguous === "latest") {
+          const late = dt.plus({ hours: 1 }).setZone(ianaTz, { keepLocalTime: false });
+          return buildResult(late, "ambiguous");
+        }
+        resolution = "ambiguous";
+      }
+    }
+  }
+  return buildResult(dt, resolution);
+}
+function buildResult(dt, resolution) {
+  const utcMs = dt.toUTC().toMillis();
+  const jdUT = utcMs / 864e5 + 24405875e-1;
+  return {
+    jdUT,
+    offsetMinutes: dt.offset,
+    utcISO: dt.toUTC().toISO() ?? "",
+    resolution
+  };
+}
+
+// ../ephemeris/src/service.ts
+import { createHash } from "crypto";
+var _redis = null;
+async function getRedis() {
+  if (_redis !== null) return _redis;
+  if (process.env["EPHEMERIS_DISABLE_REDIS"] === "1") {
+    _redis = false;
+    return null;
+  }
+  try {
+    const { createClient } = await import("redis");
+    const client = createClient({
+      url: process.env["REDIS_URL"] ?? "redis://redis:6379",
+      socket: { connectTimeout: 500, reconnectStrategy: false }
+    });
+    client.on("error", () => {
+    });
+    await client.connect();
+    _redis = client;
+    return client;
+  } catch {
+    _redis = false;
+    return null;
+  }
+}
+async function cacheGet(key) {
+  try {
+    const r = await getRedis();
+    if (!r) return null;
+    const v = await r.get(key);
+    return v ? JSON.parse(v) : null;
+  } catch {
+    return null;
+  }
+}
+async function cacheSet(key, data, ttl = 86400) {
+  try {
+    const r = await getRedis();
+    if (!r) return;
+    await r.setEx(key, ttl, JSON.stringify(data));
+  } catch {
+  }
+}
+function enrich(result, meta) {
+  const houses = result.houses.cusps.map((lon, i) => ({
+    number: i + 1,
+    longitude: lon,
+    signIdx: Math.floor(lon / 30)
+  }));
+  const aspects = result.aspects.map((a) => ({
+    planet1: a.p1,
+    planet2: a.p2,
+    p1: a.p1,
+    p2: a.p2,
+    type: a.type,
+    typeFr: a.typeFr,
+    orb: a.orb,
+    angle: a.angle,
+    exact: a.exact,
+    symbol: a.symbol,
+    tone: a.tone
+  }));
+  return {
+    planets: result.planets,
+    houses,
+    asc: result.houses.asc,
+    mc: result.houses.mc,
+    vertex: result.houses.vertex,
+    // VERTEX-V1
+    lots: result.lots,
+    // POINTS-ARABES-V1
+    aspects,
+    retrogrades: result.retrogrades,
+    moonPhase: result.moonPhase,
+    numerology: meta.localBirthDate ? computeLifePath(meta.localBirthDate) : result.numerology,
+    // STAB-PRE-5-V1
+    source: result.source,
+    zodiac: result.zodiac,
+    houseSystem: result.houseSystem,
+    JD: result.JD,
+    meta
+  };
+}
+function chartCacheKey(args) {
+  const payload = JSON.stringify({
+    d: args.localBirthDate,
+    t: args.localBirthTime,
+    z: args.ianaTz,
+    // On quantifie lat/lng à 4 décimales (~10 m) pour absorber
+    // les micro-variations de saisie sans invalider tout le temps.
+    la: Number(args.latitude.toFixed(4)),
+    lo: Number(args.longitude.toFixed(4)),
+    zo: args.zodiac,
+    hs: args.houseSystem,
+    tk: args.birthTimeKnown,
+    // C6-FIX : le moteur actif entre dans la clé — un repli gracieux
+    // swisseph↔astracore ne doit pas resservir un thème de l'autre moteur.
+    e: getActiveEngine()
+  });
+  const hash = createHash("sha256").update(payload).digest("hex").slice(0, 16);
+  return `chart:v7:${args.natalId}:${hash}`;
+}
+var EphemerisService = class {
+  /**
+   * Calcule un thème natal à partir d'une saisie locale + IANA tz.
+   *
+   * ✦ Nouvelle API recommandée. La conversion vers UTC et le JD
+   *   se font ici, une seule fois, côté serveur, sans convention
+   *   implicite.
+   */
+  async calculateNatalChart(input) {
+    const zodiac = input.zodiac ?? "tropical";
+    const houseSystem = input.houseSystem ?? "placidus";
+    const conv = localToUTC(
+      input.localBirthDate,
+      input.localBirthTime,
+      input.ianaTz,
+      {
+        onAmbiguous: input.onAmbiguous ?? "earliest",
+        onNonExistent: input.onNonExistent ?? "shiftLater",
+        longitude: input.longitude
+      }
+    );
+    const cacheKey = chartCacheKey({
+      natalId: input.natalId,
+      localBirthDate: input.localBirthDate,
+      localBirthTime: input.localBirthTime,
+      ianaTz: input.ianaTz,
+      latitude: input.latitude,
+      longitude: input.longitude,
+      zodiac,
+      houseSystem,
+      birthTimeKnown: input.birthTimeKnown
+    });
+    const cached = await cacheGet(cacheKey);
+    if (cached) return cached;
+    const result = computeChartFromJD2(
+      conv.jdUT,
+      input.latitude,
+      input.longitude,
+      { zodiac, houseSystem }
+    );
+    const meta = {
+      localBirthDate: input.localBirthDate,
+      localBirthTime: input.localBirthTime,
+      ianaTz: input.ianaTz,
+      offsetMinutes: conv.offsetMinutes,
+      resolution: conv.resolution,
+      birthTimeKnown: input.birthTimeKnown,
+      utcISO: conv.utcISO
+    };
+    const enriched = enrich(result, meta);
+    await cacheSet(cacheKey, enriched, 7 * 24 * 3600);
+    return enriched;
+  }
+  // ──────────────────────────────────────────────────────
+  // EPHEMERIS-DEEP-CONSOLIDATION-V1
+  // City resolver injectable : l'app fournit le lookup ville→coords
+  // (typiquement via la table Postgres `cities` GeoNames). Le
+  // package ephemeris est ainsi 100% indépendant de toute liste
+  // hardcodée.
+  // ──────────────────────────────────────────────────────
+  _cityResolver = null;
+  /**
+   * Injecte le resolver de ville. À appeler une fois au boot de
+   * l'application (ex: apps/api/src/index.ts).
+   *
+   * Le resolver peut être sync ou async. Doit retourner null si
+   * la ville n'est pas trouvée — le service convertit ce null en
+   * `CityNotFoundError` pour le caller.
+   */
+  setCityResolver(resolver) {
+    this._cityResolver = resolver;
+  }
+  /**
+   * Version convenience : résout le nom de ville en interne via
+   * le resolver injecté au boot.
+   *
+   * Lève `CityNotFoundError` si :
+   *   - aucun resolver n'a été injecté (mauvaise config app)
+   *   - le resolver retourne null (ville inconnue)
+   */
+  async calculateFromCityName(args) {
+    const { cityName, ...rest } = args;
+    if (!this._cityResolver) {
+      throw new CityNotFoundError(
+        cityName,
+        ["(no city resolver injected \u2014 check ephemerisService.setCityResolver() at app boot)"]
+      );
+    }
+    const city = await Promise.resolve(this._cityResolver(cityName));
+    if (!city) {
+      throw new CityNotFoundError(cityName, []);
+    }
+    return this.calculateNatalChart({
+      ...rest,
+      ianaTz: city.ianaTz,
+      latitude: city.lat,
+      longitude: city.lng
+    });
+  }
+  /** Ciel du moment présent (transits) pour une position. */
+  async getCurrentSky(latitude, longitude, opts = {}) {
+    const result = computeCurrentSky2(latitude, longitude, opts);
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    return enrich(result, {
+      localBirthDate: nowIso.slice(0, 10),
+      localBirthTime: nowIso.slice(11, 16),
+      ianaTz: "UTC",
+      offsetMinutes: 0,
+      resolution: "valid",
+      birthTimeKnown: true,
+      utcISO: nowIso
+    });
+  }
+  // ──────────────────────────────────────────────────────
+  // LEGACY — conservé pour compat pendant la migration
+  // ──────────────────────────────────────────────────────
+  /**
+   * @deprecated Utilisez `calculateNatalChart({ localBirthDate, localBirthTime, ianaTz, … })`.
+   *
+   * Ancienne signature : `birthTimeUT` en heures décimales UT.
+   * On la garde pour ne pas casser les appelants qui n'ont pas
+   * encore migré, mais elle est marquée deprecated.
+   */
+  async calculateNatalChartLegacy(natalId, birthDate, birthTimeUT, latitude, longitude, opts = {}) {
+    console.warn(
+      `[ephemeris] calculateNatalChartLegacy called for natalId=${natalId}. Migrate to calculateNatalChart({ localBirthDate, localBirthTime, ianaTz, \u2026 }).`
+    );
+    const hh = Math.floor(birthTimeUT);
+    const mm = Math.floor((birthTimeUT - hh) * 60);
+    const localBirthTime = `${String(hh).padStart(2, "0")}:${String(mm).padStart(2, "0")}`;
+    return this.calculateNatalChart({
+      natalId,
+      localBirthDate: birthDate,
+      localBirthTime,
+      ianaTz: "UTC",
+      // on impose UTC puisque l'ancienne signature passait déjà en UT
+      latitude,
+      longitude,
+      birthTimeKnown: true,
+      // on ne sait pas, on suppose oui par défaut
+      zodiac: opts.zodiac,
+      houseSystem: opts.houseSystem
+    });
+  }
+  /**
+   * @deprecated EPHEMERIS-DEEP-CONSOLIDATION-V1 — utiliser
+   * directement le resolver via setCityResolver() ou appeler
+   * calculateFromCityName() qui l'utilise en interne.
+   * Conservé pour rétro-compat ; bascule async sur le resolver injecté.
+   */
+  async getCityCoords(name) {
+    if (!this._cityResolver) {
+      throw new CityNotFoundError(
+        name,
+        ["(no city resolver injected \u2014 check ephemerisService.setCityResolver() at app boot)"]
+      );
+    }
+    const city = await Promise.resolve(this._cityResolver(name));
+    if (!city) throw new CityNotFoundError(name, []);
+    return city;
+  }
+};
+var ephemerisService = new EphemerisService();
+
+// src/index.ts
+process.env["EPHEMERIS_DISABLE_REDIS"] ??= "1";
+process.env["ASTRO_ALLOW_FALLBACK"] ??= "true";
+var SIGNS_FR = [
+  "B\xE9lier",
+  "Taureau",
+  "G\xE9meaux",
+  "Cancer",
+  "Lion",
+  "Vierge",
+  "Balance",
+  "Scorpion",
+  "Sagittaire",
+  "Capricorne",
+  "Verseau",
+  "Poissons"
+];
+function jdFromDate(d) {
+  return d.getTime() / 864e5 + 24405875e-1;
+}
+function parseUtc(datetime) {
+  const d = new Date(datetime);
+  if (Number.isNaN(d.getTime())) {
+    throw new Error(`datetime invalide : "${datetime}" (attendu ISO 8601, ex. 2026-07-18T14:00:00Z)`);
+  }
+  return d;
+}
+function formatPlanets(positions) {
+  return Object.values(positions).map((p) => ({
+    corps: p.key,
+    longitude: Number(p.longitude?.toFixed(4)),
+    signe: SIGNS_FR[p.signIdx] ?? null,
+    degreDansSigne: Number(p.degree?.toFixed(4)),
+    retrograde: p.retrograde ?? false,
+    ...p.house != null ? { maison: p.house } : {}
+  }));
+}
+function jsonResult(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+var server = new McpServer({
+  name: "llmastro-ephemeris",
+  version: "0.0.1"
+});
+server.tool(
+  "get_planet_positions",
+  "Positions \xE9cliptiques g\xE9ocentriques de tous les corps (Soleil\u2192Pluton, n\u0153uds, Lilith) \xE0 un instant donn\xE9. Calcul\xE9 c\xF4t\xE9 serveur par le moteur d'\xE9ph\xE9m\xE9ride \u2014 jamais estim\xE9 par le mod\xE8le.",
+  {
+    datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z". Sans fuseau, interpr\xE9t\xE9 en UTC.')
+  },
+  async ({ datetime }) => {
+    const jd2 = jdFromDate(parseUtc(datetime));
+    const positions = allPositions2(jd2);
+    return jsonResult({
+      datetimeUTC: parseUtc(datetime).toISOString(),
+      jd: jd2,
+      moteur: getActiveEngine(),
+      corps: formatPlanets(positions)
+    });
+  }
+);
+server.tool(
+  "get_moon_phase",
+  "Phase de la Lune (nom, illumination %, description) \xE0 un instant donn\xE9, d\xE9riv\xE9e de la position r\xE9elle Soleil/Lune.",
+  {
+    datetime: z.string().describe(`Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z". D\xE9faut d'interpr\xE9tation : UTC.`)
+  },
+  async ({ datetime }) => {
+    const jd2 = jdFromDate(parseUtc(datetime));
+    const mp = moonPhase2(jd2);
+    return jsonResult({
+      datetimeUTC: parseUtc(datetime).toISOString(),
+      jd: jd2,
+      moteur: getActiveEngine(),
+      phase: mp.phase,
+      emoji: mp.emoji,
+      illumination: Number((mp.illumination * 100).toFixed(1)) + " %",
+      description: mp.description
+    });
+  }
+);
+server.tool(
+  "get_natal_chart",
+  "Th\xE8me natal complet : positions plan\xE9taires en maisons, aspects, ascendant/MC, phase lunaire. Prend une date/heure LOCALE + fuseau IANA + coordonn\xE9es. Conversion UTC et calcul faits c\xF4t\xE9 serveur.",
+  {
+    date: z.string().describe('Date de naissance locale, format YYYY-MM-DD, ex. "1990-05-21".'),
+    time: z.string().describe('Heure de naissance locale, format HH:mm (24 h), ex. "14:30".'),
+    timezone: z.string().describe('Fuseau IANA du lieu de naissance, ex. "Europe/Paris", "America/New_York".'),
+    latitude: z.number().min(-90).max(90).describe("Latitude en degr\xE9s d\xE9cimaux (positif = Nord)."),
+    longitude: z.number().min(-180).max(180).describe("Longitude en degr\xE9s d\xE9cimaux (positif = Est).")
+  },
+  async ({ date, time, timezone, latitude, longitude }) => {
+    const { jdUT, utcISO, offsetMinutes } = localToUTC(date, time, timezone);
+    const chart = computeChartFromJD2(jdUT, latitude, longitude);
+    return jsonResult({
+      naissance: { date, time, timezone, latitude, longitude },
+      utcISO,
+      offsetMinutes,
+      jd: jdUT,
+      moteur: getActiveEngine(),
+      ascendant: {
+        longitude: Number(chart.houses.asc?.toFixed(4)),
+        signe: SIGNS_FR[Math.floor((chart.houses.asc ?? 0) / 30) % 12] ?? null
+      },
+      milieuDuCiel: {
+        longitude: Number(chart.houses.mc?.toFixed(4)),
+        signe: SIGNS_FR[Math.floor((chart.houses.mc ?? 0) / 30) % 12] ?? null
+      },
+      systemeMaisons: chart.houseSystem,
+      zodiaque: chart.zodiac,
+      phaseLunaire: { phase: chart.moonPhase.phase, illumination: chart.moonPhase.illumination },
+      retrogrades: chart.retrogrades,
+      corps: formatPlanets(chart.planets),
+      aspects: chart.aspects
+    });
+  }
+);
+server.tool(
+  "get_current_sky",
+  "Le ciel \xE0 l'instant pr\xE9sent (transits du moment) pour un lieu donn\xE9 : positions en maisons + aspects.",
+  {
+    latitude: z.number().min(-90).max(90).describe("Latitude en degr\xE9s d\xE9cimaux (positif = Nord)."),
+    longitude: z.number().min(-180).max(180).describe("Longitude en degr\xE9s d\xE9cimaux (positif = Est).")
+  },
+  async ({ latitude, longitude }) => {
+    const chart = computeCurrentSky2(latitude, longitude);
+    return jsonResult({
+      instant: (/* @__PURE__ */ new Date()).toISOString(),
+      jd: chart.JD,
+      moteur: getActiveEngine(),
+      retrogrades: chart.retrogrades,
+      phaseLunaire: { phase: chart.moonPhase.phase, illumination: chart.moonPhase.illumination },
+      corps: formatPlanets(chart.planets),
+      aspects: chart.aspects
+    });
+  }
+);
+server.tool(
+  "get_astrocartography",
+  "Astrocartographie \xE0 un instant donn\xE9 : pour chaque corps, les m\xE9ridiens MC/IC et les courbes lever/coucher, plus les parans (croisements de lignes). Utile pour \xAB o\xF9 telle plan\xE8te est-elle forte \xBB.",
+  {
+    datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z". Sans fuseau, interpr\xE9t\xE9 en UTC.')
+  },
+  async ({ datetime }) => {
+    const jd2 = jdFromDate(parseUtc(datetime));
+    const acg = computeAstrocartography(jd2);
+    return jsonResult({
+      datetimeUTC: parseUtc(datetime).toISOString(),
+      jd: jd2,
+      moteur: getActiveEngine(),
+      // Résumé lisible : on omet les tableaux de points (courbes échantillonnées),
+      // on garde les méridiens et le nombre de points par courbe.
+      lignes: acg.lines.map((l) => ({
+        corps: l.key,
+        meridienMC: Number(l.mcLng?.toFixed(4)),
+        meridienIC: Number(l.icLng?.toFixed(4)),
+        pointsLever: l.asc.length,
+        pointsCoucher: l.dsc.length
+      })),
+      parans: acg.parans.map((p) => ({
+        corpsA: p.aKey,
+        angleA: p.aAngle,
+        corpsB: p.bKey,
+        angleB: p.bAngle,
+        latitude: Number(p.lat.toFixed(3)),
+        longitude: Number(p.lng.toFixed(3))
+      }))
+    });
+  }
+);
+var NOISE_KEYS = /* @__PURE__ */ new Set(["fortune", "southNode", "ceres", "pallas", "juno", "vesta", "lilithTrue"]);
+function crossAspects(transit, natal) {
+  const out = [];
+  for (const [tk, tp] of Object.entries(transit)) {
+    if (NOISE_KEYS.has(tk)) continue;
+    for (const [nk, np] of Object.entries(natal)) {
+      if (NOISE_KEYS.has(nk)) continue;
+      let d = Math.abs(tp.longitude - np.longitude);
+      if (d > 180) d = 360 - d;
+      for (const a of ASPECT_TYPES) {
+        const isLum = tk === "sun" || tk === "moon" || nk === "sun" || nk === "moon";
+        const maxOrb = a.orb + (isLum ? 2 : 0);
+        const o = Math.abs(d - a.angle);
+        if (o <= maxOrb) {
+          out.push({
+            planeteTransit: tk,
+            aspect: a.nameFr,
+            symbole: a.symbol,
+            planeteNatale: nk,
+            orbe: Number(o.toFixed(2)),
+            exact: o < 1
+          });
+        }
+      }
+    }
+  }
+  return out.sort((x, y) => x.orbe - y.orbe);
+}
+server.tool(
+  "get_transits",
+  "Transits du moment crois\xE9s au th\xE8me natal : aspects entre les plan\xE8tes qui transitent aujourd'hui (ou \xE0 une date donn\xE9e) et les plan\xE8tes de naissance. Le c\u0153ur des \xAB pr\xE9visions \xBB.",
+  {
+    date: z.string().describe("Date de naissance locale, YYYY-MM-DD."),
+    time: z.string().describe("Heure de naissance locale, HH:mm."),
+    timezone: z.string().describe('Fuseau IANA du lieu de naissance, ex. "Europe/Paris".'),
+    latitude: z.number().min(-90).max(90).describe("Latitude de naissance (deg d\xE9cimaux)."),
+    longitude: z.number().min(-180).max(180).describe("Longitude de naissance (deg d\xE9cimaux)."),
+    datetime: z.string().optional().describe('Instant du transit en ISO UTC (d\xE9faut : maintenant), ex. "2026-07-19T09:00:00Z".')
+  },
+  async ({ date, time, timezone, latitude, longitude, datetime }) => {
+    const { jdUT: natalJd } = localToUTC(date, time, timezone);
+    const natal = computeChartFromJD2(natalJd, latitude, longitude).planets;
+    const transitDate = datetime ? parseUtc(datetime) : /* @__PURE__ */ new Date();
+    const transit = allPositions2(jdFromDate(transitDate));
+    const aspects = crossAspects(transit, natal);
+    return jsonResult({
+      naissance: { date, time, timezone },
+      instantTransit: transitDate.toISOString(),
+      moteur: getActiveEngine(),
+      nbAspects: aspects.length,
+      aspects
+    });
+  }
+);
+var HORIZONS_API = "https://ssd.jpl.nasa.gov/api/horizons.api";
+var HORIZONS_CMD = {
+  sun: "10",
+  moon: "301",
+  mercury: "199",
+  venus: "299",
+  mars: "4",
+  jupiter: "5",
+  saturn: "6",
+  uranus: "7",
+  neptune: "8",
+  pluto: "9"
+};
+async function horizonsLongitude(command, jd2) {
+  const params = new URLSearchParams({
+    format: "text",
+    COMMAND: `'${command}'`,
+    OBJ_DATA: "'NO'",
+    MAKE_EPHEM: "'YES'",
+    EPHEM_TYPE: "'OBSERVER'",
+    CENTER: "'500@399'",
+    TLIST: `'${jd2}'`,
+    TLIST_TYPE: "'JD'",
+    QUANTITIES: "'31'",
+    CSV_FORMAT: "'YES'",
+    ANG_FORMAT: "'DEG'"
+  });
+  let lastErr;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (attempt > 0) await new Promise((r) => setTimeout(r, 400 * attempt));
+    const res = await fetch(`${HORIZONS_API}?${params}`);
+    if (res.status === 503 || res.status === 429) {
+      lastErr = new Error(`HTTP ${res.status}`);
+      continue;
+    }
+    if (!res.ok) throw new Error(`Horizons HTTP ${res.status} (COMMAND=${command})`);
+    const text = await res.text();
+    const block = text.split("$$SOE")[1]?.split("$$EOE")[0];
+    if (!block) throw new Error(`Bloc SOE/EOE absent (COMMAND=${command})`);
+    const cols = block.trim().split("\n")[0].split(",").map((s) => s.trim());
+    const lon = Number(cols[3]);
+    if (!Number.isFinite(lon)) throw new Error(`Longitude illisible (COMMAND=${command})`);
+    return lon;
+  }
+  throw new Error(`Horizons indisponible apr\xE8s 3 tentatives (COMMAND=${command}) : ${String(lastErr)}`);
+}
+function arcsecDelta(a, b) {
+  let d = a - b;
+  d = ((d + 180) % 360 + 360) % 360 - 180;
+  return d * 3600;
+}
+server.tool(
+  "validate_against_horizons",
+  "Preuve d'exactitude : compare nos positions plan\xE9taires \xE0 la r\xE9f\xE9rence mondiale JPL Horizons (NASA) au m\xEAme instant, et donne l'\xE9cart en secondes d'arc. N\xE9cessite un acc\xE8s r\xE9seau.",
+  {
+    datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-19T00:00:00Z".'),
+    bodies: z.array(z.enum(["sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"])).optional().describe("Sous-ensemble de corps \xE0 valider (d\xE9faut : les 10 classiques).")
+  },
+  async ({ datetime, bodies }) => {
+    const jd2 = jdFromDate(parseUtc(datetime));
+    const ours = allPositions2(jd2);
+    const keys = bodies ?? Object.keys(HORIZONS_CMD);
+    const rows = await Promise.all(
+      keys.map(async (k) => {
+        try {
+          const ref = await horizonsLongitude(HORIZONS_CMD[k], jd2);
+          const mine = ours[k]?.longitude;
+          if (mine == null) return { corps: k, erreur: "absent de notre moteur" };
+          const ecart = arcsecDelta(mine, ref);
+          return {
+            corps: k,
+            notreLongitude: Number(mine.toFixed(5)),
+            horizonsLongitude: Number(ref.toFixed(5)),
+            ecartArcsec: Number(ecart.toFixed(1))
+          };
+        } catch (e) {
+          return { corps: k, erreur: String(e?.message ?? e) };
+        }
+      })
+    );
+    const ecarts = rows.map((r) => Math.abs(r.ecartArcsec)).filter((n) => Number.isFinite(n));
+    return jsonResult({
+      datetimeUTC: parseUtc(datetime).toISOString(),
+      jd: jd2,
+      moteur: getActiveEngine(),
+      source: "JPL Horizons (ssd.jpl.nasa.gov), quantit\xE9 31 \u2014 ObsEcLon g\xE9ocentrique apparente",
+      resume: ecarts.length ? {
+        ecartMaxArcsec: Number(Math.max(...ecarts).toFixed(1)),
+        ecartMoyenArcsec: Number((ecarts.reduce((a, b) => a + b, 0) / ecarts.length).toFixed(1))
+      } : null,
+      note: getActiveEngine() === "astracore" ? "Mode AstraCore : petits \xE9carts syst\xE9matiques attendus (\u0394T non appliqu\xE9, surtout sur la Lune). Passe en ASTRO_ENGINE=swisseph pour un match sub-arcseconde." : "Mode swisseph : match attendu au niveau de la seconde d'arc.",
+      corps: rows
+    });
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`[mcp-ephemeris] pr\xEAt \xB7 moteur actif = ${getActiveEngine()}`);
+}
+main().catch((err) => {
+  console.error("[mcp-ephemeris] \xE9chec au d\xE9marrage :", err);
+  process.exit(1);
+});