gnss-js 1.15.0 → 1.17.0

package/dist/sbf.d.ts

@@ -1,5 +1,22 @@
 import { E as Ephemeris } from './nav-BAI1a9vK.js';
 
+/**
+ * Septentrio SBF framing shared by the measurement and navigation
+ * decoders: 0x24 0x40 sync, CRC16-CCITT (poly 0x1021, init 0) as U2,
+ * block ID U2 (number in bits 0..12, revision in 13..15), total length
+ * U2 (multiple of 4, includes the 8-byte header). The CRC covers block
+ * ID through payload end.
+ */
+declare function crc16(data: Uint8Array, start: number, end: number): number;
+/**
+ * Scan a byte stream for valid SBF frames and invoke `onBlock` for each
+ * one, passing the block number (revision bits stripped), the frame
+ * start offset and the total frame length. Frames with bad CRC are
+ * counted and a resync continues at the next byte; the count of bad
+ * frames is returned.
+ */
+declare function scanSbfFrames(data: Uint8Array, view: DataView, onBlock: (id: number, offset: number, len: number) => void): number;
+
 /**
  * Septentrio SBF decoded navigation and almanac blocks.
  *
@@ -134,6 +151,46 @@ interface SbfAlmanacResult {
  */
 declare function parseSbfAlmanac(data: Uint8Array): SbfAlmanacResult;
 
+/**
+ * Septentrio SBF decoded ionosphere / UTC blocks.
+ *
+ * GPSIon (5893) and BDSIon (4120) carry the eight Klobuchar vertical
+ * delay coefficients, GALIon (4030) the three NeQuick-G effective
+ * ionisation level coefficients, and GPSUtc (5894) the GPS-UTC
+ * parameters from LNAV subframe 4 page 18 (only ΔtLS, the current
+ * leap-second count, is extracted here).
+ *
+ * Units: SBF stores the coefficients as f4 floats already in the
+ * semicircle-based SI units of the broadcast messages — alpha_n in
+ * s/semicircle^n, beta_n in s/semicircle^n, ai_n in sfu/deg^n — which
+ * are exactly the units a RINEX nav header prints. Values are passed
+ * through unscaled, so the output matches what `parseNavFile` reads
+ * from a converted nav header to float32 precision.
+ *
+ * Ported from RTKLIB demo5 (rtklibexplorer), src/rcv/septentrio.c
+ * (decode_gpsion / decode_galion / decode_cmpion / decode_gpsutc),
+ * BSD-2-Clause, and cross-checked against the Septentrio mosaic-X5
+ * reference guide (which documents all four block layouts, including
+ * the do-not-use markers RTKLIB does not check).
+ */
+interface SbfIonoUtcResult {
+    /**
+     * Iono coefficient sets keyed like `NavHeader.ionoCorrections`:
+     * `GPSA`/`GPSB` (Klobuchar alpha/beta), `GAL` ([ai0, ai1, ai2],
+     * RINEX GAL header convention), `BDSA`/`BDSB`. The blocks repeat;
+     * the last valid block of each type in the stream wins.
+     */
+    ionoCorrections: Record<string, number[]>;
+    /** GPS-UTC ΔtLS from the last GPSUtc block, if any. */
+    leapSeconds: number | null;
+}
+/**
+ * Decode every GPSIon/GALIon/BDSIon/GPSUtc block in an SBF byte
+ * stream. Blocks with do-not-use coefficients are skipped; other block
+ * types are skipped silently.
+ */
+declare function parseSbfIonoUtc(data: Uint8Array): SbfIonoUtcResult;
+
 /**
  * Septentrio SBF raw-measurement decoding (MeasEpoch + Meas3) — the
  * path from a receiver log to RINEX-grade observables.
@@ -197,4 +254,4 @@ interface SbfParseResult {
  */
 declare function parseSbfMeas(data: Uint8Array): SbfParseResult;
 
-export { type SbfAlmanac, type SbfAlmanacResult, type SbfGlonassAlmanac, type SbfKeplerAlmanac, type SbfMeasEpoch, type SbfMeasurement, type SbfNavResult, type SbfParseResult, parseSbfAlmanac, parseSbfMeas, parseSbfNav };
+export { type SbfAlmanac, type SbfAlmanacResult, type SbfGlonassAlmanac, type SbfIonoUtcResult, type SbfKeplerAlmanac, type SbfMeasEpoch, type SbfMeasurement, type SbfNavResult, type SbfParseResult, parseSbfAlmanac, parseSbfIonoUtc, parseSbfMeas, parseSbfNav, crc16 as sbfCrc16, scanSbfFrames };

package/dist/sbf.js

@@ -1,12 +1,18 @@
 import {
+  crc16,
   parseSbfAlmanac,
+  parseSbfIonoUtc,
   parseSbfMeas,
-  parseSbfNav
-} from "./chunk-BEQSEJMU.js";
+  parseSbfNav,
+  scanSbfFrames
+} from "./chunk-ZNCQNHNI.js";
 import "./chunk-HVXYFUCB.js";
 import "./chunk-LEEU5OIO.js";
 export {
   parseSbfAlmanac,
+  parseSbfIonoUtc,
   parseSbfMeas,
-  parseSbfNav
+  parseSbfNav,
+  crc16 as sbfCrc16,
+  scanSbfFrames
 };

package/dist/ubx.cjs

@@ -20,10 +20,295 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/ubx/index.ts
 var ubx_exports = {};
 __export(ubx_exports, {
-  parseUbxRawx: () => parseUbxRawx
+  parseUbxIonoUtc: () => parseUbxIonoUtc,
+  parseUbxNav: () => parseUbxNav,
+  parseUbxRawx: () => parseUbxRawx,
+  ubxFrames: () => ubxFrames
 });
 module.exports = __toCommonJS(ubx_exports);
+
+// src/ubx/frame.ts
+function* ubxFrames(data, stats = { badChecksums: 0 }) {
+  let i = 0;
+  while (i + 8 <= data.length) {
+    if (data[i] !== 181 || data[i + 1] !== 98) {
+      i++;
+      continue;
+    }
+    const len = data[i + 4] | data[i + 5] << 8;
+    const end = i + 6 + len + 2;
+    if (end > data.length) break;
+    let ckA = 0;
+    let ckB = 0;
+    for (let j = i + 2; j < i + 6 + len; j++) {
+      ckA = ckA + data[j] & 255;
+      ckB = ckB + ckA & 255;
+    }
+    if (ckA !== data[i + 6 + len] || ckB !== data[i + 7 + len]) {
+      stats.badChecksums++;
+      i++;
+      continue;
+    }
+    yield {
+      msgClass: data[i + 2],
+      msgId: data[i + 3],
+      payload: data.subarray(i + 6, i + 6 + len),
+      payloadStart: i + 6
+    };
+    i = end;
+  }
+}
+
+// src/navbits/index.ts
+var GPS_PI = 3.1415926535898;
 var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK = 7 * 86400;
+function getBitU(buff, pos, len) {
+  let bits = 0;
+  for (let i = pos; i < pos + len; i++) {
+    bits = bits * 2 + (buff[i >> 3] >> 7 - (i & 7) & 1);
+  }
+  return bits;
+}
+function getBitS(buff, pos, len) {
+  const bits = getBitU(buff, pos, len);
+  if (len <= 0 || bits < 2 ** (len - 1)) return bits;
+  return bits - 2 ** len;
+}
+function setBitU(buff, pos, len, data) {
+  let mask = 2 ** (len - 1);
+  for (let i = pos; i < pos + len; i++, mask /= 2) {
+    if (data >= mask) {
+      buff[i >> 3] |= 1 << 7 - (i & 7);
+      data -= mask;
+    } else {
+      buff[i >> 3] &= ~(1 << 7 - (i & 7));
+    }
+  }
+}
+function decodeGpsLnavFrame(subframes, opts = {}) {
+  if (subframes.length < 90) return null;
+  const b = subframes;
+  let i = 24;
+  const tow1 = getBitU(b, i, 17) * 6;
+  i += 17 + 2;
+  const id1 = getBitU(b, i, 3);
+  i += 3 + 2;
+  const week10 = getBitU(b, i, 10);
+  i += 10;
+  i += 2;
+  i += 4;
+  const svHealth = getBitU(b, i, 6);
+  i += 6;
+  const iodc0 = getBitU(b, i, 2);
+  i += 2;
+  i += 1 + 87;
+  const tgdRaw = getBitS(b, i, 8);
+  i += 8;
+  const iodc1 = getBitU(b, i, 8);
+  i += 8;
+  const tocSec = getBitU(b, i, 16) * 16;
+  i += 16;
+  const af2 = getBitS(b, i, 8) * 2 ** -55;
+  i += 8;
+  const af1 = getBitS(b, i, 16) * 2 ** -43;
+  i += 16;
+  const af0 = getBitS(b, i, 22) * 2 ** -31;
+  i = 240 + 24;
+  i += 17 + 2;
+  const id2 = getBitU(b, i, 3);
+  i += 3 + 2;
+  const iode = getBitU(b, i, 8);
+  i += 8;
+  const crs = getBitS(b, i, 16) * 2 ** -5;
+  i += 16;
+  const deltaN = getBitS(b, i, 16) * 2 ** -43 * GPS_PI;
+  i += 16;
+  const m0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const cuc = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const e = getBitU(b, i, 32) * 2 ** -33;
+  i += 32;
+  const cus = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const sqrtA = getBitU(b, i, 32) * 2 ** -19;
+  i += 32;
+  const toes = getBitU(b, i, 16) * 16;
+  i = 480 + 24;
+  i += 17 + 2;
+  const id3 = getBitU(b, i, 3);
+  i += 3 + 2;
+  const cic = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const omega0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const cis = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const i0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const crc = getBitS(b, i, 16) * 2 ** -5;
+  i += 16;
+  const omega = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const omegaDot = getBitS(b, i, 24) * 2 ** -43 * GPS_PI;
+  i += 24;
+  const iode3 = getBitU(b, i, 8);
+  i += 8;
+  const idot = getBitS(b, i, 14) * 2 ** -43 * GPS_PI;
+  const iodc = iodc0 * 256 + iodc1;
+  if (id1 !== 1 || id2 !== 2 || id3 !== 3) return null;
+  if (iode3 !== iode || iode !== (iodc & 255)) return null;
+  const ref = opts.refWeek ?? Math.floor((Date.now() - GPS_EPOCH_MS) / 1e3 / SEC_PER_WEEK);
+  let week = week10 + 1024 * Math.round((ref - week10) / 1024);
+  if (toes < tow1 - 302400) week++;
+  else if (toes > tow1 + 302400) week--;
+  const prn = opts.prn ?? "G00";
+  const tocDate = new Date(
+    GPS_EPOCH_MS + (week * SEC_PER_WEEK + tocSec) * 1e3
+  );
+  return {
+    system: prn[0] === "J" ? "J" : "G",
+    prn,
+    tocDate,
+    // Same seconds-of-week convention as parseNavFile (rinex/nav.ts).
+    toc: tocDate.getTime() / 1e3 % SEC_PER_WEEK,
+    af0,
+    af1,
+    af2,
+    iode,
+    crs,
+    deltaN,
+    m0,
+    cuc,
+    e,
+    cus,
+    sqrtA,
+    toe: toes,
+    cic,
+    omega0,
+    cis,
+    i0,
+    crc,
+    omega,
+    omegaDot,
+    idot,
+    week,
+    svHealth,
+    tgd: tgdRaw === -128 ? 0 : tgdRaw * 2 ** -31
+    // IS-GPS-200: -128 reserved
+  };
+}
+
+// src/ubx/nav.ts
+var PREAMB_CNAV = 139;
+function readLnavSubframe(view, f) {
+  const p = f.payload;
+  if (p.length < 8) return null;
+  const gnssId = p[0];
+  const svId = p[1];
+  let prn;
+  if (gnssId === 0 && svId >= 1 && svId <= 32) {
+    prn = `G${String(svId).padStart(2, "0")}`;
+  } else if (gnssId === 5 && svId >= 1 && svId <= 10) {
+    if (p.length === 44) return null;
+    prn = `J${String(svId).padStart(2, "0")}`;
+  } else {
+    return null;
+  }
+  if (p.length < 8 + 40) return null;
+  const base = f.payloadStart + 8;
+  if (view.getUint32(base, true) >>> 24 === PREAMB_CNAV) return null;
+  const buff = new Uint8Array(30);
+  for (let k = 0; k < 10; k++) {
+    const dwrd = view.getUint32(base + 4 * k, true);
+    setBitU(buff, 24 * k, 24, dwrd >>> 6 & 16777215);
+  }
+  return { prn, gnssId, svId, buff, id: getBitU(buff, 43, 3) };
+}
+function parseUbxNav(data, opts = {}) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ephemerides = [];
+  let badParity = 0;
+  let refWeek = opts.refWeek;
+  if (refWeek === void 0) {
+    for (const f of ubxFrames(data)) {
+      if (f.msgClass === 2 && f.msgId === 21 && f.payload.length >= 16) {
+        const week = view.getUint16(f.payloadStart + 8, true);
+        if (week > 0) {
+          refWeek = week;
+          break;
+        }
+      }
+    }
+  }
+  if (refWeek === void 0) return { ephemerides, badParity };
+  const subframes = /* @__PURE__ */ new Map();
+  const last = /* @__PURE__ */ new Map();
+  for (const f of ubxFrames(data)) {
+    if (f.msgClass !== 2 || f.msgId !== 19) continue;
+    const lnav = readLnavSubframe(view, f);
+    if (!lnav) continue;
+    const { prn, gnssId, svId, buff, id } = lnav;
+    if (id < 1 || id > 5) {
+      badParity++;
+      continue;
+    }
+    if (id > 3) continue;
+    const key = gnssId * 256 + svId;
+    let sf = subframes.get(key);
+    if (!sf) {
+      sf = { buf: new Uint8Array(90), have: 0 };
+      subframes.set(key, sf);
+    }
+    sf.buf.set(buff, (id - 1) * 30);
+    sf.have |= 1 << id - 1;
+    if (id !== 3 || sf.have !== 7) continue;
+    const eph = decodeGpsLnavFrame(sf.buf, { prn, refWeek });
+    if (!eph) {
+      badParity++;
+      continue;
+    }
+    const prev = last.get(prn);
+    if (prev && prev.iode === eph.iode && prev.tocDate.getTime() === eph.tocDate.getTime()) {
+      continue;
+    }
+    last.set(prn, eph);
+    ephemerides.push(eph);
+  }
+  return { ephemerides, badParity };
+}
+
+// src/ubx/iono.ts
+function parseUbxIonoUtc(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ionoCorrections = {};
+  let leapSeconds = null;
+  for (const f of ubxFrames(data)) {
+    if (f.msgClass !== 2 || f.msgId !== 19) continue;
+    const sf = readLnavSubframe(view, f);
+    if (!sf || sf.gnssId !== 0 || sf.id !== 4) continue;
+    const b = sf.buff;
+    if (getBitU(b, 48, 2) !== 1 || getBitU(b, 50, 6) !== 56) continue;
+    ionoCorrections["GPSA"] = [
+      getBitS(b, 56, 8) * 2 ** -30,
+      getBitS(b, 64, 8) * 2 ** -27,
+      getBitS(b, 72, 8) * 2 ** -24,
+      getBitS(b, 80, 8) * 2 ** -24
+    ];
+    ionoCorrections["GPSB"] = [
+      getBitS(b, 88, 8) * 2 ** 11,
+      getBitS(b, 96, 8) * 2 ** 14,
+      getBitS(b, 104, 8) * 2 ** 16,
+      getBitS(b, 112, 8) * 2 ** 16
+    ];
+    leapSeconds = getBitS(b, 192, 8);
+  }
+  return { ionoCorrections, leapSeconds };
+}
+
+// src/ubx/index.ts
+var GPS_EPOCH_MS2 = Date.UTC(1980, 0, 6);
 var MS_PER_WEEK = 7 * 864e5;
 var SIGNALS = {
   0: { 0: ["G", "1C"], 3: ["G", "2X"], 4: ["G", "2X"] },
@@ -63,33 +348,14 @@ function parseUbxRawx(data) {
   const epochs = [];
   const messageCounts = {};
   const obsCodes = {};
-  let badChecksums = 0;
-  let i = 0;
-  while (i + 8 <= data.length) {
-    if (data[i] !== 181 || data[i + 1] !== 98) {
-      i++;
-      continue;
-    }
-    const cls = data[i + 2];
-    const id = data[i + 3];
-    const len = data[i + 4] | data[i + 5] << 8;
-    const end = i + 6 + len + 2;
-    if (end > data.length) break;
-    let ckA = 0;
-    let ckB = 0;
-    for (let j = i + 2; j < i + 6 + len; j++) {
-      ckA = ckA + data[j] & 255;
-      ckB = ckB + ckA & 255;
-    }
-    if (ckA !== data[i + 6 + len] || ckB !== data[i + 7 + len]) {
-      badChecksums++;
-      i++;
-      continue;
-    }
+  const stats = { badChecksums: 0 };
+  for (const frame of ubxFrames(data, stats)) {
+    const { msgClass: cls, msgId: id } = frame;
+    const len = frame.payload.length;
     const key = `${cls.toString(16).padStart(2, "0")}-${id.toString(16).padStart(2, "0")}`;
     messageCounts[key] = (messageCounts[key] ?? 0) + 1;
     if (cls === 2 && id === 21 && len >= 16) {
-      const p = i + 6;
+      const p = frame.payloadStart;
       const rcvTow = view.getFloat64(p, true);
       const week = view.getUint16(p + 8, true);
       const leapS = view.getInt8(p + 10);
@@ -125,16 +391,18 @@ function parseUbxRawx(data) {
         if (!codes.includes(sig[1])) codes.push(sig[1]);
       }
       epochs.push({
-        timeMs: GPS_EPOCH_MS + week * MS_PER_WEEK + Math.round(rcvTow * 1e3),
+        timeMs: GPS_EPOCH_MS2 + week * MS_PER_WEEK + Math.round(rcvTow * 1e3),
         leapS: leapValid ? leapS : null,
         meas
       });
     }
-    i = end;
   }
-  return { epochs, messageCounts, obsCodes, badChecksums };
+  return { epochs, messageCounts, obsCodes, badChecksums: stats.badChecksums };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  parseUbxRawx
+  parseUbxIonoUtc,
+  parseUbxNav,
+  parseUbxRawx,
+  ubxFrames
 });

package/dist/ubx.d.cts

@@ -1,3 +1,122 @@
+import { E as Ephemeris } from './nav-BAI1a9vK.cjs';
+
+/**
+ * u-blox UBX framing shared by the measurement and navigation decoders:
+ * 0xB5 0x62 sync, message class and ID, little-endian payload length,
+ * payload, and an 8-bit Fletcher checksum over class..payload.
+ */
+/** One checksum-valid UBX frame located in a byte stream. */
+interface UbxFrame {
+    /** Message class, e.g. 0x02 for RXM. */
+    msgClass: number;
+    /** Message ID within the class, e.g. 0x15 for RXM-RAWX. */
+    msgId: number;
+    /** Payload bytes (a view into the input buffer, not a copy). */
+    payload: Uint8Array;
+    /** Byte offset of the payload within the input buffer. */
+    payloadStart: number;
+}
+/**
+ * Iterate every checksum-valid UBX frame in `data`. Bad checksums are
+ * counted in `stats.badChecksums` and a resync continues at the next
+ * byte; a frame candidate that overruns the buffer ends the scan
+ * (truncated capture).
+ */
+declare function ubxFrames(data: Uint8Array, stats?: {
+    badChecksums: number;
+}): Generator<UbxFrame>;
+
+/**
+ * u-blox UBX navigation-message decoding: GPS/QZSS LNAV broadcast
+ * ephemerides from RXM-SFRBX (class 0x02, id 0x13).
+ *
+ * Ported from RTKLIB demo5 (rtklibexplorer fork, src/rcv/ublox.c:
+ * decode_rxmsfrbx / decode_nav / decode_eph, Copyright (c) 2007-2020
+ * T. Takasu, BSD-2-Clause); the subframe fields themselves are decoded
+ * by `decodeGpsLnavFrame` (the decode_frame port in src/navbits).
+ *
+ * On D30* polarity: the receiver has already checked parity and
+ * resolved the polarity inversion of the data bits before writing the
+ * 30-bit words into the 30 LSBs of each `dwrd`, so — exactly like
+ * RTKLIB's decode_nav (`U4(p)>>6`, "24 x 10 bits w/o parity") — the
+ * conversion to parity-stripped 24-bit words is a plain 6-bit shift
+ * with NO D30* re-inversion. (Verified against the TLM preamble 0x8B
+ * at bits 29..22 of word 1 in every GPS/QZSS LNAV message of the
+ * reference F9P capture.)
+ *
+ * Other constellations in RXM-SFRBX (Galileo I/NAV, BDS D1/D2, GLONASS
+ * strings, SBAS) and GPS/QZSS CNAV are out of scope and skipped
+ * silently. LNAV subframes 4/5 are skipped here except that
+ * `parseUbxIonoUtc` (./iono.ts) decodes the subframe-4 page-18
+ * iono/UTC parameters through the shared `readLnavSubframe` helper.
+ */
+
+interface UbxNavOptions {
+    /**
+     * Full GPS week used to resolve the 10-bit broadcast week. When
+     * omitted, the week is harvested from the first RXM-RAWX message in
+     * the same stream (u-blox raw logs carry both); a stream with
+     * neither yields no ephemerides — the system clock is never used.
+     */
+    refWeek?: number;
+}
+interface UbxNavResult {
+    /** Broadcast ephemerides in stream order, duplicates suppressed. */
+    ephemerides: Ephemeris[];
+    /**
+     * Subframes rejected for inconsistency: an out-of-range subframe ID
+     * in the HOW word, or a complete subframe-1/2/3 set whose
+     * IODC/IODE cross-check failed (mixed issues of data).
+     */
+    badParity: number;
+}
+/**
+ * Decode every GPS/QZSS LNAV ephemeris broadcast in a UBX byte stream
+ * (RXM-SFRBX). Subframes 1–3 are assembled per satellite; a frame is
+ * decoded when subframe 3 arrives with 1 and 2 buffered (RTKLIB
+ * decode_nav), and repeated broadcasts of an unchanged ephemeris are
+ * suppressed by issue of data and clock epoch like `parseNovatelNav`.
+ */
+declare function parseUbxNav(data: Uint8Array, opts?: UbxNavOptions): UbxNavResult;
+
+/**
+ * u-blox UBX ionosphere / UTC decoding: the GPS LNAV subframe 4
+ * page 18 broadcast (Klobuchar coefficients + GPS-UTC parameters)
+ * from RXM-SFRBX.
+ *
+ * Ported from RTKLIB demo5 (rtklibexplorer fork, src/rcvraw.c:
+ * decode_frame_ion / decode_frame_utc, Copyright (c) 2007-2020
+ * T. Takasu, BSD-2-Clause); frame extraction is shared with
+ * `parseUbxNav` through `readLnavSubframe` (./nav.ts).
+ *
+ * Scope is GPS satellites (gnssId 0) only: QZSS also broadcasts
+ * page-18-format iono parameters, but those are the separate
+ * wide-area/Japan-area QZSS coefficient set, not the GPS one a RINEX
+ * `GPSA`/`GPSB` header carries. Scale factors follow IS-GPS-200
+ * §20.3.3.5.1 (alpha_n in s/semicircle^n, beta_n in s/semicircle^n) —
+ * the same semicircle-based units the RINEX nav header prints, so the
+ * output matches `parseNavFile` on a converted header. Like
+ * `parseUbxNav`, the decoder never consults the system clock (nothing
+ * here needs a week reference).
+ */
+interface UbxIonoUtcResult {
+    /**
+     * Iono coefficient sets keyed like `NavHeader.ionoCorrections`:
+     * `GPSA` (alpha_0..3) and `GPSB` (beta_0..3). The page repeats
+     * (nominally every 12.5 min per satellite); the last broadcast in
+     * the stream wins.
+     */
+    ionoCorrections: Record<string, number[]>;
+    /** GPS-UTC ΔtLS from the last page-18 broadcast, if any. */
+    leapSeconds: number | null;
+}
+/**
+ * Decode every GPS LNAV subframe 4 page 18 (data ID 1, SV ID 56) in a
+ * UBX byte stream (RXM-SFRBX) into Klobuchar iono coefficients and the
+ * current leap-second count.
+ */
+declare function parseUbxIonoUtc(data: Uint8Array): UbxIonoUtcResult;
+
 /**
  * u-blox UBX raw-measurement decoding (RXM-RAWX) — the path from a
  * receiver log to RINEX-grade observables.
@@ -12,6 +131,7 @@
  * RINEX attributes chosen to match RTKLIB's u-blox conversion (the de
  * facto reference: GPS L2 CL/CM as 2X, Galileo E1 as 1X, E5b as 7X).
  */
+
 interface UbxMeasurement {
     /** RINEX PRN, e.g. "G04", "R11", "S23". */
     prn: string;
@@ -53,4 +173,4 @@ interface UbxParseResult {
  */
 declare function parseUbxRawx(data: Uint8Array): UbxParseResult;
 
-export { type UbxMeasurement, type UbxParseResult, type UbxRawxEpoch, parseUbxRawx };
+export { type UbxFrame, type UbxIonoUtcResult, type UbxMeasurement, type UbxNavOptions, type UbxNavResult, type UbxParseResult, type UbxRawxEpoch, parseUbxIonoUtc, parseUbxNav, parseUbxRawx, ubxFrames };