gnss-js 2.5.0 → 2.7.0

package/dist/{chunk-B2XWO4RP.js → chunk-BWLLHLLS.js}

@@ -22,6 +22,7 @@ import {
 } from "./chunk-V2D5KUKH.js";
 import {
   C_LIGHT,
+  FREQ,
   OMEGA_E
 } from "./chunk-FIEWO4J4.js";
 
@@ -1463,6 +1464,162 @@ function postProcessRtk(base, rover, ephemerides, baseEcef, opts = {}) {
   return { track, solved, unmatched, fixRate: solved ? fixed / solved : 0 };
 }
 
+// src/positioning/zero-baseline.ts
+function carrierFreqHz2(sys, band, gloChannel) {
+  if (sys === "R") {
+    if (band === "1") return 1602e6 + (gloChannel ?? 0) * 562500;
+    if (band === "2") return 1246e6 + (gloChannel ?? 0) * 437500;
+    return FREQ.R?.[band] ?? 0;
+  }
+  return FREQ[sys]?.[band] ?? 0;
+}
+function median(a) {
+  if (a.length === 0) return 0;
+  const s = [...a].sort((x, y) => x - y);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+var ZeroBaselineEngine = class {
+  ref;
+  refSys;
+  slip;
+  /** Per (receiver|prn|code) continuous phase-SD arc. */
+  arcs = /* @__PURE__ */ new Map();
+  /** Per receiver: integrated phase-smoothed clock (m). */
+  phaseClock = /* @__PURE__ */ new Map();
+  /** Per (receiver|system): accumulated ISB (m) + count. */
+  isb = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.ref = opts.reference;
+    this.refSys = opts.referenceSystem ?? "G";
+    this.slip = opts.slipThreshM ?? 0.05;
+  }
+  reset() {
+    this.arcs.clear();
+    this.phaseClock.clear();
+    this.isb.clear();
+  }
+  /** ISB/IFB estimates accumulated so far, per receiver × system. */
+  biases() {
+    const out = [];
+    for (const [key, { sum, n }] of this.isb) {
+      const [receiver, system] = key.split("|");
+      out.push({ receiver, system, biasM: sum / n, n });
+    }
+    return out;
+  }
+  /**
+   * Ingest one time-aligned instant: observations per receiver id. Returns one
+   * {@link ReceiverClockSample} per non-reference receiver present this epoch.
+   */
+  process(epoch) {
+    const refObs = epoch.obs[this.ref];
+    if (!refObs) return [];
+    const refByKey = /* @__PURE__ */ new Map();
+    for (const o of refObs)
+      if (o.pr != null && Number.isFinite(o.pr))
+        refByKey.set(`${o.prn}|${o.code}`, o);
+    const out = [];
+    for (const rx of Object.keys(epoch.obs)) {
+      if (rx === this.ref) continue;
+      out.push(
+        this.processReceiver(rx, epoch.obs[rx], refByKey, epoch.timeMs)
+      );
+    }
+    return out;
+  }
+  processReceiver(rx, obs, refByKey, t) {
+    const codeBySys = /* @__PURE__ */ new Map();
+    const phase = [];
+    for (const o of obs) {
+      if (o.pr == null || !Number.isFinite(o.pr)) continue;
+      const r = refByKey.get(`${o.prn}|${o.code}`);
+      if (!r || r.pr == null) continue;
+      const sys = o.prn[0];
+      (codeBySys.get(sys) ?? codeBySys.set(sys, []).get(sys)).push(
+        o.pr - r.pr
+      );
+      if (o.cp != null && r.cp != null) {
+        const f = carrierFreqHz2(
+          sys,
+          o.code[0],
+          o.gloChannel ?? r.gloChannel ?? null
+        );
+        if (f > 0)
+          phase.push({
+            key: `${rx}|${o.prn}|${o.code}`,
+            sdM: (o.cp - r.cp) * (C_LIGHT / f),
+            lock: o.lockTimeS
+          });
+      }
+    }
+    if (codeBySys.size === 0)
+      return {
+        t,
+        receiver: rx,
+        clockOffsetM: null,
+        clockOffsetPhaseM: this.phaseClock.get(rx) ?? null,
+        used: 0,
+        rejected: 0,
+        residualRmsM: 0
+      };
+    const sysMedian = /* @__PURE__ */ new Map();
+    for (const [sys, v] of codeBySys) sysMedian.set(sys, median(v));
+    const allSd = [];
+    for (const v of codeBySys.values()) allSd.push(...v);
+    const clk = sysMedian.get(this.refSys) ?? median(allSd);
+    for (const [sys, med] of sysMedian) {
+      if (sys === this.refSys) continue;
+      const cur = this.isb.get(`${rx}|${sys}`) ?? { sum: 0, n: 0 };
+      cur.sum += med - clk;
+      cur.n += 1;
+      this.isb.set(`${rx}|${sys}`, cur);
+    }
+    let ss = 0, used = 0, rejected = 0;
+    for (const [sys, v] of codeBySys) {
+      const isb = sys === this.refSys ? 0 : sysMedian.get(sys) - clk;
+      for (const sd of v) {
+        const res = sd - clk - isb;
+        if (Math.abs(res) > 5) {
+          rejected++;
+          continue;
+        }
+        ss += res * res;
+        used++;
+      }
+    }
+    const residualRmsM = used ? Math.sqrt(ss / used) : 0;
+    const deltas = [];
+    for (const p of phase) {
+      const arc = this.arcs.get(p.key);
+      this.arcs.set(p.key, { lastPhaseSdM: p.sdM, lastLock: p.lock });
+      if (!arc) continue;
+      const lockReset = p.lock != null && arc.lastLock != null && p.lock < arc.lastLock;
+      if (lockReset) continue;
+      deltas.push(p.sdM - arc.lastPhaseSdM);
+    }
+    let phaseClockM = this.phaseClock.get(rx) ?? null;
+    if (phaseClockM == null) {
+      phaseClockM = clk;
+    } else if (deltas.length) {
+      const md = median(deltas);
+      const good = deltas.filter((d) => Math.abs(d - md) < this.slip);
+      const step = good.length ? good.reduce((a, b) => a + b, 0) / good.length : md;
+      phaseClockM += step;
+    }
+    this.phaseClock.set(rx, phaseClockM);
+    return {
+      t,
+      receiver: rx,
+      clockOffsetM: clk,
+      clockOffsetPhaseM: phaseClockM,
+      used,
+      rejected,
+      residualRmsM
+    };
+  }
+};
+
 // src/positioning/sbas.ts
 var P2_11 = 2 ** -11;
 var P2_31 = 2 ** -31;
@@ -3874,6 +4031,7 @@ export {
   solveDgnss,
   RtkFloatEngine,
   postProcessRtk,
+  ZeroBaselineEngine,
   sbasLongTermDeg,
   sbasIonoDeg,
   SbasProcessor,

package/dist/{chunk-MIIM4LDY.js → chunk-CVCTRIWU.js}

@@ -47,7 +47,12 @@ function vincenty(lat1, lon1, lat2, lon2) {
       (cosU2 * sinLambda2) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda2) ** 2
     );
     if (sinSigma === 0) {
-      return { distance: 0, initialBearing: 0, finalBearing: 0 };
+      return {
+        distance: 0,
+        initialBearing: 0,
+        finalBearing: 0,
+        converged: true
+      };
     }
     cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda2;
     sigma = Math.atan2(sinSigma, cosSigma);
@@ -77,7 +82,7 @@ function vincenty(lat1, lon1, lat2, lon2) {
       cosLat1 * Math.sin(-dLon),
       -sinLat1 * cosLat2 + cosLat1 * sinLat2 * Math.cos(-dLon)
     );
-    return { distance: distance2, initialBearing: ib, finalBearing: fb };
+    return { distance: distance2, initialBearing: ib, finalBearing: fb, converged: false };
   }
   const uSq = cos2Alpha * (WGS84_SEMI_MAJOR_AXIS ** 2 - WGS84_SEMI_MINOR_AXIS ** 2) / WGS84_SEMI_MINOR_AXIS ** 2;
   const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
@@ -94,10 +99,53 @@ function vincenty(lat1, lon1, lat2, lon2) {
     cosU1 * sinLambda,
     -sinU1 * cosU2 + cosU1 * sinU2 * cosLambda
   );
-  return { distance, initialBearing, finalBearing };
+  return { distance, initialBearing, finalBearing, converged: true };
+}
+function vincentyDirect(lat1, lon1, bearing, distance) {
+  const a = WGS84_SEMI_MAJOR_AXIS, b = WGS84_SEMI_MINOR_AXIS, f = WGS84_FLATTENING;
+  const sinA1 = Math.sin(bearing), cosA1 = Math.cos(bearing);
+  const tanU1 = (1 - f) * Math.tan(lat1);
+  const cosU1 = 1 / Math.sqrt(1 + tanU1 ** 2), sinU1 = tanU1 * cosU1;
+  const sigma1 = Math.atan2(tanU1, cosA1);
+  const sinAlpha = cosU1 * sinA1;
+  const cos2Alpha = 1 - sinAlpha ** 2;
+  const uSq = cos2Alpha * (a ** 2 - b ** 2) / b ** 2;
+  const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+  let sigma = distance / (b * A);
+  let sigmaPrev;
+  let cos2SigmaM, sinSigma, cosSigma;
+  let iter = 0;
+  do {
+    cos2SigmaM = Math.cos(2 * sigma1 + sigma);
+    sinSigma = Math.sin(sigma);
+    cosSigma = Math.cos(sigma);
+    const deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM ** 2) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma ** 2) * (-3 + 4 * cos2SigmaM ** 2)));
+    sigmaPrev = sigma;
+    sigma = distance / (b * A) + deltaSigma;
+  } while (Math.abs(sigma - sigmaPrev) > 1e-12 && ++iter < 200);
+  const tmp = sinU1 * sinSigma - cosU1 * cosSigma * cosA1;
+  const lat2 = Math.atan2(
+    sinU1 * cosSigma + cosU1 * sinSigma * cosA1,
+    (1 - f) * Math.sqrt(sinAlpha ** 2 + tmp ** 2)
+  );
+  const lambda = Math.atan2(
+    sinSigma * sinA1,
+    cosU1 * cosSigma - sinU1 * sinSigma * cosA1
+  );
+  const C = f / 16 * cos2Alpha * (4 + f * (4 - 3 * cos2Alpha));
+  const L = lambda - (1 - C) * f * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM ** 2)));
+  let lon2 = lon1 + L;
+  lon2 = Math.atan2(Math.sin(lon2), Math.cos(lon2));
+  return [lat2, lon2];
+}
+function meridianArc(lat) {
+  const n = WGS84_FLATTENING / (2 - WGS84_FLATTENING);
+  const n2 = n * n, n3 = n2 * n, n4 = n3 * n;
+  const mu = lat + (-3 * n / 2 + 9 * n3 / 16) * Math.sin(2 * lat) + (15 * n2 / 16 - 15 * n4 / 32) * Math.sin(4 * lat) + -35 * n3 / 48 * Math.sin(6 * lat) + 315 * n4 / 512 * Math.sin(8 * lat);
+  return WGS84_SEMI_MAJOR_AXIS / (1 + n) * (1 + n2 / 4 + n4 / 64) * mu;
 }
 function rhumbLine(lat1, lon1, lat2, lon2) {
-  const dLat = lat2 - lat1;
   let dLon = lon2 - lon1;
   const MAX_LAT = Math.PI / 2 - 1e-10;
   const isometricLat = (lat) => {
@@ -111,33 +159,28 @@ function rhumbLine(lat1, lon1, lat2, lon2) {
   const psi1 = isometricLat(lat1);
   const psi2 = isometricLat(lat2);
   const dPsi = psi2 - psi1;
-  const q = Math.abs(dPsi) > 1e-12 ? dLat / dPsi : Math.cos(lat1);
   if (Math.abs(dLon) > Math.PI) {
     dLon = dLon > 0 ? -(2 * Math.PI - dLon) : 2 * Math.PI + dLon;
   }
   const bearing = Math.atan2(dLon, dPsi);
-  const e22 = WGS84_ECCENTRICITY_SQUARED;
-  const e4 = e22 * e22;
-  const e6 = e4 * e22;
-  const meridionalRadius = WGS84_SEMI_MAJOR_AXIS * (1 - e22) * (1 + 3 / 4 * e22 + 45 / 64 * e4 + 175 / 256 * e6);
-  const distance = Math.sqrt(dLat ** 2 + q ** 2 * dLon ** 2) * meridionalRadius;
+  const dM = meridianArc(lat2) - meridianArc(lat1);
+  let q;
+  if (Math.abs(dPsi) > 1e-6) {
+    q = dM / dPsi;
+  } else {
+    const latM = (lat1 + lat2) / 2;
+    q = WGS84_SEMI_MAJOR_AXIS * Math.cos(latM) / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * Math.sin(latM) ** 2);
+  }
+  const distance = Math.sqrt(dM ** 2 + (q * dLon) ** 2);
   return { distance, bearing };
 }
 function euclidean3D(x1, y1, z1, x2, y2, z2) {
   return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2 + (z2 - z1) ** 2);
 }
 function greatCircleMidpoint(lat1, lon1, lat2, lon2) {
-  const dLon = lon2 - lon1;
-  const Bx = Math.cos(lat2) * Math.cos(dLon);
-  const By = Math.cos(lat2) * Math.sin(dLon);
-  const sumX = Math.cos(lat1) + Bx;
-  const denom = Math.sqrt(sumX ** 2 + By ** 2);
-  if (denom < 1e-15) {
-    return [(lat1 + lat2) / 2, lon1];
-  }
-  const latMid = Math.atan2(Math.sin(lat1) + Math.sin(lat2), denom);
-  const lonMid = lon1 + Math.atan2(By, sumX);
-  return [latMid, lonMid];
+  const { distance, initialBearing } = vincenty(lat1, lon1, lat2, lon2);
+  if (distance === 0) return [lat1, lon1];
+  return vincentyDirect(lat1, lon1, initialBearing, distance / 2);
 }
 function horizonDistance(heightMeters) {
   if (heightMeters <= 0) return 0;
@@ -150,18 +193,36 @@ function horizonDistance(heightMeters) {
 // src/coordinates/projections.ts
 var e2 = WGS84_ECCENTRICITY_SQUARED;
 var k0 = 0.9996;
+var UTM_BANDS = "CDEFGHJKLMNPQRSTUVWX";
+function utmZone(latDeg, lonDeg) {
+  let zone = Math.floor((lonDeg + 180) / 6) + 1;
+  if (zone > 60) zone = 1;
+  if (latDeg >= 56 && latDeg < 64 && lonDeg >= 3 && lonDeg < 12) return 32;
+  if (latDeg >= 72 && latDeg <= 84) {
+    if (lonDeg >= 0 && lonDeg < 9) return 31;
+    if (lonDeg >= 9 && lonDeg < 21) return 33;
+    if (lonDeg >= 21 && lonDeg < 33) return 35;
+    if (lonDeg >= 33 && lonDeg < 42) return 37;
+  }
+  return zone;
+}
 function geodeticToUtm(lat, lon) {
+  const rawLatDeg = lat * 180 / Math.PI;
+  const inRange = rawLatDeg >= -80 && rawLatDeg <= 84;
   const MAX_UTM_LAT = 84 * (Math.PI / 180);
   lat = Math.max(-MAX_UTM_LAT, Math.min(MAX_UTM_LAT, lat));
   const latDeg = lat * 180 / Math.PI;
+  lon = Math.atan2(Math.sin(lon), Math.cos(lon));
   const lonDeg = lon * 180 / Math.PI;
-  const zone = Math.floor((lonDeg + 180) / 6) + 1;
+  const zone = utmZone(latDeg, lonDeg);
+  const band = UTM_BANDS[Math.max(0, Math.min(19, Math.floor((latDeg + 80) / 8)))];
   const lon0 = ((zone - 1) * 6 - 180 + 3) * (Math.PI / 180);
   const ep2 = e2 / (1 - e2);
   const N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - e2 * Math.sin(lat) ** 2);
   const T = Math.tan(lat) ** 2;
   const C = ep2 * Math.cos(lat) ** 2;
-  const A = Math.cos(lat) * (lon - lon0);
+  const dLon0 = Math.atan2(Math.sin(lon - lon0), Math.cos(lon - lon0));
+  const A = Math.cos(lat) * dLon0;
   const M = WGS84_SEMI_MAJOR_AXIS * ((1 - e2 / 4 - 3 * e2 ** 2 / 64 - 5 * e2 ** 3 / 256) * lat - (3 * e2 / 8 + 3 * e2 ** 2 / 32 + 45 * e2 ** 3 / 1024) * Math.sin(2 * lat) + (15 * e2 ** 2 / 256 + 45 * e2 ** 3 / 1024) * Math.sin(4 * lat) - 35 * e2 ** 3 / 3072 * Math.sin(6 * lat));
   const easting = k0 * N * (A + (1 - T + C) * A ** 3 / 6 + (5 - 18 * T + T ** 2 + 72 * C - 58 * ep2) * A ** 5 / 120) + 5e5;
   let northing = k0 * (M + N * Math.tan(lat) * (A ** 2 / 2 + (5 - T + 9 * C + 4 * C ** 2) * A ** 4 / 24 + (61 - 58 * T + T ** 2 + 600 * C - 330 * ep2) * A ** 6 / 720));
@@ -169,7 +230,7 @@ function geodeticToUtm(lat, lon) {
   if (hemisphere === "S") {
     northing += 1e7;
   }
-  return { easting, northing, zone, hemisphere };
+  return { easting, northing, zone, hemisphere, band, inRange };
 }
 function geodeticToMaidenhead(lat, lon) {
   const latDeg = Math.max(0, Math.min(179.999999, lat * 180 / Math.PI + 90));
@@ -229,6 +290,8 @@ export {
   deg2rad,
   deg2dms,
   vincenty,
+  vincentyDirect,
+  meridianArc,
   rhumbLine,
   euclidean3D,
   greatCircleMidpoint,

package/dist/coordinates.cjs

@@ -33,9 +33,11 @@ __export(coordinates_exports, {
   getEnuDifference: () => getEnuDifference,
   greatCircleMidpoint: () => greatCircleMidpoint,
   horizonDistance: () => horizonDistance,
+  meridianArc: () => meridianArc,
   rad2deg: () => rad2deg,
   rhumbLine: () => rhumbLine,
-  vincenty: () => vincenty
+  vincenty: () => vincenty,
+  vincentyDirect: () => vincentyDirect
 });
 module.exports = __toCommonJS(coordinates_exports);
 
@@ -140,7 +142,12 @@ function vincenty(lat1, lon1, lat2, lon2) {
       (cosU2 * sinLambda2) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda2) ** 2
     );
     if (sinSigma === 0) {
-      return { distance: 0, initialBearing: 0, finalBearing: 0 };
+      return {
+        distance: 0,
+        initialBearing: 0,
+        finalBearing: 0,
+        converged: true
+      };
     }
     cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda2;
     sigma = Math.atan2(sinSigma, cosSigma);
@@ -170,7 +177,7 @@ function vincenty(lat1, lon1, lat2, lon2) {
       cosLat1 * Math.sin(-dLon),
       -sinLat1 * cosLat2 + cosLat1 * sinLat2 * Math.cos(-dLon)
     );
-    return { distance: distance2, initialBearing: ib, finalBearing: fb };
+    return { distance: distance2, initialBearing: ib, finalBearing: fb, converged: false };
   }
   const uSq = cos2Alpha * (WGS84_SEMI_MAJOR_AXIS ** 2 - WGS84_SEMI_MINOR_AXIS ** 2) / WGS84_SEMI_MINOR_AXIS ** 2;
   const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
@@ -187,10 +194,53 @@ function vincenty(lat1, lon1, lat2, lon2) {
     cosU1 * sinLambda,
     -sinU1 * cosU2 + cosU1 * sinU2 * cosLambda
   );
-  return { distance, initialBearing, finalBearing };
+  return { distance, initialBearing, finalBearing, converged: true };
+}
+function vincentyDirect(lat1, lon1, bearing, distance) {
+  const a = WGS84_SEMI_MAJOR_AXIS, b = WGS84_SEMI_MINOR_AXIS, f = WGS84_FLATTENING;
+  const sinA1 = Math.sin(bearing), cosA1 = Math.cos(bearing);
+  const tanU1 = (1 - f) * Math.tan(lat1);
+  const cosU1 = 1 / Math.sqrt(1 + tanU1 ** 2), sinU1 = tanU1 * cosU1;
+  const sigma1 = Math.atan2(tanU1, cosA1);
+  const sinAlpha = cosU1 * sinA1;
+  const cos2Alpha = 1 - sinAlpha ** 2;
+  const uSq = cos2Alpha * (a ** 2 - b ** 2) / b ** 2;
+  const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+  let sigma = distance / (b * A);
+  let sigmaPrev;
+  let cos2SigmaM, sinSigma, cosSigma;
+  let iter = 0;
+  do {
+    cos2SigmaM = Math.cos(2 * sigma1 + sigma);
+    sinSigma = Math.sin(sigma);
+    cosSigma = Math.cos(sigma);
+    const deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM ** 2) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma ** 2) * (-3 + 4 * cos2SigmaM ** 2)));
+    sigmaPrev = sigma;
+    sigma = distance / (b * A) + deltaSigma;
+  } while (Math.abs(sigma - sigmaPrev) > 1e-12 && ++iter < 200);
+  const tmp = sinU1 * sinSigma - cosU1 * cosSigma * cosA1;
+  const lat2 = Math.atan2(
+    sinU1 * cosSigma + cosU1 * sinSigma * cosA1,
+    (1 - f) * Math.sqrt(sinAlpha ** 2 + tmp ** 2)
+  );
+  const lambda = Math.atan2(
+    sinSigma * sinA1,
+    cosU1 * cosSigma - sinU1 * sinSigma * cosA1
+  );
+  const C = f / 16 * cos2Alpha * (4 + f * (4 - 3 * cos2Alpha));
+  const L = lambda - (1 - C) * f * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM ** 2)));
+  let lon2 = lon1 + L;
+  lon2 = Math.atan2(Math.sin(lon2), Math.cos(lon2));
+  return [lat2, lon2];
+}
+function meridianArc(lat) {
+  const n = WGS84_FLATTENING / (2 - WGS84_FLATTENING);
+  const n2 = n * n, n3 = n2 * n, n4 = n3 * n;
+  const mu = lat + (-3 * n / 2 + 9 * n3 / 16) * Math.sin(2 * lat) + (15 * n2 / 16 - 15 * n4 / 32) * Math.sin(4 * lat) + -35 * n3 / 48 * Math.sin(6 * lat) + 315 * n4 / 512 * Math.sin(8 * lat);
+  return WGS84_SEMI_MAJOR_AXIS / (1 + n) * (1 + n2 / 4 + n4 / 64) * mu;
 }
 function rhumbLine(lat1, lon1, lat2, lon2) {
-  const dLat = lat2 - lat1;
   let dLon = lon2 - lon1;
   const MAX_LAT = Math.PI / 2 - 1e-10;
   const isometricLat = (lat) => {
@@ -204,33 +254,28 @@ function rhumbLine(lat1, lon1, lat2, lon2) {
   const psi1 = isometricLat(lat1);
   const psi2 = isometricLat(lat2);
   const dPsi = psi2 - psi1;
-  const q = Math.abs(dPsi) > 1e-12 ? dLat / dPsi : Math.cos(lat1);
   if (Math.abs(dLon) > Math.PI) {
     dLon = dLon > 0 ? -(2 * Math.PI - dLon) : 2 * Math.PI + dLon;
   }
   const bearing = Math.atan2(dLon, dPsi);
-  const e22 = WGS84_ECCENTRICITY_SQUARED;
-  const e4 = e22 * e22;
-  const e6 = e4 * e22;
-  const meridionalRadius = WGS84_SEMI_MAJOR_AXIS * (1 - e22) * (1 + 3 / 4 * e22 + 45 / 64 * e4 + 175 / 256 * e6);
-  const distance = Math.sqrt(dLat ** 2 + q ** 2 * dLon ** 2) * meridionalRadius;
+  const dM = meridianArc(lat2) - meridianArc(lat1);
+  let q;
+  if (Math.abs(dPsi) > 1e-6) {
+    q = dM / dPsi;
+  } else {
+    const latM = (lat1 + lat2) / 2;
+    q = WGS84_SEMI_MAJOR_AXIS * Math.cos(latM) / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * Math.sin(latM) ** 2);
+  }
+  const distance = Math.sqrt(dM ** 2 + (q * dLon) ** 2);
   return { distance, bearing };
 }
 function euclidean3D(x1, y1, z1, x2, y2, z2) {
   return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2 + (z2 - z1) ** 2);
 }
 function greatCircleMidpoint(lat1, lon1, lat2, lon2) {
-  const dLon = lon2 - lon1;
-  const Bx = Math.cos(lat2) * Math.cos(dLon);
-  const By = Math.cos(lat2) * Math.sin(dLon);
-  const sumX = Math.cos(lat1) + Bx;
-  const denom = Math.sqrt(sumX ** 2 + By ** 2);
-  if (denom < 1e-15) {
-    return [(lat1 + lat2) / 2, lon1];
-  }
-  const latMid = Math.atan2(Math.sin(lat1) + Math.sin(lat2), denom);
-  const lonMid = lon1 + Math.atan2(By, sumX);
-  return [latMid, lonMid];
+  const { distance, initialBearing } = vincenty(lat1, lon1, lat2, lon2);
+  if (distance === 0) return [lat1, lon1];
+  return vincentyDirect(lat1, lon1, initialBearing, distance / 2);
 }
 function horizonDistance(heightMeters) {
   if (heightMeters <= 0) return 0;
@@ -243,18 +288,36 @@ function horizonDistance(heightMeters) {
 // src/coordinates/projections.ts
 var e2 = WGS84_ECCENTRICITY_SQUARED;
 var k0 = 0.9996;
+var UTM_BANDS = "CDEFGHJKLMNPQRSTUVWX";
+function utmZone(latDeg, lonDeg) {
+  let zone = Math.floor((lonDeg + 180) / 6) + 1;
+  if (zone > 60) zone = 1;
+  if (latDeg >= 56 && latDeg < 64 && lonDeg >= 3 && lonDeg < 12) return 32;
+  if (latDeg >= 72 && latDeg <= 84) {
+    if (lonDeg >= 0 && lonDeg < 9) return 31;
+    if (lonDeg >= 9 && lonDeg < 21) return 33;
+    if (lonDeg >= 21 && lonDeg < 33) return 35;
+    if (lonDeg >= 33 && lonDeg < 42) return 37;
+  }
+  return zone;
+}
 function geodeticToUtm(lat, lon) {
+  const rawLatDeg = lat * 180 / Math.PI;
+  const inRange = rawLatDeg >= -80 && rawLatDeg <= 84;
   const MAX_UTM_LAT = 84 * (Math.PI / 180);
   lat = Math.max(-MAX_UTM_LAT, Math.min(MAX_UTM_LAT, lat));
   const latDeg = lat * 180 / Math.PI;
+  lon = Math.atan2(Math.sin(lon), Math.cos(lon));
   const lonDeg = lon * 180 / Math.PI;
-  const zone = Math.floor((lonDeg + 180) / 6) + 1;
+  const zone = utmZone(latDeg, lonDeg);
+  const band = UTM_BANDS[Math.max(0, Math.min(19, Math.floor((latDeg + 80) / 8)))];
   const lon0 = ((zone - 1) * 6 - 180 + 3) * (Math.PI / 180);
   const ep2 = e2 / (1 - e2);
   const N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - e2 * Math.sin(lat) ** 2);
   const T = Math.tan(lat) ** 2;
   const C = ep2 * Math.cos(lat) ** 2;
-  const A = Math.cos(lat) * (lon - lon0);
+  const dLon0 = Math.atan2(Math.sin(lon - lon0), Math.cos(lon - lon0));
+  const A = Math.cos(lat) * dLon0;
   const M = WGS84_SEMI_MAJOR_AXIS * ((1 - e2 / 4 - 3 * e2 ** 2 / 64 - 5 * e2 ** 3 / 256) * lat - (3 * e2 / 8 + 3 * e2 ** 2 / 32 + 45 * e2 ** 3 / 1024) * Math.sin(2 * lat) + (15 * e2 ** 2 / 256 + 45 * e2 ** 3 / 1024) * Math.sin(4 * lat) - 35 * e2 ** 3 / 3072 * Math.sin(6 * lat));
   const easting = k0 * N * (A + (1 - T + C) * A ** 3 / 6 + (5 - 18 * T + T ** 2 + 72 * C - 58 * ep2) * A ** 5 / 120) + 5e5;
   let northing = k0 * (M + N * Math.tan(lat) * (A ** 2 / 2 + (5 - T + 9 * C + 4 * C ** 2) * A ** 4 / 24 + (61 - 58 * T + T ** 2 + 600 * C - 330 * ep2) * A ** 6 / 720));
@@ -262,7 +325,7 @@ function geodeticToUtm(lat, lon) {
   if (hemisphere === "S") {
     northing += 1e7;
   }
-  return { easting, northing, zone, hemisphere };
+  return { easting, northing, zone, hemisphere, band, inRange };
 }
 function geodeticToMaidenhead(lat, lon) {
   const latDeg = Math.max(0, Math.min(179.999999, lat * 180 / Math.PI + 90));
@@ -331,7 +394,9 @@ function geodeticToGeohash(lat, lon, precision = 8) {
   getEnuDifference,
   greatCircleMidpoint,
   horizonDistance,
+  meridianArc,
   rad2deg,
   rhumbLine,
-  vincenty
+  vincenty,
+  vincentyDirect
 });

package/dist/coordinates.d.cts

@@ -14,13 +14,29 @@ declare function deg2dms(deg: number): [number, number, number];
  * Vincenty's inverse formula — orthodromic (great-circle) distance,
  * initial bearing, and final bearing on the WGS84 ellipsoid.
  * All angles in radians.
- * @returns { distance (m), initialBearing (rad), finalBearing (rad) }
+ * @returns { distance (m), initialBearing (rad), finalBearing (rad),
+ *   converged } — `converged` is false for near-antipodal pairs, where the
+ *   iteration fails and a spherical approximation is returned instead
+ *   (distance good to ~0.5 %, bearings unreliable).
  */
 declare function vincenty(lat1: number, lon1: number, lat2: number, lon2: number): {
     distance: number;
     initialBearing: number;
     finalBearing: number;
+    converged: boolean;
 };
+/**
+ * Vincenty's direct formula — the point reached from (lat1, lon1) after
+ * `distance` metres along the geodesic leaving at `bearing` (radians,
+ * clockwise from north) on the WGS84 ellipsoid.
+ * @returns [lat, lon] in radians, lon wrapped to (-π, π]
+ */
+declare function vincentyDirect(lat1: number, lon1: number, bearing: number, distance: number): [number, number];
+/**
+ * Meridian arc length from the equator to geodetic latitude `lat` (radians)
+ * on WGS84, via the rectifying latitude (Helmert series in n, sub-mm).
+ */
+declare function meridianArc(lat: number): number;
 /**
  * Loxodromic (rhumb line) distance and constant bearing on the WGS84 ellipsoid.
  * Uses the ellipsoidal rhumb-line formula with isometric latitudes.
@@ -41,7 +57,8 @@ declare function rhumbLine(lat1: number, lon1: number, lat2: number, lon2: numbe
  */
 declare function euclidean3D(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
 /**
- * Geodetic midpoint along the great-circle arc.
+ * Midpoint of the geodesic (shortest path on the WGS84 ellipsoid) between
+ * two points: half the Vincenty distance along the initial bearing.
  * @returns [lat, lon] in radians
  */
 declare function greatCircleMidpoint(lat1: number, lon1: number, lat2: number, lon2: number): [number, number];
@@ -57,12 +74,18 @@ declare function horizonDistance(heightMeters: number): number;
  * Convert geodetic coordinates to UTM.
  * @param lat Latitude in radians
  * @param lon Longitude in radians
+ * @returns easting/northing (m), zone (1–60, with the Norway/Svalbard
+ *   exceptions), hemisphere, MGRS latitude `band` letter (C–X), and
+ *   `inRange` — false outside UTM's 80°S–84°N, where the values are
+ *   computed at the clamped latitude and are not a valid UTM position.
  */
 declare function geodeticToUtm(lat: number, lon: number): {
     easting: number;
     northing: number;
     zone: number;
     hemisphere: 'N' | 'S';
+    band: string;
+    inRange: boolean;
 };
 /**
  * Maidenhead grid locator (6 characters) from geodetic coordinates.
@@ -78,4 +101,4 @@ declare function geodeticToMaidenhead(lat: number, lon: number): string;
  */
 declare function geodeticToGeohash(lat: number, lon: number, precision?: number): string;
 
-export { deg2dms, deg2rad, euclidean3D, geodeticToGeohash, geodeticToMaidenhead, geodeticToUtm, greatCircleMidpoint, horizonDistance, rad2deg, rhumbLine, vincenty };
+export { deg2dms, deg2rad, euclidean3D, geodeticToGeohash, geodeticToMaidenhead, geodeticToUtm, greatCircleMidpoint, horizonDistance, meridianArc, rad2deg, rhumbLine, vincenty, vincentyDirect };