gnss-js 1.19.0 → 1.21.0

package/dist/novatel.cjs

@@ -202,6 +202,202 @@ function decodeGpsLnavFrame(subframes, opts = {}) {
   };
 }
 
+// src/navbits/cnav.ts
+var GPS_EPOCH_MS2 = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK2 = 7 * 86400;
+var HALF_WEEK = 302400;
+var CNAV_PREAMBLE = 139;
+var CNAV_A_REF = 26559710;
+var CNAV_OMEGA_DOT_REF = -26e-10;
+function crc24q(buff, bitLen) {
+  let crc = 0;
+  for (let i = 0; i < bitLen; i++) {
+    crc ^= (buff[i >> 3] >> 7 - (i & 7) & 1) << 23;
+    const msb = crc & 8388608;
+    crc = crc << 1 & 16777215;
+    if (msb) crc ^= 8801531;
+  }
+  return crc;
+}
+function cnavCrcOk(msg) {
+  if (msg.length < 38) return false;
+  return crc24q(msg, 276) === getBitU(msg, 276, 24);
+}
+function getBitU33(b, pos) {
+  return getBitU(b, pos, 1) * 2 ** 32 + getBitU(b, pos + 1, 32);
+}
+function getBitS33(b, pos) {
+  const u = getBitU33(b, pos);
+  return u < 2 ** 32 ? u : u - 2 ** 33;
+}
+function decodeType10(b, tow) {
+  return {
+    tow,
+    week: getBitU(b, 38, 13),
+    health: getBitU(b, 51, 3),
+    top: getBitU(b, 54, 11) * 300,
+    uraEd: getBitS(b, 65, 5),
+    toe: getBitU(b, 70, 11) * 300,
+    deltaA: getBitS(b, 81, 26) * 2 ** -9,
+    aDot: getBitS(b, 107, 25) * 2 ** -21,
+    deltaN0: getBitS(b, 132, 17) * 2 ** -44 * GPS_PI,
+    deltaN0Dot: getBitS(b, 149, 23) * 2 ** -57 * GPS_PI,
+    m0: getBitS33(b, 172) * 2 ** -32 * GPS_PI,
+    e: getBitU33(b, 205) * 2 ** -34,
+    omega: getBitS33(b, 238) * 2 ** -32 * GPS_PI,
+    integrityFlag: getBitU(b, 271, 1) === 1,
+    l2cPhasing: getBitU(b, 272, 1) === 1
+  };
+}
+function decodeType11(b) {
+  return {
+    toe: getBitU(b, 38, 11) * 300,
+    omega0: getBitS33(b, 49) * 2 ** -32 * GPS_PI,
+    i0: getBitS33(b, 82) * 2 ** -32 * GPS_PI,
+    deltaOmegaDot: getBitS(b, 115, 17) * 2 ** -44 * GPS_PI,
+    i0Dot: getBitS(b, 132, 15) * 2 ** -44 * GPS_PI,
+    cis: getBitS(b, 147, 16) * 2 ** -30,
+    cic: getBitS(b, 163, 16) * 2 ** -30,
+    crs: getBitS(b, 179, 24) * 2 ** -8,
+    crc: getBitS(b, 203, 24) * 2 ** -8,
+    cus: getBitS(b, 227, 21) * 2 ** -30,
+    cuc: getBitS(b, 248, 21) * 2 ** -30
+  };
+}
+var isc = (b, pos) => {
+  const raw = getBitS(b, pos, 13);
+  return raw === -4096 ? null : raw * 2 ** -35;
+};
+function decodeClock(b, msgType) {
+  const clock = {
+    msgType,
+    top: getBitU(b, 38, 11) * 300,
+    uraNed0: getBitS(b, 49, 5),
+    uraNed1: getBitU(b, 54, 3),
+    uraNed2: getBitU(b, 57, 3),
+    toc: getBitU(b, 60, 11) * 300,
+    af0: getBitS(b, 71, 26) * 2 ** -35,
+    af1: getBitS(b, 97, 20) * 2 ** -48,
+    af2: getBitS(b, 117, 10) * 2 ** -60
+  };
+  if (msgType === 30) {
+    clock.tgd = isc(b, 127);
+    clock.iscL1ca = isc(b, 140);
+    clock.iscL2c = isc(b, 153);
+    clock.iscL5i5 = isc(b, 166);
+    clock.iscL5q5 = isc(b, 179);
+    clock.ionoAlpha = [
+      getBitS(b, 192, 8) * 2 ** -30,
+      getBitS(b, 200, 8) * 2 ** -27,
+      getBitS(b, 208, 8) * 2 ** -24,
+      getBitS(b, 216, 8) * 2 ** -24
+    ];
+    clock.ionoBeta = [
+      getBitS(b, 224, 8) * 2 ** 11,
+      getBitS(b, 232, 8) * 2 ** 14,
+      getBitS(b, 240, 8) * 2 ** 16,
+      getBitS(b, 248, 8) * 2 ** 16
+    ];
+    clock.wnOp = getBitU(b, 256, 8);
+  }
+  return clock;
+}
+function resolveWeek(week, towSec, sec) {
+  if (sec < towSec - HALF_WEEK) return week + 1;
+  if (sec > towSec + HALF_WEEK) return week - 1;
+  return week;
+}
+function gpsDate(week, sec) {
+  return new Date(GPS_EPOCH_MS2 + (week * SEC_PER_WEEK2 + sec) * 1e3);
+}
+var CnavAssembler = class {
+  sats = /* @__PURE__ */ new Map();
+  /**
+   * Push one 300-bit CNAV message (38+ bytes, bit 0 = first bit of
+   * the preamble). Returns the newly completed ephemeris, or null.
+   * Messages that are not MT10/MT11/MT30-37, or whose preamble/PRN
+   * are out of range, are ignored.
+   */
+  push(msg) {
+    if (msg.length < 38 || getBitU(msg, 0, 8) !== CNAV_PREAMBLE) return null;
+    const prn = getBitU(msg, 8, 6);
+    if (prn < 1 || prn > 32) return null;
+    const type = getBitU(msg, 14, 6);
+    const tow = getBitU(msg, 20, 17) * 6;
+    let sat = this.sats.get(prn);
+    if (!sat) {
+      sat = {};
+      this.sats.set(prn, sat);
+    }
+    if (type === 10) sat.t10 = decodeType10(msg, tow);
+    else if (type === 11) sat.t11 = decodeType11(msg);
+    else if (type >= 30 && type <= 37) {
+      sat.clock = decodeClock(msg, type);
+      if (type === 30) sat.extras = sat.clock;
+    } else return null;
+    return this.tryEmit(prn, sat);
+  }
+  tryEmit(prn, sat) {
+    const { t10, t11, clock, extras } = sat;
+    if (!t10 || !t11 || !clock) return null;
+    if (t10.toe !== t11.toe || clock.toc !== t10.toe) return null;
+    const key = `${t10.week}:${t10.toe}:${clock.af0}:${clock.af1}`;
+    if (key === sat.lastKey) return null;
+    sat.lastKey = key;
+    const weekToe = resolveWeek(t10.week, t10.tow, t10.toe);
+    const a = CNAV_A_REF + t10.deltaA;
+    return {
+      system: "G",
+      prn: `G${String(prn).padStart(2, "0")}`,
+      week: t10.week,
+      health: t10.health,
+      uraEd: t10.uraEd,
+      uraNed0: clock.uraNed0,
+      uraNed1: clock.uraNed1,
+      uraNed2: clock.uraNed2,
+      top: t10.top,
+      toe: t10.toe,
+      toeDate: gpsDate(weekToe, t10.toe),
+      a,
+      deltaA: t10.deltaA,
+      aDot: t10.aDot,
+      deltaN0: t10.deltaN0,
+      deltaN0Dot: t10.deltaN0Dot,
+      m0: t10.m0,
+      e: t10.e,
+      omega: t10.omega,
+      omega0: t11.omega0,
+      i0: t11.i0,
+      omegaDot: CNAV_OMEGA_DOT_REF * GPS_PI + t11.deltaOmegaDot,
+      deltaOmegaDot: t11.deltaOmegaDot,
+      i0Dot: t11.i0Dot,
+      cis: t11.cis,
+      cic: t11.cic,
+      crs: t11.crs,
+      crc: t11.crc,
+      cus: t11.cus,
+      cuc: t11.cuc,
+      toc: clock.toc,
+      tocDate: gpsDate(weekToe, clock.toc),
+      af0: clock.af0,
+      af1: clock.af1,
+      af2: clock.af2,
+      clockMsgType: clock.msgType,
+      tgd: extras?.tgd ?? null,
+      iscL1ca: extras?.iscL1ca ?? null,
+      iscL2c: extras?.iscL2c ?? null,
+      iscL5i5: extras?.iscL5i5 ?? null,
+      iscL5q5: extras?.iscL5q5 ?? null,
+      ...extras?.ionoAlpha && { ionoAlpha: extras.ionoAlpha },
+      ...extras?.ionoBeta && { ionoBeta: extras.ionoBeta },
+      ...extras?.wnOp !== void 0 && { wnOp: extras.wnOp },
+      integrityFlag: t10.integrityFlag,
+      l2cPhasing: t10.l2cPhasing,
+      tow: t10.tow
+    };
+  }
+};
+
 // src/constants/time.ts
 var MILLISECONDS_IN_SECOND = 1e3;
 var MILLISECONDS_GPS_TAI = 19e3;
@@ -291,21 +487,22 @@ function getUtcDate(date) {
 
 // src/novatel/nav.ts
 var ID_IONUTC = 8;
+var ID_RAWCNAVFRAME = 1066;
 var ID_RAWEPHEM = 41;
 var ID_GLOEPHEMERIS = 723;
 var ID_GALEPHEMERIS = 1122;
 var ID_QZSSEPHEMERIS = 1336;
 var ID_GPSEPHEM = 7;
 var ID_BDSEPHEMERIS = 1696;
-var GPS_EPOCH_MS2 = Date.UTC(1980, 0, 6);
+var GPS_EPOCH_MS3 = Date.UTC(1980, 0, 6);
 var BDT_EPOCH_MS = Date.UTC(2006, 0, 1);
-var SEC_PER_WEEK2 = 7 * 86400;
+var SEC_PER_WEEK3 = 7 * 86400;
 var SEC_PER_DAY = 86400;
-var MS_PER_WEEK = SEC_PER_WEEK2 * 1e3;
-var gpsMs = (week, sec) => GPS_EPOCH_MS2 + week * MS_PER_WEEK + sec * 1e3;
-var sowOf = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK2;
+var MS_PER_WEEK = SEC_PER_WEEK3 * 1e3;
+var gpsMs = (week, sec) => GPS_EPOCH_MS3 + week * MS_PER_WEEK + sec * 1e3;
+var sowOf = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK3;
 function nearWeekMs(refMs, sow) {
-  const refWeek = Math.floor((refMs - GPS_EPOCH_MS2) / MS_PER_WEEK);
+  const refWeek = Math.floor((refMs - GPS_EPOCH_MS3) / MS_PER_WEEK);
   let ms = gpsMs(refWeek, sow);
   if (ms < refMs - MS_PER_WEEK / 2) ms += MS_PER_WEEK;
   else if (ms > refMs + MS_PER_WEEK / 2) ms -= MS_PER_WEEK;
@@ -332,9 +529,9 @@ function decodeGloEphemeris(view, p) {
   tof += Math.floor(tow / SEC_PER_DAY) * SEC_PER_DAY;
   if (tof < tow - 43200) tof += SEC_PER_DAY;
   else if (tof > tow + 43200) tof -= SEC_PER_DAY;
-  const toeGpsMs = GPS_EPOCH_MS2 + (week * SEC_PER_WEEK2 + tow) * 1e3;
-  const tofGpsMs = GPS_EPOCH_MS2 + (week * SEC_PER_WEEK2 + tof) * 1e3;
-  const tofUtcSec = (getUtcDate(new Date(tofGpsMs)).getTime() - GPS_EPOCH_MS2) / 1e3;
+  const toeGpsMs = GPS_EPOCH_MS3 + (week * SEC_PER_WEEK3 + tow) * 1e3;
+  const tofGpsMs = GPS_EPOCH_MS3 + (week * SEC_PER_WEEK3 + tof) * 1e3;
+  const tofUtcSec = (getUtcDate(new Date(tofGpsMs)).getTime() - GPS_EPOCH_MS3) / 1e3;
   return {
     system: "R",
     prn: `R${String(slot).padStart(2, "0")}`,
@@ -342,7 +539,7 @@ function decodeGloEphemeris(view, p) {
     tauN: -view.getFloat64(p + 100, true),
     // RINEX stores −τ_n
     gammaN: view.getFloat64(p + 116, true),
-    messageFrameTime: (tofUtcSec % SEC_PER_WEEK2 + SEC_PER_WEEK2) % SEC_PER_WEEK2,
+    messageFrameTime: (tofUtcSec % SEC_PER_WEEK3 + SEC_PER_WEEK3) % SEC_PER_WEEK3,
     x: view.getFloat64(p + 28, true) / 1e3,
     y: view.getFloat64(p + 36, true) / 1e3,
     z: view.getFloat64(p + 44, true) / 1e3,
@@ -399,7 +596,7 @@ function decodeGalEphemeris(view, p, headerMs) {
       omega: view.getFloat64(p + 60, true),
       omegaDot: view.getFloat64(p + 140, true),
       idot: view.getFloat64(p + 124, true),
-      week: Math.floor((toeMs - GPS_EPOCH_MS2) / MS_PER_WEEK),
+      week: Math.floor((toeMs - GPS_EPOCH_MS3) / MS_PER_WEEK),
       // RINEX Galileo SVH bit layout (E1B DVS/HS in bits 0-2, E5a in
       // 3-5, E5b in 6-8) — same packing as RTKLIB.
       svHealth: svhE5b << 7 | dvsE5b << 6 | svhE5a << 4 | dvsE5a << 3 | svhE1b << 1 | dvsE1b,
@@ -497,6 +694,9 @@ function parseNovatelNav(data) {
   const ephemerides = [];
   const ionoCorrections = {};
   let leapSeconds = null;
+  const cnav = [];
+  const cnavAssembler = new CnavAssembler();
+  let cnavBadCrc = 0;
   const lastKep = /* @__PURE__ */ new Map();
   const lastGlo = /* @__PURE__ */ new Map();
   const pushKepler = (key, eph) => {
@@ -527,6 +727,14 @@ function parseNovatelNav(data) {
     } else if (frame.id === ID_QZSSEPHEMERIS && frame.msgLen >= 204) {
       const eph = decodeGpsQzssEphemeris(view, frame.payload, "J");
       if (eph) pushKepler(eph.prn, eph);
+    } else if (frame.id === ID_RAWCNAVFRAME && frame.msgLen >= 50) {
+      const msg = data.subarray(frame.payload + 12, frame.payload + 50);
+      if (!cnavCrcOk(msg)) {
+        cnavBadCrc++;
+      } else {
+        const eph = cnavAssembler.push(msg);
+        if (eph) cnav.push(eph);
+      }
     } else if (frame.id === ID_IONUTC && frame.msgLen >= 108) {
       const p = frame.payload;
       const alpha = [];
@@ -549,11 +757,18 @@ function parseNovatelNav(data) {
       ephemerides.push(eph);
     }
   }
-  return { ephemerides, ionoCorrections, leapSeconds, badCrc: stats.badCrc };
+  return {
+    ephemerides,
+    ionoCorrections,
+    leapSeconds,
+    cnav,
+    cnavBadCrc,
+    badCrc: stats.badCrc
+  };
 }
 
 // src/novatel/index.ts
-var GPS_EPOCH_MS3 = Date.UTC(1980, 0, 6);
+var GPS_EPOCH_MS4 = Date.UTC(1980, 0, 6);
 var MS_PER_WEEK2 = 7 * 864e5;
 var HDR = 28;
 var ID_RANGE = 43;
@@ -723,7 +938,7 @@ function parseNovatelRange(data) {
           if (!codes.includes(code)) codes.push(code);
         }
         epochs.push({
-          timeMs: GPS_EPOCH_MS3 + week * MS_PER_WEEK2 + towMs,
+          timeMs: GPS_EPOCH_MS4 + week * MS_PER_WEEK2 + towMs,
           meas
         });
       }
@@ -775,7 +990,7 @@ function parseNovatelRange(data) {
           if (!codes.includes(code)) codes.push(code);
         }
         epochs.push({
-          timeMs: GPS_EPOCH_MS3 + week * MS_PER_WEEK2 + towMs,
+          timeMs: GPS_EPOCH_MS4 + week * MS_PER_WEEK2 + towMs,
           meas
         });
       }

package/dist/novatel.d.cts

@@ -1,4 +1,4 @@
-import { E as Ephemeris } from './nav-DImXUdbp.cjs';
+import { E as Ephemeris, C as CnavEphemeris } from './nav-DImXUdbp.cjs';
 
 /**
  * NovAtel OEM4/6/7 binary framing shared by the measurement and
@@ -75,6 +75,13 @@ interface NovatelNavResult {
     ionoCorrections: Record<string, number[]>;
     /** GPS−UTC leap seconds (Δt_LS) from IONUTC, null when unseen. */
     leapSeconds: number | null;
+    /**
+     * GPS CNAV ephemerides assembled from RAWCNAVFRAME (1066) raw
+     * L2C/L5 messages, repeats suppressed by the shared assembler.
+     */
+    cnav: CnavEphemeris[];
+    /** RAWCNAVFRAME messages whose CRC-24Q check failed (dropped). */
+    cnavBadCrc: number;
     /** Frames whose CRC failed (corruption indicator). */
     badCrc: number;
 }

package/dist/novatel.d.ts

@@ -1,4 +1,4 @@
-import { E as Ephemeris } from './nav-DImXUdbp.js';
+import { E as Ephemeris, C as CnavEphemeris } from './nav-DImXUdbp.js';
 
 /**
  * NovAtel OEM4/6/7 binary framing shared by the measurement and
@@ -75,6 +75,13 @@ interface NovatelNavResult {
     ionoCorrections: Record<string, number[]>;
     /** GPS−UTC leap seconds (Δt_LS) from IONUTC, null when unseen. */
     leapSeconds: number | null;
+    /**
+     * GPS CNAV ephemerides assembled from RAWCNAVFRAME (1066) raw
+     * L2C/L5 messages, repeats suppressed by the shared assembler.
+     */
+    cnav: CnavEphemeris[];
+    /** RAWCNAVFRAME messages whose CRC-24Q check failed (dropped). */
+    cnavBadCrc: number;
     /** Frames whose CRC failed (corruption indicator). */
     badCrc: number;
 }

package/dist/novatel.js

@@ -4,8 +4,8 @@ import {
   oem4Frames,
   parseNovatelNav,
   parseNovatelRange
-} from "./chunk-2IM5VXNI.js";
-import "./chunk-IQ5OIMQD.js";
+} from "./chunk-7RKLWE6R.js";
+import "./chunk-WZDFZ76K.js";
 import "./chunk-HVXYFUCB.js";
 import "./chunk-LEEU5OIO.js";
 export {

package/dist/orbit.cjs

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/orbit/index.ts
 var orbit_exports = {};
 __export(orbit_exports, {
+  almanacEpochMs: () => almanacEpochMs,
+  almanacSatPosition: () => almanacSatPosition,
   computeAllPositions: () => computeAllPositions,
   computeDop: () => computeDop,
   computeLiveSkyPositions: () => computeLiveSkyPositions,
@@ -31,6 +33,8 @@ __export(orbit_exports, {
   ecefToGeodetic: () => ecefToGeodetic,
   ephInfoToEphemeris: () => ephInfoToEphemeris,
   geodeticToEcef: () => geodeticToEcef,
+  glonassAlmanacEpochMs: () => glonassAlmanacEpochMs,
+  glonassAlmanacPosition: () => glonassAlmanacPosition,
   glonassPosition: () => glonassPosition,
   keplerPosition: () => keplerPosition,
   maskRadForAzimuth: () => maskRadForAzimuth,
@@ -170,10 +174,184 @@ function getGpsLeap(date) {
   return leap_seconds - 19;
 }
 
-// src/orbit/index.ts
+// src/orbit/almanac.ts
 var GM_GPS = 3986005e8;
 var GM_GAL = 3986004418e5;
 var GM_BDS = 3986004418e5;
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var BDT_EPOCH_MS = Date.UTC(2006, 0, 1);
+var WEEK_MS = 6048e5;
+var BDT_MINUS_GPST_MS = 14e3;
+var BDS_GEO_PRNS = /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 59, 60, 61, 62, 63]);
+function almanacEpochMs(alm) {
+  if (alm.system === "C") {
+    return BDT_EPOCH_MS + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3 + BDT_MINUS_GPST_MS;
+  }
+  return GPS_EPOCH_MS + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3;
+}
+function almanacSatPosition(alm, timeMs) {
+  const GM = alm.system === "E" ? GM_GAL : alm.system === "C" ? GM_BDS : GM_GPS;
+  const a = alm.sqrtA * alm.sqrtA;
+  const n0 = Math.sqrt(GM / (a * a * a));
+  const tk = (timeMs - almanacEpochMs(alm)) / 1e3;
+  const Mk = alm.m0 + n0 * tk;
+  let Ek = Mk;
+  for (let i = 0; i < 12; i++) {
+    const dE = (Mk - (Ek - alm.e * Math.sin(Ek))) / (1 - alm.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 - alm.e * alm.e) * sinE, cosE - alm.e);
+  const uk = vk + alm.omega;
+  const rk = a * (1 - alm.e * cosE);
+  const ik = alm.i0OrDeltaI;
+  const xp = rk * Math.cos(uk);
+  const yp = rk * Math.sin(uk);
+  const clockBias = alm.af0 + alm.af1 * tk;
+  const isGeo = alm.system === "C" && BDS_GEO_PRNS.has(Number(alm.prn.slice(1)));
+  if (isGeo) {
+    const omegak2 = alm.omega0 + alm.omegaDot * tk - OMEGA_E * alm.toaSec;
+    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: alm.prn,
+      x: xg * cosPhi + yg * sinPhi * COS5 + zg * sinPhi * SIN5,
+      y: -xg * sinPhi + yg * cosPhi * COS5 + zg * cosPhi * SIN5,
+      z: -yg * SIN5 + zg * COS5,
+      clockBias
+    };
+  }
+  const omegak = alm.omega0 + (alm.omegaDot - OMEGA_E) * tk - OMEGA_E * alm.toaSec;
+  const cosO = Math.cos(omegak);
+  const sinO = Math.sin(omegak);
+  const cosI = Math.cos(ik);
+  const sinI = Math.sin(ik);
+  return {
+    prn: alm.prn,
+    x: xp * cosO - yp * cosI * sinO,
+    y: xp * sinO + yp * cosI * cosO,
+    z: yp * sinI,
+    clockBias
+  };
+}
+
+// src/orbit/almanac-glo.ts
+var C20 = -108263e-8;
+var J = -1.5 * C20;
+var AE = 6378.136;
+var MU = 398600.44;
+var OMEGA_Z = 7292115e-11;
+var I_MEAN = 63 * Math.PI / 180;
+var T_MEAN = 43200;
+var GLO_1996_UTC_MS = Date.UTC(1996, 0, 1) - 108e5;
+var DAY_MS = 864e5;
+var FOUR_YEARS_DAYS = 1461;
+function glonassAlmanacEpochMs(alm) {
+  const utcMs = GLO_1996_UTC_MS + ((alm.n4 - 1) * FOUR_YEARS_DAYS + (alm.nDay - 1)) * DAY_MS + alm.tLambda * 1e3;
+  return utcMs + getGpsLeap(new Date(utcMs)) * 1e3;
+}
+function c20Deltas(lam, tau, B, h, l, n, sinI, cosI) {
+  const sin2i = sinI * sinI;
+  const cos2i = cosI * cosI;
+  const s1 = Math.sin(lam);
+  const c1 = Math.cos(lam);
+  const s2 = Math.sin(2 * lam);
+  const c2 = Math.cos(2 * lam);
+  const s3 = Math.sin(3 * lam);
+  const c3 = Math.cos(3 * lam);
+  const s4 = Math.sin(4 * lam);
+  const c4 = Math.cos(4 * lam);
+  const daOverA = 2 * B * (1 - 1.5 * sin2i) * (l * c1 + h * s1) + B * sin2i * (0.5 * h * s1 - 0.5 * l * c1 + c2 + 3.5 * l * c3 + 3.5 * h * s3);
+  const dh = B * (1 - 1.5 * sin2i) * (l * n * tau + s1 + 1.5 * l * s2 - 1.5 * h * c2) - 0.25 * B * sin2i * (s1 - 7 / 3 * s3 + 5 * l * s2 - 8.5 * l * s4 + 8.5 * h * c4 + h * c2) + B * cos2i * (l * n * tau - 0.5 * l * s2);
+  const dl = B * (1 - 1.5 * sin2i) * (-h * n * tau + c1 + 1.5 * l * c2 + 1.5 * h * s2) - 0.25 * B * sin2i * (-c1 - 7 / 3 * c3 - 5 * h * s2 - 8.5 * l * c4 - 8.5 * h * s4 + l * c2) + B * cos2i * (-h * n * tau + 0.5 * h * s2);
+  const nodeBracket = n * tau + 3.5 * l * s1 - 2.5 * h * c1 - 0.5 * s2 - 7 / 6 * l * s3 + 7 / 6 * h * c3;
+  const dOmega = -B * cosI * nodeBracket;
+  const di = 0.5 * B * sinI * cosI * (-l * c1 + h * s1 + c2 + 7 / 3 * l * c3 + 7 / 3 * h * s3);
+  const dLambda = 2 * B * (1 - 1.5 * sin2i) * (n * tau + 1.75 * l * s1 - 1.75 * h * c1) + 3 * B * sin2i * (-(7 / 24) * h * c1 - 7 / 24 * l * s1 - 49 / 72 * h * c3 + 49 / 72 * l * s3 + 0.25 * s2) + B * cos2i * nodeBracket;
+  return { daOverA, dh, dl, dOmega, di, dLambda };
+}
+function glonassAlmanacPosition(alm, timeMs) {
+  const i = I_MEAN + alm.deltaI;
+  const sinI = Math.sin(i);
+  const cosI = Math.cos(i);
+  const sin2i = sinI * sinI;
+  const e = alm.epsilon;
+  const oneMinusE2 = 1 - e * e;
+  const Tdr = T_MEAN + alm.deltaT;
+  const n = 2 * Math.PI / Tdr;
+  const cosW = Math.cos(alm.omega);
+  let a = Math.cbrt((Tdr / (2 * Math.PI)) ** 2 * MU);
+  for (let k = 0; k < 10; k++) {
+    const p = a * oneMinusE2;
+    const tOsc = Tdr / (1 + 1.5 * C20 * (AE / p) ** 2 * ((2 - 2.5 * sin2i) * (Math.pow(oneMinusE2, 1.5) / (1 + e * cosW) ** 2) + (1 + e * cosW) ** 3 / oneMinusE2));
+    const aNext = Math.cbrt((tOsc / (2 * Math.PI)) ** 2 * MU);
+    const converged = Math.abs(aNext - a) < 1e-3;
+    a = aNext;
+    if (converged) break;
+  }
+  const tStar = (timeMs - glonassAlmanacEpochMs(alm)) / 1e3;
+  const W = Math.floor(tStar / Tdr);
+  const nodeShift = Tdr * W + alm.deltaTDot * W * W;
+  const omegaDot = 1.5 * C20 * n * (AE / a) ** 2 * cosI * oneMinusE2 ** -2;
+  const lambdaK = alm.lambda + (omegaDot - OMEGA_Z) * nodeShift;
+  const tau = tStar - nodeShift;
+  const h = e * Math.sin(alm.omega);
+  const l = e * cosW;
+  const E0 = 2 * Math.atan(Math.sqrt((1 - e) / (1 + e)) * Math.tan(-alm.omega / 2));
+  const M = E0 - e * Math.sin(E0);
+  const B = J * (AE / a) ** 2;
+  const d1 = c20Deltas(M + alm.omega, 0, B, h, l, n, sinI, cosI);
+  const d2 = c20Deltas(M + alm.omega + n * tau, tau, B, h, l, n, sinI, cosI);
+  const hi = h + (d2.dh - d1.dh);
+  const li = l + (d2.dl - d1.dl);
+  const epsI = Math.hypot(hi, li);
+  const omegaI = epsI === 0 ? 0 : Math.atan2(hi, li);
+  const aI = a + a * (d2.daOverA - d1.daOverA);
+  const iI = i + (d2.di - d1.di);
+  const omegaG = lambdaK + (d2.dOmega - d1.dOmega) - OMEGA_Z * tau;
+  const lambdaStar = M + alm.omega + n * tau + (d2.dLambda - d1.dLambda);
+  const Mi = lambdaStar - omegaI;
+  let E = Mi;
+  for (let k = 0; k < 30; k++) {
+    const next = Mi + epsI * Math.sin(E);
+    const converged = Math.abs(next - E) < 1e-12;
+    E = next;
+    if (converged) break;
+  }
+  const v = 2 * Math.atan(Math.sqrt((1 + epsI) / (1 - epsI)) * Math.tan(E / 2));
+  const u = v + omegaI;
+  const rKm = aI * (1 - epsI * Math.cos(E));
+  const cosU = Math.cos(u);
+  const sinU = Math.sin(u);
+  const cosO = Math.cos(omegaG);
+  const sinO = Math.sin(omegaG);
+  const cosIi = Math.cos(iI);
+  const sinIi = Math.sin(iI);
+  return {
+    prn: alm.prn,
+    x: 1e3 * rKm * (cosU * cosO - sinU * sinO * cosIi),
+    y: 1e3 * rKm * (cosU * sinO + sinU * cosO * cosIi),
+    z: 1e3 * rKm * sinU * sinIi,
+    clockBias: -alm.tau
+  };
+}
+
+// src/orbit/index.ts
+var GM_GPS2 = 3986005e8;
+var GM_GAL2 = 3986004418e5;
+var GM_BDS2 = 3986004418e5;
 var GM_GLO = 39860044e7;
 var BDS_GEO_MAX_INCLINATION_RAD = 0.1;
 var BDS_GEO_MIN_SEMIMAJOR_AXIS_M = 4e7;
@@ -181,9 +359,9 @@ 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;
+  if (sys === "E") return GM_GAL2;
+  if (sys === "C") return GM_BDS2;
+  return GM_GPS2;
 }
 var geoVelocityPass = false;
 function keplerPosition(eph, t) {
@@ -519,10 +697,10 @@ function selectBest(ephs, timeMs) {
   }
   return best;
 }
-var GPS_EPOCH_MS = START_GPS_TIME.getTime();
+var GPS_EPOCH_MS2 = START_GPS_TIME.getTime();
 var MS_PER_WEEK = 7 * 864e5;
 var BDS_EPOCH_MS = START_BDS_TIME.getTime();
-var GAL_EPOCH_MS = GPS_EPOCH_MS + 1024 * MS_PER_WEEK;
+var GAL_EPOCH_MS = GPS_EPOCH_MS2 + 1024 * MS_PER_WEEK;
 function ephInfoToEphemeris(info) {
   const sys = info.prn.charAt(0);
   if (sys === "R") {
@@ -573,8 +751,8 @@ function ephInfoToEphemeris(info) {
   } else if (sys === "E") {
     epochMs = GAL_EPOCH_MS;
   } else {
-    epochMs = GPS_EPOCH_MS;
-    const weeksNow = (info.lastReceived - GPS_EPOCH_MS) / MS_PER_WEEK;
+    epochMs = GPS_EPOCH_MS2;
+    const weeksNow = (info.lastReceived - GPS_EPOCH_MS2) / MS_PER_WEEK;
     week += 1024 * Math.round((weeksNow - week) / 1024);
   }
   const tocDate = new Date(epochMs + week * MS_PER_WEEK + tocSec * 1e3);
@@ -755,6 +933,8 @@ function computeVisibilityFromPositions(all, elevationMaskDeg = 10) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  almanacEpochMs,
+  almanacSatPosition,
   computeAllPositions,
   computeDop,
   computeLiveSkyPositions,
@@ -766,6 +946,8 @@ function computeVisibilityFromPositions(all, elevationMaskDeg = 10) {
   ecefToGeodetic,
   ephInfoToEphemeris,
   geodeticToEcef,
+  glonassAlmanacEpochMs,
+  glonassAlmanacPosition,
   glonassPosition,
   keplerPosition,
   maskRadForAzimuth,