gnss-js 1.27.0 → 1.29.0

package/dist/positioning.cjs

@@ -22,15 +22,23 @@ var positioning_exports = {};
 __export(positioning_exports, {
   IONO_L1_M_PER_TECU: () => IONO_L1_M_PER_TECU,
   RtkFloatEngine: () => RtkFloatEngine,
+  buildPppAntenna: () => buildPppAntenna,
+  createPppCorrections: () => createPppCorrections,
   gimSlantIonoDelayL1: () => gimSlantIonoDelayL1,
   gimVerticalTec: () => gimVerticalTec,
+  gmst: () => gmst,
   ionoFree: () => ionoFree,
   klobucharDelay: () => klobucharDelay,
   lambdaReduction: () => lambdaReduction,
   lambdaSearch: () => lambdaSearch,
+  moonEcef: () => moonEcef,
+  niellMapping: () => niellMapping,
   satClockCorrection: () => satClockCorrection,
+  solidEarthTide: () => solidEarthTide,
   solveDgnss: () => solveDgnss,
+  solvePpp: () => solvePpp,
   solveSpp: () => solveSpp,
+  sunEcef: () => sunEcef,
   toRtkEpoch: () => toRtkEpoch
 });
 module.exports = __toCommonJS(positioning_exports);
@@ -41,6 +49,9 @@ var WGS84_FLATTENING = 1 / 298.257223563;
 var WGS84_ECCENTRICITY_SQUARED = 0.006694379990197;
 
 // src/coordinates/ecef.ts
+function clampUnit(x) {
+  return x < -1 ? -1 : x > 1 ? 1 : x;
+}
 function ecefToGeodetic(x, y, z) {
   const lon = Math.atan2(y, x);
   const p = Math.sqrt(x * x + y * y);
@@ -64,6 +75,24 @@ function ecefToGeodetic(x, y, z) {
   const alt = p / Math.cos(lat) - N;
   return [lat, lon, alt];
 }
+function getEnuDifference(x, y, z, xRef, yRef, zRef) {
+  const [latRef, lonRef] = ecefToGeodetic(xRef, yRef, zRef);
+  const deltaX = x - xRef;
+  const deltaY = y - yRef;
+  const deltaZ = z - zRef;
+  const deltaE = -Math.sin(lonRef) * deltaX + Math.cos(lonRef) * deltaY;
+  const deltaN = -Math.cos(lonRef) * Math.sin(latRef) * deltaX - Math.sin(lonRef) * Math.sin(latRef) * deltaY + Math.cos(latRef) * deltaZ;
+  const deltaU = Math.cos(lonRef) * Math.cos(latRef) * deltaX + Math.sin(lonRef) * Math.cos(latRef) * deltaY + Math.sin(latRef) * deltaZ;
+  return [deltaE, deltaN, deltaU];
+}
+function getAer(x, y, z, xRef, yRef, zRef) {
+  const slant = Math.sqrt((x - xRef) ** 2 + (y - yRef) ** 2 + (z - zRef) ** 2);
+  if (!slant) return [0, 0, 0];
+  const [deltaE, deltaN, deltaU] = getEnuDifference(x, y, z, xRef, yRef, zRef);
+  const elevation = Math.asin(clampUnit(deltaU / slant));
+  const azimuth = Math.atan2(deltaE, deltaN);
+  return [elevation, azimuth, slant];
+}
 
 // src/constants/time.ts
 var MILLISECONDS_IN_SECOND = 1e3;
@@ -1518,6 +1547,867 @@ var RtkFloatEngine = class {
   }
 };
 
+// src/rinex/sp3.ts
+function sp3Position(sp3, prn, tMs, order = 9) {
+  const samples = sp3.satellites[prn];
+  const { epochs } = sp3;
+  const n = epochs.length;
+  if (!samples || n < order) return null;
+  if (tMs < epochs[0] || tMs > epochs[n - 1]) return null;
+  let lo = 0;
+  let hi = n - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (epochs[mid] <= tMs) lo = mid;
+    else hi = mid - 1;
+  }
+  let start = lo - (order >> 1) + (order % 2 === 0 ? 1 : 0);
+  start = Math.max(0, Math.min(n - order, start));
+  for (let i = start; i < start + order; i++) {
+    if (!samples[i]) return null;
+  }
+  const t0 = epochs[start];
+  const t = (tMs - t0) / 1e3;
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  for (let i = 0; i < order; i++) {
+    const ti = (epochs[start + i] - t0) / 1e3;
+    let w = 1;
+    for (let j = 0; j < order; j++) {
+      if (j === i) continue;
+      const tj = (epochs[start + j] - t0) / 1e3;
+      w *= (t - tj) / (ti - tj);
+    }
+    const s = samples[start + i];
+    x += w * s.x;
+    y += w * s.y;
+    z += w * s.z;
+  }
+  let clk = null;
+  const a = samples[lo];
+  const b = samples[Math.min(lo + 1, n - 1)];
+  if (a?.clk != null && b?.clk != null) {
+    const span = epochs[Math.min(lo + 1, n - 1)] - epochs[lo];
+    const f = span > 0 ? (tMs - epochs[lo]) / span : 0;
+    clk = a.clk * (1 - f) + b.clk * f;
+  } else if (a?.clk != null) {
+    clk = a.clk;
+  }
+  return { x, y, z, clk };
+}
+
+// src/positioning/ppp-tropo.ts
+var HYD_AVG_A = [
+  0.0012769934,
+  1268323e-9,
+  0.0012465397,
+  0.0012196049,
+  0.0012045996
+];
+var HYD_AVG_B = [
+  0.0029153695,
+  0.0029152299,
+  0.0029288445,
+  0.0029022565,
+  0.0029024912
+];
+var HYD_AVG_C = [
+  0.062610505,
+  0.062837393,
+  0.063721774,
+  0.063824265,
+  0.064258455
+];
+var HYD_AMP_A = [0, 12709626e-12, 26523662e-12, 34000452e-12, 41202191e-12];
+var HYD_AMP_B = [0, 21414979e-12, 30160779e-12, 72562722e-12, 11723375e-11];
+var HYD_AMP_C = [0, 901284e-10, 43497037e-12, 84795348e-11, 0.0017037206];
+var HT_A = 253e-7;
+var HT_B = 549e-5;
+var HT_C = 114e-5;
+var WET_A = [
+  58021897e-11,
+  56794847e-11,
+  58118019e-11,
+  59727542e-11,
+  61641693e-11
+];
+var WET_B = [
+  0.0014275268,
+  0.0015138625,
+  0.0014572752,
+  0.0015007428,
+  0.0017599082
+];
+var WET_C = [
+  0.043472961,
+  0.04672951,
+  0.043908931,
+  0.044626982,
+  0.054736038
+];
+var LATS = [15, 30, 45, 60, 75];
+function interpLat(table, absLatDeg) {
+  if (absLatDeg <= 15) return table[0];
+  if (absLatDeg >= 75) return table[4];
+  let i = 0;
+  while (i < 4 && absLatDeg > LATS[i + 1]) i++;
+  const t = (absLatDeg - LATS[i]) / (LATS[i + 1] - LATS[i]);
+  return table[i] + t * (table[i + 1] - table[i]);
+}
+function marini(sinEl, a, b, c) {
+  const num = 1 + a / (1 + b / (1 + c));
+  const den = sinEl + a / (sinEl + b / (sinEl + c));
+  return num / den;
+}
+function dayOfYear(timeMs) {
+  const d = new Date(timeMs);
+  const start = Date.UTC(d.getUTCFullYear(), 0, 1);
+  return Math.floor((timeMs - start) / 864e5) + 1;
+}
+function niellMapping(elRad, latRad, heightM, timeMs) {
+  const sinEl = Math.sin(Math.max(elRad, 1e-3));
+  const absLat = Math.abs(latRad * 180 / Math.PI);
+  const hKm = heightM / 1e3;
+  let doy = dayOfYear(timeMs);
+  if (latRad < 0) doy += 365.25 / 2;
+  const yfrac = Math.cos(2 * Math.PI * (doy - 28) / 365.25);
+  const ah = interpLat(HYD_AVG_A, absLat) - interpLat(HYD_AMP_A, absLat) * yfrac;
+  const bh = interpLat(HYD_AVG_B, absLat) - interpLat(HYD_AMP_B, absLat) * yfrac;
+  const ch = interpLat(HYD_AVG_C, absLat) - interpLat(HYD_AMP_C, absLat) * yfrac;
+  const mHt = marini(sinEl, HT_A, HT_B, HT_C);
+  const dmdh = 1 / sinEl - mHt;
+  const mh = marini(sinEl, ah, bh, ch) + dmdh * hKm;
+  const aw = interpLat(WET_A, absLat);
+  const bw = interpLat(WET_B, absLat);
+  const cw = interpLat(WET_C, absLat);
+  const mw = marini(sinEl, aw, bw, cw);
+  const h = heightM < 0 ? 0 : heightM > 1e4 ? 1e4 : heightM;
+  const pres = 1013.25 * Math.pow(1 - 22557e-9 * h, 5.2568);
+  const zhd = 22768e-7 * pres / (1 - 266e-5 * Math.cos(2 * latRad) - 28e-5 * (h / 1e3));
+  return { zhd, mh, mw };
+}
+
+// src/positioning/ppp-astro.ts
+var AU = 149597870700;
+var GPS_UTC_LEAP = 18;
+var J2000_MS = Date.UTC(2e3, 0, 1, 12, 0, 0);
+var DEG = Math.PI / 180;
+function daysSinceJ2000(timeMs) {
+  return (timeMs - GPS_UTC_LEAP * 1e3 - J2000_MS) / 864e5;
+}
+function gmst(timeMs) {
+  const d = daysSinceJ2000(timeMs);
+  let deg = 280.46061837 + 360.98564736629 * d;
+  deg %= 360;
+  if (deg < 0) deg += 360;
+  return deg * DEG;
+}
+function eciToEcef(v, theta) {
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return [v[0] * c + v[1] * s, -v[0] * s + v[1] * c, v[2]];
+}
+function sunEcef(timeMs) {
+  const n = daysSinceJ2000(timeMs);
+  const L = (280.46 + 0.9856474 * n) * DEG;
+  const g = (357.528 + 0.9856003 * n) * DEG;
+  const lambda = L + (1.915 * Math.sin(g) + 0.02 * Math.sin(2 * g)) * DEG;
+  const eps = (23.439 - 4e-7 * n) * DEG;
+  const R = (1.00014 - 0.01671 * Math.cos(g) - 14e-5 * Math.cos(2 * g)) * AU;
+  const eci = [
+    R * Math.cos(lambda),
+    R * Math.cos(eps) * Math.sin(lambda),
+    R * Math.sin(eps) * Math.sin(lambda)
+  ];
+  return eciToEcef(eci, gmst(timeMs));
+}
+function moonEcef(timeMs) {
+  const T = daysSinceJ2000(timeMs) / 36525;
+  const L0 = 218.31617 + 481267.88088 * T - 1.3972 * T;
+  const l = 134.96292 + 477198.86753 * T;
+  const lp = 357.52543 + 35999.04944 * T;
+  const F = 93.27283 + 483202.01873 * T;
+  const D = 297.85027 + 445267.11135 * T;
+  const s = (x) => Math.sin(x * DEG);
+  const c = (x) => Math.cos(x * DEG);
+  const lon = L0 + 6.28875 * s(l) + 1.274018 * s(2 * D - l) + 0.658309 * s(2 * D) + 0.213616 * s(2 * l) - 0.185596 * s(lp) - 0.114336 * s(2 * F) + 0.058793 * s(2 * D - 2 * l) + 0.057212 * s(2 * D - lp - l) + 0.05332 * s(2 * D + l);
+  const lat = 5.128189 * s(F) + 0.280606 * s(l + F) + 0.277693 * s(l - F) + 0.173238 * s(2 * D - F) + 0.055413 * s(2 * D + F - l) + 0.046272 * s(2 * D - F - l);
+  const r = (385e3 - 20905 * c(l) - 3699 * c(2 * D - l) - 2956 * c(2 * D) - 570 * c(2 * l)) * 1e3;
+  const eps = (23.4393 - 4e-7 * daysSinceJ2000(timeMs)) * DEG;
+  const lonR = lon * DEG;
+  const latR = lat * DEG;
+  const xe = r * Math.cos(latR) * Math.cos(lonR);
+  const ye = r * Math.cos(latR) * Math.sin(lonR);
+  const ze = r * Math.sin(latR);
+  const eci = [
+    xe,
+    ye * Math.cos(eps) - ze * Math.sin(eps),
+    ye * Math.sin(eps) + ze * Math.cos(eps)
+  ];
+  return eciToEcef(eci, gmst(timeMs));
+}
+var H2 = 0.6078;
+var L2 = 0.0847;
+var RE = 6378137;
+var GM_SUN_RATIO = 332946.0482;
+var GM_MOON_RATIO = 0.0123000371;
+function solidEarthTide(rcv, sun, moon) {
+  const rNorm = Math.hypot(rcv[0], rcv[1], rcv[2]);
+  const rHat = [
+    rcv[0] / rNorm,
+    rcv[1] / rNorm,
+    rcv[2] / rNorm
+  ];
+  const disp = [0, 0, 0];
+  for (const [body, ratio] of [
+    [sun, GM_SUN_RATIO],
+    [moon, GM_MOON_RATIO]
+  ]) {
+    const rj = Math.hypot(body[0], body[1], body[2]);
+    const jHat = [
+      body[0] / rj,
+      body[1] / rj,
+      body[2] / rj
+    ];
+    const dot2 = rHat[0] * jHat[0] + rHat[1] * jHat[1] + rHat[2] * jHat[2];
+    const factor = ratio * RE * RE * RE * RE / (rj * rj * rj);
+    const radialScale = H2 * (1.5 * dot2 * dot2 - 0.5);
+    const tanScale = 3 * L2 * dot2;
+    for (let k = 0; k < 3; k++) {
+      disp[k] += factor * (radialScale * rHat[k] + tanScale * (jHat[k] - dot2 * rHat[k]));
+    }
+  }
+  return disp;
+}
+
+// src/positioning/ppp-antenna.ts
+function parseAntexTime(s) {
+  const p = s.trim().split(/\s+/).map(Number);
+  if (p.length < 3 || p.some((v) => Number.isNaN(v))) return null;
+  return Date.UTC(
+    p[0],
+    (p[1] || 1) - 1,
+    p[2] || 1,
+    p[3] ?? 0,
+    p[4] ?? 0,
+    Math.floor(p[5] ?? 0)
+  );
+}
+function freqOf(entry, code) {
+  return entry.frequencies.find((f) => f.frequency === code);
+}
+function combineIf(fA, fB, f1, f2) {
+  const g = f1 * f1 / (f1 * f1 - f2 * f2);
+  const mm = 1e-3;
+  const pco = [
+    (g * fA.pcoN - (g - 1) * fB.pcoN) * mm,
+    (g * fA.pcoE - (g - 1) * fB.pcoE) * mm,
+    (g * fA.pcoU - (g - 1) * fB.pcoU) * mm
+  ];
+  const nz = Math.min(fA.pcvNoazi.length, fB.pcvNoazi.length);
+  const pcvNoazi = new Array(nz);
+  for (let i = 0; i < nz; i++) {
+    pcvNoazi[i] = (g * fA.pcvNoazi[i] - (g - 1) * fB.pcvNoazi[i]) * mm;
+  }
+  return { pco, pcvZen1Deg: 0, pcvDzenDeg: 0, pcvNoazi };
+}
+function buildPppAntenna(antex) {
+  const sats = /* @__PURE__ */ new Map();
+  const rcvs = /* @__PURE__ */ new Map();
+  for (const a of antex.antennas) {
+    if (a.isSatellite) {
+      const list = sats.get(a.serialNo) ?? [];
+      list.push(a);
+      sats.set(a.serialNo, list);
+    } else if (!rcvs.has(a.type)) {
+      rcvs.set(a.type, a);
+    }
+  }
+  const withZen = (entry, off) => ({
+    ...off,
+    pcvZen1Deg: entry.zen1,
+    pcvDzenDeg: entry.dzen
+  });
+  return {
+    satOffset(prn, dateMs, band1, band2, f1, f2) {
+      const list = sats.get(prn);
+      if (!list) return null;
+      const entry = list.find((e) => {
+        const from = parseAntexTime(e.validFrom);
+        const until = parseAntexTime(e.validUntil);
+        return (from == null || dateMs >= from) && (until == null || dateMs <= until);
+      });
+      if (!entry) return null;
+      const a = freqOf(entry, band1);
+      const b = freqOf(entry, band2);
+      if (!a || !b) return null;
+      return withZen(entry, combineIf(a, b, f1, f2));
+    },
+    rcvOffset(antType, band1, band2, f1, f2) {
+      const entry = rcvs.get(antType);
+      if (!entry) return null;
+      const a = freqOf(entry, band1);
+      const b = freqOf(entry, band2);
+      if (!a || !b) return null;
+      return withZen(entry, combineIf(a, b, f1, f2));
+    }
+  };
+}
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function norm(a) {
+  const n = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / n, a[1] / n, a[2] / n];
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function satBodyFrame(satEcef, sunEcef2) {
+  const z = norm([-satEcef[0], -satEcef[1], -satEcef[2]]);
+  const eSun = norm([
+    sunEcef2[0] - satEcef[0],
+    sunEcef2[1] - satEcef[1],
+    sunEcef2[2] - satEcef[2]
+  ]);
+  const y = norm(cross(z, eSun));
+  const x = norm(cross(y, z));
+  return { x, y, z };
+}
+function satPcoToEcef(pcoBody, frame) {
+  return [
+    pcoBody[0] * frame.x[0] + pcoBody[1] * frame.y[0] + pcoBody[2] * frame.z[0],
+    pcoBody[0] * frame.x[1] + pcoBody[1] * frame.y[1] + pcoBody[2] * frame.z[1],
+    pcoBody[0] * frame.x[2] + pcoBody[1] * frame.y[2] + pcoBody[2] * frame.z[2]
+  ];
+}
+function enuToEcef(enu, latRad, lonRad) {
+  const sl = Math.sin(latRad);
+  const cl = Math.cos(latRad);
+  const so = Math.sin(lonRad);
+  const co = Math.cos(lonRad);
+  const [e, n, u] = enu;
+  return [
+    -so * e - sl * co * n + cl * co * u,
+    co * e - sl * so * n + cl * so * u,
+    cl * n + sl * u
+  ];
+}
+function interpPcv(off, angleDeg) {
+  const { pcvZen1Deg, pcvDzenDeg, pcvNoazi } = off;
+  if (pcvDzenDeg <= 0 || pcvNoazi.length < 2) return 0;
+  const x = (angleDeg - pcvZen1Deg) / pcvDzenDeg;
+  if (x <= 0) return pcvNoazi[0];
+  if (x >= pcvNoazi.length - 1) return pcvNoazi[pcvNoazi.length - 1];
+  const i = Math.floor(x);
+  const t = x - i;
+  return pcvNoazi[i] * (1 - t) + pcvNoazi[i + 1] * t;
+}
+function phaseWindup(prn, losRcvToSat, satFrame, latRad, lonRad, state) {
+  const k = [
+    -losRcvToSat[0],
+    -losRcvToSat[1],
+    -losRcvToSat[2]
+  ];
+  const kx = satFrame.x;
+  const ky = satFrame.y;
+  const kdotx = dot(k, kx);
+  const kcrossY = cross(k, ky);
+  const dS = [
+    kx[0] - k[0] * kdotx - kcrossY[0],
+    kx[1] - k[1] * kdotx - kcrossY[1],
+    kx[2] - k[2] * kdotx - kcrossY[2]
+  ];
+  const north = enuToEcef([0, 1, 0], latRad, lonRad);
+  const east = enuToEcef([1, 0, 0], latRad, lonRad);
+  const kdotn = dot(k, north);
+  const kcrossE = cross(k, east);
+  const dR = [
+    north[0] - k[0] * kdotn + kcrossE[0],
+    north[1] - k[1] * kdotn + kcrossE[1],
+    north[2] - k[2] * kdotn + kcrossE[2]
+  ];
+  const nS = Math.hypot(dS[0], dS[1], dS[2]) || 1;
+  const nR = Math.hypot(dR[0], dR[1], dR[2]) || 1;
+  let cosPhi = dot(dS, dR) / (nS * nR);
+  cosPhi = Math.max(-1, Math.min(1, cosPhi));
+  const zeta = cross(dS, dR);
+  const sign = dot(k, zeta) >= 0 ? 1 : -1;
+  const dphi = sign * Math.acos(cosPhi) / (2 * Math.PI);
+  const prev = state.get(prn);
+  const wu = prev == null ? dphi : dphi + Math.round(prev - dphi);
+  state.set(prn, wu);
+  return wu;
+}
+
+// src/positioning/ppp-corrections.ts
+function applyCorrections(corrections, geom, ctx) {
+  if (corrections.evaluate) return corrections.evaluate(geom, ctx);
+  return { rangeM: 0, phaseWindupM: 0 };
+}
+function createPppCorrections(cfg) {
+  const useSat = cfg.satPco ?? false;
+  const useRcv = cfg.rcvPco ?? true;
+  const useTides = cfg.tides ?? true;
+  const useWindup = cfg.windup ?? true;
+  const antDelta = cfg.antDeltaEnu ?? [0, 0, 0];
+  const windupState = /* @__PURE__ */ new Map();
+  return {
+    epochContext(timeMs, rcvEcef) {
+      const sun = sunEcef(timeMs);
+      const moon = moonEcef(timeMs);
+      const tideDisp = useTides ? solidEarthTide(rcvEcef, sun, moon) : [0, 0, 0];
+      return { timeMs, sun, moon, tideDisp };
+    },
+    evaluate(geom, ctx) {
+      let rangeM = 0;
+      let phaseWindupM = 0;
+      const e = geom.los;
+      const [latDeg, lonDeg] = ecefToGeodetic(
+        geom.rcvEcef[0],
+        geom.rcvEcef[1],
+        geom.rcvEcef[2]
+      );
+      const latRad = latDeg * Math.PI / 180;
+      const lonRad = lonDeg * Math.PI / 180;
+      const frame = ctx ? satBodyFrame(geom.satEcef, ctx.sun) : null;
+      if (useSat && frame && geom.band1 && geom.band2) {
+        const off = cfg.antenna.satOffset(
+          geom.prn,
+          ctx.timeMs,
+          geom.band1,
+          geom.band2,
+          geom.f1,
+          geom.f2
+        );
+        if (off) {
+          const pcoEcef = satPcoToEcef(off.pco, frame);
+          rangeM += dot(e, pcoEcef);
+          const satR = Math.hypot(
+            geom.satEcef[0],
+            geom.satEcef[1],
+            geom.satEcef[2]
+          );
+          const cosNadir = (e[0] * geom.satEcef[0] + e[1] * geom.satEcef[1] + e[2] * geom.satEcef[2]) / satR;
+          const nadirDeg = Math.acos(Math.max(-1, Math.min(1, cosNadir))) * 180 / Math.PI;
+          rangeM += interpPcv(off, nadirDeg);
+        }
+      }
+      if (useRcv && geom.band1 && geom.band2) {
+        const off = cfg.antenna.rcvOffset(
+          cfg.rcvAntType,
+          geom.band1,
+          geom.band2,
+          geom.f1,
+          geom.f2
+        );
+        if (off) {
+          const total = [
+            off.pco[0] + antDelta[0],
+            off.pco[1] + antDelta[1],
+            off.pco[2] + antDelta[2]
+          ];
+          const ecef = enuToEcef(total, latRad, lonRad);
+          rangeM -= dot(e, ecef);
+          const zenithDeg = 90 - geom.elRad * 180 / Math.PI;
+          rangeM += interpPcv(off, zenithDeg);
+        }
+      }
+      if (useTides && ctx) {
+        rangeM -= dot(e, ctx.tideDisp);
+      }
+      if (useWindup && frame) {
+        const wu = phaseWindup(geom.prn, e, frame, latRad, lonRad, windupState);
+        const lambdaIf = 299792458 / (geom.f1 + geom.f2);
+        phaseWindupM = wu * lambdaIf;
+      }
+      return { rangeM, phaseWindupM };
+    }
+  };
+}
+
+// src/positioning/ppp.ts
+function matVec(P, h) {
+  const n = P.length;
+  const out = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    let s = 0;
+    const Pi = P[i];
+    for (let j = 0; j < n; j++) s += Pi[j] * h[j];
+    out[i] = s;
+  }
+  return out;
+}
+function ekfUpdateScalar(x, P, h, innovation, r, rejectK = 0) {
+  const n = x.length;
+  const Ph = matVec(P, h);
+  let hPh = 0;
+  for (let i = 0; i < n; i++) hPh += h[i] * Ph[i];
+  const s = hPh + r;
+  if (s <= 0) return false;
+  if (rejectK > 0 && innovation * innovation > rejectK * rejectK * s) {
+    return false;
+  }
+  const K = Ph.map((v) => v / s);
+  for (let i = 0; i < n; i++) x[i] += K[i] * innovation;
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      P[i][j] -= K[i] * Ph[j];
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const m = 0.5 * (P[i][j] + P[j][i]);
+      P[i][j] = m;
+      P[j][i] = m;
+    }
+  }
+  return true;
+}
+function ifCoeffs(f1, f2) {
+  const g = f1 * f1 / (f1 * f1 - f2 * f2);
+  const lambdaIf = C_LIGHT / (f1 + f2);
+  return { g, lambdaIf };
+}
+function sagnacRotate(x, y, z, travelS) {
+  const theta = OMEGA_E * travelS;
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return [x * c + y * s, -x * s + y * c, z];
+}
+function satStateAtEmission(sp3, prn, recvTimeMs, rcv) {
+  let travelS = 0.075;
+  let sx = 0;
+  let sy = 0;
+  let sz = 0;
+  let clkS = null;
+  let velDotPos = 0;
+  for (let iter = 0; iter < 3; iter++) {
+    const tEmit = recvTimeMs - travelS * 1e3;
+    const p = sp3Position(sp3, prn, tEmit);
+    if (!p || p.clk == null) return null;
+    const pPlus = sp3Position(sp3, prn, tEmit + 500);
+    const pMinus = sp3Position(sp3, prn, tEmit - 500);
+    if (pPlus && pMinus) {
+      const vx = (pPlus.x - pMinus.x) / 1;
+      const vy = (pPlus.y - pMinus.y) / 1;
+      const vz = (pPlus.z - pMinus.z) / 1;
+      velDotPos = p.x * vx + p.y * vy + p.z * vz;
+    }
+    clkS = p.clk;
+    const [rx, ry, rz] = sagnacRotate(p.x, p.y, p.z, travelS);
+    sx = rx;
+    sy = ry;
+    sz = rz;
+    const dx = sx - rcv[0];
+    const dy = sy - rcv[1];
+    const dz = sz - rcv[2];
+    const range = Math.hypot(dx, dy, dz);
+    travelS = range / C_LIGHT;
+  }
+  if (clkS == null) return null;
+  const relS = -2 * velDotPos / (C_LIGHT * C_LIGHT);
+  const clkM = C_LIGHT * (clkS + relS);
+  return { state: { x: sx, y: sy, z: sz, clkM }, travelS };
+}
+var IDX_X = 0;
+var IDX_Y = 1;
+var IDX_Z = 2;
+var IDX_ZWD = 3;
+var NBASE = 4;
+var CLK_VAR = 1e10;
+function solvePpp(epochs, sp3, opts) {
+  const elevMask = (opts.elevationMaskDeg ?? 10) * Math.PI / 180;
+  const codeSigma = opts.codeSigma ?? 3;
+  const phaseSigma = opts.phaseSigma ?? 0.01;
+  const ztdQ = opts.ztdProcessNoise ?? 1e-8;
+  const corrections = opts.corrections;
+  const x = [
+    opts.aprioriPos[0],
+    opts.aprioriPos[1],
+    opts.aprioriPos[2],
+    0.1
+    // zenith wet delay (m) a priori
+  ];
+  const P = [];
+  for (let i = 0; i < NBASE; i++) {
+    P.push(new Array(NBASE).fill(0));
+  }
+  P[IDX_X][IDX_X] = 100 * 100;
+  P[IDX_Y][IDX_Y] = 100 * 100;
+  P[IDX_Z][IDX_Z] = 100 * 100;
+  P[IDX_ZWD][IDX_ZWD] = 0.5 * 0.5;
+  const clkIdx = /* @__PURE__ */ new Map();
+  const clockSeeded = /* @__PURE__ */ new Set();
+  const ambIdx = /* @__PURE__ */ new Map();
+  const lastSeen = /* @__PURE__ */ new Map();
+  const mwState = /* @__PURE__ */ new Map();
+  const detectSlip = (o, ei) => {
+    const lamW = C_LIGHT / (o.f1 - o.f2);
+    const lw = o.l1 - o.l2;
+    const pn = (o.f1 * o.c1 + o.f2 * o.c2) / (o.f1 + o.f2);
+    const mw = lw - pn / lamW;
+    const st = mwState.get(o.prn);
+    let slip = o.slip;
+    if (!st || ei - st.lastEi > 2)
+      slip = true;
+    else if (Math.abs(mw - st.mean) > 4) slip = true;
+    if (slip) mwState.set(o.prn, { mean: mw, n: 1, lastEi: ei });
+    else {
+      const n = st.n + 1;
+      mwState.set(o.prn, {
+        mean: st.mean + (mw - st.mean) / Math.min(n, 100),
+        n,
+        lastEi: ei
+      });
+    }
+    return slip;
+  };
+  const growState = (initVal, initVar) => {
+    const idx = x.length;
+    x.push(initVal);
+    for (const row of P) row.push(0);
+    P.push(new Array(x.length).fill(0));
+    P[idx][idx] = initVar;
+    return idx;
+  };
+  const dropState = (idx) => {
+    x.splice(idx, 1);
+    P.splice(idx, 1);
+    for (const row of P) row.splice(idx, 1);
+    for (const [prn, i] of ambIdx) {
+      if (i === idx) ambIdx.delete(prn);
+      else if (i > idx) ambIdx.set(prn, i - 1);
+    }
+    for (const [sys, i] of clkIdx) {
+      if (i > idx) clkIdx.set(sys, i - 1);
+    }
+  };
+  const clockOf = (sys) => {
+    let i = clkIdx.get(sys);
+    if (i === void 0) {
+      i = growState(0, CLK_VAR);
+      clkIdx.set(sys, i);
+    }
+    return i;
+  };
+  const series = [];
+  const truth = opts.groundTruth;
+  const t0 = epochs[0]?.timeMs ?? 0;
+  let convergenceSec = null;
+  let convergedStreak = 0;
+  for (let ei = 0; ei < epochs.length; ei++) {
+    const epoch = epochs[ei];
+    for (const ci of clkIdx.values()) P[ci][ci] = CLK_VAR;
+    P[IDX_ZWD][IDX_ZWD] += ztdQ * (ei > 0 ? 1 : 0);
+    const rcv = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
+    const [latDeg, , heightM] = ecefToGeodetic(rcv[0], rcv[1], rcv[2]);
+    const latRad = latDeg * Math.PI / 180;
+    const epochCtx = corrections?.epochContext?.(epoch.timeMs, rcv) ?? null;
+    const vis = [];
+    for (const o of epoch.obs) {
+      if (o.c1 === 0 || o.c2 === 0 || o.l1 === 0 || o.l2 === 0) continue;
+      const slip = detectSlip(o, ei);
+      const sat = satStateAtEmission(sp3, o.prn, epoch.timeMs, rcv);
+      if (!sat) continue;
+      const [elRad, azRad] = getAer(
+        sat.state.x,
+        sat.state.y,
+        sat.state.z,
+        rcv[0],
+        rcv[1],
+        rcv[2]
+      );
+      if (elRad < elevMask) continue;
+      const dx = sat.state.x - rcv[0];
+      const dy = sat.state.y - rcv[1];
+      const dz = sat.state.z - rcv[2];
+      const range = Math.hypot(dx, dy, dz);
+      const e = [dx / range, dy / range, dz / range];
+      const { g } = ifCoeffs(o.f1, o.f2);
+      const lam1 = C_LIGHT / o.f1;
+      const lam2 = C_LIGHT / o.f2;
+      if (o.c1 === 0 || o.c2 === 0 || o.l1 === 0 || o.l2 === 0) continue;
+      const pIf = g * o.c1 - (g - 1) * o.c2;
+      const lIf = g * (o.l1 * lam1) - (g - 1) * (o.l2 * lam2);
+      if (!Number.isFinite(pIf) || !Number.isFinite(lIf)) continue;
+      const trop = opts.troposphere ?? true ? niellMapping(elRad, latRad, heightM, epoch.timeMs) : { zhd: 0, mh: 0, mw: 0 };
+      const { zhd, mh, mw } = trop;
+      const geom = {
+        prn: o.prn,
+        satEcef: [sat.state.x, sat.state.y, sat.state.z],
+        rcvEcef: rcv,
+        los: e,
+        elRad,
+        azRad,
+        f1: o.f1,
+        f2: o.f2,
+        band1: o.band1,
+        band2: o.band2,
+        g
+      };
+      const corr = corrections ? applyCorrections(corrections, geom, epochCtx) : { rangeM: 0, phaseWindupM: 0 };
+      vis.push({
+        prn: o.prn,
+        e,
+        elRad,
+        pIf,
+        lIf,
+        satClkM: sat.state.clkM,
+        range,
+        tropoFixed: zhd * mh + corr.rangeM,
+        mw,
+        windupM: corr.phaseWindupM,
+        slip
+      });
+    }
+    const zwd0 = x[IDX_ZWD];
+    const bySys = /* @__PURE__ */ new Map();
+    for (const v of vis) {
+      const sys = v.prn[0];
+      const r = v.pIf - (v.range - v.satClkM + v.tropoFixed + zwd0 * v.mw);
+      const arr = bySys.get(sys);
+      if (arr) arr.push(r);
+      else bySys.set(sys, [r]);
+    }
+    for (const [sys, res] of bySys) {
+      const ci = clockOf(sys);
+      if (!clockSeeded.has(sys)) {
+        res.sort((a, b) => a - b);
+        x[ci] = res[Math.floor(res.length / 2)];
+        clockSeeded.add(sys);
+      }
+      P[ci][ci] = CLK_VAR;
+    }
+    let nSats = 0;
+    let sumPhaseResSq = 0;
+    let nPhaseRes = 0;
+    for (const v of vis) {
+      const ci = clockOf(v.prn[0]);
+      const common = v.range + x[ci] - v.satClkM + v.tropoFixed + zwd0 * v.mw;
+      let ai = ambIdx.get(v.prn);
+      if (ai === void 0 || v.slip) {
+        const bInit = v.lIf - (common + v.windupM);
+        if (ai === void 0) {
+          ai = growState(bInit, 100 * 100);
+        } else {
+          x[ai] = bInit;
+          for (let j = 0; j < P.length; j++) {
+            P[ai][j] = 0;
+            P[j][ai] = 0;
+          }
+          P[ai][ai] = 100 * 100;
+        }
+        ambIdx.set(v.prn, ai);
+      }
+      const n = x.length;
+      const sinEl = Math.max(Math.sin(v.elRad), 0.1);
+      const rCode = (codeSigma / sinEl) ** 2;
+      const rPhase = (phaseSigma / sinEl) ** 2;
+      {
+        const h = new Array(n).fill(0);
+        h[IDX_X] = -v.e[0];
+        h[IDX_Y] = -v.e[1];
+        h[IDX_Z] = -v.e[2];
+        h[ci] = 1;
+        h[IDX_ZWD] = v.mw;
+        const innov = v.pIf - common;
+        if (Math.abs(innov) < 1e6) ekfUpdateScalar(x, P, h, innov, rCode, 4);
+      }
+      {
+        const commonPh = v.range + x[ci] - v.satClkM + v.tropoFixed + x[IDX_ZWD] * v.mw;
+        const innov = v.lIf - (commonPh + v.windupM + x[ai]);
+        if (Math.abs(innov) > 0.15) {
+          x[ai] = v.lIf - (commonPh + v.windupM);
+          for (let j = 0; j < P.length; j++) {
+            P[ai][j] = 0;
+            P[j][ai] = 0;
+          }
+          P[ai][ai] = 100 * 100;
+        } else {
+          const h = new Array(n).fill(0);
+          h[IDX_X] = -v.e[0];
+          h[IDX_Y] = -v.e[1];
+          h[IDX_Z] = -v.e[2];
+          h[ci] = 1;
+          h[IDX_ZWD] = v.mw;
+          h[ai] = 1;
+          if (ekfUpdateScalar(x, P, h, innov, rPhase, 4)) {
+            sumPhaseResSq += innov * innov;
+            nPhaseRes++;
+          }
+        }
+      }
+      lastSeen.set(v.prn, ei);
+      nSats++;
+    }
+    for (const [prn, seen] of [...lastSeen]) {
+      if (ei - seen > 20) {
+        const idx = ambIdx.get(prn);
+        if (idx !== void 0) dropState(idx);
+        lastSeen.delete(prn);
+      }
+    }
+    const pos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
+    let enu = null;
+    let error3d = null;
+    if (truth) {
+      enu = getEnuDifference(
+        pos[0],
+        pos[1],
+        pos[2],
+        truth[0],
+        truth[1],
+        truth[2]
+      );
+      error3d = Math.hypot(
+        pos[0] - truth[0],
+        pos[1] - truth[1],
+        pos[2] - truth[2]
+      );
+      if (error3d < 0.1) {
+        convergedStreak++;
+        if (convergedStreak >= 10 && convergenceSec == null) {
+          convergenceSec = (epoch.timeMs - t0) / 1e3;
+        }
+      } else {
+        convergedStreak = 0;
+        convergenceSec = null;
+      }
+    }
+    series.push({
+      timeMs: epoch.timeMs,
+      enu,
+      error3d,
+      position: pos,
+      nSats,
+      ztdWet: x[IDX_ZWD],
+      phaseResRms: nPhaseRes > 0 ? Math.sqrt(sumPhaseResSq / nPhaseRes) : 0
+    });
+  }
+  const finalPos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
+  const llh = ecefToGeodetic(finalPos[0], finalPos[1], finalPos[2]);
+  const finalError3d = truth ? Math.hypot(
+    finalPos[0] - truth[0],
+    finalPos[1] - truth[1],
+    finalPos[2] - truth[2]
+  ) : null;
+  return {
+    position: finalPos,
+    llh,
+    series,
+    ztdWet: x[IDX_ZWD],
+    epochsUsed: epochs.length,
+    convergenceSec,
+    finalError3d
+  };
+}
+
 // src/positioning/index.ts
 var GM_GPS2 = 3986005e8;
 var F_REL = -4442807633e-19;
@@ -1658,7 +2548,8 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
         let ionoM = 0;
         if ((gim || iono) && positionSane) {
           let l1M = null;
-          if (gim) l1M = gimSlantIonoDelayL1(gim, rxLat, rxLon, azim, elev, timeMs);
+          if (gim)
+            l1M = gimSlantIonoDelayL1(gim, rxLat, rxLon, azim, elev, timeMs);
           if (l1M === null && iono) {
             l1M = C_LIGHT * klobucharDelay(iono, rxLat, rxLon, azim, elev, gpsTow);
           }
@@ -1748,14 +2639,22 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
 0 && (module.exports = {
   IONO_L1_M_PER_TECU,
   RtkFloatEngine,
+  buildPppAntenna,
+  createPppCorrections,
   gimSlantIonoDelayL1,
   gimVerticalTec,
+  gmst,
   ionoFree,
   klobucharDelay,
   lambdaReduction,
   lambdaSearch,
+  moonEcef,
+  niellMapping,
   satClockCorrection,
+  solidEarthTide,
   solveDgnss,
+  solvePpp,
   solveSpp,
+  sunEcef,
   toRtkEpoch
 });