gnss-js 1.0.1 → 1.2.0

package/dist/positioning.cjs

@@ -0,0 +1,565 @@
+"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/positioning/index.ts
+var positioning_exports = {};
+__export(positioning_exports, {
+  ionoFree: () => ionoFree,
+  satClockCorrection: () => satClockCorrection,
+  solveSpp: () => solveSpp
+});
+module.exports = __toCommonJS(positioning_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 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/constants/time.ts
+var MILLISECONDS_IN_SECOND = 1e3;
+var MILLISECONDS_GPS_TAI = 19e3;
+var START_GPS_TIME = /* @__PURE__ */ new Date("1980-01-06T00:00:00Z");
+var START_BDS_TIME = /* @__PURE__ */ new Date("2006-01-01T00:00:14Z");
+var START_NTP_TIME = /* @__PURE__ */ new Date("1900-01-01T00:00:00Z");
+
+// src/time/gnss.ts
+function getTaiDate(date) {
+  return new Date(date.getTime() + MILLISECONDS_GPS_TAI);
+}
+function getNtpTime(date) {
+  return getTaiDate(date).getTime() - START_NTP_TIME.getTime();
+}
+
+// src/time/utc.ts
+var LEAP_SECONDS_TABLE = [
+  [3692217600, 37],
+  // 1 Jan 2017
+  [3644697600, 36],
+  // 1 Jul 2015
+  [3550089600, 35],
+  // 1 Jul 2012
+  [3439756800, 34],
+  // 1 Jan 2009
+  [3345062400, 33],
+  // 1 Jan 2006
+  [3124137600, 32],
+  // 1 Jan 1999
+  [3076704e3, 31],
+  // 1 Jul 1997
+  [3029443200, 30],
+  // 1 Jan 1996
+  [2982009600, 29],
+  // 1 Jul 1994
+  [2950473600, 28],
+  // 1 Jul 1993
+  [2918937600, 27],
+  // 1 Jul 1992
+  [2871676800, 26],
+  // 1 Jan 1991
+  [2840140800, 25],
+  // 1 Jan 1990
+  [2776982400, 24],
+  // 1 Jan 1988
+  [2698012800, 23],
+  // 1 Jul 1985
+  [2634854400, 22],
+  // 1 Jul 1983
+  [2603318400, 21],
+  // 1 Jul 1982
+  [2571782400, 20],
+  // 1 Jul 1981
+  [2524521600, 19],
+  // 1 Jan 1980
+  [2492985600, 18],
+  // 1 Jan 1979
+  [2461449600, 17],
+  // 1 Jan 1978
+  [2429913600, 16],
+  // 1 Jan 1977
+  [2398291200, 15],
+  // 1 Jan 1976
+  [2366755200, 14],
+  // 1 Jan 1975
+  [2335219200, 13],
+  // 1 Jan 1974
+  [2303683200, 12],
+  // 1 Jan 1973
+  [2287785600, 11],
+  // 1 Jul 1972
+  [2272060800, 10]
+  // 1 Jan 1972
+];
+function getLeap(date) {
+  const ntp_time = getNtpTime(date);
+  for (const [timestamp, leapSeconds] of LEAP_SECONDS_TABLE) {
+    if (ntp_time / MILLISECONDS_IN_SECOND - leapSeconds >= timestamp) {
+      return leapSeconds;
+    }
+  }
+  return 8;
+}
+function getGpsLeap(date) {
+  const leap_seconds = getLeap(date);
+  if (leap_seconds < 0) return 0;
+  return leap_seconds - 19;
+}
+
+// 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 BDS_GEO_MAX_INCLINATION_RAD = 0.1;
+var BDS_GEO_MIN_SEMIMAJOR_AXIS_M = 4e7;
+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) < BDS_GEO_MAX_INCLINATION_RAD && a > BDS_GEO_MIN_SEMIMAJOR_AXIS_M;
+  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 computeSatPosition(eph, timeMs) {
+  if (eph.system === "R" || eph.system === "S") {
+    const leapMs = getGpsLeap(new Date(timeMs)) * 1e3;
+    return glonassPosition(eph, (timeMs - leapMs) / 1e3);
+  }
+  const GPS_EPOCH = START_GPS_TIME.getTime();
+  const gpsSeconds = (timeMs - GPS_EPOCH) / 1e3;
+  let tow = gpsSeconds % (7 * 86400);
+  if (eph.system === "C") tow = (tow - 14 + 604800) % 604800;
+  return keplerPosition(eph, tow);
+}
+var GPS_EPOCH_MS = START_GPS_TIME.getTime();
+var BDS_EPOCH_MS = START_BDS_TIME.getTime();
+
+// src/constants/gnss.ts
+var C_LIGHT = 299792458;
+
+// src/positioning/index.ts
+var GM_GPS2 = 3986005e8;
+var F_REL = -4442807633e-19;
+function satClockCorrection(eph, tMs) {
+  if (eph.system === "R" || eph.system === "S") {
+    const dt2 = (tMs - eph.tocDate.getTime()) / 1e3;
+    return eph.tauN + eph.gammaN * dt2;
+  }
+  const k = eph;
+  const dt = (tMs - k.tocDate.getTime()) / 1e3;
+  const poly = k.af0 + k.af1 * dt + k.af2 * dt * dt;
+  const a = k.sqrtA * k.sqrtA;
+  const n = Math.sqrt(GM_GPS2 / (a * a * a)) + k.deltaN;
+  const tk = dt;
+  const Mk = k.m0 + n * tk;
+  let Ek = Mk;
+  for (let i = 0; i < 8; i++) {
+    Ek = Mk + k.e * Math.sin(Ek);
+  }
+  const rel = F_REL * k.e * k.sqrtA * Math.sin(Ek);
+  return poly + rel;
+}
+function ionoFree(p1, p2, f1, f2) {
+  const g = f1 * f1 / (f1 * f1 - f2 * f2);
+  return g * p1 - (g - 1) * p2;
+}
+function tropoDelay(elevationRad) {
+  const sinEl = Math.sin(elevationRad);
+  return 2.47 / (sinEl + 0.0121);
+}
+function sagnac(pos, travelTimeS) {
+  const OMEGA_E2 = 72921151467e-15;
+  const theta = OMEGA_E2 * travelTimeS;
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return [pos.x * c + pos.y * s, -pos.x * s + pos.y * c, pos.z];
+}
+function solveLinear(A, b) {
+  const n = b.length;
+  const M = A.map((row, i) => [...row, b[i]]);
+  for (let col = 0; col < n; col++) {
+    let pivot = col;
+    for (let r = col + 1; r < n; r++) {
+      if (Math.abs(M[r][col]) > Math.abs(M[pivot][col])) pivot = r;
+    }
+    if (Math.abs(M[pivot][col]) < 1e-12) return null;
+    [M[col], M[pivot]] = [M[pivot], M[col]];
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f = M[r][col] / M[col][col];
+      for (let c = col; c <= n; c++) M[r][c] -= f * M[col][c];
+    }
+  }
+  return M.map((row, i) => row[n] / M[i][i]);
+}
+function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
+  const {
+    elevationMaskDeg = 10,
+    troposphere = true,
+    maxIterations = 15,
+    convergenceM = 1e-4
+  } = opts;
+  const all = [...pseudoranges.keys()].filter((p) => ephemerides.has(p));
+  const minSats = (list) => 3 + new Set(list.map((p) => p[0])).size;
+  if (all.length < minSats(all)) return null;
+  const gaussNewton = (prns) => {
+    const systems = [...new Set(prns.map((p) => p[0]))].sort();
+    const dim = 3 + systems.length;
+    const sysIndex = new Map(systems.map((s, i) => [s, 3 + i]));
+    let x2 = 0;
+    let y2 = 0;
+    let z2 = 0;
+    const clock2 = new Map(systems.map((s) => [s, 0]));
+    const residuals2 = {};
+    let iterations2 = 0;
+    let converged2 = false;
+    for (let iter = 0; iter < maxIterations; iter++) {
+      iterations2 = iter + 1;
+      const HtH = Array.from(
+        { length: dim },
+        () => new Array(dim).fill(0)
+      );
+      const Htv = new Array(dim).fill(0);
+      let rows = 0;
+      for (const k of Object.keys(residuals2)) delete residuals2[k];
+      for (const prn of prns) {
+        const psr = pseudoranges.get(prn);
+        const eph = ephemerides.get(prn);
+        const sys = prn[0];
+        const clk = clock2.get(sys);
+        const tTx = timeMs - psr / C_LIGHT * 1e3;
+        const sat = computeSatPosition(eph, tTx);
+        if (!Number.isFinite(sat.x)) continue;
+        const dts = satClockCorrection(eph, tTx);
+        const travel = Math.hypot(sat.x - x2, sat.y - y2, sat.z - z2) / C_LIGHT;
+        const [sx, sy, sz] = sagnac(sat, travel);
+        const rho = Math.hypot(sx - x2, sy - y2, sz - z2);
+        const ux = (x2 - sx) / rho;
+        const uy = (y2 - sy) / rho;
+        const uz = (z2 - sz) / rho;
+        let elev = Math.PI / 2;
+        let weight = 1;
+        const positionSane = x2 * x2 + y2 * y2 + z2 * z2 > 1e12;
+        if (positionSane) {
+          const azel = ecefToAzEl(x2, y2, z2, sx, sy, sz);
+          elev = azel.el;
+          if (iter >= 2 && elev < elevationMaskDeg * Math.PI / 180) continue;
+          const sinEl = Math.max(Math.sin(elev), 0.1);
+          weight = sinEl * sinEl;
+        }
+        const tropo = troposphere && positionSane ? tropoDelay(elev) : 0;
+        const predicted = rho + clk - C_LIGHT * dts + tropo;
+        const v = psr - predicted;
+        const h = new Array(dim).fill(0);
+        h[0] = ux;
+        h[1] = uy;
+        h[2] = uz;
+        h[sysIndex.get(sys)] = 1;
+        for (let i = 0; i < dim; i++) {
+          for (let j = 0; j < dim; j++) HtH[i][j] += weight * h[i] * h[j];
+          Htv[i] += weight * h[i] * v;
+        }
+        residuals2[prn] = v;
+        rows++;
+      }
+      if (rows < dim) return null;
+      const dx = solveLinear(HtH, Htv);
+      if (!dx) return null;
+      x2 += dx[0];
+      y2 += dx[1];
+      z2 += dx[2];
+      for (const s of systems)
+        clock2.set(s, clock2.get(s) + dx[sysIndex.get(s)]);
+      if (Math.hypot(dx[0], dx[1], dx[2]) < convergenceM) {
+        converged2 = true;
+        break;
+      }
+    }
+    return { x: x2, y: y2, z: z2, clock: clock2, residuals: residuals2, iterations: iterations2, converged: converged2 };
+  };
+  const REJECT_THRESHOLD_M = 50;
+  let candidates = all;
+  const rejected = [];
+  let inner = null;
+  for (let round = 0; round <= all.length; round++) {
+    inner = gaussNewton(candidates);
+    if (!inner) return null;
+    const vals = Object.entries(inner.residuals);
+    let worst = null;
+    let worstAbs = REJECT_THRESHOLD_M;
+    for (const [prn, v] of vals) {
+      if (Math.abs(v) > worstAbs) {
+        worstAbs = Math.abs(v);
+        worst = prn;
+      }
+    }
+    if (!worst) break;
+    const remaining = candidates.filter((p) => p !== worst);
+    if (remaining.length < minSats(remaining)) break;
+    rejected.push(worst);
+    candidates = remaining;
+  }
+  if (!inner) return null;
+  const { x, y, z, clock, residuals, iterations, converged } = inner;
+  const used = [];
+  const azels = [];
+  for (const prn of candidates) {
+    if (!(prn in residuals)) continue;
+    const eph = ephemerides.get(prn);
+    const sat = computeSatPosition(eph, timeMs);
+    if (!Number.isFinite(sat.x)) continue;
+    const azel = ecefToAzEl(x, y, z, sat.x, sat.y, sat.z);
+    if (azel.el >= elevationMaskDeg * Math.PI / 180) {
+      used.push(prn);
+      azels.push(azel);
+    }
+  }
+  return {
+    position: [x, y, z],
+    clockBias: Object.fromEntries(clock),
+    usedSatellites: used,
+    rejectedSatellites: rejected,
+    residuals,
+    dop: computeDop(azels),
+    iterations,
+    converged
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ionoFree,
+  satClockCorrection,
+  solveSpp
+});

package/dist/positioning.d.cts

@@ -0,0 +1,68 @@
+import { E as Ephemeris } from './nav-BAI1a9vK.cjs';
+import { DopValues } from './orbit.cjs';
+import './ephemeris-Ohl6NAfw.cjs';
+import './ecef-CF0uAysr.cjs';
+
+/**
+ * Single-point positioning (SPP) from pseudoranges and broadcast
+ * ephemerides.
+ *
+ * Weighted iterative least squares with one receiver-clock unknown per
+ * constellation (absorbing inter-system time offsets), satellite clock
+ * polynomial + relativistic correction, Sagnac (Earth-rotation)
+ * correction, elevation masking/weighting, and a simple tropospheric
+ * model. Ionospheric delay is NOT modelled — use the iono-free
+ * combination (ionoFree helper) with dual-frequency pseudoranges for
+ * metre-level results, or expect ~2–10 m of iono bias on L1-only.
+ */
+
+interface SppOptions {
+    /** Elevation mask in degrees (applied after the first pass). Default 10. */
+    elevationMaskDeg?: number;
+    /** Apply the simple tropospheric model. Default true. */
+    troposphere?: boolean;
+    /** Maximum Gauss-Newton iterations. Default 15. */
+    maxIterations?: number;
+    /** Convergence threshold on the position update (m). Default 1e-4. */
+    convergenceM?: number;
+}
+interface SppSolution {
+    /** Receiver position, ECEF meters. */
+    position: [number, number, number];
+    /** Receiver clock bias per constellation (meters). */
+    clockBias: Record<string, number>;
+    /** PRNs used in the final solution. */
+    usedSatellites: string[];
+    /** PRNs rejected as outliers (bad ephemeris/measurement). */
+    rejectedSatellites: string[];
+    /** Post-fit residuals per PRN (m). */
+    residuals: Record<string, number>;
+    /** Dilution of precision at the solution. */
+    dop: DopValues | null;
+    iterations: number;
+    converged: boolean;
+}
+/**
+ * Broadcast satellite clock correction in seconds at time `tMs`
+ * (GPS-scale epoch milliseconds), including the relativistic
+ * eccentricity term for Keplerian systems.
+ */
+declare function satClockCorrection(eph: Ephemeris, tMs: number): number;
+/**
+ * Ionosphere-free pseudorange combination of two frequencies (Hz).
+ * Removes the first-order ionospheric delay.
+ */
+declare function ionoFree(p1: number, p2: number, f1: number, f2: number): number;
+/**
+ * Solve receiver position from one epoch of pseudoranges.
+ *
+ * @param pseudoranges PRN → pseudorange in meters (single frequency, or
+ *   an iono-free combination built with `ionoFree`).
+ * @param ephemerides PRN → broadcast ephemeris (from `parseNavFile` or
+ *   the RTCM decoder via `ephInfoToEphemeris`).
+ * @param timeMs Receiver epoch in GPS-scale milliseconds (RINEX epoch
+ *   time as produced by the parser).
+ */
+declare function solveSpp(pseudoranges: Map<string, number>, ephemerides: Map<string, Ephemeris>, timeMs: number, opts?: SppOptions): SppSolution | null;
+
+export { type SppOptions, type SppSolution, ionoFree, satClockCorrection, solveSpp };

package/dist/positioning.d.ts

@@ -0,0 +1,68 @@
+import { E as Ephemeris } from './nav-BAI1a9vK.js';
+import { DopValues } from './orbit.js';
+import './ephemeris-Ohl6NAfw.js';
+import './ecef-CF0uAysr.js';
+
+/**
+ * Single-point positioning (SPP) from pseudoranges and broadcast
+ * ephemerides.
+ *
+ * Weighted iterative least squares with one receiver-clock unknown per
+ * constellation (absorbing inter-system time offsets), satellite clock
+ * polynomial + relativistic correction, Sagnac (Earth-rotation)
+ * correction, elevation masking/weighting, and a simple tropospheric
+ * model. Ionospheric delay is NOT modelled — use the iono-free
+ * combination (ionoFree helper) with dual-frequency pseudoranges for
+ * metre-level results, or expect ~2–10 m of iono bias on L1-only.
+ */
+
+interface SppOptions {
+    /** Elevation mask in degrees (applied after the first pass). Default 10. */
+    elevationMaskDeg?: number;
+    /** Apply the simple tropospheric model. Default true. */
+    troposphere?: boolean;
+    /** Maximum Gauss-Newton iterations. Default 15. */
+    maxIterations?: number;
+    /** Convergence threshold on the position update (m). Default 1e-4. */
+    convergenceM?: number;
+}
+interface SppSolution {
+    /** Receiver position, ECEF meters. */
+    position: [number, number, number];
+    /** Receiver clock bias per constellation (meters). */
+    clockBias: Record<string, number>;
+    /** PRNs used in the final solution. */
+    usedSatellites: string[];
+    /** PRNs rejected as outliers (bad ephemeris/measurement). */
+    rejectedSatellites: string[];
+    /** Post-fit residuals per PRN (m). */
+    residuals: Record<string, number>;
+    /** Dilution of precision at the solution. */
+    dop: DopValues | null;
+    iterations: number;
+    converged: boolean;
+}
+/**
+ * Broadcast satellite clock correction in seconds at time `tMs`
+ * (GPS-scale epoch milliseconds), including the relativistic
+ * eccentricity term for Keplerian systems.
+ */
+declare function satClockCorrection(eph: Ephemeris, tMs: number): number;
+/**
+ * Ionosphere-free pseudorange combination of two frequencies (Hz).
+ * Removes the first-order ionospheric delay.
+ */
+declare function ionoFree(p1: number, p2: number, f1: number, f2: number): number;
+/**
+ * Solve receiver position from one epoch of pseudoranges.
+ *
+ * @param pseudoranges PRN → pseudorange in meters (single frequency, or
+ *   an iono-free combination built with `ionoFree`).
+ * @param ephemerides PRN → broadcast ephemeris (from `parseNavFile` or
+ *   the RTCM decoder via `ephInfoToEphemeris`).
+ * @param timeMs Receiver epoch in GPS-scale milliseconds (RINEX epoch
+ *   time as produced by the parser).
+ */
+declare function solveSpp(pseudoranges: Map<string, number>, ephemerides: Map<string, Ephemeris>, timeMs: number, opts?: SppOptions): SppSolution | null;
+
+export { type SppOptions, type SppSolution, ionoFree, satClockCorrection, solveSpp };