gnss-js 2.1.0 → 2.3.0

package/dist/positioning.cjs

@@ -25,8 +25,10 @@ __export(positioning_exports, {
   RtkFloatEngine: () => RtkFloatEngine,
   SbasProcessor: () => SbasProcessor,
   Sp3EphemerisSource: () => Sp3EphemerisSource,
+  antexFreqOfGroup: () => antexFreqOfGroup,
   applyOrbitClock: () => applyOrbitClock,
   buildPppAntenna: () => buildPppAntenna,
+  buildRtkAntenna: () => buildRtkAntenna,
   createPppCorrections: () => createPppCorrections,
   estimateNarrowlaneFcb: () => estimateNarrowlaneFcb,
   estimateNetworkFcbs: () => estimateNetworkFcbs,
@@ -45,6 +47,7 @@ __export(positioning_exports, {
   niellMapping: () => niellMapping,
   nlWavelength: () => nlWavelength,
   postProcessRtk: () => postProcessRtk,
+  rcvAntennaRangeM: () => rcvAntennaRangeM,
   resolvePppAmbiguities: () => resolvePppAmbiguities,
   satClockCorrection: () => satClockCorrection,
   sbasIonoDeg: () => sbasIonoDeg,
@@ -759,6 +762,211 @@ function lambdaReduction(Q, n) {
   return Z;
 }
 
+// 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"],
@@ -824,8 +1032,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;
@@ -850,14 +1066,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,
@@ -868,7 +1113,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;
@@ -876,17 +1123,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) {
@@ -1125,7 +1384,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). */
@@ -1248,7 +1508,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;
@@ -2399,14 +2660,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) {
@@ -2420,8 +2681,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;
@@ -2703,170 +2964,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);
@@ -4265,8 +4362,10 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
   RtkFloatEngine,
   SbasProcessor,
   Sp3EphemerisSource,
+  antexFreqOfGroup,
   applyOrbitClock,
   buildPppAntenna,
+  buildRtkAntenna,
   createPppCorrections,
   estimateNarrowlaneFcb,
   estimateNetworkFcbs,
@@ -4285,6 +4384,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
   niellMapping,
   nlWavelength,
   postProcessRtk,
+  rcvAntennaRangeM,
   resolvePppAmbiguities,
   satClockCorrection,
   sbasIonoDeg,