gnss-js 0.1.2 → 1.0.1

package/dist/orbit.cjs

@@ -0,0 +1,511 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/orbit/index.ts
+var orbit_exports = {};
+__export(orbit_exports, {
+  computeAllPositions: () => computeAllPositions,
+  computeDop: () => computeDop,
+  computeLiveSkyPositions: () => computeLiveSkyPositions,
+  computeSatPosition: () => computeSatPosition,
+  ecefToAzEl: () => ecefToAzEl,
+  ecefToGeodetic: () => ecefToGeodetic,
+  geodeticToEcef: () => geodeticToEcef,
+  glonassPosition: () => glonassPosition,
+  keplerPosition: () => keplerPosition,
+  navTimesFromEph: () => navTimesFromEph,
+  selectEphemeris: () => selectEphemeris
+});
+module.exports = __toCommonJS(orbit_exports);
+
+// src/constants/wgs84.ts
+var WGS84_SEMI_MAJOR_AXIS = 6378137;
+var WGS84_FLATTENING = 1 / 298.257223563;
+var WGS84_ECCENTRICITY_SQUARED = 0.006694379990197;
+
+// src/coordinates/ecef.ts
+function geodeticToEcef(lat, lon, h) {
+  const N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * Math.sin(lat) ** 2);
+  const x = (N + h) * Math.cos(lat) * Math.cos(lon);
+  const y = (N + h) * Math.cos(lat) * Math.sin(lon);
+  const z = ((1 - WGS84_ECCENTRICITY_SQUARED) * N + h) * Math.sin(lat);
+  return [x, y, z];
+}
+function ecefToGeodetic(x, y, z) {
+  const lon = Math.atan2(y, x);
+  const p = Math.sqrt(x * x + y * y);
+  if (p < 1e-10) {
+    const b = WGS84_SEMI_MAJOR_AXIS * Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED);
+    const lat2 = z >= 0 ? Math.PI / 2 : -Math.PI / 2;
+    const alt2 = Math.abs(z) - b;
+    return [lat2, lon, alt2];
+  }
+  let lat = Math.atan2(z, p * (1 - WGS84_ECCENTRICITY_SQUARED));
+  let N;
+  for (let i = 0; i < 10; i++) {
+    const sinLat2 = Math.sin(lat);
+    N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * sinLat2 * sinLat2);
+    const prevLat = lat;
+    lat = Math.atan2(z + WGS84_ECCENTRICITY_SQUARED * N * sinLat2, p);
+    if (Math.abs(lat - prevLat) < 1e-15) break;
+  }
+  const sinLat = Math.sin(lat);
+  N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * sinLat * sinLat);
+  const alt = p / Math.cos(lat) - N;
+  return [lat, lon, alt];
+}
+
+// src/orbit/index.ts
+var GM_GPS = 3986005e8;
+var GM_GAL = 3986004418e5;
+var GM_BDS = 3986004418e5;
+var GM_GLO = 39860044e7;
+var OMEGA_E = 72921151467e-15;
+var AE_GLO = 6378136;
+var J2_GLO = 108263e-8;
+var TWO_PI = 2 * Math.PI;
+function gmForSystem(sys) {
+  if (sys === "E") return GM_GAL;
+  if (sys === "C") return GM_BDS;
+  return GM_GPS;
+}
+function keplerPosition(eph, t) {
+  const GM = gmForSystem(eph.system);
+  const a = eph.sqrtA * eph.sqrtA;
+  const n0 = Math.sqrt(GM / (a * a * a));
+  const n = n0 + eph.deltaN;
+  let tk = t - eph.toe;
+  if (tk > 302400) tk -= 604800;
+  if (tk < -302400) tk += 604800;
+  const Mk = eph.m0 + n * tk;
+  let Ek = Mk;
+  for (let i = 0; i < 10; i++) {
+    const dE = (Mk - (Ek - eph.e * Math.sin(Ek))) / (1 - eph.e * Math.cos(Ek));
+    Ek += dE;
+    if (Math.abs(dE) < 1e-12) break;
+  }
+  const sinE = Math.sin(Ek);
+  const cosE = Math.cos(Ek);
+  const vk = Math.atan2(Math.sqrt(1 - eph.e * eph.e) * sinE, cosE - eph.e);
+  const phik = vk + eph.omega;
+  const sin2phi = Math.sin(2 * phik);
+  const cos2phi = Math.cos(2 * phik);
+  const duk = eph.cus * sin2phi + eph.cuc * cos2phi;
+  const drk = eph.crs * sin2phi + eph.crc * cos2phi;
+  const dik = eph.cis * sin2phi + eph.cic * cos2phi;
+  const uk = phik + duk;
+  const rk = a * (1 - eph.e * cosE) + drk;
+  const ik = eph.i0 + dik + eph.idot * tk;
+  const xp = rk * Math.cos(uk);
+  const yp = rk * Math.sin(uk);
+  const isBdsGeo = eph.system === "C" && Math.abs(eph.i0) < 0.1 && a > 4e7;
+  if (isBdsGeo) {
+    const omegak2 = eph.omega0 + eph.omegaDot * tk - OMEGA_E * eph.toe;
+    const cosO2 = Math.cos(omegak2);
+    const sinO2 = Math.sin(omegak2);
+    const cosI2 = Math.cos(ik);
+    const sinI2 = Math.sin(ik);
+    const xg = xp * cosO2 - yp * cosI2 * sinO2;
+    const yg = xp * sinO2 + yp * cosI2 * cosO2;
+    const zg = yp * sinI2;
+    const phi = OMEGA_E * tk;
+    const cosPhi = Math.cos(phi);
+    const sinPhi = Math.sin(phi);
+    const COS5 = Math.cos(-5 * Math.PI / 180);
+    const SIN5 = Math.sin(-5 * Math.PI / 180);
+    return {
+      prn: eph.prn,
+      x: xg * cosPhi + yg * sinPhi * COS5 + zg * sinPhi * SIN5,
+      y: -xg * sinPhi + yg * cosPhi * COS5 + zg * cosPhi * SIN5,
+      z: -yg * SIN5 + zg * COS5
+    };
+  }
+  const omegak = eph.omega0 + (eph.omegaDot - OMEGA_E) * tk - OMEGA_E * eph.toe;
+  const cosO = Math.cos(omegak);
+  const sinO = Math.sin(omegak);
+  const cosI = Math.cos(ik);
+  const sinI = Math.sin(ik);
+  return {
+    prn: eph.prn,
+    x: xp * cosO - yp * cosI * sinO,
+    y: xp * sinO + yp * cosI * cosO,
+    z: yp * sinI
+  };
+}
+function gloDerivatives(state, acc) {
+  const [x, y, z, vx, vy, vz] = state;
+  const [ax, ay, az] = acc;
+  const r = Math.sqrt(x * x + y * y + z * z);
+  const r2 = r * r;
+  const r3 = r2 * r;
+  const r5 = r2 * r3;
+  const mu_r3 = GM_GLO / r3;
+  const j2_term = 1.5 * J2_GLO * AE_GLO * AE_GLO / r5;
+  const dvx = -mu_r3 * x + j2_term * x * (5 * z * z / r2 - 1) + OMEGA_E * OMEGA_E * x + 2 * OMEGA_E * vy + ax;
+  const dvy = -mu_r3 * y + j2_term * y * (5 * z * z / r2 - 1) + OMEGA_E * OMEGA_E * y - 2 * OMEGA_E * vx + ay;
+  const dvz = -mu_r3 * z + j2_term * z * (5 * z * z / r2 - 3) + az;
+  return [vx, vy, vz, dvx, dvy, dvz];
+}
+function rk4Step(state, acc, dt) {
+  const k1 = gloDerivatives(state, acc);
+  const s2 = state.map((v, i) => v + k1[i] * dt / 2);
+  const k2 = gloDerivatives(s2, acc);
+  const s3 = state.map((v, i) => v + k2[i] * dt / 2);
+  const k3 = gloDerivatives(s3, acc);
+  const s4 = state.map((v, i) => v + k3[i] * dt);
+  const k4 = gloDerivatives(s4, acc);
+  return state.map(
+    (v, i) => v + dt / 6 * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i])
+  );
+}
+function glonassPosition(eph, tUtc) {
+  const ephTime = eph.tocDate.getTime() / 1e3;
+  const dt = tUtc - ephTime;
+  let state = [
+    eph.x * 1e3,
+    eph.y * 1e3,
+    eph.z * 1e3,
+    eph.xDot * 1e3,
+    eph.yDot * 1e3,
+    eph.zDot * 1e3
+  ];
+  const acc = [
+    eph.xAcc * 1e3,
+    eph.yAcc * 1e3,
+    eph.zAcc * 1e3
+  ];
+  const step = dt > 0 ? 60 : -60;
+  const nSteps = Math.floor(Math.abs(dt) / 60);
+  const remainder = dt - nSteps * step;
+  for (let i = 0; i < nSteps; i++) {
+    state = rk4Step(state, acc, step);
+  }
+  if (Math.abs(remainder) > 1e-3) {
+    state = rk4Step(state, acc, remainder);
+  }
+  return { prn: eph.prn, x: state[0], y: state[1], z: state[2] };
+}
+function ecefToAzEl(rxX, rxY, rxZ, satX, satY, satZ) {
+  const [lat, lon] = ecefToGeodetic(rxX, rxY, rxZ);
+  const dx = satX - rxX;
+  const dy = satY - rxY;
+  const dz = satZ - rxZ;
+  const sinLat = Math.sin(lat);
+  const cosLat = Math.cos(lat);
+  const sinLon = Math.sin(lon);
+  const cosLon = Math.cos(lon);
+  const east = -sinLon * dx + cosLon * dy;
+  const north = -sinLat * cosLon * dx - sinLat * sinLon * dy + cosLat * dz;
+  const up = cosLat * cosLon * dx + cosLat * sinLon * dy + sinLat * dz;
+  const az = Math.atan2(east, north);
+  const el = Math.atan2(up, Math.sqrt(east * east + north * north));
+  return { az: (az + TWO_PI) % TWO_PI, el };
+}
+function computeDop(satAzEls) {
+  const n = satAzEls.length;
+  if (n < 4) return null;
+  const H = [];
+  for (const { az, el } of satAzEls) {
+    const cosEl = Math.cos(el);
+    H.push([cosEl * Math.sin(az), cosEl * Math.cos(az), Math.sin(el), 1]);
+  }
+  const HtH = Array.from({ length: 4 }, () => new Array(4).fill(0));
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      let sum = 0;
+      for (let k = 0; k < n; k++) {
+        sum += H[k][i] * H[k][j];
+      }
+      HtH[i][j] = sum;
+    }
+  }
+  const Q = invert4x4(HtH);
+  if (!Q) return null;
+  const gdop = Math.sqrt(Q[0][0] + Q[1][1] + Q[2][2] + Q[3][3]);
+  const pdop = Math.sqrt(Q[0][0] + Q[1][1] + Q[2][2]);
+  const hdop = Math.sqrt(Q[0][0] + Q[1][1]);
+  const vdop = Math.sqrt(Q[2][2]);
+  return { gdop, pdop, hdop, vdop };
+}
+function invert4x4(m) {
+  const a = m.flat();
+  const inv = new Array(16).fill(0);
+  inv[0] = a[5] * a[10] * a[15] - a[5] * a[11] * a[14] - a[9] * a[6] * a[15] + a[9] * a[7] * a[14] + a[13] * a[6] * a[11] - a[13] * a[7] * a[10];
+  inv[4] = -a[4] * a[10] * a[15] + a[4] * a[11] * a[14] + a[8] * a[6] * a[15] - a[8] * a[7] * a[14] - a[12] * a[6] * a[11] + a[12] * a[7] * a[10];
+  inv[8] = a[4] * a[9] * a[15] - a[4] * a[11] * a[13] - a[8] * a[5] * a[15] + a[8] * a[7] * a[13] + a[12] * a[5] * a[11] - a[12] * a[7] * a[9];
+  inv[12] = -a[4] * a[9] * a[14] + a[4] * a[10] * a[13] + a[8] * a[5] * a[14] - a[8] * a[6] * a[13] - a[12] * a[5] * a[10] + a[12] * a[6] * a[9];
+  inv[1] = -a[1] * a[10] * a[15] + a[1] * a[11] * a[14] + a[9] * a[2] * a[15] - a[9] * a[3] * a[14] - a[13] * a[2] * a[11] + a[13] * a[3] * a[10];
+  inv[5] = a[0] * a[10] * a[15] - a[0] * a[11] * a[14] - a[8] * a[2] * a[15] + a[8] * a[3] * a[14] + a[12] * a[2] * a[11] - a[12] * a[3] * a[10];
+  inv[9] = -a[0] * a[9] * a[15] + a[0] * a[11] * a[13] + a[8] * a[1] * a[15] - a[8] * a[3] * a[13] - a[12] * a[1] * a[11] + a[12] * a[3] * a[9];
+  inv[13] = a[0] * a[9] * a[14] - a[0] * a[10] * a[13] - a[8] * a[1] * a[14] + a[8] * a[2] * a[13] + a[12] * a[1] * a[10] - a[12] * a[2] * a[9];
+  inv[2] = a[1] * a[6] * a[15] - a[1] * a[7] * a[14] - a[5] * a[2] * a[15] + a[5] * a[3] * a[14] + a[13] * a[2] * a[7] - a[13] * a[3] * a[6];
+  inv[6] = -a[0] * a[6] * a[15] + a[0] * a[7] * a[14] + a[4] * a[2] * a[15] - a[4] * a[3] * a[14] - a[12] * a[2] * a[7] + a[12] * a[3] * a[6];
+  inv[10] = a[0] * a[5] * a[15] - a[0] * a[7] * a[13] - a[4] * a[1] * a[15] + a[4] * a[3] * a[13] + a[12] * a[1] * a[7] - a[12] * a[3] * a[5];
+  inv[14] = -a[0] * a[5] * a[14] + a[0] * a[6] * a[13] + a[4] * a[1] * a[14] - a[4] * a[2] * a[13] - a[12] * a[1] * a[6] + a[12] * a[2] * a[5];
+  inv[3] = -a[1] * a[6] * a[11] + a[1] * a[7] * a[10] + a[5] * a[2] * a[11] - a[5] * a[3] * a[10] - a[9] * a[2] * a[7] + a[9] * a[3] * a[6];
+  inv[7] = a[0] * a[6] * a[11] - a[0] * a[7] * a[10] - a[4] * a[2] * a[11] + a[4] * a[3] * a[10] + a[8] * a[2] * a[7] - a[8] * a[3] * a[6];
+  inv[11] = -a[0] * a[5] * a[11] + a[0] * a[7] * a[9] + a[4] * a[1] * a[11] - a[4] * a[3] * a[9] - a[8] * a[1] * a[7] + a[8] * a[3] * a[5];
+  inv[15] = a[0] * a[5] * a[10] - a[0] * a[6] * a[9] - a[4] * a[1] * a[10] + a[4] * a[2] * a[9] + a[8] * a[1] * a[6] - a[8] * a[2] * a[5];
+  let det = a[0] * inv[0] + a[1] * inv[4] + a[2] * inv[8] + a[3] * inv[12];
+  if (Math.abs(det) < 1e-20) return null;
+  det = 1 / det;
+  const result = Array.from(
+    { length: 4 },
+    () => new Array(4).fill(0)
+  );
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      result[i][j] = inv[i * 4 + j] * det;
+    }
+  }
+  return result;
+}
+function selectEphemeris(ephemerides, prn, timeMs) {
+  let best = null;
+  let bestDt = Infinity;
+  for (const eph of ephemerides) {
+    if (eph.prn !== prn) continue;
+    const ephTime = eph.tocDate.getTime();
+    const dt = Math.abs(timeMs - ephTime);
+    if (dt > 4 * 3600 * 1e3) continue;
+    if (dt < bestDt) {
+      bestDt = dt;
+      best = eph;
+    }
+  }
+  return best;
+}
+function computeSatPosition(eph, timeMs) {
+  if (eph.system === "R" || eph.system === "S") {
+    return glonassPosition(eph, timeMs / 1e3);
+  }
+  const GPS_EPOCH = Date.UTC(1980, 0, 6);
+  const gpsSeconds = (timeMs - GPS_EPOCH) / 1e3;
+  const tow = gpsSeconds % (7 * 86400);
+  return keplerPosition(eph, tow);
+}
+function navTimesFromEph(ephs) {
+  let minT = Infinity, maxT = -Infinity;
+  for (const eph of ephs) {
+    const t = eph.tocDate.getTime();
+    if (t < minT) minT = t;
+    if (t > maxT) maxT = t;
+  }
+  const span = maxT - minT;
+  const step = Math.max(span / 500, 3e4);
+  const times = [];
+  for (let t = minT; t <= maxT; t += step) times.push(t);
+  if (times.length === 0 && isFinite(minT)) times.push(minT);
+  return times;
+}
+function computeAllPositions(ephemerides, times, rxPos) {
+  const ephByPrn = /* @__PURE__ */ new Map();
+  for (const eph of ephemerides) {
+    let arr = ephByPrn.get(eph.prn);
+    if (!arr) {
+      arr = [];
+      ephByPrn.set(eph.prn, arr);
+    }
+    arr.push(eph);
+  }
+  const prns = [...ephByPrn.keys()].sort();
+  const positions = {};
+  for (const prn of prns) positions[prn] = [];
+  let sinLat = 0, cosLat = 1, sinLon = 0, cosLon = 1;
+  let hasRx = false;
+  if (rxPos) {
+    const [rxX, rxY, rxZ] = rxPos;
+    if (rxX !== 0 || rxY !== 0 || rxZ !== 0) {
+      hasRx = true;
+      const [gLat, gLon] = ecefToGeodetic(rxX, rxY, rxZ);
+      sinLat = Math.sin(gLat);
+      cosLat = Math.cos(gLat);
+      sinLon = Math.sin(gLon);
+      cosLon = Math.cos(gLon);
+    }
+  }
+  for (const t of times) {
+    for (const prn of prns) {
+      const eph = selectBest(ephByPrn.get(prn), t);
+      if (!eph) {
+        positions[prn].push(null);
+        continue;
+      }
+      const pos = computeSatPosition(eph, t);
+      const [geoLat, geoLon] = ecefToGeodetic(pos.x, pos.y, pos.z);
+      let az = 0, el = 0;
+      if (hasRx) {
+        const dx = pos.x - rxPos[0];
+        const dy = pos.y - rxPos[1];
+        const dz = pos.z - rxPos[2];
+        const east = -sinLon * dx + cosLon * dy;
+        const north = -sinLat * cosLon * dx - sinLat * sinLon * dy + cosLat * dz;
+        const up = cosLat * cosLon * dx + cosLat * sinLon * dy + sinLat * dz;
+        az = (Math.atan2(east, north) + TWO_PI) % TWO_PI;
+        el = Math.atan2(up, Math.sqrt(east * east + north * north));
+      }
+      positions[prn].push({ lat: geoLat, lon: geoLon, az, el });
+    }
+  }
+  return { prns, times, positions };
+}
+function selectBest(ephs, timeMs) {
+  let best = null;
+  let bestDt = Infinity;
+  for (const eph of ephs) {
+    const dt = Math.abs(timeMs - eph.tocDate.getTime());
+    const maxAge = eph.system === "R" || eph.system === "S" ? 18e5 : 4 * 36e5;
+    if (dt > maxAge) continue;
+    if (dt < bestDt) {
+      bestDt = dt;
+      best = eph;
+    }
+  }
+  return best;
+}
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var BDS_EPOCH_MS = Date.UTC(2006, 0, 1);
+var GAL_EPOCH_MS = GPS_EPOCH_MS;
+function ephInfoToEphemeris(info) {
+  const sys = info.prn.charAt(0);
+  if (sys === "R") {
+    if (info.x === void 0 || info.y === void 0 || info.z === void 0)
+      return null;
+    if (info.vx === void 0 || info.vy === void 0 || info.vz === void 0)
+      return null;
+    const now = new Date(info.lastReceived);
+    const utcMidnight = Date.UTC(
+      now.getUTCFullYear(),
+      now.getUTCMonth(),
+      now.getUTCDate()
+    );
+    const tbSec = (info.tb ?? 0) * 900;
+    const moscowOffset = 3 * 3600;
+    const tocMs = utcMidnight + (tbSec - moscowOffset) * 1e3;
+    return {
+      system: "R",
+      prn: info.prn,
+      tocDate: new Date(tocMs),
+      tauN: -(info.af0 ?? 0),
+      // RTCM stores -tauN
+      gammaN: info.gammaN ?? 0,
+      messageFrameTime: 0,
+      x: info.x,
+      xDot: info.vx,
+      xAcc: info.ax ?? 0,
+      y: info.y,
+      yDot: info.vy,
+      yAcc: info.ay ?? 0,
+      z: info.z,
+      zDot: info.vz,
+      zAcc: info.az ?? 0,
+      health: info.health,
+      freqNum: info.freqChannel ?? 0
+    };
+  }
+  if (info.sqrtA === void 0 || info.eccentricity === void 0 || info.inclination === void 0 || info.omega0 === void 0 || info.argPerigee === void 0 || info.meanAnomaly === void 0 || info.toe === void 0 || info.week === void 0)
+    return null;
+  let epochMs;
+  const tocSec = info.toc ?? info.toe;
+  if (sys === "C") {
+    epochMs = BDS_EPOCH_MS;
+  } else if (sys === "E") {
+    epochMs = GAL_EPOCH_MS;
+  } else {
+    epochMs = GPS_EPOCH_MS;
+  }
+  const tocDate = new Date(epochMs + info.week * 7 * 864e5 + tocSec * 1e3);
+  return {
+    system: sys,
+    prn: info.prn,
+    toc: tocSec,
+    tocDate,
+    af0: info.af0 ?? 0,
+    af1: info.af1 ?? 0,
+    af2: info.af2 ?? 0,
+    iode: info.iode ?? 0,
+    crs: info.crs ?? 0,
+    deltaN: info.deltaN ?? 0,
+    m0: info.meanAnomaly,
+    cuc: info.cuc ?? 0,
+    e: info.eccentricity,
+    cus: info.cus ?? 0,
+    sqrtA: info.sqrtA,
+    toe: info.toe,
+    cic: info.cic ?? 0,
+    omega0: info.omega0,
+    cis: info.cis ?? 0,
+    i0: info.inclination,
+    crc: info.crc ?? 0,
+    omega: info.argPerigee,
+    omegaDot: info.omegaDot ?? 0,
+    idot: info.idot ?? 0,
+    week: info.week,
+    svHealth: info.health,
+    tgd: 0
+  };
+}
+function computeLiveSkyPositions(ephemerides, rxPos, cn0Map) {
+  const now = Date.now();
+  const result = [];
+  const [rxX, rxY, rxZ] = rxPos;
+  const [rxLat, rxLon] = ecefToGeodetic(rxX, rxY, rxZ);
+  const sinRxLat = Math.sin(rxLat), cosRxLat = Math.cos(rxLat);
+  const sinRxLon = Math.sin(rxLon), cosRxLon = Math.cos(rxLon);
+  for (const info of ephemerides.values()) {
+    const eph = ephInfoToEphemeris(info);
+    if (!eph) continue;
+    try {
+      const pos = computeSatPosition(eph, now);
+      const [satLat, satLon] = ecefToGeodetic(pos.x, pos.y, pos.z);
+      const dx = pos.x - rxX, dy = pos.y - rxY, dz = pos.z - rxZ;
+      const east = -sinRxLon * dx + cosRxLon * dy;
+      const north = -sinRxLat * cosRxLon * dx - sinRxLat * sinRxLon * dy + cosRxLat * dz;
+      const up = cosRxLat * cosRxLon * dx + cosRxLat * sinRxLon * dy + sinRxLat * dz;
+      const az = (Math.atan2(east, north) + TWO_PI) % TWO_PI;
+      const el = Math.atan2(up, Math.sqrt(east * east + north * north));
+      if (el > -0.05) {
+        result.push({
+          prn: info.prn,
+          az,
+          el,
+          lat: satLat,
+          lon: satLon,
+          cn0: cn0Map?.get(info.prn)
+        });
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeAllPositions,
+  computeDop,
+  computeLiveSkyPositions,
+  computeSatPosition,
+  ecefToAzEl,
+  ecefToGeodetic,
+  geodeticToEcef,
+  glonassPosition,
+  keplerPosition,
+  navTimesFromEph,
+  selectEphemeris
+});

package/dist/orbit.d.cts

@@ -0,0 +1,117 @@
+import { E as Ephemeris, G as GlonassEphemeris, K as KeplerEphemeris } from './nav-BAI1a9vK.cjs';
+import { E as EphemerisInfo } from './ephemeris-C10stHhM.cjs';
+export { e as ecefToGeodetic, g as geodeticToEcef } from './ecef-CF0uAysr.cjs';
+
+/**
+ * Satellite orbit computation from broadcast ephemerides.
+ * Supports GPS, Galileo, BeiDou (Keplerian) and GLONASS (Runge-Kutta).
+ */
+
+interface SatPosition {
+    prn: string;
+    x: number;
+    y: number;
+    z: number;
+}
+interface SatAzEl {
+    prn: string;
+    az: number;
+    el: number;
+    lat: number;
+    lon: number;
+    cn0?: number;
+}
+interface DopValues {
+    gdop: number;
+    pdop: number;
+    hdop: number;
+    vdop: number;
+}
+/**
+ * Compute satellite ECEF position from Keplerian ephemeris.
+ * @param eph Broadcast ephemeris
+ * @param t GPS time of week in seconds
+ */
+declare function keplerPosition(eph: KeplerEphemeris, t: number): SatPosition;
+/**
+ * Compute GLONASS satellite ECEF position.
+ * @param eph GLONASS ephemeris
+ * @param tUtc Target time as UTC seconds since Unix epoch
+ */
+declare function glonassPosition(eph: GlonassEphemeris, tUtc: number): SatPosition;
+/**
+ * Compute azimuth and elevation from receiver ECEF to satellite ECEF.
+ * @param rxX Receiver X in meters (ECEF)
+ * @param rxY Receiver Y in meters (ECEF)
+ * @param rxZ Receiver Z in meters (ECEF)
+ * @param satX Satellite X in meters (ECEF)
+ * @param satY Satellite Y in meters (ECEF)
+ * @param satZ Satellite Z in meters (ECEF)
+ * @returns {az: radians, el: radians}
+ */
+declare function ecefToAzEl(rxX: number, rxY: number, rxZ: number, satX: number, satY: number, satZ: number): {
+    az: number;
+    el: number;
+};
+/**
+ * Compute DOP values from a set of satellite az/el.
+ * @param satAzEls Array of satellite azimuth/elevation pairs (radians)
+ * @returns DOP values (GDOP, PDOP, HDOP, VDOP), or null if fewer than 4 satellites
+ */
+declare function computeDop(satAzEls: {
+    az: number;
+    el: number;
+}[]): DopValues | null;
+/**
+ * Find the best ephemeris for a given PRN at a given time.
+ * Selects the one with the closest epoch (toe/toc) to the target time.
+ * @param ephemerides Array of candidate ephemerides
+ * @param prn Satellite PRN identifier (e.g. "G01")
+ * @param timeMs Target time in Unix milliseconds
+ */
+declare function selectEphemeris(ephemerides: Ephemeris[], prn: string, timeMs: number): Ephemeris | null;
+/**
+ * Compute satellite position from ephemeris.
+ * @param eph Ephemeris record
+ * @param timeMs Target time in Unix milliseconds
+ * @returns Satellite position with ECEF coordinates in meters
+ */
+declare function computeSatPosition(eph: Ephemeris, timeMs: number): SatPosition;
+interface EpochSkyData {
+    time: number;
+    satellites: SatAzEl[];
+    dop: DopValues | null;
+}
+/**
+ * Derive evenly-spaced epoch times from an ephemeris set's toc range.
+ * @param ephs Array of ephemerides to derive the time span from
+ * @returns Array of epoch timestamps in Unix milliseconds
+ */
+declare function navTimesFromEph(ephs: Ephemeris[]): number[];
+interface SatPoint {
+    lat: number;
+    lon: number;
+    az: number;
+    el: number;
+}
+interface AllPositionsData {
+    /** All unique PRNs sorted. */
+    prns: string[];
+    /** Epoch timestamps in Unix ms. */
+    times: number[];
+    /** positions[prn][epochIdx] — null if no valid ephemeris. */
+    positions: Record<string, (SatPoint | null)[]>;
+}
+/**
+ * Compute satellite positions for ALL PRNs at all times in a single pass.
+ * Returns geodetic (lat/lon) for ground tracks and az/el for sky plot.
+ * When rxPos is provided, az/el are computed; otherwise they are 0.
+ */
+declare function computeAllPositions(ephemerides: Ephemeris[], times: number[], rxPos?: [number, number, number]): AllPositionsData;
+/**
+ * Compute current satellite az/el from live RTCM3 ephemeris data.
+ * Returns array of SatAzEl for all satellites with valid ephemeris.
+ */
+declare function computeLiveSkyPositions(ephemerides: Map<string, EphemerisInfo>, rxPos: [number, number, number], cn0Map?: Map<string, number>): SatAzEl[];
+
+export { type AllPositionsData, type DopValues, type EpochSkyData, type SatAzEl, type SatPoint, type SatPosition, computeAllPositions, computeDop, computeLiveSkyPositions, computeSatPosition, ecefToAzEl, glonassPosition, keplerPosition, navTimesFromEph, selectEphemeris };