gnss-js 1.22.0 → 1.24.0

package/dist/positioning.cjs

@@ -20,10 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/positioning/index.ts
 var positioning_exports = {};
 __export(positioning_exports, {
+  RtkFloatEngine: () => RtkFloatEngine,
   ionoFree: () => ionoFree,
   klobucharDelay: () => klobucharDelay,
+  lambdaReduction: () => lambdaReduction,
+  lambdaSearch: () => lambdaSearch,
   satClockCorrection: () => satClockCorrection,
-  solveSpp: () => solveSpp
+  solveDgnss: () => solveDgnss,
+  solveSpp: () => solveSpp,
+  toRtkEpoch: () => toRtkEpoch
 });
 module.exports = __toCommonJS(positioning_exports);
 
@@ -155,8 +160,7 @@ var GM_GPS = 3986005e8;
 var GM_GAL = 3986004418e5;
 var GM_BDS = 3986004418e5;
 var GM_GLO = 39860044e7;
-var BDS_GEO_MAX_INCLINATION_RAD = 0.1;
-var BDS_GEO_MIN_SEMIMAJOR_AXIS_M = 4e7;
+var BDS_GEO_PRNS = /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 59, 60, 61, 62, 63]);
 var AE_GLO = 6378136;
 var J2_GLO = 108263e-8;
 var TWO_PI = 2 * Math.PI;
@@ -203,7 +207,7 @@ function keplerPosition(eph, t) {
   const yp = rk * Math.sin(uk);
   const xpDot = drkDot * Math.cos(uk) - rk * ukDot * Math.sin(uk);
   const ypDot = drkDot * Math.sin(uk) + rk * ukDot * Math.cos(uk);
-  const isBdsGeo = eph.system === "C" && Math.abs(eph.i0) < BDS_GEO_MAX_INCLINATION_RAD && a > BDS_GEO_MIN_SEMIMAJOR_AXIS_M;
+  const isBdsGeo = eph.system === "C" && BDS_GEO_PRNS.has(Number(eph.prn.slice(1)));
   if (isBdsGeo) {
     const omegak2 = eph.omega0 + eph.omegaDot * tk - OMEGA_E * eph.toe;
     const cosO2 = Math.cos(omegak2);
@@ -393,6 +397,12 @@ function invert4x4(m) {
   }
   return result;
 }
+function selectEphemeris(ephemerides, prn, timeMs) {
+  return selectBest(
+    ephemerides.filter((e) => e.prn === prn),
+    timeMs
+  );
+}
 function computeSatPosition(eph, timeMs) {
   if (eph.system === "R" || eph.system === "S") {
     const leapMs = getGpsLeap(new Date(timeMs)) * 1e3;
@@ -404,6 +414,20 @@ function computeSatPosition(eph, timeMs) {
   if (eph.system === "C") tow = (tow - 14 + 604800) % 604800;
   return keplerPosition(eph, tow);
 }
+function selectBest(ephs, timeMs) {
+  let best = null;
+  let bestDt = Infinity;
+  for (const eph of ephs) {
+    const dt = Math.abs(timeMs - eph.tocDate.getTime());
+    const maxAge = eph.system === "R" || eph.system === "S" ? 18e5 : 4 * 36e5;
+    if (dt > maxAge) continue;
+    if (dt < bestDt) {
+      bestDt = dt;
+      best = eph;
+    }
+  }
+  return best;
+}
 var GPS_EPOCH_MS = START_GPS_TIME.getTime();
 var MS_PER_WEEK = 7 * 864e5;
 var BDS_EPOCH_MS = START_BDS_TIME.getTime();
@@ -440,6 +464,1012 @@ function klobucharDelay(coeffs, latRad, lonRad, azRad, elRad, gpsTowSec) {
   return F * (5e-9 + amp * (1 - x2 / 2 + x2 * x2 / 24));
 }
 
+// src/positioning/lambda.ts
+var LOOPMAX = 1e4;
+var ROUND = (x) => Math.floor(x + 0.5);
+var SGN = (x) => x <= 0 ? -1 : 1;
+function ldFactor(n, Q, L, D) {
+  const A = Float64Array.from(Q);
+  for (let i = n - 1; i >= 0; i--) {
+    D[i] = A[i + i * n];
+    if (D[i] <= 0) return false;
+    const a = Math.sqrt(D[i]);
+    for (let j = 0; j <= i; j++) L[i + j * n] = A[i + j * n] / a;
+    for (let j = 0; j <= i - 1; j++)
+      for (let k = 0; k <= j; k++) A[j + k * n] -= L[i + k * n] * L[i + j * n];
+    for (let j = 0; j <= i; j++) L[i + j * n] /= L[i + i * n];
+  }
+  return true;
+}
+function gauss(n, L, Z, i, j) {
+  const mu = ROUND(L[i + j * n]);
+  if (mu !== 0) {
+    for (let k = i; k < n; k++) L[k + n * j] -= mu * L[k + i * n];
+    for (let k = 0; k < n; k++) Z[k + n * j] -= mu * Z[k + i * n];
+  }
+}
+function perm(n, L, D, j, del, Z) {
+  const eta = D[j] / del;
+  const lam = D[j + 1] * L[j + 1 + j * n] / del;
+  D[j] = eta * D[j + 1];
+  D[j + 1] = del;
+  for (let k = 0; k <= j - 1; k++) {
+    const a0 = L[j + k * n];
+    const a1 = L[j + 1 + k * n];
+    L[j + k * n] = -L[j + 1 + j * n] * a0 + a1;
+    L[j + 1 + k * n] = eta * a0 + lam * a1;
+  }
+  L[j + 1 + j * n] = lam;
+  for (let k = j + 2; k < n; k++) {
+    const t = L[k + j * n];
+    L[k + j * n] = L[k + (j + 1) * n];
+    L[k + (j + 1) * n] = t;
+  }
+  for (let k = 0; k < n; k++) {
+    const t = Z[k + j * n];
+    Z[k + j * n] = Z[k + (j + 1) * n];
+    Z[k + (j + 1) * n] = t;
+  }
+}
+function reduction(n, L, D, Z) {
+  let j = n - 2;
+  let k = n - 2;
+  while (j >= 0) {
+    if (j <= k) for (let i = j + 1; i < n; i++) gauss(n, L, Z, i, j);
+    const del = D[j] + L[j + 1 + j * n] * L[j + 1 + j * n] * D[j + 1];
+    if (del + 1e-6 < D[j + 1]) {
+      perm(n, L, D, j, del, Z);
+      k = j;
+      j = n - 2;
+    } else j--;
+  }
+}
+function search(n, m, L, D, zs, zn, s) {
+  let nn = 0;
+  let imax = 0;
+  let maxdist = 1e99;
+  const S = new Float64Array(n * n);
+  const dist = new Float64Array(n);
+  const zb = new Float64Array(n);
+  const z = new Float64Array(n);
+  const step = new Float64Array(n);
+  let k = n - 1;
+  dist[k] = 0;
+  zb[k] = zs[k];
+  z[k] = ROUND(zb[k]);
+  let y = zb[k] - z[k];
+  step[k] = SGN(y);
+  let c = 0;
+  for (; c < LOOPMAX; c++) {
+    const newdist = dist[k] + y * y / D[k];
+    if (newdist < maxdist) {
+      if (k !== 0) {
+        dist[--k] = newdist;
+        for (let i = 0; i <= k; i++)
+          S[k + i * n] = S[k + 1 + i * n] + (z[k + 1] - zb[k + 1]) * L[k + 1 + i * n];
+        zb[k] = zs[k] + S[k + k * n];
+        z[k] = ROUND(zb[k]);
+        y = zb[k] - z[k];
+        step[k] = SGN(y);
+      } else {
+        if (nn < m) {
+          if (nn === 0 || newdist > s[imax]) imax = nn;
+          for (let i = 0; i < n; i++) zn[i + nn * n] = z[i];
+          s[nn++] = newdist;
+        } else {
+          if (newdist < s[imax]) {
+            for (let i = 0; i < n; i++) zn[i + imax * n] = z[i];
+            s[imax] = newdist;
+            imax = 0;
+            for (let i = 0; i < m; i++) if (s[imax] < s[i]) imax = i;
+          }
+          maxdist = s[imax];
+        }
+        z[0] += step[0];
+        y = zb[0] - z[0];
+        step[0] = -step[0] - SGN(step[0]);
+      }
+    } else {
+      if (k === n - 1) break;
+      k++;
+      z[k] += step[k];
+      y = zb[k] - z[k];
+      step[k] = -step[k] - SGN(step[k]);
+    }
+  }
+  for (let i = 0; i < m - 1; i++) {
+    for (let j = i + 1; j < m; j++) {
+      if (s[i] < s[j]) continue;
+      const t = s[i];
+      s[i] = s[j];
+      s[j] = t;
+      for (let l = 0; l < n; l++) {
+        const u = zn[l + i * n];
+        zn[l + i * n] = zn[l + j * n];
+        zn[l + j * n] = u;
+      }
+    }
+  }
+  return c < LOOPMAX;
+}
+function solveZt(n, m, Z, E) {
+  const w = n + m;
+  const M = new Float64Array(n * w);
+  for (let r = 0; r < n; r++) {
+    for (let cIdx = 0; cIdx < n; cIdx++) M[r * w + cIdx] = Z[cIdx + r * n];
+    for (let cIdx = 0; cIdx < m; cIdx++) M[r * w + n + cIdx] = E[r + cIdx * n];
+  }
+  for (let col = 0; col < n; col++) {
+    let piv = col;
+    for (let r = col + 1; r < n; r++)
+      if (Math.abs(M[r * w + col]) > Math.abs(M[piv * w + col])) piv = r;
+    if (Math.abs(M[piv * w + col]) < 1e-12) return null;
+    if (piv !== col) {
+      for (let cIdx = col; cIdx < w; cIdx++) {
+        const t = M[col * w + cIdx];
+        M[col * w + cIdx] = M[piv * w + cIdx];
+        M[piv * w + cIdx] = t;
+      }
+    }
+    const d = M[col * w + col];
+    for (let cIdx = col; cIdx < w; cIdx++) M[col * w + cIdx] /= d;
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f = M[r * w + col];
+      if (f === 0) continue;
+      for (let cIdx = col; cIdx < w; cIdx++)
+        M[r * w + cIdx] -= f * M[col * w + cIdx];
+    }
+  }
+  const X = new Float64Array(n * m);
+  for (let r = 0; r < n; r++)
+    for (let cIdx = 0; cIdx < m; cIdx++) X[r + cIdx * n] = M[r * w + n + cIdx];
+  return X;
+}
+function lambdaSearch(a, Q, n, m = 2) {
+  if (n <= 0 || m <= 0 || a.length < n || Q.length < n * n) return null;
+  const L = new Float64Array(n * n);
+  const D = new Float64Array(n);
+  if (!ldFactor(n, Q, L, D)) return null;
+  const Z = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) Z[i + i * n] = 1;
+  reduction(n, L, D, Z);
+  const z = new Float64Array(n);
+  for (let j = 0; j < n; j++) {
+    let sum = 0;
+    for (let k = 0; k < n; k++) sum += Z[k + j * n] * a[k];
+    z[j] = sum;
+  }
+  const E = new Float64Array(n * m);
+  const s = new Float64Array(m);
+  if (!search(n, m, L, D, z, E, s)) return null;
+  const F = solveZt(n, m, Z, E);
+  if (!F) return null;
+  const candidates = [];
+  for (let c = 0; c < m; c++) {
+    const v = new Float64Array(n);
+    for (let i = 0; i < n; i++) v[i] = ROUND(F[i + c * n]);
+    candidates.push(v);
+  }
+  const ratio = m >= 2 && s[0] > 0 ? s[1] / s[0] : Infinity;
+  return { candidates, residuals: s, ratio };
+}
+function lambdaReduction(Q, n) {
+  if (n <= 0 || Q.length < n * n) return null;
+  const L = new Float64Array(n * n);
+  const D = new Float64Array(n);
+  if (!ldFactor(n, Q, L, D)) return null;
+  const Z = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) Z[i + i * n] = 1;
+  reduction(n, L, D, Z);
+  return Z;
+}
+
+// src/positioning/rtk.ts
+var L1_CODES = {
+  G: ["1C"],
+  E: ["1C"],
+  R: ["1C"],
+  J: ["1C"],
+  C: ["2I", "1P"]
+  // B1I first (classic B1), then B1C
+};
+function toRtkEpoch(meas) {
+  const out = /* @__PURE__ */ new Map();
+  const rank = /* @__PURE__ */ new Map();
+  for (const m of meas) {
+    const prefs = L1_CODES[m.prn[0]];
+    if (!prefs || m.pr === null || !Number.isFinite(m.pr)) continue;
+    const r = prefs.indexOf(m.code);
+    if (r < 0) continue;
+    const prev = rank.get(m.prn);
+    if (prev !== void 0 && prev <= r) continue;
+    rank.set(m.prn, r);
+    out.set(m.prn, {
+      code: m.code,
+      pr: m.pr,
+      cp: m.cp ?? null,
+      lockTimeMs: m.lockTimeS !== void 0 ? Math.round(m.lockTimeS * 1e3) : void 0,
+      gloChannel: m.gloChannel ?? null
+    });
+  }
+  return out;
+}
+function carrierFreqHz(sys, code, gloChannel) {
+  const band = code[0];
+  switch (sys) {
+    case "G":
+    case "J":
+      return band === "1" ? 157542e4 : band === "2" ? 12276e5 : 117645e4;
+    case "E":
+      return band === "1" ? 157542e4 : band === "5" ? 117645e4 : band === "7" ? 120714e4 : band === "8" ? 1191795e3 : 127875e4;
+    case "C":
+      return band === "1" ? 157542e4 : band === "2" ? 1561098e3 : band === "5" ? 117645e4 : band === "7" ? 120714e4 : 126852e4;
+    case "R": {
+      if (gloChannel === null) return 0;
+      if (band === "1") return 1602e6 + gloChannel * 562500;
+      if (band === "2") return 1246e6 + gloChannel * 437500;
+      return 1202025e3;
+    }
+    default:
+      return 0;
+  }
+}
+function sagnac(pos, travelTimeS) {
+  const theta = OMEGA_E * travelTimeS;
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return [pos.x * c + pos.y * s, -pos.x * s + pos.y * c, pos.z];
+}
+function tropoDelay(elevationRad) {
+  const sinEl = Math.sin(elevationRad);
+  return 2.47 / (sinEl + 0.0121);
+}
+function resolveEphemeris(src, prn, timeMs) {
+  if (Array.isArray(src))
+    return selectEphemeris(src, prn, timeMs);
+  return src.get(prn) ?? null;
+}
+function buildGeometry(rover, base, basePos, ephemerides, timeMs, maskRad, troposphere) {
+  const out = [];
+  for (const [prn, mR] of rover) {
+    const sys = prn[0];
+    if (!"GERCJ".includes(sys)) continue;
+    const mB = base.get(prn);
+    if (!mB || mB.code !== mR.code) continue;
+    if (mR.pr === null || mB.pr === null || !Number.isFinite(mR.pr) || !Number.isFinite(mB.pr))
+      continue;
+    const eph = resolveEphemeris(ephemerides, prn, timeMs);
+    if (!eph) continue;
+    const satAt = (pr) => {
+      const tTx = timeMs - pr / C_LIGHT * 1e3;
+      const dts = satClockCorrection(eph, tTx);
+      const sat = computeSatPosition(eph, tTx - dts * 1e3);
+      return Number.isFinite(sat.x) ? sat : null;
+    };
+    const satB = satAt(mB.pr);
+    const satR = satAt(mR.pr);
+    if (!satB || !satR) continue;
+    const travelB = Math.hypot(
+      satB.x - basePos[0],
+      satB.y - basePos[1],
+      satB.z - basePos[2]
+    ) / C_LIGHT;
+    const [bx, by, bz] = sagnac(satB, travelB);
+    const rhoB = Math.hypot(bx - basePos[0], by - basePos[1], bz - basePos[2]);
+    const elB = ecefToAzEl(basePos[0], basePos[1], basePos[2], bx, by, bz).el;
+    if (elB < maskRad) continue;
+    const gloK = sys === "R" ? mR.gloChannel ?? mB.gloChannel ?? eph.freqNum ?? null : null;
+    const freq = carrierFreqHz(sys, mR.code, gloK);
+    out.push({
+      prn,
+      group: sys + mR.code,
+      lambda: freq > 0 ? C_LIGHT / freq : 0,
+      satR,
+      rhoB,
+      elB,
+      tropoB: troposphere ? tropoDelay(elB) : 0,
+      prR: mR.pr,
+      prB: mB.pr,
+      cpR: mR.cp ?? null,
+      cpB: mB.cp ?? null,
+      lockR: mR.lockTimeMs,
+      lockB: mB.lockTimeMs
+    });
+  }
+  return out;
+}
+function roverTerms(g, x, y, z, troposphere) {
+  const travel = Math.hypot(g.satR.x - x, g.satR.y - y, g.satR.z - z) / C_LIGHT;
+  const [sx, sy, sz] = sagnac(g.satR, travel);
+  const rho = Math.hypot(sx - x, sy - y, sz - z);
+  const u = [
+    (x - sx) / rho,
+    (y - sy) / rho,
+    (z - sz) / rho
+  ];
+  let dTropo = 0;
+  if (troposphere) {
+    const elR = ecefToAzEl(x, y, z, sx, sy, sz).el;
+    dTropo = tropoDelay(Math.max(elR, 0.05)) - g.tropoB;
+  }
+  return { rho, u, dTropo };
+}
+function sdVariance(sigmaM, elRad) {
+  const sinEl = Math.max(Math.sin(elRad), 0.05);
+  return 2 * sigmaM * sigmaM * (1 + 1 / (sinEl * sinEl));
+}
+function zeros(n, m) {
+  return Array.from({ length: n }, () => new Array(m).fill(0));
+}
+function matInv(A) {
+  const n = A.length;
+  const M = A.map((row, i) => {
+    const r = [...row, ...new Array(n).fill(0)];
+    r[n + i] = 1;
+    return r;
+  });
+  for (let col = 0; col < n; col++) {
+    let pivot = col;
+    for (let r = col + 1; r < n; r++) {
+      if (Math.abs(M[r][col]) > Math.abs(M[pivot][col])) pivot = r;
+    }
+    if (Math.abs(M[pivot][col]) < 1e-13) return null;
+    [M[col], M[pivot]] = [M[pivot], M[col]];
+    const d = M[col][col];
+    for (let c = 0; c < 2 * n; c++) M[col][c] /= d;
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f = M[r][col];
+      if (f === 0) continue;
+      for (let c = 0; c < 2 * n; c++) M[r][c] -= f * M[col][c];
+    }
+  }
+  return M.map((row) => row.slice(n));
+}
+function matMul(A, B) {
+  const n = A.length;
+  const k = B.length;
+  const m = B[0]?.length ?? 0;
+  const C = zeros(n, m);
+  for (let i = 0; i < n; i++) {
+    for (let l = 0; l < k; l++) {
+      const a = A[i][l];
+      if (a === 0) continue;
+      for (let j = 0; j < m; j++) C[i][j] += a * B[l][j];
+    }
+  }
+  return C;
+}
+function transpose(A) {
+  const n = A.length;
+  const m = A[0]?.length ?? 0;
+  const T = zeros(m, n);
+  for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) T[j][i] = A[i][j];
+  return T;
+}
+function groupEntries(geom) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const g of geom) {
+    const list = groups.get(g.group);
+    if (list) list.push(g);
+    else groups.set(g.group, [g]);
+  }
+  return groups;
+}
+function ddCovariance(rows, sigmaCode, sigmaPhase) {
+  const n = rows.length;
+  const R = zeros(n, n);
+  const sd = (r, g) => sdVariance(r.kind === "code" ? sigmaCode : sigmaPhase, g.elB);
+  for (let i = 0; i < n; i++) {
+    const ri = rows[i];
+    R[i][i] = sd(ri, ri.g) + sd(ri, ri.ref);
+    for (let j = i + 1; j < n; j++) {
+      const rj = rows[j];
+      if (ri.ref.prn === rj.ref.prn && ri.kind === rj.kind && ri.g.group === rj.g.group) {
+        R[i][j] = R[j][i] = sd(ri, ri.ref);
+      }
+    }
+  }
+  return R;
+}
+function solveDgnss(rover, base, basePos, ephemerides, timeMs, opts = {}) {
+  const {
+    elevationMaskDeg = 10,
+    troposphere = true,
+    maxIterations = 15,
+    convergenceM = 1e-4,
+    codeSigmaM = 0.3,
+    rejectThresholdM = 20,
+    initialPosition
+  } = opts;
+  let geom = buildGeometry(
+    rover,
+    base,
+    basePos,
+    ephemerides,
+    timeMs,
+    elevationMaskDeg * Math.PI / 180,
+    troposphere
+  );
+  const rejected = [];
+  for (; ; ) {
+    const groups = groupEntries(geom);
+    const rows = [];
+    const refSatellites = {};
+    for (const [group, list] of groups) {
+      if (list.length < 2) continue;
+      const ref = list.reduce((a, b) => b.elB > a.elB ? b : a);
+      refSatellites[group] = ref.prn;
+      for (const g of list) {
+        if (g === ref) continue;
+        rows.push({
+          g,
+          ref,
+          kind: "code",
+          z: g.prR - g.prB - (ref.prR - ref.prB)
+        });
+      }
+    }
+    if (rows.length < 3) return null;
+    const W = matInv(ddCovariance(rows, codeSigmaM, codeSigmaM));
+    if (!W) return null;
+    let [x, y, z] = initialPosition ?? basePos;
+    let iterations = 0;
+    let converged = false;
+    const residuals = {};
+    let cov = null;
+    for (let iter = 0; iter < maxIterations; iter++) {
+      iterations = iter + 1;
+      const H = [];
+      const v = [];
+      const terms = /* @__PURE__ */ new Map();
+      const termOf = (g) => {
+        let t = terms.get(g.prn);
+        if (!t) {
+          t = roverTerms(g, x, y, z, troposphere);
+          terms.set(g.prn, t);
+        }
+        return t;
+      };
+      for (const row of rows) {
+        const ts = termOf(row.g);
+        const tr = termOf(row.ref);
+        const pred = ts.rho - row.g.rhoB + ts.dTropo - (tr.rho - row.ref.rhoB + tr.dTropo);
+        v.push(row.z - pred);
+        H.push([ts.u[0] - tr.u[0], ts.u[1] - tr.u[1], ts.u[2] - tr.u[2]]);
+      }
+      const Ht = transpose(H);
+      const HtW = matMul(Ht, W);
+      const N = matMul(HtW, H);
+      const b = matMul(
+        HtW,
+        v.map((s) => [s])
+      );
+      const Ninv = matInv(N);
+      if (!Ninv) return null;
+      const dx = matMul(
+        Ninv,
+        b.map((r) => [r[0]])
+      );
+      x += dx[0][0];
+      y += dx[1][0];
+      z += dx[2][0];
+      cov = Ninv;
+      rows.forEach((row, i) => {
+        residuals[row.g.prn] = v[i] - (H[i][0] * dx[0][0] + H[i][1] * dx[1][0] + H[i][2] * dx[2][0]);
+      });
+      if (Math.hypot(dx[0][0], dx[1][0], dx[2][0]) < convergenceM) {
+        converged = true;
+        break;
+      }
+    }
+    let worst = null;
+    let worstAbs = rejectThresholdM;
+    for (const [prn, r] of Object.entries(residuals)) {
+      if (Math.abs(r) > worstAbs) {
+        worstAbs = Math.abs(r);
+        worst = prn;
+      }
+    }
+    if (worst && geom.length > 4) {
+      rejected.push(worst);
+      geom = geom.filter((g) => g.prn !== worst);
+      continue;
+    }
+    const usedSatellites = [
+      ...new Set(rows.flatMap((r) => [r.g.prn, r.ref.prn]))
+    ].sort();
+    return {
+      position: [x, y, z],
+      baseline: [x - basePos[0], y - basePos[1], z - basePos[2]],
+      sigmas: cov ? [
+        Math.sqrt(Math.max(cov[0][0], 0)),
+        Math.sqrt(Math.max(cov[1][1], 0)),
+        Math.sqrt(Math.max(cov[2][2], 0))
+      ] : [0, 0, 0],
+      usedSatellites,
+      refSatellites,
+      residuals,
+      rejectedSatellites: rejected,
+      nSats: usedSatellites.length,
+      iterations,
+      converged
+    };
+  }
+}
+var RtkFloatEngine = class {
+  basePos;
+  ephemerides;
+  o;
+  /** State vector [x, y, z, N₁…] and covariance; null before init. */
+  x = null;
+  P = [];
+  amb = [];
+  refs = /* @__PURE__ */ new Map();
+  track = /* @__PURE__ */ new Map();
+  lastMs = null;
+  constructor(basePos, ephemerides, opts = {}) {
+    this.basePos = basePos;
+    this.ephemerides = ephemerides;
+    this.o = {
+      mode: opts.mode ?? "kinematic",
+      elevationMaskDeg: opts.elevationMaskDeg ?? 10,
+      troposphere: opts.troposphere ?? true,
+      codeSigmaM: opts.codeSigmaM ?? 0.3,
+      phaseSigmaM: opts.phaseSigmaM ?? 3e-3,
+      processNoisePosM: opts.processNoisePosM ?? 0,
+      kinematicSigmaM: opts.kinematicSigmaM ?? 30,
+      ambProcessNoiseCycles: opts.ambProcessNoiseCycles ?? 1e-4,
+      ambInitSigmaCycles: opts.ambInitSigmaCycles ?? 30,
+      maxGapMs: opts.maxGapMs ?? 1e4,
+      codeGateM: opts.codeGateM ?? 30,
+      slipGateM: opts.slipGateM ?? 5,
+      updateIterations: opts.updateIterations ?? 2,
+      ambiguityResolution: opts.ambiguityResolution ?? "off",
+      ratioThreshold: opts.ratioThreshold ?? 3,
+      arElevationMaskDeg: opts.arElevationMaskDeg ?? 0,
+      glonassAr: opts.glonassAr ?? false,
+      partialFixing: opts.partialFixing ?? true,
+      minFixAmbiguities: opts.minFixAmbiguities ?? 4
+    };
+  }
+  /** Clear all filter state (position, ambiguities, lock history). */
+  reset() {
+    this.x = null;
+    this.P = [];
+    this.amb = [];
+    this.refs.clear();
+    this.track.clear();
+    this.lastMs = null;
+  }
+  ambIndex(prn) {
+    return this.amb.findIndex((a) => a.prn === prn);
+  }
+  /** Remove one ambiguity state (row/col) from x and P. */
+  dropAmb(idx) {
+    const s = 3 + idx;
+    this.amb.splice(idx, 1);
+    this.x.splice(s, 1);
+    this.P.splice(s, 1);
+    for (const row of this.P) row.splice(s, 1);
+  }
+  /** Append an ambiguity state with the given value and variance. */
+  addAmb(entry, value, variance) {
+    this.amb.push(entry);
+    this.x.push(value);
+    const n = this.x.length;
+    for (const row of this.P) row.push(0);
+    const newRow = new Array(n).fill(0);
+    newRow[n - 1] = variance;
+    this.P.push(newRow);
+  }
+  /**
+   * Re-map a group's DD ambiguities from the old reference r to the
+   * new reference r' (which must hold a state): N_i' = N_i − N_r' and
+   * the old reference's slot becomes N_r = −N_r'. Exact linear
+   * transform of state and covariance (P' = T P Tᵀ).
+   */
+  retarget(group, oldRef, newRefIdx) {
+    const n = this.x.length;
+    const j = 3 + newRefIdx;
+    const T = zeros(n, n);
+    for (let i = 0; i < n; i++) T[i][i] = 1;
+    for (let k = 0; k < this.amb.length; k++) {
+      if (this.amb[k].group !== group) continue;
+      const s = 3 + k;
+      if (s === j) T[s][s] = -1;
+      else T[s][j] -= 1;
+    }
+    this.x = matMul(
+      T,
+      this.x.map((v) => [v])
+    ).map((r) => r[0]);
+    this.P = matMul(matMul(T, this.P), transpose(T));
+    const entry = this.amb[newRefIdx];
+    entry.prn = oldRef;
+  }
+  /**
+   * Try to fix the ambiguity subset `idxs` (indices into `this.amb`):
+   * extract the float subvector b and covariance Q_b from the filter,
+   * run MLAMBDA and, without touching the filter state, condition the
+   * position on the best integer candidate,
+   *   xa = x − P_xb·Q_b⁻¹·(b − ǎ)
+   * (RTKLIB rtkpos.c `resamb_LAMBDA`). Returns null when Q_b is not
+   * positive definite / invertible or the search fails; ratio
+   * validation is the caller's job.
+   */
+  tryFix(idxs) {
+    const k = idxs.length;
+    const b = new Float64Array(k);
+    const Qb = new Float64Array(k * k);
+    const QbRows = [];
+    for (let i = 0; i < k; i++) {
+      const si = 3 + idxs[i];
+      b[i] = this.x[si];
+      const row = [];
+      for (let j = 0; j < k; j++) {
+        const sj = 3 + idxs[j];
+        const q = (this.P[si][sj] + this.P[sj][si]) / 2;
+        Qb[i + j * k] = q;
+        row.push(q);
+      }
+      QbRows.push(row);
+    }
+    const res = lambdaSearch(b, Qb, k, 2);
+    if (!res) return null;
+    const best = res.candidates[0];
+    const QbInv = matInv(QbRows);
+    if (!QbInv) return null;
+    const db = [];
+    for (let i = 0; i < k; i++) db.push(b[i] - best[i]);
+    const position = [
+      this.x[0],
+      this.x[1],
+      this.x[2]
+    ];
+    for (let r = 0; r < 3; r++) {
+      let dx = 0;
+      for (let i = 0; i < k; i++) {
+        let yi = 0;
+        for (let j = 0; j < k; j++) yi += QbInv[i][j] * db[j];
+        dx += this.P[r][3 + idxs[i]] * yi;
+      }
+      position[r] -= dx;
+    }
+    return { ratio: res.ratio, position, intAmb: [...best] };
+  }
+  /**
+   * Process one synchronized epoch (same nominal `timeMs` for both
+   * receivers). Returns null until a first position can be
+   * initialised (via an internal DGNSS solve) or when the epoch has
+   * fewer than 3 usable DD rows.
+   */
+  process(rover, base, timeMs) {
+    const o = this.o;
+    const geom = buildGeometry(
+      rover,
+      base,
+      this.basePos,
+      this.ephemerides,
+      timeMs,
+      o.elevationMaskDeg * Math.PI / 180,
+      o.troposphere
+    );
+    const byPrn = new Map(geom.map((g) => [g.prn, g]));
+    const dtS = this.lastMs !== null ? (timeMs - this.lastMs) / 1e3 : 0;
+    if (this.x) {
+      for (let i = this.amb.length - 1; i >= 0; i--) {
+        const prn = this.amb[i].prn;
+        const tr = this.track.get(prn);
+        const seen = byPrn.get(prn);
+        const hasPhase = seen && seen.cpR !== null && seen.cpB !== null;
+        const staleMs = tr ? timeMs - tr.lastMs : Infinity;
+        if (!hasPhase && staleMs > o.maxGapMs) this.dropAmb(i);
+      }
+    }
+    const slipped = /* @__PURE__ */ new Set();
+    for (const g of geom) {
+      if (g.cpR === null || g.cpB === null) continue;
+      const tr = this.track.get(g.prn);
+      if (!tr) continue;
+      if (timeMs - tr.lastMs > o.maxGapMs) slipped.add(g.prn);
+      else if (g.lockR !== void 0 && tr.lockR !== void 0 && g.lockR < tr.lockR || g.lockB !== void 0 && tr.lockB !== void 0 && g.lockB < tr.lockB)
+        slipped.add(g.prn);
+    }
+    if (!this.x) {
+      const dg = solveDgnss(
+        rover,
+        base,
+        this.basePos,
+        this.ephemerides,
+        timeMs,
+        {
+          elevationMaskDeg: o.elevationMaskDeg,
+          troposphere: o.troposphere,
+          codeSigmaM: o.codeSigmaM
+        }
+      );
+      if (!dg) return null;
+      this.x = [...dg.position];
+      this.P = zeros(3, 3);
+      for (let i = 0; i < 3; i++) {
+        const s = Math.max(dg.sigmas[i], 1);
+        this.P[i][i] = 25 * s * s;
+      }
+      this.amb = [];
+    } else if (o.mode === "kinematic") {
+      for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < this.x.length; j++) {
+          this.P[i][j] = 0;
+          this.P[j][i] = 0;
+        }
+        this.P[i][i] = o.kinematicSigmaM * o.kinematicSigmaM;
+      }
+    } else {
+      const q = o.processNoisePosM * o.processNoisePosM * dtS;
+      for (let i = 0; i < 3; i++) this.P[i][i] += q;
+    }
+    const qAmb = o.ambProcessNoiseCycles * o.ambProcessNoiseCycles * dtS;
+    for (let k = 0; k < this.amb.length; k++) this.P[3 + k][3 + k] += qAmb;
+    const groups = groupEntries(geom);
+    const newRefs = /* @__PURE__ */ new Map();
+    for (const [group, list] of groups) {
+      if (list.length < 2) continue;
+      const phase = list.filter(
+        (g) => g.cpR !== null && g.cpB !== null && !slipped.has(g.prn)
+      );
+      const pool = phase.length >= 2 ? phase : list;
+      const prevRef = this.refs.get(group);
+      const best = pool.reduce((a, b) => b.elB > a.elB ? b : a);
+      let ref = best;
+      if (best.prn !== prevRef) {
+        const anyState = this.amb.some((a) => a.group === group);
+        if (anyState) {
+          if (this.ambIndex(best.prn) >= 0) {
+            this.retarget(group, prevRef ?? best.prn, this.ambIndex(best.prn));
+          } else if (prevRef && pool.some((g) => g.prn === prevRef)) {
+            ref = pool.find((g) => g.prn === prevRef);
+          } else {
+            for (let i = this.amb.length - 1; i >= 0; i--)
+              if (this.amb[i].group === group) this.dropAmb(i);
+          }
+        }
+      }
+      newRefs.set(group, ref);
+      this.refs.set(group, ref.prn);
+    }
+    for (const group of [...this.refs.keys()])
+      if (!newRefs.has(group)) this.refs.delete(group);
+    for (const prn of slipped) {
+      const i = this.ambIndex(prn);
+      if (i >= 0) this.dropAmb(i);
+    }
+    const initAmb = (g, ref) => {
+      if (g.lambda <= 0 || ref.lambda <= 0) return;
+      const zPhi = g.lambda * (g.cpR - g.cpB) - ref.lambda * (ref.cpR - ref.cpB);
+      const zP = g.prR - g.prB - (ref.prR - ref.prB);
+      const n0 = (zPhi - zP) / g.lambda;
+      this.addAmb(
+        { prn: g.prn, group: g.group, lambda: g.lambda },
+        n0,
+        o.ambInitSigmaCycles * o.ambInitSigmaCycles
+      );
+    };
+    for (const [group, ref] of newRefs) {
+      for (const g of groups.get(group)) {
+        if (g === ref || g.cpR === null || g.cpB === null) continue;
+        if (ref.cpR === null || ref.cpB === null) continue;
+        const i = this.ambIndex(g.prn);
+        if (i >= 0) {
+          this.amb[i].lambda = g.lambda;
+          this.amb[i].group = g.group;
+          continue;
+        }
+        initAmb(g, ref);
+      }
+    }
+    for (let i = this.amb.length - 1; i >= 0; i--) {
+      const a = this.amb[i];
+      if (newRefs.get(a.group)?.prn === a.prn) this.dropAmb(i);
+    }
+    let rows = [];
+    for (const [group, ref] of newRefs) {
+      for (const g of groups.get(group)) {
+        if (g === ref) continue;
+        rows.push({
+          g,
+          ref,
+          kind: "code",
+          z: g.prR - g.prB - (ref.prR - ref.prB),
+          ambIdx: -1
+        });
+        const i = this.ambIndex(g.prn);
+        if (i >= 0 && g.cpR !== null && g.cpB !== null && ref.cpR !== null && ref.cpB !== null && g.lambda > 0 && ref.lambda > 0) {
+          rows.push({
+            g,
+            ref,
+            kind: "phase",
+            z: g.lambda * (g.cpR - g.cpB) - ref.lambda * (ref.cpR - ref.cpB),
+            ambIdx: i
+          });
+        }
+      }
+    }
+    if (rows.length < 3) {
+      this.lastMs = timeMs;
+      return null;
+    }
+    const predict = (row, xs) => {
+      const ts = roverTerms(row.g, xs[0], xs[1], xs[2], o.troposphere);
+      const tr = roverTerms(row.ref, xs[0], xs[1], xs[2], o.troposphere);
+      let pred = ts.rho - row.g.rhoB + ts.dTropo - (tr.rho - row.ref.rhoB + tr.dTropo);
+      const h = new Array(this.x.length).fill(0);
+      h[0] = ts.u[0] - tr.u[0];
+      h[1] = ts.u[1] - tr.u[1];
+      h[2] = ts.u[2] - tr.u[2];
+      if (row.ambIdx >= 0) {
+        pred += this.amb[row.ambIdx].lambda * this.x[3 + row.ambIdx];
+        h[3 + row.ambIdx] = this.amb[row.ambIdx].lambda;
+      }
+      return { pred, h };
+    };
+    const dropPrns = /* @__PURE__ */ new Set();
+    const codeInn = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (row.kind !== "code") continue;
+      const v = row.z - predict(row, this.x).pred;
+      codeInn.set(row.g.prn, v);
+      if (Math.abs(v) > o.codeGateM) dropPrns.add(row.g.prn);
+    }
+    for (const row of rows) {
+      if (row.kind !== "phase" || dropPrns.has(row.g.prn)) continue;
+      const v = row.z - predict(row, this.x).pred;
+      const vc = codeInn.get(row.g.prn) ?? 0;
+      if (Math.abs(v - vc) > o.slipGateM) {
+        const zP = row.g.prR - row.g.prB - (row.ref.prR - row.ref.prB);
+        const lam = this.amb[row.ambIdx].lambda;
+        this.x[3 + row.ambIdx] = (row.z - zP) / lam;
+        const s = 3 + row.ambIdx;
+        for (let j = 0; j < this.x.length; j++) {
+          this.P[s][j] = 0;
+          this.P[j][s] = 0;
+        }
+        this.P[s][s] = o.ambInitSigmaCycles * o.ambInitSigmaCycles;
+      }
+    }
+    if (dropPrns.size) rows = rows.filter((r) => !dropPrns.has(r.g.prn));
+    if (rows.length < 3) {
+      this.lastMs = timeMs;
+      return null;
+    }
+    const n = this.x.length;
+    const R = ddCovariance(rows, o.codeSigmaM, o.phaseSigmaM);
+    const xPrior = [...this.x];
+    const PPrior = this.P;
+    let xi = [...this.x];
+    let K = [];
+    let H = [];
+    for (let it = 0; it < Math.max(o.updateIterations, 1); it++) {
+      H = [];
+      const v = [];
+      for (const row of rows) {
+        const { pred, h } = predict(row, xi);
+        let corr = 0;
+        for (let j = 0; j < n; j++) corr += h[j] * (xPrior[j] - xi[j]);
+        v.push(row.z - pred - corr);
+        H.push(h);
+      }
+      const Ht = transpose(H);
+      const S = matMul(matMul(H, PPrior), Ht);
+      for (let i = 0; i < rows.length; i++)
+        for (let j = 0; j < rows.length; j++) S[i][j] += R[i][j];
+      const Sinv = matInv(S);
+      if (!Sinv) {
+        this.lastMs = timeMs;
+        return null;
+      }
+      K = matMul(matMul(PPrior, Ht), Sinv);
+      const dx = matMul(
+        K,
+        v.map((s) => [s])
+      );
+      xi = xPrior.map((s, i) => s + dx[i][0]);
+    }
+    this.x = xi;
+    const KH = matMul(K, H);
+    const IKH = zeros(n, n);
+    for (let i = 0; i < n; i++)
+      for (let j = 0; j < n; j++) IKH[i][j] = (i === j ? 1 : 0) - KH[i][j];
+    const Pnew = matMul(IKH, PPrior);
+    for (let i = 0; i < n; i++)
+      for (let j = i; j < n; j++) {
+        const s = (Pnew[i][j] + Pnew[j][i]) / 2;
+        Pnew[i][j] = s;
+        Pnew[j][i] = s;
+      }
+    this.P = Pnew;
+    let status = rows.some(
+      (r) => r.kind === "phase"
+    ) ? "float" : "dgnss";
+    let ratio;
+    let nFixed;
+    let fixedPos = null;
+    let fixedAmbiguities;
+    if (o.ambiguityResolution === "instant") {
+      const cands = [];
+      for (const row of rows) {
+        if (row.kind !== "phase") continue;
+        if (row.g.prn[0] === "R" && !o.glonassAr) continue;
+        if (row.g.elB < o.arElevationMaskDeg * Math.PI / 180) continue;
+        cands.push({ idx: row.ambIdx, el: row.g.elB });
+      }
+      cands.sort((a, b) => b.el - a.el);
+      const floor = Math.max(
+        o.minFixAmbiguities,
+        Math.ceil(cands.length / 2),
+        1
+      );
+      while (cands.length >= floor) {
+        const fix = this.tryFix(cands.map((c) => c.idx));
+        if (!fix) break;
+        const capped = Math.min(fix.ratio, 999.9);
+        ratio ??= capped;
+        if (fix.ratio >= o.ratioThreshold) {
+          ratio = capped;
+          status = "fixed";
+          nFixed = cands.length;
+          fixedPos = fix.position;
+          fixedAmbiguities = {};
+          cands.forEach((c, i) => {
+            fixedAmbiguities[this.amb[c.idx].prn] = fix.intAmb[i];
+          });
+          break;
+        }
+        if (!o.partialFixing) break;
+        cands.pop();
+      }
+    }
+    for (const g of geom) {
+      if (g.cpR === null || g.cpB === null) continue;
+      this.track.set(g.prn, { lockR: g.lockR, lockB: g.lockB, lastMs: timeMs });
+    }
+    this.lastMs = timeMs;
+    const ambiguities = {};
+    for (let k = 0; k < this.amb.length; k++)
+      ambiguities[this.amb[k].prn] = this.x[3 + k];
+    const refSatellites = {};
+    for (const [group, ref] of newRefs) refSatellites[group] = ref.prn;
+    const nSats = new Set(rows.flatMap((r) => [r.g.prn, r.ref.prn])).size;
+    return {
+      timeMs,
+      position: fixedPos ?? [this.x[0], this.x[1], this.x[2]],
+      floatBaseline: [
+        this.x[0] - this.basePos[0],
+        this.x[1] - this.basePos[1],
+        this.x[2] - this.basePos[2]
+      ],
+      status,
+      nSats,
+      ratio,
+      nFixed,
+      fixedBaseline: fixedPos ? [
+        fixedPos[0] - this.basePos[0],
+        fixedPos[1] - this.basePos[1],
+        fixedPos[2] - this.basePos[2]
+      ] : void 0,
+      fixedAmbiguities,
+      sigmas: [
+        Math.sqrt(Math.max(this.P[0][0], 0)),
+        Math.sqrt(Math.max(this.P[1][1], 0)),
+        Math.sqrt(Math.max(this.P[2][2], 0))
+      ],
+      ambiguities,
+      refSatellites
+    };
+  }
+};
+
 // src/positioning/index.ts
 var GM_GPS2 = 3986005e8;
 var F_REL = -4442807633e-19;
@@ -476,11 +1506,11 @@ var PRIMARY_FREQ_HZ = {
   R: 1602e6
 };
 var F_L1 = 157542e4;
-function tropoDelay(elevationRad) {
+function tropoDelay2(elevationRad) {
   const sinEl = Math.sin(elevationRad);
   return 2.47 / (sinEl + 0.0121);
 }
-function sagnac(pos, travelTimeS) {
+function sagnac2(pos, travelTimeS) {
   const theta = OMEGA_E * travelTimeS;
   const c = Math.cos(theta);
   const s = Math.sin(theta);
@@ -551,7 +1581,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
         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 [sx, sy, sz] = sagnac(sat, travel);
+        const [sx, sy, sz] = sagnac2(sat, travel);
         const rho = Math.hypot(sx - x2, sy - y2, sz - z2);
         const ux = (x2 - sx) / rho;
         const uy = (y2 - sy) / rho;
@@ -568,7 +1598,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
           const sinEl = Math.max(Math.sin(elev), 0.1);
           weight = sinEl * sinEl;
         }
-        const tropo = troposphere && positionSane ? tropoDelay(elev) : 0;
+        const tropo = troposphere && positionSane ? tropoDelay2(elev) : 0;
         let ionoM = 0;
         if (iono && positionSane) {
           const f = PRIMARY_FREQ_HZ[sys] ?? F_L1;
@@ -653,8 +1683,13 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RtkFloatEngine,
   ionoFree,
   klobucharDelay,
+  lambdaReduction,
+  lambdaSearch,
   satClockCorrection,
-  solveSpp
+  solveDgnss,
+  solveSpp,
+  toRtkEpoch
 });