gnss-js 1.35.0 → 1.37.0

package/dist/binex.js

@@ -6,8 +6,8 @@ import {
   decodeBinexEph,
   getBnxi,
   parseBinex
-} from "./chunk-OK4GGNOO.js";
-import "./chunk-IQ5OIMQD.js";
+} from "./chunk-D25WNE43.js";
+import "./chunk-V2D5KUKH.js";
 export {
   binexCrc16,
   binexCrc32,

package/dist/{chunk-AFEDNWXI.js → chunk-24TKGUTY.js}

@@ -7,16 +7,18 @@ import {
   galFnavPageCrcOk,
   galInavPageCrcOk,
   testGloString
-} from "./chunk-5AUK42AL.js";
+} from "./chunk-FA2UTLEQ.js";
 import {
   CnavAssembler,
   cnavCrcOk,
   crc24q
-} from "./chunk-726LQBGM.js";
+} from "./chunk-YUW33VXK.js";
 import {
+  GpsLnavAssembler,
   getBitS,
-  getBitU
-} from "./chunk-IQ5OIMQD.js";
+  getBitU,
+  setBitU
+} from "./chunk-V2D5KUKH.js";
 import {
   getGpsLeap
 } from "./chunk-HVXYFUCB.js";
@@ -423,38 +425,78 @@ function parseSbfIonoUtc(data) {
   return { ionoCorrections, leapSeconds };
 }
 
+// src/sbf/rawnav-gps.ts
+var WNC_DNU = 65535;
+function extractSbfLnavSubframe(view, b) {
+  const sf = new Uint8Array(30);
+  for (let k = 0; k < 10; k++) {
+    const w = view.getUint32(b + 20 + 4 * k, true);
+    setBitU(sf, 24 * k, 24, w >>> 6 & 16777215);
+  }
+  return sf;
+}
+function feedGpsLnavBlock(view, b, assembler) {
+  const prn = svidToPrn(view.getUint8(b + 14));
+  if (!prn || prn[0] !== "G" && prn[0] !== "J") return {};
+  if (view.getUint8(b + 15) !== 1) return {};
+  const wnc = view.getUint16(b + 12, true);
+  if (wnc === WNC_DNU) return {};
+  const r = assembler.push(prn, extractSbfLnavSubframe(view, b), wnc);
+  if (r.kind === "eph") return { eph: r.eph };
+  if (r.kind === "decodeFailed") return { badParity: true };
+  return {};
+}
+function parseSbfGpsNav(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ephemerides = [];
+  const assembler = new GpsLnavAssembler();
+  let badParity = 0;
+  let messages = 0;
+  scanSbfFrames(data, view, (id, b, len) => {
+    if (id !== 4017 && id !== 4066 || len < 60) return;
+    messages++;
+    const r = feedGpsLnavBlock(view, b, assembler);
+    if (r.eph) ephemerides.push(r.eph);
+    else if (r.badParity) badParity++;
+  });
+  return { ephemerides, badParity, messages };
+}
+
 // src/sbf/rawnav.ts
-var SIGNAL_OF_BLOCK = {
+var CNAV_SIGNAL_OF_BLOCK = {
   4018: "L2C",
   4019: "L5"
 };
+function newCnavAssemblers() {
+  return { L2C: new CnavAssembler(), L5: new CnavAssembler() };
+}
+function feedCnavBlock(view, b, id, asm) {
+  const signal = CNAV_SIGNAL_OF_BLOCK[id];
+  if (!signal) return {};
+  const msg = new Uint8Array(40);
+  for (let k = 0; k < 10; k++) {
+    const w = view.getUint32(b + 20 + 4 * k, true);
+    msg[4 * k] = w >>> 24;
+    msg[4 * k + 1] = w >>> 16 & 255;
+    msg[4 * k + 2] = w >>> 8 & 255;
+    msg[4 * k + 3] = w & 255;
+  }
+  if (!cnavCrcOk(msg)) return { badCrc: true };
+  const eph = asm[signal].push(msg);
+  return eph ? { eph: { ...eph, signal } } : {};
+}
 function parseSbfCnav(data) {
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
   const ephemerides = [];
-  const assemblers = {
-    L2C: new CnavAssembler(),
-    L5: new CnavAssembler()
-  };
+  const asm = newCnavAssemblers();
   let badCrc = 0;
   let messages = 0;
   scanSbfFrames(data, view, (id, b, len) => {
-    const signal = SIGNAL_OF_BLOCK[id];
-    if (!signal || len < 60) return;
+    if (!CNAV_SIGNAL_OF_BLOCK[id] || len < 60) return;
     messages++;
-    const msg = new Uint8Array(40);
-    for (let k = 0; k < 10; k++) {
-      const w = view.getUint32(b + 20 + 4 * k, true);
-      msg[4 * k] = w >>> 24;
-      msg[4 * k + 1] = w >>> 16 & 255;
-      msg[4 * k + 2] = w >>> 8 & 255;
-      msg[4 * k + 3] = w & 255;
-    }
-    if (!cnavCrcOk(msg)) {
-      badCrc++;
-      return;
-    }
-    const eph = assemblers[signal].push(msg);
-    if (eph) ephemerides.push({ ...eph, signal });
+    const r = feedCnavBlock(view, b, id, asm);
+    if (r.eph) ephemerides.push(r.eph);
+    else if (r.badCrc) badCrc++;
   });
   return { ephemerides, badCrc, messages };
 }
@@ -462,50 +504,51 @@ function parseSbfCnav(data) {
 // src/sbf/rawnav-gal.ts
 var INAV_SOURCES = [17, 21, 22];
 var FNAV_SOURCES = [20, 22];
+function newGalAssemblers() {
+  return { inav: new GalInavAssembler(), fnav: new GalFnavAssembler() };
+}
+function feedGalBlock(data, view, b, id, asm) {
+  const prnStr = svidToPrn(data[b + 14]);
+  if (!prnStr || prnStr[0] !== "E") return {};
+  const prn = parseInt(prnStr.slice(1), 10);
+  const source = data[b + 17] & 31;
+  const page = new Uint8Array(32);
+  for (let k = 0; k < 8; k++) {
+    const w = view.getUint32(b + 20 + 4 * k, true);
+    page[4 * k] = w >>> 24;
+    page[4 * k + 1] = w >>> 16 & 255;
+    page[4 * k + 2] = w >>> 8 & 255;
+    page[4 * k + 3] = w & 255;
+  }
+  let eph;
+  let src;
+  if (id === 4023) {
+    src = "inav";
+    if (!INAV_SOURCES.includes(source)) return {};
+    if (getBitU2(page, 0) !== 0 || getBitU2(page, 114) !== 1) return {};
+    if (!galInavPageCrcOk(page)) return { badCrc: true };
+    eph = asm.inav.push(prn, page);
+  } else {
+    src = "fnav";
+    if (!FNAV_SOURCES.includes(source)) return {};
+    if (isFnavDummy(page)) return {};
+    if (!galFnavPageCrcOk(page)) return { badCrc: true };
+    eph = asm.fnav.push(prn, page);
+  }
+  return eph ? { eph: { ...eph, source: src } } : {};
+}
 function parseSbfGalNav(data) {
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
   const ephemerides = [];
-  const inav = new GalInavAssembler();
-  const fnav = new GalFnavAssembler();
+  const asm = newGalAssemblers();
   let badCrc = 0;
   let messages = 0;
   scanSbfFrames(data, view, (id, b, len) => {
     if (id !== 4022 && id !== 4023 || len < 52) return;
     messages++;
-    const prnStr = svidToPrn(data[b + 14]);
-    if (!prnStr || prnStr[0] !== "E") return;
-    const prn = parseInt(prnStr.slice(1), 10);
-    const source = data[b + 17] & 31;
-    const page = new Uint8Array(32);
-    for (let k = 0; k < 8; k++) {
-      const w = view.getUint32(b + 20 + 4 * k, true);
-      page[4 * k] = w >>> 24;
-      page[4 * k + 1] = w >>> 16 & 255;
-      page[4 * k + 2] = w >>> 8 & 255;
-      page[4 * k + 3] = w & 255;
-    }
-    let eph;
-    let src;
-    if (id === 4023) {
-      src = "inav";
-      if (!INAV_SOURCES.includes(source)) return;
-      if (getBitU2(page, 0) !== 0 || getBitU2(page, 114) !== 1) return;
-      if (!galInavPageCrcOk(page)) {
-        badCrc++;
-        return;
-      }
-      eph = inav.push(prn, page);
-    } else {
-      src = "fnav";
-      if (!FNAV_SOURCES.includes(source)) return;
-      if (isFnavDummy(page)) return;
-      if (!galFnavPageCrcOk(page)) {
-        badCrc++;
-        return;
-      }
-      eph = fnav.push(prn, page);
-    }
-    if (eph) ephemerides.push({ ...eph, source: src });
+    const r = feedGalBlock(data, view, b, id, asm);
+    if (r.eph) ephemerides.push(r.eph);
+    else if (r.badCrc) badCrc++;
   });
   return { ephemerides, badCrc, messages };
 }
@@ -520,7 +563,26 @@ function isFnavDummy(page) {
 var GPS_EPOCH_MS2 = Date.UTC(1980, 0, 6);
 var MS_PER_WEEK2 = 7 * 86400 * 1e3;
 var TOW_DNU = 4294967295;
-var WNC_DNU = 65535;
+var WNC_DNU2 = 65535;
+function feedBdsBlock(view, b, assembler) {
+  const prn = svidToPrn(view.getUint8(b + 14));
+  if (!prn || prn[0] !== "C") return {};
+  const sf = new Uint8Array(38);
+  for (let k = 0; k < 10; k++) {
+    const w = view.getUint32(b + 20 + 4 * k, true);
+    sf[4 * k] = w >>> 24;
+    if (k < 9) {
+      sf[4 * k + 1] = w >>> 16 & 255;
+      sf[4 * k + 2] = w >>> 8 & 255;
+      sf[4 * k + 3] = w & 255;
+    } else {
+      sf[37] = w >>> 16 & 240;
+    }
+  }
+  if (!bdsSubframeParityOk(sf)) return { badCrc: true };
+  const eph = assembler.push(prn, sf);
+  return eph ? { eph } : {};
+}
 function parseSbfBdsNav(data) {
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
   const ephemerides = [];
@@ -530,29 +592,41 @@ function parseSbfBdsNav(data) {
   scanSbfFrames(data, view, (id, b, len) => {
     if (id !== 4047 || len < 60) return;
     messages++;
-    const prn = svidToPrn(view.getUint8(b + 14));
-    if (!prn || prn[0] !== "C") return;
-    const sf = new Uint8Array(38);
-    for (let k = 0; k < 10; k++) {
-      const w = view.getUint32(b + 20 + 4 * k, true);
-      sf[4 * k] = w >>> 24;
-      if (k < 9) {
-        sf[4 * k + 1] = w >>> 16 & 255;
-        sf[4 * k + 2] = w >>> 8 & 255;
-        sf[4 * k + 3] = w & 255;
-      } else {
-        sf[37] = w >>> 16 & 240;
-      }
-    }
-    if (!bdsSubframeParityOk(sf)) {
-      badCrc++;
-      return;
-    }
-    const eph = assembler.push(prn, sf);
-    if (eph) ephemerides.push(eph);
+    const r = feedBdsBlock(view, b, assembler);
+    if (r.eph) ephemerides.push(r.eph);
+    else if (r.badCrc) badCrc++;
   });
   return { ephemerides, badCrc, messages };
 }
+function feedGloBlock(view, b, assembler) {
+  const prn = svidToPrn(view.getUint8(b + 14));
+  if (!prn || prn[0] !== "R") return {};
+  const towMs = view.getUint32(b + 8, true);
+  const wnc = view.getUint16(b + 12, true);
+  if (towMs === TOW_DNU || wnc === WNC_DNU2) return {};
+  const str = new Uint8Array(11);
+  for (let k = 0; k < 3; k++) {
+    const w = view.getUint32(b + 20 + 4 * k, true);
+    str[4 * k] = w >>> 24;
+    if (k < 2) {
+      str[4 * k + 1] = w >>> 16 & 255;
+      str[4 * k + 2] = w >>> 8 & 255;
+      str[4 * k + 3] = w & 255;
+    } else {
+      str[9] = w >>> 16 & 255;
+      str[10] = w >>> 8 & 248;
+    }
+  }
+  if (!testGloString(str)) return { badCrc: true };
+  const eph = assembler.push(
+    prn,
+    str,
+    new Date(GPS_EPOCH_MS2 + wnc * MS_PER_WEEK2 + towMs),
+    view.getUint8(b + 18) - 8
+    // FreqNr, offset by 8
+  );
+  return eph ? { eph } : {};
+}
 function parseSbfGloNav(data) {
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
   const ephemerides = [];
@@ -562,38 +636,161 @@ function parseSbfGloNav(data) {
   scanSbfFrames(data, view, (id, b, len) => {
     if (id !== 4026 || len < 32) return;
     messages++;
-    const prn = svidToPrn(view.getUint8(b + 14));
-    if (!prn || prn[0] !== "R") return;
-    const towMs = view.getUint32(b + 8, true);
-    const wnc = view.getUint16(b + 12, true);
-    if (towMs === TOW_DNU || wnc === WNC_DNU) return;
-    const str = new Uint8Array(11);
-    for (let k = 0; k < 3; k++) {
-      const w = view.getUint32(b + 20 + 4 * k, true);
-      str[4 * k] = w >>> 24;
-      if (k < 2) {
-        str[4 * k + 1] = w >>> 16 & 255;
-        str[4 * k + 2] = w >>> 8 & 255;
-        str[4 * k + 3] = w & 255;
-      } else {
-        str[9] = w >>> 16 & 255;
-        str[10] = w >>> 8 & 248;
-      }
+    const r = feedGloBlock(view, b, assembler);
+    if (r.eph) ephemerides.push(r.eph);
+    else if (r.badCrc) badCrc++;
+  });
+  return { ephemerides, badCrc, messages };
+}
+
+// src/sbf/navigation.ts
+var F4_DNU3 = -2e10;
+function ephKey(e) {
+  const source = "source" in e ? e.source : "";
+  return `${e.prn}|${e.tocDate.getTime()}|${source}`;
+}
+function decodeSbfNavigation(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ephemerides = [];
+  const seen = /* @__PURE__ */ new Set();
+  const cnav = [];
+  const ionoCorrections = {};
+  let leapSeconds = null;
+  const counts = {
+    decodedNav: 0,
+    gpsLnavRaw: 0,
+    cnavRaw: 0,
+    galRaw: 0,
+    gloRaw: 0,
+    bdsRaw: 0,
+    badFrames: 0
+  };
+  const cnavAsm = newCnavAssemblers();
+  const galAsm = newGalAssemblers();
+  const gloAsm = new GloStringAssembler();
+  const bdsAsm = new BdsAssembler();
+  const lnavAsm = new GpsLnavAssembler();
+  const addEph = (e) => {
+    if (!e) return;
+    const key = ephKey(e);
+    if (seen.has(key)) return;
+    seen.add(key);
+    ephemerides.push(e);
+  };
+  const f4s = (b, n) => {
+    const out = [];
+    for (let k = 0; k < n; k++) {
+      const v = view.getFloat32(b + 4 * k, true);
+      if (v === F4_DNU3) return null;
+      out.push(v);
     }
-    if (!testGloString(str)) {
-      badCrc++;
-      return;
+    return out;
+  };
+  scanSbfFrames(data, view, (id, b, len) => {
+    switch (id) {
+      /* ---- decoded ephemeris blocks ---- */
+      case 5891:
+        if (len >= 140) {
+          counts.decodedNav++;
+          addEph(decodeGpsQzsNav(view, b, "G"));
+        }
+        return;
+      case 4095:
+        if (len >= 140) {
+          counts.decodedNav++;
+          addEph(decodeGpsQzsNav(view, b, "J"));
+        }
+        return;
+      case 4002:
+        if (len >= 149) {
+          counts.decodedNav++;
+          addEph(decodeGalNav(view, b));
+        }
+        return;
+      case 4081:
+        if (len >= 140) {
+          counts.decodedNav++;
+          addEph(decodeBdsNav(view, b));
+        }
+        return;
+      case 4004:
+        if (len >= 96) {
+          counts.decodedNav++;
+          addEph(decodeGloNav(view, b));
+        }
+        return;
+      /* ---- raw navigation-frame blocks ---- */
+      case 4017:
+      // GPSRawCA
+      case 4066: {
+        if (len < 60) return;
+        counts.gpsLnavRaw++;
+        const r = feedGpsLnavBlock(view, b, lnavAsm);
+        if (r.eph) addEph(r.eph);
+        else if (r.badParity) counts.badFrames++;
+        return;
+      }
+      case 4018:
+      // GPSRawL2C
+      case 4019: {
+        if (len < 60) return;
+        counts.cnavRaw++;
+        const r = feedCnavBlock(view, b, id, cnavAsm);
+        if (r.eph) cnav.push(r.eph);
+        else if (r.badCrc) counts.badFrames++;
+        return;
+      }
+      case 4022:
+      // GALRawFNAV
+      case 4023: {
+        if (len < 52) return;
+        counts.galRaw++;
+        const r = feedGalBlock(data, view, b, id, galAsm);
+        if (r.eph) addEph(r.eph);
+        else if (r.badCrc) counts.badFrames++;
+        return;
+      }
+      case 4026: {
+        if (len < 32) return;
+        counts.gloRaw++;
+        const r = feedGloBlock(view, b, gloAsm);
+        if (r.eph) addEph(r.eph);
+        else if (r.badCrc) counts.badFrames++;
+        return;
+      }
+      case 4047: {
+        if (len < 60) return;
+        counts.bdsRaw++;
+        const r = feedBdsBlock(view, b, bdsAsm);
+        if (r.eph) addEph(r.eph);
+        else if (r.badCrc) counts.badFrames++;
+        return;
+      }
+      /* ---- iono / UTC ---- */
+      case 5893:
+      // GPSIon
+      case 4120: {
+        if (len < 48) return;
+        const alpha = f4s(b + 16, 4);
+        const beta = f4s(b + 32, 4);
+        if (!alpha || !beta) return;
+        const sys = id === 5893 ? "GPS" : "BDS";
+        ionoCorrections[`${sys}A`] = alpha;
+        ionoCorrections[`${sys}B`] = beta;
+        return;
+      }
+      case 4030: {
+        if (len < 28) return;
+        const ai = f4s(b + 16, 3);
+        if (ai) ionoCorrections["GAL"] = ai;
+        return;
+      }
+      case 5894:
+        if (len >= 37) leapSeconds = view.getInt8(b + 33);
+        return;
     }
-    const eph = assembler.push(
-      prn,
-      str,
-      new Date(GPS_EPOCH_MS2 + wnc * MS_PER_WEEK2 + towMs),
-      view.getUint8(b + 18) - 8
-      // FreqNr, offset by 8
-    );
-    if (eph) ephemerides.push(eph);
   });
-  return { ephemerides, badCrc, messages };
+  return { ephemerides, cnav, ionoCorrections, leapSeconds, counts };
 }
 
 // src/navbits/rs255.ts
@@ -1793,10 +1990,12 @@ export {
   parseSbfNav,
   parseSbfAlmanac,
   parseSbfIonoUtc,
+  parseSbfGpsNav,
   parseSbfCnav,
   parseSbfGalNav,
   parseSbfBdsNav,
   parseSbfGloNav,
+  decodeSbfNavigation,
   parseSbfHas,
   parseSbfMeas
 };

package/dist/{chunk-BLGBMRX7.js → chunk-3FG4XVCB.js}

@@ -1959,6 +1959,28 @@ function solvePpp(epochs, sp3, opts) {
       phaseResRms: nPhaseRes > 0 ? Math.sqrt(sumPhaseResSq / nPhaseRes) : 0
     });
   }
+  let finalState;
+  if (opts.exposeState) {
+    const ambs = [];
+    for (const [prn, index] of ambIdx) {
+      const s = arcSnap.get(prn);
+      if (!s || s.nEpochs < 10) continue;
+      ambs.push({
+        prn,
+        index,
+        aIF: x[index],
+        mwCyc: mwState.get(prn)?.mean ?? s.mwCyc,
+        f1: s.f1,
+        f2: s.f2,
+        elevDeg: s.elevSum / s.nEpochs
+      });
+    }
+    finalState = {
+      position: [x[IDX_X], x[IDX_Y], x[IDX_Z]],
+      covariance: P.map((row) => row.slice()),
+      ambiguities: ambs
+    };
+  }
   for (const prn of [...arcSnap.keys()]) flushArc(prn);
   const finalPos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
   const llh = ecefToGeodetic(finalPos[0], finalPos[1], finalPos[2]);
@@ -1975,7 +1997,8 @@ function solvePpp(epochs, sp3, opts) {
     epochsUsed: epochs.length,
     convergenceSec,
     finalError3d,
-    arcs
+    arcs,
+    finalState
   };
 }
 
@@ -2068,6 +2091,117 @@ function resolvePppAmbiguities(sats, Qaif, opts = {}) {
     rejectedWl
   };
 }
+function solveSpd(A, b) {
+  const n = b.length;
+  const L = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j <= i; j++) {
+      let s = A[i][j];
+      for (let k = 0; k < j; k++) s -= L[i][k] * L[j][k];
+      if (i === j) {
+        if (s <= 0) return null;
+        L[i][j] = Math.sqrt(s);
+      } else {
+        L[i][j] = s / L[j][j];
+      }
+    }
+  }
+  const y = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    let s = b[i];
+    for (let k = 0; k < i; k++) s -= L[i][k] * y[k];
+    y[i] = s / L[i][i];
+  }
+  const x = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let s = y[i];
+    for (let k = i + 1; k < n; k++) s -= L[k][i] * x[k];
+    x[i] = s / L[i][i];
+  }
+  return x;
+}
+function fixPppPosition(state, fcb, opts = {}) {
+  const floatPos = state.position;
+  const noFix = {
+    fixed: false,
+    position: floatPos,
+    floatPosition: floatPos,
+    shift: [0, 0, 0],
+    nFixed: 0,
+    ratio: 0,
+    refPrn: null
+  };
+  const amb = state.ambiguities;
+  if (amb.length < 3) return noFix;
+  const sats = amb.map((a) => ({
+    prn: a.prn,
+    aIF: a.aIF,
+    mwCyc: a.mwCyc,
+    f1: a.f1,
+    f2: a.f2,
+    wlBiasCyc: fcb.satWlFcb.get(a.prn) ?? 0,
+    nlBiasCyc: fcb.satNlFcb.get(a.prn) ?? 0,
+    elevDeg: a.elevDeg
+  }));
+  const n = sats.length;
+  const Qaif = new Float64Array(n * n);
+  for (let i = 0; i < n; i++)
+    for (let j = 0; j < n; j++)
+      Qaif[i * n + j] = state.covariance[amb[i].index][amb[j].index];
+  const res = resolvePppAmbiguities(sats, Qaif, opts);
+  if (!res.fixed || res.refPrn === null) {
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  }
+  const idxOfPrn = new Map(amb.map((a) => [a.prn, a.index]));
+  const floatOfPrn = new Map(amb.map((a) => [a.prn, a.aIF]));
+  const kept = res.sats.filter((s) => idxOfPrn.has(s.prn));
+  const refPos = kept.findIndex((s) => s.prn === res.refPrn);
+  if (refPos < 0 || kept.length < 2) {
+    return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  }
+  const ambIdx = kept.map((s) => idxOfPrn.get(s.prn));
+  const aFloat = kept.map((s) => floatOfPrn.get(s.prn));
+  const aFixed = kept.map((s) => s.aIF);
+  const others = kept.map((_, i) => i).filter((i) => i !== refPos);
+  const m = others.length;
+  const P = state.covariance;
+  const qAA = (i, j) => P[ambIdx[i]][ambIdx[j]];
+  const qXA = (r, i) => P[r][ambIdx[i]];
+  const Qzz = Array.from({ length: m }, () => new Array(m).fill(0));
+  const z = new Array(m).fill(0);
+  for (let a = 0; a < m; a++) {
+    const ia = others[a];
+    z[a] = aFloat[ia] - aFloat[refPos] - (aFixed[ia] - aFixed[refPos]);
+    for (let b = 0; b < m; b++) {
+      const ib = others[b];
+      Qzz[a][b] = qAA(ia, ib) - qAA(ia, refPos) - qAA(refPos, ib) + qAA(refPos, refPos);
+    }
+  }
+  const Qxz = [0, 1, 2].map(
+    (r) => others.map((ia) => qXA(r, ia) - qXA(r, refPos))
+  );
+  const y = solveSpd(Qzz, z);
+  if (!y) return { ...noFix, ratio: res.ratio, refPrn: res.refPrn };
+  const shift = [0, 0, 0];
+  for (let r = 0; r < 3; r++) {
+    let s = 0;
+    for (let a = 0; a < m; a++) s += Qxz[r][a] * y[a];
+    shift[r] = -s;
+  }
+  return {
+    fixed: true,
+    position: [
+      floatPos[0] + shift[0],
+      floatPos[1] + shift[1],
+      floatPos[2] + shift[2]
+    ],
+    floatPosition: floatPos,
+    shift,
+    nFixed: m,
+    ratio: res.ratio,
+    refPrn: res.refPrn
+  };
+}
 
 // src/positioning/ppp-fcb.ts
 function extractWidelaneArcs(station, epochs, opts = {}) {
@@ -2504,6 +2638,7 @@ export {
   wlWavelength,
   nlWavelength,
   resolvePppAmbiguities,
+  fixPppPosition,
   extractWidelaneArcs,
   estimateWidelaneFcb,
   estimateNarrowlaneFcb,

package/dist/{chunk-F4CM6Q4F.js → chunk-5X4AG4MK.js}

@@ -1,10 +1,10 @@
 import {
   CnavAssembler,
   cnavCrcOk
-} from "./chunk-726LQBGM.js";
+} from "./chunk-YUW33VXK.js";
 import {
   decodeGpsLnavFrame
-} from "./chunk-IQ5OIMQD.js";
+} from "./chunk-V2D5KUKH.js";
 import {
   getUtcDate
 } from "./chunk-HVXYFUCB.js";

package/dist/{chunk-5RNDQQ6J.js → chunk-6SWJTN6H.js}

@@ -1,10 +1,10 @@
 import {
   CNAV_A_REF,
   CNAV_OMEGA_DOT_REF
-} from "./chunk-726LQBGM.js";
+} from "./chunk-YUW33VXK.js";
 import {
   GPS_PI
-} from "./chunk-IQ5OIMQD.js";
+} from "./chunk-V2D5KUKH.js";
 import {
   C_LIGHT
 } from "./chunk-FIEWO4J4.js";