gnss-js 2.10.1 → 2.12.0

package/dist/sbf.cjs

@@ -30,6 +30,7 @@ __export(sbf_exports, {
   isSbasL1Preamble: () => isSbasL1Preamble,
   isSbasL5Correction: () => isSbasL5Correction,
   parseSbfAlmanac: () => parseSbfAlmanac,
+  parseSbfBdsCnav: () => parseSbfBdsCnav,
   parseSbfBdsNav: () => parseSbfBdsNav,
   parseSbfCnav: () => parseSbfCnav,
   parseSbfGalNav: () => parseSbfGalNav,
@@ -942,7 +943,7 @@ var isc = (b, pos) => {
   return raw === -4096 ? null : raw * 2 ** -35;
 };
 function decodeClock(b, msgType) {
-  const clock = {
+  const clock2 = {
     msgType,
     top: getBitU(b, 38, 11) * 300,
     uraNed0: getBitS(b, 49, 5),
@@ -954,26 +955,26 @@ function decodeClock(b, msgType) {
     af2: getBitS(b, 117, 10) * 2 ** -60
   };
   if (msgType === 30) {
-    clock.tgd = isc(b, 127);
-    clock.iscL1ca = isc(b, 140);
-    clock.iscL2c = isc(b, 153);
-    clock.iscL5i5 = isc(b, 166);
-    clock.iscL5q5 = isc(b, 179);
-    clock.ionoAlpha = [
+    clock2.tgd = isc(b, 127);
+    clock2.iscL1ca = isc(b, 140);
+    clock2.iscL2c = isc(b, 153);
+    clock2.iscL5i5 = isc(b, 166);
+    clock2.iscL5q5 = isc(b, 179);
+    clock2.ionoAlpha = [
       getBitS(b, 192, 8) * 2 ** -30,
       getBitS(b, 200, 8) * 2 ** -27,
       getBitS(b, 208, 8) * 2 ** -24,
       getBitS(b, 216, 8) * 2 ** -24
     ];
-    clock.ionoBeta = [
+    clock2.ionoBeta = [
       getBitS(b, 224, 8) * 2 ** 11,
       getBitS(b, 232, 8) * 2 ** 14,
       getBitS(b, 240, 8) * 2 ** 16,
       getBitS(b, 248, 8) * 2 ** 16
     ];
-    clock.wnOp = getBitU(b, 256, 8);
+    clock2.wnOp = getBitU(b, 256, 8);
   }
-  return clock;
+  return clock2;
 }
 function resolveWeek(week, towSec, sec) {
   if (sec < towSec - HALF_WEEK) return week + 1;
@@ -1011,10 +1012,10 @@ var CnavAssembler = class {
     return this.tryEmit(prn, sat);
   }
   tryEmit(prn, sat) {
-    const { t10, t11, clock, extras } = sat;
-    if (!t10 || !t11 || !clock) return null;
-    if (t10.toe !== t11.toe || clock.toc !== t10.toe) return null;
-    const key = `${t10.week}:${t10.toe}:${clock.af0}:${clock.af1}`;
+    const { t10, t11, clock: clock2, extras } = sat;
+    if (!t10 || !t11 || !clock2) return null;
+    if (t10.toe !== t11.toe || clock2.toc !== t10.toe) return null;
+    const key = `${t10.week}:${t10.toe}:${clock2.af0}:${clock2.af1}`;
     if (key === sat.lastKey) return null;
     sat.lastKey = key;
     const weekToe = resolveWeek(t10.week, t10.tow, t10.toe);
@@ -1025,9 +1026,9 @@ var CnavAssembler = class {
       week: t10.week,
       health: t10.health,
       uraEd: t10.uraEd,
-      uraNed0: clock.uraNed0,
-      uraNed1: clock.uraNed1,
-      uraNed2: clock.uraNed2,
+      uraNed0: clock2.uraNed0,
+      uraNed1: clock2.uraNed1,
+      uraNed2: clock2.uraNed2,
       top: t10.top,
       toe: t10.toe,
       toeDate: gpsDate(weekToe, t10.toe),
@@ -1050,12 +1051,12 @@ var CnavAssembler = class {
       crc: t11.crc,
       cus: t11.cus,
       cuc: t11.cuc,
-      toc: clock.toc,
-      tocDate: gpsDate(weekToe, clock.toc),
-      af0: clock.af0,
-      af1: clock.af1,
-      af2: clock.af2,
-      clockMsgType: clock.msgType,
+      toc: clock2.toc,
+      tocDate: gpsDate(weekToe, clock2.toc),
+      af0: clock2.af0,
+      af1: clock2.af1,
+      af2: clock2.af2,
+      clockMsgType: clock2.msgType,
       tgd: extras?.tgd ?? null,
       iscL1ca: extras?.iscL1ca ?? null,
       iscL2c: extras?.iscL2c ?? null,
@@ -2168,6 +2169,378 @@ function parseSbfGloNav(data) {
   return { ephemerides, badCrc, messages };
 }
 
+// src/navbits/bds-cnav.ts
+var BDT_EPOCH_MS3 = Date.UTC(2006, 0, 1);
+var SEC_PER_WEEK8 = 7 * 86400;
+var HALF_WEEK4 = 302400;
+var BDS_CNAV_A_REF_MEO = 27906100;
+var BDS_CNAV_A_REF_IGSO_GEO = 42162200;
+function bdsCnavAref(satType) {
+  return satType === 3 ? BDS_CNAV_A_REF_MEO : BDS_CNAV_A_REF_IGSO_GEO;
+}
+function ephI(b, p) {
+  return {
+    toe: getBitU(b, p, 11) * 300,
+    satType: getBitU(b, p + 11, 2),
+    deltaA: getBitS(b, p + 13, 26) * 2 ** -9,
+    aDot: getBitS(b, p + 39, 25) * 2 ** -21,
+    deltaN0: getBitS(b, p + 64, 17) * 2 ** -44 * GPS_PI,
+    deltaN0Dot: getBitS(b, p + 81, 23) * 2 ** -57 * GPS_PI,
+    m0: getBitS33(b, p + 104) * 2 ** -32 * GPS_PI,
+    e: getBitU33(b, p + 137) * 2 ** -34,
+    omega: getBitS33(b, p + 170) * 2 ** -32 * GPS_PI
+  };
+}
+function ephII(b, p) {
+  return {
+    omega0: getBitS33(b, p) * 2 ** -32 * GPS_PI,
+    i0: getBitS33(b, p + 33) * 2 ** -32 * GPS_PI,
+    omegaDot: getBitS(b, p + 66, 19) * 2 ** -44 * GPS_PI,
+    i0Dot: getBitS(b, p + 85, 15) * 2 ** -44 * GPS_PI,
+    cis: getBitS(b, p + 100, 16) * 2 ** -30,
+    cic: getBitS(b, p + 116, 16) * 2 ** -30,
+    crs: getBitS(b, p + 132, 24) * 2 ** -8,
+    crc: getBitS(b, p + 156, 24) * 2 ** -8,
+    cus: getBitS(b, p + 180, 21) * 2 ** -30,
+    cuc: getBitS(b, p + 201, 21) * 2 ** -30
+  };
+}
+function clock(b, p) {
+  return {
+    toc: getBitU(b, p, 11) * 300,
+    af0: getBitS(b, p + 11, 25) * 2 ** -34,
+    af1: getBitS(b, p + 36, 22) * 2 ** -50,
+    af2: getBitS(b, p + 58, 11) * 2 ** -66
+  };
+}
+function sisaiOc(b, p) {
+  return {
+    top: getBitU(b, p, 11) * 300,
+    ocb: getBitS(b, p + 11, 5),
+    oc1: getBitS(b, p + 16, 3),
+    oc2: getBitS(b, p + 19, 3)
+  };
+}
+var delay = (b, p) => getBitS(b, p, 12) * 2 ** -34;
+function crcOk(msg, dataBits) {
+  const need = Math.ceil((dataBits + 24) / 8);
+  return msg.length >= need && crc24q(msg, dataBits) === getBitU(msg, dataBits, 24);
+}
+var bdsCnav1Sf2CrcOk = (sf2) => crcOk(sf2, 576);
+var bdsCnav1Sf3CrcOk = (sf3) => crcOk(sf3, 240);
+var bdsCnav2CrcOk = (msg) => crcOk(msg, 264);
+var bdsCnav3CrcOk = (msg) => crcOk(msg, 462);
+function resolveWeek2(week, towSec, sec) {
+  if (sec < towSec - HALF_WEEK4) return week + 1;
+  if (sec > towSec + HALF_WEEK4) return week - 1;
+  return week;
+}
+function bdtDate(week, sec) {
+  return new Date(BDT_EPOCH_MS3 + (week * SEC_PER_WEEK8 + sec) * 1e3);
+}
+var emptyStatus = () => ({
+  top: null,
+  sisaiOe: null,
+  sisaiOcb: null,
+  sisaiOc1: null,
+  sisaiOc2: null,
+  sismai: null,
+  health: null,
+  integrityFlags: null
+});
+function applyOc(s, oc) {
+  s.top = oc.top;
+  s.sisaiOcb = oc.ocb;
+  s.sisaiOc1 = oc.oc1;
+  s.sisaiOc2 = oc.oc2;
+}
+function build(message, prn, wn, tTm, e1, e2, c, d, s) {
+  const week = resolveWeek2(wn, tTm, e1.toe);
+  const weekToc = resolveWeek2(wn, tTm, c.toc);
+  return {
+    system: "C",
+    prn,
+    message,
+    week,
+    toe: e1.toe,
+    toeDate: bdtDate(week, e1.toe),
+    toc: c.toc,
+    tocDate: bdtDate(weekToc, c.toc),
+    satType: e1.satType,
+    a: bdsCnavAref(e1.satType) + e1.deltaA,
+    deltaA: e1.deltaA,
+    aDot: e1.aDot,
+    deltaN0: e1.deltaN0,
+    deltaN0Dot: e1.deltaN0Dot,
+    m0: e1.m0,
+    e: e1.e,
+    omega: e1.omega,
+    ...e2,
+    af0: c.af0,
+    af1: c.af1,
+    af2: c.af2,
+    ...d,
+    ...s,
+    tow: tTm
+  };
+}
+var prnLabel = (prn) => `C${String(prn).padStart(2, "0")}`;
+var BdsCnav1Assembler = class {
+  status = /* @__PURE__ */ new Map();
+  lastKey = /* @__PURE__ */ new Map();
+  /**
+   * Push one frame's CRC-valid subframes (bit-0 aligned; pass null for
+   * a subframe that failed its CRC) for satellite `prn` (1-63). `tTm`
+   * is the frame's transmit time, s of the BDT week. Returns the newly
+   * seen ephemeris, or null.
+   */
+  push(prn, sf2, sf3, tTm) {
+    let s = this.status.get(prn);
+    if (!s) this.status.set(prn, s = emptyStatus());
+    if (sf3) {
+      const page = getBitU(sf3, 0, 6);
+      if (page >= 1 && page <= 4) {
+        s.health = getBitU(sf3, 6, 2);
+        s.integrityFlags = getBitU(sf3, 8, 3);
+        s.sismai = getBitU(sf3, 11, 4);
+        if (page === 1) {
+          s.sisaiOe = getBitU(sf3, 15, 5);
+          applyOc(s, sisaiOc(sf3, 20));
+        } else if (page === 3) s.sisaiOe = getBitU(sf3, 15, 5);
+        else applyOc(s, sisaiOc(sf3, 15));
+      }
+    }
+    if (!sf2) return null;
+    const wn = getBitU(sf2, 0, 13);
+    const iodc = getBitU(sf2, 21, 10);
+    const iode = getBitU(sf2, 31, 8);
+    const e1 = ephI(sf2, 39);
+    const c = clock(sf2, 464);
+    const key = `${wn}:${iodc}:${iode}:${e1.toe}:${c.toc}`;
+    if (this.lastKey.get(prn) === key) return null;
+    this.lastKey.set(prn, key);
+    return build(
+      "CNV1",
+      prnLabel(prn),
+      wn,
+      tTm,
+      e1,
+      ephII(sf2, 242),
+      c,
+      {
+        iode,
+        iodc,
+        tgdB1Cp: delay(sf2, 557),
+        tgdB2ap: delay(sf2, 533),
+        iscB1Cd: delay(sf2, 545),
+        iscB2ad: null,
+        tgdB2bI: null
+      },
+      { ...s }
+    );
+  }
+};
+var BdsCnav2Assembler = class {
+  sats = /* @__PURE__ */ new Map();
+  /**
+   * Push one CRC-valid 288-bit message (bit 0 = first PRN bit, the
+   * preamble stripped). Returns the newly completed ephemeris, or null.
+   */
+  push(msg) {
+    const prn = getBitU(msg, 0, 6);
+    const type = getBitU(msg, 6, 6);
+    const sow = getBitU(msg, 12, 18) * 3;
+    if (prn < 1) return null;
+    let sat = this.sats.get(prn);
+    if (!sat) this.sats.set(prn, sat = { status: emptyStatus() });
+    const s = sat.status;
+    if (type === 10) {
+      sat.t10 = {
+        wn: getBitU(msg, 30, 13),
+        iode: getBitU(msg, 53, 8),
+        e1: ephI(msg, 61),
+        sow
+      };
+      s.integrityFlags = getBitU(msg, 43, 3) << 3 | getBitU(msg, 50, 3);
+      s.sismai = getBitU(msg, 46, 4);
+      if (sat.t11 && sat.t11.sow < sow) sat.t11 = void 0;
+    } else if (type === 11 || type >= 30 && type <= 34 || type === 40) {
+      s.health = getBitU(msg, 30, 2);
+      s.integrityFlags = getBitU(msg, 32, 3) << 3 | getBitU(msg, 39, 3);
+      s.sismai = getBitU(msg, 35, 4);
+      if (type === 11) {
+        if (!sat.t10 || sow <= sat.t10.sow) return null;
+        sat.t11 = { e2: ephII(msg, 42), sow };
+      } else if (type === 34) {
+        applyOc(s, sisaiOc(msg, 42));
+        sat.clock = { c: clock(msg, 64), iodc: getBitU(msg, 133, 10) };
+      } else if (type === 40) {
+        s.sisaiOe = getBitU(msg, 42, 5);
+        applyOc(s, sisaiOc(msg, 47));
+        return null;
+      } else {
+        sat.clock = { c: clock(msg, 42), iodc: getBitU(msg, 111, 10) };
+        if (type === 30)
+          sat.delays = {
+            tgdB2ap: delay(msg, 121),
+            iscB2ad: delay(msg, 133),
+            tgdB1Cp: delay(msg, 219)
+          };
+      }
+    } else return null;
+    const { t10, t11, clock: ck } = sat;
+    if (!t10 || !t11 || !ck || (ck.iodc & 255) !== t10.iode) return null;
+    const key = `${t10.wn}:${ck.iodc}:${t10.iode}:${t10.e1.toe}:${ck.c.toc}`;
+    if (sat.lastKey === key) return null;
+    sat.lastKey = key;
+    return build(
+      "CNV2",
+      prnLabel(prn),
+      t10.wn,
+      t10.sow,
+      t10.e1,
+      t11.e2,
+      ck.c,
+      {
+        iode: t10.iode,
+        iodc: ck.iodc,
+        tgdB1Cp: sat.delays?.tgdB1Cp ?? null,
+        tgdB2ap: sat.delays?.tgdB2ap ?? null,
+        iscB1Cd: null,
+        iscB2ad: sat.delays?.iscB2ad ?? null,
+        tgdB2bI: null
+      },
+      { ...s }
+    );
+  }
+};
+var BdsCnav3Assembler = class {
+  sats = /* @__PURE__ */ new Map();
+  /**
+   * Push one CRC-valid 486-bit message (bit 0 = first MesType bit) from
+   * satellite `prn`. Returns the newly completed ephemeris, or null.
+   */
+  push(prn, msg) {
+    const type = getBitU(msg, 0, 6);
+    const sow = getBitU(msg, 6, 20);
+    let sat = this.sats.get(prn);
+    if (!sat) this.sats.set(prn, sat = { status: emptyStatus() });
+    const s = sat.status;
+    if (type === 10) {
+      sat.t10 = { e1: ephI(msg, 30), e2: ephII(msg, 233), sow };
+      s.integrityFlags = getBitU(msg, 455, 3);
+      s.sismai = getBitU(msg, 458, 4);
+    } else if (type === 30) {
+      sat.t30 = {
+        wn: getBitU(msg, 26, 13),
+        c: clock(msg, 43),
+        tgd: delay(msg, 112)
+      };
+      applyOc(s, sisaiOc(msg, 433));
+      s.sisaiOe = getBitU(msg, 455, 5);
+      s.health = getBitU(msg, 460, 2);
+    } else return null;
+    const { t10, t30 } = sat;
+    if (!t10 || !t30 || t10.e1.toe !== t30.c.toc) return null;
+    const key = `${t30.wn}:${t10.e1.toe}:${t30.c.af0}:${t10.e1.m0}`;
+    if (sat.lastKey === key) return null;
+    sat.lastKey = key;
+    return build(
+      "CNV3",
+      prnLabel(prn),
+      t30.wn,
+      t10.sow,
+      t10.e1,
+      t10.e2,
+      t30.c,
+      {
+        iode: null,
+        iodc: null,
+        tgdB1Cp: null,
+        tgdB2ap: null,
+        iscB1Cd: null,
+        iscB2ad: null,
+        tgdB2bI: t30.tgd
+      },
+      { ...s }
+    );
+  }
+};
+
+// src/sbf/rawnav-bds-cnav.ts
+var GPS_BDT_OFFSET = 14;
+var B1C_FRAME_S = 18;
+var TOW_DNU2 = 4294967295;
+function newBdsCnavAssemblers() {
+  return {
+    b1c: new BdsCnav1Assembler(),
+    b2a: new BdsCnav2Assembler(),
+    b2b: new BdsCnav3Assembler()
+  };
+}
+function navBits(view, wordsAt, start, nBits) {
+  const out = new Uint8Array(Math.ceil(nBits / 8));
+  for (let i = 0; i < nBits; i++) {
+    const p = start + i;
+    const w = view.getUint32(wordsAt + 4 * (p >>> 5), true);
+    if (w >>> 31 - (p & 31) & 1) out[i >> 3] |= 128 >> (i & 7);
+  }
+  return out;
+}
+var MIN_LEN = { 4218: 248, 4219: 92, 4242: 144 };
+function feedBdsCnavBlock(view, b, id, len, asm) {
+  if (len < (MIN_LEN[id] ?? Infinity)) return {};
+  const prnStr = svidToPrn(view.getUint8(b + 14));
+  if (!prnStr || prnStr[0] !== "C") return {};
+  const prn = Number(prnStr.slice(1));
+  const words = b + 20;
+  if (id === 4218) {
+    const towMs = view.getUint32(b + 8, true);
+    if (towMs === TOW_DNU2) return {};
+    const sf2 = navBits(view, words, 72, 600);
+    const sf3 = navBits(view, words, 1272, 264);
+    const sf2Ok = bdsCnav1Sf2CrcOk(sf2);
+    const bdt = (towMs / 1e3 - GPS_BDT_OFFSET + 604800) % 604800;
+    const tTm = (Math.floor(bdt) - B1C_FRAME_S + 604800) % 604800;
+    const eph = asm.b1c.push(
+      prn,
+      sf2Ok ? sf2 : null,
+      bdsCnav1Sf3CrcOk(sf3) ? sf3 : null,
+      tTm
+    );
+    if (!sf2Ok) return { badCrc: true };
+    return eph ? { eph } : {};
+  }
+  if (id === 4219) {
+    const msg = navBits(view, words, 0, 288);
+    if (!bdsCnav2CrcOk(msg)) return { badCrc: true };
+    const eph = asm.b2a.push(msg);
+    return eph ? { eph } : {};
+  }
+  if (id === 4242) {
+    const msg = navBits(view, words, 12, 486);
+    if (!bdsCnav3CrcOk(msg)) return { badCrc: true };
+    const eph = asm.b2b.push(prn, msg);
+    return eph ? { eph } : {};
+  }
+  return {};
+}
+function parseSbfBdsCnav(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const asm = newBdsCnavAssemblers();
+  const ephemerides = [];
+  let badCrc = 0;
+  let messages = 0;
+  scanSbfFrames(data, view, (id, b, len) => {
+    if (id !== 4218 && id !== 4219 && id !== 4242) return;
+    messages++;
+    const r = feedBdsCnavBlock(view, b, id, len, asm);
+    if (r.eph) ephemerides.push(r.eph);
+    else if (r.badCrc) badCrc++;
+  });
+  return { ephemerides, badCrc, messages };
+}
+
 // src/navbits/sbas.ts
 var GPS_EPOCH_MS9 = Date.UTC(1980, 0, 6);
 var MS_PER_WEEK4 = 7 * 86400 * 1e3;
@@ -2353,6 +2726,7 @@ function decodeSbfNavigation(data, opts = {}) {
   const ephemerides = [];
   const seen = /* @__PURE__ */ new Set();
   const cnav = [];
+  const bdsCnav = [];
   const ionoCorrections = {};
   let leapSeconds = null;
   const counts = {
@@ -2362,6 +2736,7 @@ function decodeSbfNavigation(data, opts = {}) {
     galRaw: 0,
     gloRaw: 0,
     bdsRaw: 0,
+    bdsCnavRaw: 0,
     sbasRaw: 0,
     sbasL5Raw: 0,
     navicRaw: 0,
@@ -2373,6 +2748,7 @@ function decodeSbfNavigation(data, opts = {}) {
   const galAsm = newGalAssemblers();
   const gloAsm = new GloStringAssembler();
   const bdsAsm = new BdsAssembler();
+  const bdsCnavAsm = newBdsCnavAssemblers();
   const lnavAsm = new GpsLnavAssembler();
   const navicAsm = new NavicAssembler();
   const addEph = (e) => {
@@ -2479,6 +2855,17 @@ function decodeSbfNavigation(data, opts = {}) {
         else if (r.badCrc) counts.badFrames++;
         return;
       }
+      case 4218:
+      // BDSRawB1C
+      case 4219:
+      // BDSRawB2a
+      case 4242: {
+        counts.bdsCnavRaw++;
+        const r = feedBdsCnavBlock(view, b, id, len, bdsCnavAsm);
+        if (r.eph) bdsCnav.push(r.eph);
+        else if (r.badCrc) counts.badFrames++;
+        return;
+      }
       case 4020: {
         if (len < 52) return;
         counts.sbasRaw++;
@@ -2535,7 +2922,15 @@ function decodeSbfNavigation(data, opts = {}) {
     prns: [...dfmcPrns].sort(),
     messages: Object.values(dfmcByType).reduce((a, v) => a + v, 0)
   };
-  return { ephemerides, cnav, ionoCorrections, leapSeconds, dfmc, counts };
+  return {
+    ephemerides,
+    cnav,
+    bdsCnav,
+    ionoCorrections,
+    leapSeconds,
+    dfmc,
+    counts
+  };
 }
 
 // src/navbits/rs255.ts
@@ -3740,6 +4135,7 @@ function parseSbfMeas(data) {
   isSbasL1Preamble,
   isSbasL5Correction,
   parseSbfAlmanac,
+  parseSbfBdsCnav,
   parseSbfBdsNav,
   parseSbfCnav,
   parseSbfGalNav,

package/dist/sbf.d.cts

@@ -1,6 +1,6 @@
-export { S as SbfAlmanac, a as SbfAlmanacResult, b as SbfGlonassAlmanac, c as SbfKeplerAlmanac, d as SbfNavResult, p as parseSbfAlmanac, e as parseSbfNav } from './nav-BYmYoh9A.cjs';
+export { S as SbfAlmanac, a as SbfAlmanacResult, b as SbfGlonassAlmanac, c as SbfKeplerAlmanac, d as SbfNavResult, p as parseSbfAlmanac, e as parseSbfNav } from './nav-CvZXmumD.cjs';
 import { R as ReceiverPvt } from './receiver-pvt-CVFvi4kT.cjs';
-import { K as KeplerEphemeris, C as CnavEphemeris, G as GlonassEphemeris, E as Ephemeris } from './nav-DImXUdbp.cjs';
+import { K as KeplerEphemeris, C as CnavEphemeris, B as BdsCnavEphemeris, G as GlonassEphemeris, E as Ephemeris } from './nav-COp0Vmlw.cjs';
 import { H as HasMessage } from './has-BaXnQarR.cjs';
 
 /**
@@ -273,6 +273,43 @@ interface SbfCnavResult {
  */
 declare function parseSbfCnav(data: Uint8Array): SbfCnavResult;
 
+/**
+ * Septentrio SBF raw BeiDou-3 navigation blocks — BDSRawB1C (4218),
+ * BDSRawB2a (4219) and BDSRawB2b (4242) — into B-CNAV1/2/3 ephemerides.
+ *
+ * Block layout: after the 8-byte SBF header, TOW u4 + WNc u2, SVID u1,
+ * then CRCPassed u1 (B1C: CRCSF2 u1 + CRCSF3 u1), Source/Reserved
+ * bytes, RxChannel u1, and NAVBits as u4 words at +20 — the first bit
+ * is the MSB of NAVBits[0], each u4 little-endian in the stream. The
+ * receiver has already run the LDPC decoding; the positions inside
+ * NAVBits were established on TU Delft DLF500 captures (every message
+ * passes CRC-24Q at these offsets) and the decoded fields match DLR's
+ * BRD400DLR RINEX 4 records:
+ *
+ *  - B1C (u4[57]): subframe 1 as its 72 raw BCH symbols, then
+ *    subframe 2's 600 decoded bits at bit 72 and subframe 3's 264 at
+ *    bit 1272 — each at the start of its 1200/528-symbol slot.
+ *  - B2a (u4[18]): the 288-bit message from the PRN (no preamble).
+ *  - B2b (u4[31]): PRN (6) + reserved (6), then the 486-bit message.
+ *
+ * The receiver's CRC flags are ignored in favor of re-checking CRC-24Q,
+ * so `badCrc` counts exactly what this library rejected.
+ */
+
+interface SbfBdsCnavResult {
+    /** Assembled B-CNAV1/2/3 ephemerides in stream order, repeats suppressed. */
+    ephemerides: BdsCnavEphemeris[];
+    /** Messages whose CRC-24Q check failed (dropped). */
+    badCrc: number;
+    /** Total BDSRawB1C/B2a/B2b blocks seen (with valid SBF framing). */
+    messages: number;
+}
+/**
+ * Decode every BDSRawB1C/B2a/B2b block in an SBF byte stream into
+ * BeiDou-3 B-CNAV ephemerides (RINEX 4 CNV1/CNV2/CNV3).
+ */
+declare function parseSbfBdsCnav(data: Uint8Array): SbfBdsCnavResult;
+
 /** Callback fed every CRC-valid SBAS message (any type), as MSB-first bits. */
 type SbasMessageCb = (msg: Uint8Array, prn: number, week: number, tow: number) => void;
 /** Callback fed every CRC-valid native-DFMC (L5) message, with its type. */
@@ -364,7 +401,7 @@ declare function parseSbfGeoL5(data: Uint8Array, opts?: {
  * A Septentrio broadcasts navigation data as a mix of *decoded* blocks
  * (GPSNav/GALNav/GLONav/BDSNav/QZSNav — already-parsed ephemeris) and
  * *raw* navigation-frame blocks (GPSRawCA, GALRawINAV/FNAV, GLORawCA,
- * BDSRaw, GPSRawL2C/L5, GEORawL1) whose bits must be assembled — and which class a
+ * BDSRaw, BDSRawB1C/B2a/B2b, GPSRawL2C/L5, GEORawL1) whose bits must be assembled — and which class a
  * given receiver emits depends on its configuration. The granular
  * `parseSbf*` functions each re-scan the whole stream for one class;
  * this decoder walks the byte stream **once**, routing every navigation
@@ -394,6 +431,8 @@ interface SbfNavCounts {
     gloRaw: number;
     /** Raw BeiDou D1/D2 subframe blocks (BDSRaw). */
     bdsRaw: number;
+    /** Raw BeiDou-3 B-CNAV blocks (BDSRawB1C/B2a/B2b). */
+    bdsCnavRaw: number;
     /** Raw SBAS L1 GEO message blocks (GEORawL1). */
     sbasRaw: number;
     /** Raw SBAS L5 GEO message blocks (GEORawL5) — DO-229-on-L5 + native DFMC. */
@@ -412,6 +451,8 @@ interface SbfNavigation {
     ephemerides: Ephemeris[];
     /** GPS L2C/L5 CNAV ephemerides (RINEX-4 nav records). */
     cnav: SbfCnavEphemeris[];
+    /** BeiDou-3 B-CNAV1/2/3 ephemerides (RINEX-4 CNV1/CNV2/CNV3 records). */
+    bdsCnav: BdsCnavEphemeris[];
     /**
      * Iono coefficient sets keyed like `NavHeader.ionoCorrections`
      * (GPSA/GPSB, GAL, BDSA/BDSB); the last valid block of each type wins.
@@ -426,7 +467,7 @@ interface SbfNavigation {
 }
 /**
  * Decode every navigation block in an SBF byte stream in a single pass:
- * decoded ephemeris blocks, raw GPS/QZSS LNAV, GPS CNAV, Galileo I/NAV +
+ * decoded ephemeris blocks, raw GPS/QZSS LNAV, GPS CNAV, BeiDou-3 B-CNAV, Galileo I/NAV +
  * F/NAV, GLONASS strings, BeiDou D1/D2, and the Klobuchar/NeQuick iono +
  * GPS-UTC leap-second blocks. See the module header for merge semantics.
  */
@@ -671,4 +712,4 @@ interface SbfParseResult {
  */
 declare function parseSbfMeas(data: Uint8Array): SbfParseResult;
 
-export { CnavEphemeris, type DfmcCensus, type DfmcMessageCb, type GeoL5Result, HasMessage, ReceiverPvt, SBAS_L5_MT_NAMES, SBAS_L5_PREAMBLE_UW, type SbasMessageCb, type SbfBdsNavResult, type SbfCnavEphemeris, type SbfCnavResult, type SbfGalEphemeris, type SbfGalNavResult, type SbfGeoL5Result, type SbfGeoNavResult, type SbfGloNavResult, type SbfGpsNavResult, type SbfHasMessage, type SbfHasResult, type SbfIonoUtcResult, type SbfMeasEpoch, type SbfMeasurement, type SbfNavCounts, type SbfNavicResult, type SbfNavigation, type SbfParseResult, type SbfPvt, type SbfPvtResult, type SbfReceiverSetup, decodeSbfNavigation, extractSbfNavicSubframe, feedGeoBlock, feedGeoL5Block, feedNavicBlock, isSbasL1Preamble, isSbasL5Correction, parseSbfBdsNav, parseSbfCnav, parseSbfGalNav, parseSbfGeoL5, parseSbfGeoNav, parseSbfGloNav, parseSbfGpsNav, parseSbfHas, parseSbfIonoUtc, parseSbfMeas, parseSbfNavic, parseSbfPvt, parseSbfReceiverSetup, sbasL5MessageName, sbasL5MessageType, crc16 as sbfCrc16, scanSbfFrames };
+export { BdsCnavEphemeris, CnavEphemeris, type DfmcCensus, type DfmcMessageCb, type GeoL5Result, HasMessage, ReceiverPvt, SBAS_L5_MT_NAMES, SBAS_L5_PREAMBLE_UW, type SbasMessageCb, type SbfBdsCnavResult, type SbfBdsNavResult, type SbfCnavEphemeris, type SbfCnavResult, type SbfGalEphemeris, type SbfGalNavResult, type SbfGeoL5Result, type SbfGeoNavResult, type SbfGloNavResult, type SbfGpsNavResult, type SbfHasMessage, type SbfHasResult, type SbfIonoUtcResult, type SbfMeasEpoch, type SbfMeasurement, type SbfNavCounts, type SbfNavicResult, type SbfNavigation, type SbfParseResult, type SbfPvt, type SbfPvtResult, type SbfReceiverSetup, decodeSbfNavigation, extractSbfNavicSubframe, feedGeoBlock, feedGeoL5Block, feedNavicBlock, isSbasL1Preamble, isSbasL5Correction, parseSbfBdsCnav, parseSbfBdsNav, parseSbfCnav, parseSbfGalNav, parseSbfGeoL5, parseSbfGeoNav, parseSbfGloNav, parseSbfGpsNav, parseSbfHas, parseSbfIonoUtc, parseSbfMeas, parseSbfNavic, parseSbfPvt, parseSbfReceiverSetup, sbasL5MessageName, sbasL5MessageType, crc16 as sbfCrc16, scanSbfFrames };