gnss-js 2.2.0 → 2.4.0

package/dist/index.cjs

@@ -116,6 +116,7 @@ __export(src_exports, {
   almanacEpochMs: () => almanacEpochMs,
   almanacSatPosition: () => almanacSatPosition,
   analyzeQuality: () => analyzeQuality,
+  antexFreqOfGroup: () => antexFreqOfGroup,
   applyHelmert: () => applyHelmert,
   applyIonoDcb: () => applyIonoDcb,
   applyOrbitClock: () => applyOrbitClock,
@@ -127,6 +128,7 @@ __export(src_exports, {
   buildGloChannelMap: () => buildGloChannelMap,
   buildObsIndices: () => buildObsIndices,
   buildPppAntenna: () => buildPppAntenna,
+  buildRtkAntenna: () => buildRtkAntenna,
   clampUnit: () => clampUnit,
   clkBias: () => clkBias,
   computeAllPositions: () => computeAllPositions,
@@ -309,6 +311,7 @@ __export(src_exports, {
   postProcessRtk: () => postProcessRtk,
   rad2deg: () => rad2deg,
   rangeRate: () => rangeRate,
+  rcvAntennaRangeM: () => rcvAntennaRangeM,
   readString: () => readString,
   reportDecodeError: () => reportDecodeError,
   resetGloFreqCache: () => resetGloFreqCache,
@@ -13226,6 +13229,211 @@ function lambdaReduction(Q, n) {
   return Z2;
 }
 
+// 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/rtk-antenna.ts
+function freqOf2(entry, code) {
+  return entry.frequencies.find((f) => f.frequency === code);
+}
+function buildRtkAntenna(antex) {
+  const rcvs = /* @__PURE__ */ new Map();
+  for (const a of antex.antennas) {
+    if (!a.isSatellite && !rcvs.has(a.type)) rcvs.set(a.type, a);
+  }
+  const mm = 1e-3;
+  return {
+    rcvOffset(antType, freq) {
+      const entry = rcvs.get(antType);
+      if (!entry) return null;
+      const f = freqOf2(entry, freq);
+      if (!f) return null;
+      return {
+        pco: [f.pcoN * mm, f.pcoE * mm, f.pcoU * mm],
+        pcvZen1Deg: entry.zen1,
+        pcvDzenDeg: entry.dzen,
+        pcvNoazi: f.pcvNoazi.map((v) => v * mm)
+      };
+    }
+  };
+}
+function rcvAntennaRangeM(off, losRcvToSat, latRad, lonRad, elRad, antDeltaEnu = [0, 0, 0]) {
+  const total = [
+    off.pco[0] + antDeltaEnu[0],
+    off.pco[1] + antDeltaEnu[1],
+    off.pco[2] + antDeltaEnu[2]
+  ];
+  const ecef = enuToEcef(total, latRad, lonRad);
+  let m = -dot(losRcvToSat, ecef);
+  const zenithDeg = 90 - elRad * 180 / Math.PI;
+  m += interpPcv(off, zenithDeg);
+  return m;
+}
+function antexFreqOfGroup(group) {
+  return `${group[0]}0${group[1]}`;
+}
+
 // src/positioning/rtk.ts
 var L1_CODES = {
   G: ["1C"],
@@ -13291,8 +13499,16 @@ function resolveEphemeris(src, prn, timeMs) {
     return selectEphemeris(src, prn, timeMs);
   return src.get(prn) ?? null;
 }
-function buildGeometry(rover, base, basePos, ephemerides, timeMs, maskRad, troposphere) {
+var ZERO_DELTA = [0, 0, 0];
+function buildGeometry(rover, base, basePos, ephemerides, timeMs, maskRad, troposphere, antenna = null) {
   const out = [];
+  let baseLatRad = 0;
+  let baseLonRad = 0;
+  if (antenna?.base) {
+    const [latDeg, lonDeg] = ecefToGeodetic(basePos[0], basePos[1], basePos[2]);
+    baseLatRad = latDeg * Math.PI / 180;
+    baseLonRad = lonDeg * Math.PI / 180;
+  }
   for (const [prn, mR] of rover) {
     const sys = prn[0];
     if (!"GERCJ".includes(sys)) continue;
@@ -13317,14 +13533,43 @@ function buildGeometry(rover, base, basePos, ephemerides, timeMs, maskRad, tropo
       satB.z - basePos[2]
     ) / C_LIGHT;
     const [bx, by, bz] = sagnac(satB, travelB);
-    const rhoB = Math.hypot(bx - basePos[0], by - basePos[1], bz - basePos[2]);
+    let rhoB = Math.hypot(bx - basePos[0], by - basePos[1], bz - basePos[2]);
     const elB = ecefToAzEl(basePos[0], basePos[1], basePos[2], bx, by, bz).el;
     if (elB < maskRad) continue;
+    const group = sys + mR.code;
+    let offR = null;
+    let roverDelta = ZERO_DELTA;
+    if (antenna) {
+      const antexFreq = antexFreqOfGroup(group);
+      if (antenna.base) {
+        const offB = antenna.model.rcvOffset(antenna.base.type, antexFreq);
+        if (offB) {
+          const inv = 1 / rhoB;
+          const losB = [
+            (bx - basePos[0]) * inv,
+            (by - basePos[1]) * inv,
+            (bz - basePos[2]) * inv
+          ];
+          rhoB += rcvAntennaRangeM(
+            offB,
+            losB,
+            baseLatRad,
+            baseLonRad,
+            elB,
+            antenna.base.deltaEnu
+          );
+        }
+      }
+      if (antenna.rover) {
+        offR = antenna.model.rcvOffset(antenna.rover.type, antexFreq);
+        roverDelta = antenna.rover.deltaEnu ?? ZERO_DELTA;
+      }
+    }
     const gloK = sys === "R" ? mR.gloChannel ?? mB.gloChannel ?? eph.freqNum ?? null : null;
     const freq = carrierFreqHz(sys, mR.code, gloK);
     out.push({
       prn,
-      group: sys + mR.code,
+      group,
       lambda: freq > 0 ? C_LIGHT / freq : 0,
       satR,
       rhoB,
@@ -13335,7 +13580,9 @@ function buildGeometry(rover, base, basePos, ephemerides, timeMs, maskRad, tropo
       cpR: mR.cp ?? null,
       cpB: mB.cp ?? null,
       lockR: mR.lockTimeMs,
-      lockB: mB.lockTimeMs
+      lockB: mB.lockTimeMs,
+      offR,
+      roverDelta
     });
   }
   return out;
@@ -13343,17 +13590,29 @@ function buildGeometry(rover, base, basePos, ephemerides, timeMs, maskRad, tropo
 function roverTerms(g, x, y, z, troposphere) {
   const travel = Math.hypot(g.satR.x - x, g.satR.y - y, g.satR.z - z) / C_LIGHT;
   const [sx, sy, sz] = sagnac(g.satR, travel);
-  const rho = Math.hypot(sx - x, sy - y, sz - z);
+  let rho = Math.hypot(sx - x, sy - y, sz - z);
   const u = [
     (x - sx) / rho,
     (y - sy) / rho,
     (z - sz) / rho
   ];
+  const needEl = troposphere || g.offR != null;
+  const elR = needEl ? ecefToAzEl(x, y, z, sx, sy, sz).el : 0;
   let dTropo = 0;
   if (troposphere) {
-    const elR = ecefToAzEl(x, y, z, sx, sy, sz).el;
     dTropo = tropoDelay(Math.max(elR, 0.05)) - g.tropoB;
   }
+  if (g.offR) {
+    const [latDeg, lonDeg] = ecefToGeodetic(x, y, z);
+    rho += rcvAntennaRangeM(
+      g.offR,
+      [-u[0], -u[1], -u[2]],
+      latDeg * Math.PI / 180,
+      lonDeg * Math.PI / 180,
+      elR,
+      g.roverDelta
+    );
+  }
   return { rho, u, dTropo };
 }
 function sdVariance(sigmaM, elRad) {
@@ -13592,7 +13851,8 @@ var RtkFloatEngine = class {
       arElevationMaskDeg: opts.arElevationMaskDeg ?? 0,
       glonassAr: opts.glonassAr ?? false,
       partialFixing: opts.partialFixing ?? true,
-      minFixAmbiguities: opts.minFixAmbiguities ?? 4
+      minFixAmbiguities: opts.minFixAmbiguities ?? 4,
+      antenna: opts.antenna ?? null
     };
   }
   /** Clear all filter state (position, ambiguities, lock history). */
@@ -13715,7 +13975,8 @@ var RtkFloatEngine = class {
       this.ephemerides,
       timeMs,
       o.elevationMaskDeg * Math.PI / 180,
-      o.troposphere
+      o.troposphere,
+      o.antenna
     );
     const byPrn = new Map(geom.map((g) => [g.prn, g]));
     const dtS = this.lastMs !== null ? (timeMs - this.lastMs) / 1e3 : 0;
@@ -14315,6 +14576,10 @@ var SbasProcessor = class {
   tlat = 0;
   degr = null;
   mt27 = null;
+  /** MT28 clock-ephemeris covariance per PRN: the upper-triangular Cholesky
+   *  factor E (10 elements [E11,E22,E33,E44,E12,E13,E14,E23,E24,E34]) and its
+   *  scale exponent. Keyed by PRN; cleared on a mask change. */
+  mt28 = /* @__PURE__ */ new Map();
   ion = [];
   /** GEO PRN(s) whose messages have been ingested. */
   geoPrns = /* @__PURE__ */ new Set();
@@ -14345,6 +14610,8 @@ var SbasProcessor = class {
         return this.decodeMt10(msg) ? type : -1;
       case 27:
         return this.decodeMt27(msg) ? type : -1;
+      case 28:
+        return this.decodeMt28(msg) ? type : -1;
       case 18:
         return this.decodeIgpMask(msg) ? type : -1;
       case 24:
@@ -14371,6 +14638,7 @@ var SbasProcessor = class {
       return true;
     this.iodp = iodp;
     this.sats = prns.map((prn) => ({ prn }));
+    this.mt28.clear();
     this.satIdx.clear();
     this.sats.forEach((s, k) => {
       if (s.prn) this.satIdx.set(s.prn, k);
@@ -14436,7 +14704,9 @@ var SbasProcessor = class {
       iiono: u(117, 9) || 1,
       cionoRamp: u(126, 10) * 5e-6,
       rssUdre: u(136, 1) === 1,
-      rssIono: u(137, 1) === 1
+      rssIono: u(137, 1) === 1,
+      ccovariance: u(138, 7) * 0.1
+      // Table B-49: 0..12.7 m, 0.1 m
     };
     return true;
   }
@@ -14488,6 +14758,51 @@ var SbasProcessor = class {
     }
     return best ?? DELTA_UDRE[s.udreOutside] ?? 1;
   }
+  /** MT28 clock-ephemeris covariance (ICAO Annex 10 Vol I §3.5.4.7 / Table B-51):
+   *  two satellites per message, each an upper-triangular Cholesky factor E and a
+   *  scale exponent that together define the relative clock-ephemeris covariance
+   *  used for a geometry-dependent δUDRE (§3.5.5.6.2.5). Slots are indexed into
+   *  the current MT1 mask, so a mismatched IODP is dropped. */
+  decodeMt28(msg) {
+    if (this.iodp !== getBitU(msg, 14, 2)) return false;
+    for (const base of [16, 121]) {
+      const slot = getBitU(msg, base, 6);
+      const prn = this.sats[slot]?.prn;
+      const scaleExp = getBitU(msg, base + 6, 3);
+      const e = [
+        getBitU(msg, base + 9, 9),
+        getBitU(msg, base + 18, 9),
+        getBitU(msg, base + 27, 9),
+        getBitU(msg, base + 36, 9),
+        getBitS(msg, base + 45, 10),
+        getBitS(msg, base + 55, 10),
+        getBitS(msg, base + 65, 10),
+        getBitS(msg, base + 75, 10),
+        getBitS(msg, base + 85, 10),
+        getBitS(msg, base + 95, 10)
+      ];
+      if (prn && e.some((v) => v !== 0)) this.mt28.set(prn, { scaleExp, e });
+    }
+    return true;
+  }
+  /** Geometry-dependent δUDRE multiplier from MT28 (§3.5.5.6.2.5):
+   *  δUDRE = √(Iᵀ·C·I) + ε_c, with C = Rᵀ·R, R = E·2^(scaleExp−5),
+   *  I = [î_user→sat, 1], ε_c = C_covariance·2^(scaleExp−5). Since C = RᵀR,
+   *  Iᵀ·C·I = ‖R·I‖², so we form R·I directly. Null when no MT28 for `prn`. */
+  mt28DeltaUdre(prn, los) {
+    const m = this.mt28.get(prn);
+    if (!m) return null;
+    const sf = 2 ** (m.scaleExp - 5);
+    const [e11, e22, e33, e44, e12, e13, e14, e23, e24, e34] = m.e;
+    const [ix, iy, iz] = los;
+    const v0 = (e11 * ix + e12 * iy + e13 * iz + e14) * sf;
+    const v1 = (e22 * iy + e23 * iz + e24) * sf;
+    const v2 = (e33 * iz + e34) * sf;
+    const v3 = e44 * sf;
+    const iCi = v0 * v0 + v1 * v1 + v2 * v2 + v3 * v3;
+    const ec = (this.degr?.ccovariance ?? 0) * sf;
+    return Math.sqrt(iCi) + ec;
+  }
   decodeMixed(msg, week, tow) {
     if (this.iodp !== getBitU(msg, 110, 2)) return false;
     const blk = getBitU(msg, 112, 2);
@@ -14692,7 +15007,7 @@ var SbasProcessor = class {
    * no valid (unexpired) long-term + fast correction is available. Add `dPos`
    * to the satellite ECEF position and `dClkS` to its clock bias.
    */
-  satCorrection(prn, week, tow, userLatRad, userLonRad) {
+  satCorrection(prn, week, tow, userLatRad, userLonRad, losUnitEcef) {
     const idx = this.satIdx.get(prn);
     if (idx === void 0) return null;
     const s = this.sats[idx];
@@ -14714,7 +15029,8 @@ var SbasProcessor = class {
     const tf = now - s.fcorr.t0s + this.tlat;
     if (Math.abs(tf) > MAXSBSAGEF || s.fcorr.udre >= 15) return null;
     const prc = s.fcorr.prc;
-    const dudre = userLatRad != null && userLonRad != null ? this.deltaUdre(
+    const mt28 = losUnitEcef ? this.mt28DeltaUdre(prn, losUnitEcef) : null;
+    const dudre = mt28 != null ? mt28 : userLatRad != null && userLonRad != null ? this.deltaUdre(
       userLatRad * 180 / Math.PI,
       userLonRad * 180 / Math.PI
     ) : 1;
@@ -14843,14 +15159,14 @@ var SbasProcessor = class {
 };
 
 // src/positioning/ssr-apply.ts
-var cross = (a, b) => [
+var cross2 = (a, b) => [
   a[1] * b[2] - a[2] * b[1],
   a[2] * b[0] - a[0] * b[2],
   a[0] * b[1] - a[1] * b[0]
 ];
-var norm = (a) => Math.hypot(a[0], a[1], a[2]);
+var norm2 = (a) => Math.hypot(a[0], a[1], a[2]);
 var unit = (a) => {
-  const n = norm(a);
+  const n = norm2(a);
   return n > 0 ? [a[0] / n, a[1] / n, a[2] / n] : [0, 0, 0];
 };
 function applyOrbitClock(eph, corr, timeMs) {
@@ -14864,8 +15180,8 @@ function applyOrbitClock(eph, corr, timeMs) {
   const p = [s.x, s.y, s.z];
   const v = [s.vx, s.vy, s.vz];
   const er = unit(p);
-  const en = unit(cross(p, v));
-  const ea = cross(en, er);
+  const en = unit(cross2(p, v));
+  const ea = cross2(en, er);
   const dr = corr.radial + (corr.dotRadial ?? 0) * age;
   const da = corr.along + (corr.dotAlong ?? 0) * age;
   const dc = corr.cross + (corr.dotCross ?? 0) * age;
@@ -15075,170 +15391,6 @@ function solidEarthTide(rcv, sun, moon) {
   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 cross2(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 norm2(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 = norm2([-satEcef[0], -satEcef[1], -satEcef[2]]);
-  const eSun = norm2([
-    sunEcef2[0] - satEcef[0],
-    sunEcef2[1] - satEcef[1],
-    sunEcef2[2] - satEcef[2]
-  ]);
-  const y = norm2(cross2(z, eSun));
-  const x = norm2(cross2(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 = cross2(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 = cross2(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 = cross2(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);
@@ -16598,7 +16750,10 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
       used.push(prn);
       azels.push(azel);
       if (sbas) {
-        const sc = sbas.satCorrection(prn, gpsWeek, gpsTow, rxLat, rxLon);
+        const dx = sat.x - x, dy = sat.y - y, dz = sat.z - z;
+        const dr = Math.hypot(dx, dy, dz) || 1;
+        const los = [dx / dr, dy / dr, dz / dr];
+        const sc = sbas.satCorrection(prn, gpsWeek, gpsTow, rxLat, rxLon, los);
         const si = sbas.ionoDelay(
           gpsWeek,
           gpsTow,
@@ -18989,6 +19144,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   almanacEpochMs,
   almanacSatPosition,
   analyzeQuality,
+  antexFreqOfGroup,
   applyHelmert,
   applyIonoDcb,
   applyOrbitClock,
@@ -19000,6 +19156,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   buildGloChannelMap,
   buildObsIndices,
   buildPppAntenna,
+  buildRtkAntenna,
   clampUnit,
   clkBias,
   computeAllPositions,
@@ -19182,6 +19339,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   postProcessRtk,
   rad2deg,
   rangeRate,
+  rcvAntennaRangeM,
   readString,
   reportDecodeError,
   resetGloFreqCache,