gnss-js 1.47.0 → 1.49.0

package/dist/{chunk-ROVSSEGZ.js → chunk-2IM5JYKP.js}

@@ -1,6 +1,6 @@
 import {
   decodeSbasGeoNav
-} from "./chunk-ZIGMN3E5.js";
+} from "./chunk-WQX354KD.js";
 import {
   CnavAssembler,
   cnavCrcOk

package/dist/{chunk-EQNC24OB.js → chunk-DEVUKH6A.js}

@@ -9,7 +9,7 @@ import {
 import {
   decodeSbasGeoNav,
   sbasCrcOk
-} from "./chunk-ZIGMN3E5.js";
+} from "./chunk-WQX354KD.js";
 import {
   CnavAssembler,
   cnavCrcOk
@@ -292,6 +292,7 @@ function parseUbxRawNav(data, opts = {}) {
         continue;
       }
       if (refWeek === 0) continue;
+      opts.onSbasMessage?.(msg, svId, refWeek, refTow);
       const eph = decodeSbasGeoNav(msg, svId, refWeek, refTow);
       if (eph) {
         const key = `${eph.prn}@${eph.tocDate.getTime()}`;

package/dist/{chunk-75OYCNTY.js → chunk-DWLVCXA6.js}

@@ -1,3 +1,6 @@
+import {
+  sbasMessageType
+} from "./chunk-WQX354KD.js";
 import {
   computeDop,
   computeSatPosition,
@@ -13,6 +16,10 @@ import {
   clkBias,
   sp3Position
 } from "./chunk-GPEP67TG.js";
+import {
+  getBitS,
+  getBitU
+} from "./chunk-V2D5KUKH.js";
 import {
   C_LIGHT,
   OMEGA_E
@@ -45,8 +52,8 @@ function klobucharDelay(coeffs, latRad, lonRad, azRad, elRad, gpsTowSec) {
   const F = 1 + 16 * Math.pow(0.53 - E, 3);
   const x = 2 * Math.PI * (t - 50400) / per;
   if (Math.abs(x) >= 1.57) return F * 5e-9;
-  const x2 = x * x;
-  return F * (5e-9 + amp * (1 - x2 / 2 + x2 * x2 / 24));
+  const x22 = x * x;
+  return F * (5e-9 + amp * (1 - x22 / 2 + x22 * x22 / 24));
 }
 
 // src/positioning/gim.ts
@@ -1198,6 +1205,492 @@ function postProcessRtk(base, rover, ephemerides, baseEcef, opts = {}) {
   return { track, solved, unmatched, fixRate: solved ? fixed / solved : 0 };
 }
 
+// src/positioning/sbas.ts
+var P2_11 = 2 ** -11;
+var P2_31 = 2 ** -31;
+var P2_39 = 2 ** -39;
+var D2R = Math.PI / 180;
+var R2D = 180 / Math.PI;
+var SEC_PER_WEEK = 604800;
+var MAXSBSAGEF = 30;
+var MAXSBSAGEL = 1800;
+var MAXBAND = 10;
+var two = (n) => String(n).padStart(2, "0");
+var VAR_FCORR = [
+  0.052,
+  0.0924,
+  0.1444,
+  0.283,
+  0.4678,
+  0.8315,
+  1.2992,
+  1.8709,
+  2.5465,
+  3.326,
+  5.1968,
+  20.787,
+  230.9661,
+  2078.695
+];
+var varfcorr = (udre) => udre > 0 && udre <= 14 ? VAR_FCORR[udre - 1] : 0;
+var VAR_ICORR = [
+  84e-4,
+  0.0333,
+  0.0749,
+  0.1331,
+  0.2079,
+  0.2994,
+  0.4075,
+  0.5322,
+  0.6735,
+  0.8315,
+  1.1974,
+  1.8709,
+  3.326,
+  20.787,
+  187.0826
+];
+var varicorr = (give) => give > 0 && give <= 15 ? VAR_ICORR[give - 1] : 0;
+var DEGF = [
+  0,
+  5e-5,
+  9e-5,
+  12e-5,
+  15e-5,
+  2e-4,
+  3e-4,
+  45e-5,
+  6e-4,
+  9e-4,
+  15e-4,
+  21e-4,
+  27e-4,
+  33e-4,
+  46e-4,
+  58e-4
+];
+var degfcorr = (ai) => ai > 0 && ai <= 15 ? DEGF[ai] : 58e-4;
+var x1 = [-75, -65, -55, -50, -45, -40, -35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 65, 75, 85];
+var x2 = [-55, -50, -45, -40, -35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55];
+var x3 = [-75, -65, -55, -50, -45, -40, -35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 65, 75];
+var x4 = [-85, -75, -65, -55, -50, -45, -40, -35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 65, 75];
+var x5 = [-180, -175, -170, -165, -160, -155, -150, -145, -140, -135, -130, -125, -120, -115, -110, -105, -100, -95, -90, -85, -80, -75, -70, -65, -60, -55, -50, -45, -40, -35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175];
+var x6 = [-180, -170, -160, -150, -140, -130, -120, -110, -100, -90, -80, -70, -60, -50, -40, -30, -20, -10, 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170];
+var x7 = [-180, -150, -120, -90, -60, -30, 0, 30, 60, 90, 120, 150];
+var x8 = [-170, -140, -110, -80, -50, -20, 10, 40, 70, 100, 130, 160];
+var igpband1 = [
+  [{ coord: -180, arr: x1, bits: 1, bite: 28 }, { coord: -175, arr: x2, bits: 29, bite: 51 }, { coord: -170, arr: x3, bits: 52, bite: 78 }, { coord: -165, arr: x2, bits: 79, bite: 101 }, { coord: -160, arr: x3, bits: 102, bite: 128 }, { coord: -155, arr: x2, bits: 129, bite: 151 }, { coord: -150, arr: x3, bits: 152, bite: 178 }, { coord: -145, arr: x2, bits: 179, bite: 201 }],
+  [{ coord: -140, arr: x4, bits: 1, bite: 28 }, { coord: -135, arr: x2, bits: 29, bite: 51 }, { coord: -130, arr: x3, bits: 52, bite: 78 }, { coord: -125, arr: x2, bits: 79, bite: 101 }, { coord: -120, arr: x3, bits: 102, bite: 128 }, { coord: -115, arr: x2, bits: 129, bite: 151 }, { coord: -110, arr: x3, bits: 152, bite: 178 }, { coord: -105, arr: x2, bits: 179, bite: 201 }],
+  [{ coord: -100, arr: x3, bits: 1, bite: 27 }, { coord: -95, arr: x2, bits: 28, bite: 50 }, { coord: -90, arr: x1, bits: 51, bite: 78 }, { coord: -85, arr: x2, bits: 79, bite: 101 }, { coord: -80, arr: x3, bits: 102, bite: 128 }, { coord: -75, arr: x2, bits: 129, bite: 151 }, { coord: -70, arr: x3, bits: 152, bite: 178 }, { coord: -65, arr: x2, bits: 179, bite: 201 }],
+  [{ coord: -60, arr: x3, bits: 1, bite: 27 }, { coord: -55, arr: x2, bits: 28, bite: 50 }, { coord: -50, arr: x4, bits: 51, bite: 78 }, { coord: -45, arr: x2, bits: 79, bite: 101 }, { coord: -40, arr: x3, bits: 102, bite: 128 }, { coord: -35, arr: x2, bits: 129, bite: 151 }, { coord: -30, arr: x3, bits: 152, bite: 178 }, { coord: -25, arr: x2, bits: 179, bite: 201 }],
+  [{ coord: -20, arr: x3, bits: 1, bite: 27 }, { coord: -15, arr: x2, bits: 28, bite: 50 }, { coord: -10, arr: x3, bits: 51, bite: 77 }, { coord: -5, arr: x2, bits: 78, bite: 100 }, { coord: 0, arr: x1, bits: 101, bite: 128 }, { coord: 5, arr: x2, bits: 129, bite: 151 }, { coord: 10, arr: x3, bits: 152, bite: 178 }, { coord: 15, arr: x2, bits: 179, bite: 201 }],
+  [{ coord: 20, arr: x3, bits: 1, bite: 27 }, { coord: 25, arr: x2, bits: 28, bite: 50 }, { coord: 30, arr: x3, bits: 51, bite: 77 }, { coord: 35, arr: x2, bits: 78, bite: 100 }, { coord: 40, arr: x4, bits: 101, bite: 128 }, { coord: 45, arr: x2, bits: 129, bite: 151 }, { coord: 50, arr: x3, bits: 152, bite: 178 }, { coord: 55, arr: x2, bits: 179, bite: 201 }],
+  [{ coord: 60, arr: x3, bits: 1, bite: 27 }, { coord: 65, arr: x2, bits: 28, bite: 50 }, { coord: 70, arr: x3, bits: 51, bite: 77 }, { coord: 75, arr: x2, bits: 78, bite: 100 }, { coord: 80, arr: x3, bits: 101, bite: 127 }, { coord: 85, arr: x2, bits: 128, bite: 150 }, { coord: 90, arr: x1, bits: 151, bite: 178 }, { coord: 95, arr: x2, bits: 179, bite: 201 }],
+  [{ coord: 100, arr: x3, bits: 1, bite: 27 }, { coord: 105, arr: x2, bits: 28, bite: 50 }, { coord: 110, arr: x3, bits: 51, bite: 77 }, { coord: 115, arr: x2, bits: 78, bite: 100 }, { coord: 120, arr: x3, bits: 101, bite: 127 }, { coord: 125, arr: x2, bits: 128, bite: 150 }, { coord: 130, arr: x4, bits: 151, bite: 178 }, { coord: 135, arr: x2, bits: 179, bite: 201 }],
+  [{ coord: 140, arr: x3, bits: 1, bite: 27 }, { coord: 145, arr: x2, bits: 28, bite: 50 }, { coord: 150, arr: x3, bits: 51, bite: 77 }, { coord: 155, arr: x2, bits: 78, bite: 100 }, { coord: 160, arr: x3, bits: 101, bite: 127 }, { coord: 165, arr: x2, bits: 128, bite: 150 }, { coord: 170, arr: x3, bits: 151, bite: 177 }, { coord: 175, arr: x2, bits: 178, bite: 200 }]
+];
+var igpband2 = [
+  [{ coord: 60, arr: x5, bits: 1, bite: 72 }, { coord: 65, arr: x6, bits: 73, bite: 108 }, { coord: 70, arr: x6, bits: 109, bite: 144 }, { coord: 75, arr: x6, bits: 145, bite: 180 }, { coord: 85, arr: x7, bits: 181, bite: 192 }],
+  [{ coord: -60, arr: x5, bits: 1, bite: 72 }, { coord: -65, arr: x6, bits: 73, bite: 108 }, { coord: -70, arr: x6, bits: 109, bite: 144 }, { coord: -75, arr: x6, bits: 145, bite: 180 }, { coord: -85, arr: x8, bits: 181, bite: 192 }]
+];
+var gpsSeconds = (week, tow) => week * SEC_PER_WEEK + tow;
+function maskPrn(i) {
+  if (i >= 1 && i <= 37) return `G${two(i)}`;
+  if (i >= 38 && i <= 61) return `R${two(i - 37)}`;
+  if (i >= 120 && i <= 138) return `S${two(i - 100)}`;
+  if (i >= 193 && i <= 202) return `J${two(i - 192)}`;
+  return null;
+}
+function ionppp(latRad, lonRad, azRad, elRad, re, hion) {
+  const rp = re / (re + hion) * Math.cos(elRad);
+  const ap = Math.PI / 2 - elRad - Math.asin(rp);
+  const sinap = Math.sin(ap);
+  const tanap = Math.tan(ap);
+  const cosaz = Math.cos(azRad);
+  const latP = Math.asin(
+    Math.sin(latRad) * Math.cos(ap) + Math.cos(latRad) * sinap * cosaz
+  );
+  let lonP;
+  if (latRad > 70 * D2R && tanap * cosaz > Math.tan(Math.PI / 2 - latRad) || latRad < -70 * D2R && -tanap * cosaz > Math.tan(Math.PI / 2 + latRad)) {
+    lonP = lonRad + Math.PI - Math.asin(sinap * Math.sin(azRad) / Math.cos(latP));
+  } else {
+    lonP = lonRad + Math.asin(sinap * Math.sin(azRad) / Math.cos(latP));
+  }
+  return { fp: 1 / Math.sqrt(1 - rp * rp), latP, lonP };
+}
+var SbasProcessor = class {
+  sats = [];
+  satIdx = /* @__PURE__ */ new Map();
+  iodp = -1;
+  tlat = 0;
+  ion = [];
+  /** GEO PRN(s) whose messages have been ingested. */
+  geoPrns = /* @__PURE__ */ new Set();
+  /**
+   * Ingest one decoded SBAS L1 message (250-bit, MSB-first) received at the
+   * given GPS week / time-of-week. Returns the message type, or -1 if it was
+   * not a recognised/applicable correction message.
+   */
+  update(msg, week, tow, geoPrn) {
+    if (week === 0) return -1;
+    const type = sbasMessageType(msg);
+    if (geoPrn != null && geoPrn >= 120 && geoPrn <= 158)
+      this.geoPrns.add(`S${two(geoPrn - 100)}`);
+    switch (type) {
+      case 1:
+        return this.decodeMask(msg) ? type : -1;
+      case 0:
+      case 2:
+      case 3:
+      case 4:
+      case 5:
+        return this.decodeFast(msg, type, week, tow) ? type : -1;
+      case 6:
+        return this.decodeIntegrity(msg) ? type : -1;
+      case 7:
+        return this.decodeDegradation(msg) ? type : -1;
+      case 18:
+        return this.decodeIgpMask(msg) ? type : -1;
+      case 24:
+        return this.decodeMixed(msg, week, tow) ? type : -1;
+      case 25:
+        return this.decodeLongCorrHalf(msg, 14, week, tow) && this.decodeLongCorrHalf(msg, 120, week, tow) ? type : -1;
+      case 26:
+        return this.decodeIgpDelay(msg, week, tow) ? type : -1;
+      case 9:
+      // GEO nav — handled by decodeSbasGeoNav elsewhere
+      case 63:
+        return type;
+      default:
+        return -1;
+    }
+  }
+  decodeMask(msg) {
+    const sats = [];
+    for (let i = 1; i <= 210; i++) {
+      if (getBitU(msg, 13 + i, 1)) sats.push({ prn: maskPrn(i) });
+    }
+    this.iodp = getBitU(msg, 224, 2);
+    this.sats = sats;
+    this.satIdx.clear();
+    sats.forEach((s, k) => {
+      if (s.prn) this.satIdx.set(s.prn, k);
+    });
+    return true;
+  }
+  decodeFast(msg, type, week, tow) {
+    if (this.iodp !== getBitU(msg, 16, 2)) return false;
+    const iodf = getBitU(msg, 14, 2);
+    const t0s = gpsSeconds(week, tow);
+    for (let i = 0; i < 13; i++) {
+      const j = 13 * ((type === 0 ? 2 : type) - 2) + i;
+      if (j >= this.sats.length) break;
+      const udre = getBitU(msg, 174 + 4 * i, 4);
+      const prc = getBitS(msg, 18 + i * 12, 12) * 0.125;
+      const prev = this.sats[j].fcorr;
+      this.sats[j].fcorr = {
+        prc,
+        udre: udre + 1,
+        ai: prev?.ai ?? 0,
+        iodf,
+        t0s
+      };
+    }
+    return true;
+  }
+  decodeIntegrity(msg) {
+    const iodf = [0, 1, 2, 3].map((i) => getBitU(msg, 14 + i * 2, 2));
+    for (let i = 0; i < this.sats.length; i++) {
+      const f = this.sats[i].fcorr;
+      if (!f || f.iodf !== iodf[Math.floor(i / 13)]) continue;
+      f.udre = getBitU(msg, 22 + i * 4, 4) + 1;
+    }
+    return true;
+  }
+  decodeDegradation(msg) {
+    if (this.iodp !== getBitU(msg, 18, 2)) return false;
+    this.tlat = getBitU(msg, 14, 4);
+    for (let i = 0; i < this.sats.length; i++) {
+      const ai = getBitU(msg, 22 + i * 4, 4);
+      if (this.sats[i].fcorr) this.sats[i].fcorr.ai = ai;
+      else this.sats[i].fcorr = { prc: 0, udre: 0, ai, iodf: -1, t0s: 0 };
+    }
+    return true;
+  }
+  decodeMixed(msg, week, tow) {
+    if (this.iodp !== getBitU(msg, 110, 2)) return false;
+    const blk = getBitU(msg, 112, 2);
+    const iodf = getBitU(msg, 114, 2);
+    const t0s = gpsSeconds(week, tow);
+    for (let i = 0; i < 6; i++) {
+      const j = 13 * blk + i;
+      if (j >= this.sats.length) break;
+      const udre = getBitU(msg, 86 + 4 * i, 4);
+      const prc = getBitS(msg, 14 + i * 12, 12) * 0.125;
+      const prev = this.sats[j].fcorr;
+      this.sats[j].fcorr = {
+        prc,
+        udre: udre + 1,
+        ai: prev?.ai ?? 0,
+        iodf,
+        t0s
+      };
+    }
+    return this.decodeLongCorrHalf(msg, 120, week, tow);
+  }
+  decodeLongCorrHalf(msg, p, week, tow) {
+    if (getBitU(msg, p, 1) === 0) {
+      if (this.iodp === getBitU(msg, p + 103, 2)) {
+        const a = this.decodeLong0(msg, p + 1, week, tow);
+        const b = this.decodeLong0(msg, p + 52, week, tow);
+        return a || b;
+      }
+    } else if (this.iodp === getBitU(msg, p + 104, 2)) {
+      return this.decodeLong1(msg, p + 1, week, tow);
+    }
+    return false;
+  }
+  decodeLong0(msg, p, week, tow) {
+    const n = getBitU(msg, p, 6);
+    if (n === 0 || n > this.sats.length) return false;
+    this.sats[n - 1].lcorr = {
+      iode: getBitU(msg, p + 6, 8),
+      dpos: [
+        getBitS(msg, p + 14, 9) * 0.125,
+        getBitS(msg, p + 23, 9) * 0.125,
+        getBitS(msg, p + 32, 9) * 0.125
+      ],
+      dvel: [0, 0, 0],
+      daf0: getBitS(msg, p + 41, 10) * P2_31,
+      daf1: 0,
+      t0s: gpsSeconds(week, tow)
+    };
+    return true;
+  }
+  decodeLong1(msg, p, week, tow) {
+    const n = getBitU(msg, p, 6);
+    if (n === 0 || n > this.sats.length) return false;
+    let t = getBitU(msg, p + 90, 13) * 16 - tow % 86400;
+    if (t <= -43200) t += 86400;
+    else if (t > 43200) t -= 86400;
+    this.sats[n - 1].lcorr = {
+      iode: getBitU(msg, p + 6, 8),
+      dpos: [
+        getBitS(msg, p + 14, 11) * 0.125,
+        getBitS(msg, p + 25, 11) * 0.125,
+        getBitS(msg, p + 36, 11) * 0.125
+      ],
+      dvel: [
+        getBitS(msg, p + 58, 8) * P2_11,
+        getBitS(msg, p + 66, 8) * P2_11,
+        getBitS(msg, p + 74, 8) * P2_11
+      ],
+      daf0: getBitS(msg, p + 47, 11) * P2_31,
+      daf1: getBitS(msg, p + 82, 8) * P2_39,
+      t0s: gpsSeconds(week, tow + t)
+    };
+    return true;
+  }
+  decodeIgpMask(msg) {
+    const band = getBitU(msg, 18, 4);
+    let p;
+    let m;
+    if (band <= 8) {
+      p = igpband1[band];
+      m = 8;
+    } else if (band <= 10) {
+      p = igpband2[band - 9];
+      m = 5;
+    } else return false;
+    const igp = [];
+    for (let i = 1; i <= 201; i++) {
+      if (!getBitU(msg, 23 + i, 1)) continue;
+      for (let j = 0; j < m; j++) {
+        const b = p[j];
+        if (i < b.bits || b.bite < i) continue;
+        const varying = b.arr[i - b.bits];
+        igp.push({
+          lat: band <= 8 ? varying : b.coord,
+          lon: band <= 8 ? b.coord : varying,
+          delay: 0,
+          give: 0,
+          t0s: 0
+        });
+        break;
+      }
+    }
+    this.ion[band] = { iodi: getBitU(msg, 22, 2), igp };
+    return true;
+  }
+  decodeIgpDelay(msg, week, tow) {
+    const band = getBitU(msg, 14, 4);
+    const b = this.ion[band];
+    if (band > MAXBAND || !b || b.iodi !== getBitU(msg, 217, 2)) return false;
+    const block = getBitU(msg, 18, 4);
+    const t0s = gpsSeconds(week, tow);
+    for (let i = 0; i < 15; i++) {
+      const j = block * 15 + i;
+      if (j >= b.igp.length) continue;
+      const give = getBitU(msg, 22 + i * 13 + 9, 4);
+      const delay = getBitU(msg, 22 + i * 13, 9);
+      b.igp[j].delay = delay === 511 ? 0 : delay * 0.125;
+      b.igp[j].give = give + 1 >= 16 ? 0 : give + 1;
+      b.igp[j].t0s = t0s;
+    }
+    return true;
+  }
+  /** PRNs currently in the correction mask (in mask order). */
+  activeSats() {
+    return this.sats.map((s) => s.prn).filter((p) => !!p);
+  }
+  /** Number of ionospheric grid points with a valid delay across all bands. */
+  ionoGridPoints() {
+    let n = 0;
+    for (const b of this.ion) if (b) {
+      for (const g of b.igp) if (g.give > 0) n++;
+    }
+    return n;
+  }
+  /**
+   * Satellite range/clock correction for a PRN at a GPS week/tow, or null if
+   * 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) {
+    const idx = this.satIdx.get(prn);
+    if (idx === void 0) return null;
+    const s = this.sats[idx];
+    const now = gpsSeconds(week, tow);
+    const drs = [0, 0, 0];
+    let dclk = 0;
+    let iode = -1;
+    if (s.lcorr && s.lcorr.t0s !== 0) {
+      const t = now - s.lcorr.t0s;
+      if (Math.abs(t) > MAXSBSAGEL) return null;
+      for (let i = 0; i < 3; i++)
+        drs[i] = s.lcorr.dpos[i] + s.lcorr.dvel[i] * t;
+      dclk = s.lcorr.daf0 + s.lcorr.daf1 * t;
+      iode = s.lcorr.iode;
+    } else if (prn[0] !== "S") {
+      return null;
+    }
+    if (!s.fcorr || s.fcorr.t0s === 0) return null;
+    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 varM2 = varfcorr(s.fcorr.udre) + degfcorr(s.fcorr.ai) * tf * tf / 2;
+    return { dPos: drs, dClkS: dclk + prc / C_LIGHT, prcM: prc, varM2, iode };
+  }
+  /**
+   * Slant L1 ionospheric delay (m) at the pierce point for a receiver geodetic
+   * position (lat/lon rad, height m) and a satellite az/el (rad), interpolated
+   * from the SBAS grid — or null if the pierce point isn't covered. RTKLIB
+   * `sbsioncorr`.
+   */
+  ionoDelay(week, tow, latRad, lonRad, heightM, azRad, elRad) {
+    if (heightM < -100 || elRad <= 0) return { delayM: 0, varM2: 0 };
+    const { fp, latP, lonP } = ionppp(
+      latRad,
+      lonRad,
+      azRad,
+      elRad,
+      6378.1363,
+      350
+    );
+    const igp = this.searchIgp(latP, lonP);
+    if (!igp) return null;
+    const { pts, x, y } = igp;
+    const w = [0, 0, 0, 0];
+    if (pts[0] && pts[1] && pts[2] && pts[3]) {
+      w[0] = (1 - x) * (1 - y);
+      w[1] = (1 - x) * y;
+      w[2] = x * (1 - y);
+      w[3] = x * y;
+    } else if (pts[0] && pts[1] && pts[2]) {
+      w[1] = y;
+      w[2] = x;
+      w[0] = 1 - w[1] - w[2];
+      if (w[0] < 0) return null;
+    } else if (pts[0] && pts[2] && pts[3]) {
+      w[0] = 1 - x;
+      w[3] = y;
+      w[2] = 1 - w[0] - w[3];
+      if (w[2] < 0) return null;
+    } else if (pts[0] && pts[1] && pts[3]) {
+      w[0] = 1 - y;
+      w[3] = x;
+      w[1] = 1 - w[0] - w[3];
+      if (w[1] < 0) return null;
+    } else if (pts[1] && pts[2] && pts[3]) {
+      w[1] = 1 - x;
+      w[2] = 1 - y;
+      w[3] = 1 - w[1] - w[2];
+      if (w[3] < 0) return null;
+    } else return null;
+    const now = gpsSeconds(week, tow);
+    let delay = 0;
+    let varM2 = 0;
+    for (let i = 0; i < 4; i++) {
+      const g = pts[i];
+      if (!g) continue;
+      delay += w[i] * g.delay;
+      varM2 += w[i] * varicorr(g.give) * 9e-8 * Math.abs(now - g.t0s);
+    }
+    return { delayM: delay * fp, varM2: varM2 * fp * fp };
+  }
+  /** Find the four IGPs bracketing a pierce point (RTKLIB `searchigp`). */
+  searchIgp(latP, lonP) {
+    const lat = latP * R2D;
+    let lon = lonP * R2D;
+    if (lon >= 180) lon -= 360;
+    const latp = [0, 0];
+    const lonp = [0, 0, 0, 0];
+    let x;
+    let y;
+    if (lat >= -55 && lat < 55) {
+      latp[0] = Math.floor(lat / 5) * 5;
+      latp[1] = latp[0] + 5;
+      lonp[0] = lonp[1] = Math.floor(lon / 5) * 5;
+      lonp[2] = lonp[3] = lonp[0] + 5;
+      x = (lon - lonp[0]) / 5;
+      y = (lat - latp[0]) / 5;
+    } else {
+      latp[0] = Math.floor((lat - 5) / 10) * 10 + 5;
+      latp[1] = latp[0] + 10;
+      lonp[0] = lonp[1] = Math.floor(lon / 10) * 10;
+      lonp[2] = lonp[3] = lonp[0] + 10;
+      x = (lon - lonp[0]) / 10;
+      y = (lat - latp[0]) / 10;
+      if (lat >= 75 && lat < 85) {
+        lonp[1] = Math.floor(lon / 90) * 90;
+        lonp[3] = lonp[1] + 90;
+      } else if (lat >= -85 && lat < -75) {
+        lonp[0] = Math.floor((lon - 50) / 90) * 90 + 40;
+        lonp[2] = lonp[0] + 90;
+      } else if (lat >= 85) {
+        for (let i = 0; i < 4; i++) lonp[i] = Math.floor(lon / 90) * 90;
+      } else if (lat < -85) {
+        for (let i = 0; i < 4; i++)
+          lonp[i] = Math.floor((lon - 50) / 90) * 90 + 40;
+      }
+    }
+    for (let i = 0; i < 4; i++) if (lonp[i] === 180) lonp[i] = -180;
+    const pts = [null, null, null, null];
+    for (const band of this.ion) {
+      if (!band) continue;
+      for (const g of band.igp) {
+        if (g.t0s === 0 || g.give <= 0) continue;
+        if (g.lat === latp[0] && g.lon === lonp[0]) pts[0] = g;
+        else if (g.lat === latp[1] && g.lon === lonp[1]) pts[1] = g;
+        else if (g.lat === latp[0] && g.lon === lonp[2]) pts[2] = g;
+        else if (g.lat === latp[1] && g.lon === lonp[3]) pts[3] = g;
+      }
+    }
+    if (!pts[0] && !pts[1] && !pts[2] && !pts[3]) return null;
+    return { pts, x, y };
+  }
+};
+
 // src/positioning/ppp-tropo.ts
 var HYD_AVG_A = [
   0.0012769934,
@@ -1722,11 +2215,13 @@ var IDX_Z = 2;
 var IDX_ZWD = 3;
 var NBASE = 4;
 var CLK_VAR = 1e10;
+var POS_VAR = 60 * 60;
 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 kinematic = opts.mode === "kinematic";
   const corrections = opts.corrections;
   const x = [
     opts.aprioriPos[0],
@@ -1822,6 +2317,15 @@ function solvePpp(epochs, sp3, opts) {
   let convergedStreak = 0;
   for (let ei = 0; ei < epochs.length; ei++) {
     const epoch = epochs[ei];
+    if (kinematic && ei > 0) {
+      for (const p of [IDX_X, IDX_Y, IDX_Z]) {
+        for (let j = 0; j < x.length; j++) {
+          P[p][j] = 0;
+          P[j][p] = 0;
+        }
+        P[p][p] = POS_VAR;
+      }
+    }
     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]];
@@ -2580,7 +3084,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
     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 x9 = 0;
     let y2 = 0;
     let z2 = 0;
     const clock2 = new Map(systems.map((s) => [s, 0]));
@@ -2596,8 +3100,8 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
       const Htv = new Array(dim).fill(0);
       let rows = 0;
       for (const k of Object.keys(residuals2)) delete residuals2[k];
-      const positionSaneIter = x2 * x2 + y2 * y2 + z2 * z2 > 1e12;
-      const [rxLat, rxLon, rxHgt] = positionSaneIter ? ecefToGeodetic(x2, y2, z2) : [0, 0, 0];
+      const positionSaneIter = x9 * x9 + y2 * y2 + z2 * z2 > 1e12;
+      const [rxLat, rxLon, rxHgt] = positionSaneIter ? ecefToGeodetic(x9, y2, z2) : [0, 0, 0];
       for (const prn of prns) {
         const psr = pseudoranges.get(prn);
         const eph = ephemerides.get(prn);
@@ -2609,10 +3113,10 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
         if (!Number.isFinite(sat.x)) continue;
         const isKepler = eph.system !== "R" && eph.system !== "S";
         const dts = dtsClock - (tgd && isKepler ? eph.tgd : 0);
-        const travel = Math.hypot(sat.x - x2, sat.y - y2, sat.z - z2) / C_LIGHT;
+        const travel = Math.hypot(sat.x - x9, sat.y - y2, sat.z - z2) / C_LIGHT;
         const [sx, sy, sz] = sagnac2(sat, travel);
-        const rho = Math.hypot(sx - x2, sy - y2, sz - z2);
-        const ux = (x2 - sx) / rho;
+        const rho = Math.hypot(sx - x9, sy - y2, sz - z2);
+        const ux = (x9 - sx) / rho;
         const uy = (y2 - sy) / rho;
         const uz = (z2 - sz) / rho;
         let elev = Math.PI / 2;
@@ -2620,7 +3124,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
         let weight = 1;
         const positionSane = positionSaneIter;
         if (positionSane) {
-          const azel = ecefToAzEl(x2, y2, z2, sx, sy, sz);
+          const azel = ecefToAzEl(x9, y2, z2, sx, sy, sz);
           elev = azel.el;
           azim = azel.az;
           if (iter >= 2 && elev < elevationMaskDeg * Math.PI / 180) continue;
@@ -2658,7 +3162,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
       if (rows < dim) return null;
       const dx = solveLinear(HtH, Htv);
       if (!dx) return null;
-      x2 += dx[0];
+      x9 += dx[0];
       y2 += dx[1];
       z2 += dx[2];
       for (const s of systems)
@@ -2668,7 +3172,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
         break;
       }
     }
-    return { x: x2, y: y2, z: z2, clock: clock2, residuals: residuals2, iterations: iterations2, converged: converged2 };
+    return { x: x9, y: y2, z: z2, clock: clock2, residuals: residuals2, iterations: iterations2, converged: converged2 };
   };
   const REJECT_THRESHOLD_M = 50;
   let candidates = all;
@@ -2730,6 +3234,7 @@ export {
   solveDgnss,
   RtkFloatEngine,
   postProcessRtk,
+  SbasProcessor,
   niellMapping,
   gmst,
   sunEcef,

package/dist/{chunk-ZIGMN3E5.js → chunk-WQX354KD.js}

@@ -50,6 +50,7 @@ function decodeSbasGeoNav(msg, prn, week, tow) {
 }
 
 export {
+  sbasMessageType,
   sbasCrcOk,
   decodeSbasGeoNav
 };

package/dist/{chunk-MEDAWNWM.js → chunk-XFPDTGSV.js}

@@ -11,7 +11,7 @@ import {
 import {
   decodeSbasGeoNav,
   sbasCrcOk
-} from "./chunk-ZIGMN3E5.js";
+} from "./chunk-WQX354KD.js";
 import {
   geodeticToEcef
 } from "./chunk-37QNKGTC.js";