gnss-js 2.13.1 → 2.14.0

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(src_exports, {
   BAND_LABELS: () => BAND_LABELS,
   BAND_PRESETS: () => BAND_PRESETS,
   BDS_SATELLITES: () => BDS_SATELLITES,
+  BLQ_CONSTITUENTS: () => BLQ_CONSTITUENTS,
   BitReader: () => BitReader,
   CONSTELLATIONS: () => CONSTELLATIONS,
   C_LIGHT: () => C_LIGHT,
@@ -121,6 +122,7 @@ __export(src_exports, {
   analyzeQuality: () => analyzeQuality,
   antexFreqOfGroup: () => antexFreqOfGroup,
   applyHelmert: () => applyHelmert,
+  applyHelmertFit: () => applyHelmertFit,
   applyIonoDcb: () => applyIonoDcb,
   applyOrbitClock: () => applyOrbitClock,
   biasMetres: () => biasMetres,
@@ -168,6 +170,7 @@ __export(src_exports, {
   ecefToAzEl: () => ecefToAzEl,
   ecefToGeodetic: () => ecefToGeodetic,
   ephInfoToEphemeris: () => ephInfoToEphemeris,
+  estimateHelmert: () => estimateHelmert,
   estimateNarrowlaneFcb: () => estimateNarrowlaneFcb,
   estimateNetworkFcbs: () => estimateNetworkFcbs,
   estimateWidelaneFcb: () => estimateWidelaneFcb,
@@ -179,6 +182,7 @@ __export(src_exports, {
   feedNavicBlock: () => feedNavicBlock,
   fetchSourcetable: () => fetchSourcetable,
   findSatBias: () => findSatBias,
+  fitCoordinateSeries: () => fitCoordinateSeries,
   fixPppPosition: () => fixPppPosition,
   fmtD: () => fmtD,
   fmtF: () => fmtF,
@@ -273,12 +277,14 @@ __export(src_exports, {
   nlWavelength: () => nlWavelength,
   nmeaCoordToDecimal: () => nmeaCoordToDecimal,
   obsEpochToDate: () => obsEpochToDate,
+  oceanLoadingEnu: () => oceanLoadingEnu,
   oem4Frames: () => oem4Frames,
   padL: () => padL,
   padR: () => padR,
   parseAntex: () => parseAntex,
   parseBiasSinex: () => parseBiasSinex,
   parseBinex: () => parseBinex,
+  parseBlq: () => parseBlq,
   parseClk: () => parseClk,
   parseCrxDataLine: () => parseCrxDataLine,
   parseIonex: () => parseIonex,
@@ -16804,6 +16810,103 @@ function solidEarthTide(rcv, sun, moon) {
   return disp;
 }
 
+// src/positioning/ocean-loading.ts
+var BLQ_CONSTITUENTS = [
+  "M2",
+  "S2",
+  "N2",
+  "K2",
+  "K1",
+  "O1",
+  "P1",
+  "Q1",
+  "Mf",
+  "Mm",
+  "Ssa"
+];
+var ARGS = [
+  [140519e-9, 2, -2, 0, 0],
+  // M2
+  [145444e-9, 0, 0, 0, 0],
+  // S2
+  [13788e-8, 2, -3, 1, 0],
+  // N2
+  [145842e-9, 2, 0, 0, 0],
+  // K2
+  [72921e-9, 1, 0, 0, 0.25],
+  // K1
+  [67598e-9, 1, -2, 0, -0.25],
+  // O1
+  [72523e-9, -1, 0, 0, -0.25],
+  // P1
+  [64959e-9, 1, -3, 1, -0.25],
+  // Q1
+  [53234e-10, 0, 2, 0, 0],
+  // Mf
+  [26392e-10, 0, 1, -1, 0],
+  // Mm
+  [3982e-10, 2, 0, 0, 0]
+  // Ssa
+];
+var D2R2 = Math.PI / 180;
+function oceanLoadingEnu(c, utcMs) {
+  const day = Math.floor(utcMs / 864e5);
+  const fday = (utcMs - day * 864e5) / 1e3;
+  const days = day - Date.UTC(1975, 0, 1) / 864e5 + 1;
+  const t = (27392.500528 + 1.000000035 * days) / 36525;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const a = [
+    fday,
+    (279.69668 + 36000.768930485 * t + 303e-6 * t2) * D2R2,
+    // H0
+    (270.434358 + 481267.88314137 * t - 1133e-6 * t2 + 19e-7 * t3) * D2R2,
+    // S0
+    (334.329653 + 4069.0340329577 * t - 0.010325 * t2 - 12e-6 * t3) * D2R2,
+    // P0
+    2 * Math.PI
+  ];
+  const dp = [0, 0, 0];
+  for (let i = 0; i < ARGS.length; i++) {
+    let ang = 0;
+    for (let j = 0; j < 5; j++) ang += a[j] * ARGS[i][j];
+    for (let k = 0; k < 3; k++)
+      dp[k] += c.amplitude[i][k] * Math.cos(ang - c.phase[i][k] * D2R2);
+  }
+  return [-dp[1], -dp[2], dp[0]];
+}
+function parseBlq(text) {
+  const out = /* @__PURE__ */ new Map();
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    if (!l.trim() || l.startsWith("$$")) continue;
+    const name = l.trim().split(/\s+/)[0].toUpperCase();
+    const rows = [];
+    let j = i + 1;
+    while (j < lines.length && rows.length < 6) {
+      const r = lines[j];
+      j++;
+      if (r.startsWith("$$") || !r.trim()) continue;
+      const v = r.trim().split(/\s+/).map(Number);
+      if (v.length !== 11 || v.some((x) => !Number.isFinite(x))) break;
+      rows.push(v);
+    }
+    if (rows.length === 6) {
+      out.set(name, {
+        amplitude: BLQ_CONSTITUENTS.map(
+          (_, k) => [rows[0][k], rows[1][k], rows[2][k]]
+        ),
+        phase: BLQ_CONSTITUENTS.map(
+          (_, k) => [rows[3][k], rows[4][k], rows[5][k]]
+        )
+      });
+      i = j - 1;
+    }
+  }
+  return out;
+}
+
 // src/positioning/ppp-corrections.ts
 function applyCorrections(corrections, geom, ctx) {
   if (corrections.evaluate) return corrections.evaluate(geom, ctx);
@@ -16821,6 +16924,14 @@ function createPppCorrections(cfg) {
       const sun = sunEcef(timeMs);
       const moon = moonEcef(timeMs);
       const tideDisp = useTides ? solidEarthTide(rcvEcef, sun, moon) : [0, 0, 0];
+      if (cfg.oceanLoading) {
+        const [e, n, u] = oceanLoadingEnu(cfg.oceanLoading, timeMs);
+        const [lat, lon] = ecefToGeodetic(rcvEcef[0], rcvEcef[1], rcvEcef[2]);
+        const d = enuToEcef([e, n, u], lat, lon);
+        tideDisp[0] += d[0];
+        tideDisp[1] += d[1];
+        tideDisp[2] += d[2];
+      }
       return { timeMs, sun, moon, tideDisp };
     },
     evaluate(geom, ctx) {
@@ -16875,7 +16986,7 @@ function createPppCorrections(cfg) {
           rangeM += interpPcv(off, zenithDeg);
         }
       }
-      if (useTides && ctx) {
+      if (ctx) {
         rangeM -= dot(e, ctx.tideDisp);
       }
       if (useWindup && frame) {
@@ -17261,7 +17372,7 @@ var PppEngine = class {
     for (const ci of clkIdx.values()) P[ci][ci] = CLK_VAR;
     P[IDX_ZWD][IDX_ZWD] += ztdQ * (ei > 0 ? 1 : 0);
     const rcv = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
-    const [latRad, , heightM] = ecefToGeodetic(rcv[0], rcv[1], rcv[2]);
+    const [latRad, lonRad, heightM] = ecefToGeodetic(rcv[0], rcv[1], rcv[2]);
     const epochCtx = corrections?.epochContext?.(epoch.timeMs, rcv) ?? null;
     const vis = [];
     let epochZhd = 0;
@@ -17294,7 +17405,17 @@ var PppEngine = class {
       const pIf = g * o.c1 - (g - 1) * o.c2;
       const lIf = g * (o.l1 * lam1) - (g - 1) * (o.l2 * lam2);
       if (!Number.isFinite(pIf) || !Number.isFinite(lIf)) continue;
-      const trop = opts.troposphere ?? true ? niellMapping(elRad, latRad, heightM, epoch.timeMs) : { zhd: 0, mh: 0, mw: 0 };
+      const trop = opts.troposphere ?? true ? opts.troposphereModel ? opts.troposphereModel.delays(
+        epoch.timeMs,
+        latRad,
+        lonRad,
+        heightM,
+        elRad,
+        azRad
+      ) : {
+        ...niellMapping(elRad, latRad, heightM, epoch.timeMs),
+        gradient: 0
+      } : { zhd: 0, mh: 0, mw: 0, gradient: 0 };
       const { zhd, mh, mw } = trop;
       epochZhd = zhd;
       const geom = {
@@ -17319,7 +17440,7 @@ var PppEngine = class {
         lIf,
         satClkM: sat.state.clkM,
         range,
-        tropoFixed: zhd * mh + corr.rangeM,
+        tropoFixed: zhd * mh + trop.gradient + corr.rangeM,
         mw,
         windupM: corr.phaseWindupM,
         slip,
@@ -19314,6 +19435,495 @@ async function analyzeQuality(file, header, onProgress, signal) {
   };
 }
 
+// src/analysis/noise-model.ts
+function cholesky(M, n) {
+  for (let j = 0; j < n; j++) {
+    let d = M[j * n + j];
+    for (let k = 0; k < j; k++) d -= M[j * n + k] ** 2;
+    if (d <= 0) return false;
+    d = Math.sqrt(d);
+    M[j * n + j] = d;
+    for (let i = j + 1; i < n; i++) {
+      let s = M[i * n + j];
+      for (let k = 0; k < j; k++) s -= M[i * n + k] * M[j * n + k];
+      M[i * n + j] = s / d;
+    }
+  }
+  return true;
+}
+function forward(L, n, b) {
+  for (let i = 0; i < n; i++) {
+    let s = b[i];
+    for (let k = 0; k < i; k++) s -= L[i * n + k] * b[k];
+    b[i] = s / L[i * n + i];
+  }
+}
+function flickerCovariance(idx) {
+  const N = idx[idx.length - 1] + 1;
+  const h = new Float64Array(N);
+  h[0] = 1;
+  for (let i = 1; i < N; i++) h[i] = h[i - 1] * (i - 1 + 0.5) / i;
+  const n = idx.length;
+  const F = new Float64Array(n * n);
+  for (let a = 0; a < n; a++)
+    for (let b = 0; b <= a; b++) {
+      const ia = idx[a];
+      const ib = idx[b];
+      let s = 0;
+      for (let k = 0; k <= ib; k++) s += h[ia - k] * h[ib - k];
+      F[a * n + b] = s;
+      F[b * n + a] = s;
+    }
+  let tr = 0;
+  for (let a = 0; a < n; a++) tr += F[a * n + a];
+  const scale = n / tr;
+  for (let i = 0; i < F.length; i++) F[i] *= scale;
+  return F;
+}
+var MAX_SAMPLES = 360;
+function fitWhiteFlicker(A, y, tYears) {
+  let rows = A.map((_, i) => i);
+  if (rows.length > MAX_SAMPLES) {
+    const step = rows.length / MAX_SAMPLES;
+    rows = Array.from({ length: MAX_SAMPLES }, (_, k) => Math.floor(k * step));
+  }
+  const n = rows.length;
+  const p = A[0]?.length ?? 0;
+  if (n < p + 5) return null;
+  const dts = rows.slice(1).map((r, k) => tYears[r] - tYears[rows[k]]).filter((d) => d > 0).sort((a, b) => a - b);
+  const dt = dts[dts.length >> 1] ?? 1 / 365.25;
+  const t0 = tYears[rows[0]];
+  const idx = rows.map((r) => Math.round((tYears[r] - t0) / dt));
+  for (let k = 1; k < n; k++)
+    if (idx[k] <= idx[k - 1]) idx[k] = idx[k - 1] + 1;
+  const F = flickerCovariance(idx);
+  const evaluate = (phi) => {
+    const C2 = new Float64Array(n * n);
+    for (let i = 0; i < n * n; i++) C2[i] = phi * F[i];
+    for (let i = 0; i < n; i++) C2[i * n + i] += 1 - phi;
+    if (!cholesky(C2, n)) return null;
+    const Aw = Array.from({ length: p }, (_, j) => {
+      const col = Float64Array.from(rows, (r) => A[r][j]);
+      forward(C2, n, col);
+      return col;
+    });
+    const yw = Float64Array.from(rows, (r) => y[r]);
+    forward(C2, n, yw);
+    const N = Array.from(
+      { length: p },
+      (_, a) => Array.from({ length: p }, (_2, b) => {
+        let s = 0;
+        for (let i = 0; i < n; i++) s += Aw[a][i] * Aw[b][i];
+        return s;
+      })
+    );
+    const rhs = Array.from({ length: p }, (_, a) => {
+      let s = 0;
+      for (let i = 0; i < n; i++) s += Aw[a][i] * yw[i];
+      return s;
+    });
+    const Ninv = invert(N);
+    if (!Ninv) return null;
+    const beta = Ninv.map((row) => row.reduce((s, v, k) => s + v * rhs[k], 0));
+    let rss = 0;
+    for (let i = 0; i < n; i++) {
+      let m = 0;
+      for (let j = 0; j < p; j++) m += Aw[j][i] * beta[j];
+      rss += (yw[i] - m) ** 2;
+    }
+    const sigma2 = rss / n;
+    let logdet = 0;
+    for (let i = 0; i < n; i++) logdet += 2 * Math.log(C2[i * n + i]);
+    const logL = -0.5 * (n * Math.log(sigma2) + logdet + n);
+    return {
+      logL,
+      velocity: beta[1],
+      velocitySigma: Math.sqrt(sigma2 * Ninv[1][1])
+    };
+  };
+  let best = null;
+  for (let k = 0; k <= 20; k++) {
+    const phi = Math.min(k / 20, 0.995);
+    const r = evaluate(phi);
+    if (r && (!best || r.logL > best.r.logL)) best = { phi, r };
+  }
+  if (!best) return null;
+  let lo = Math.max(0, best.phi - 0.05);
+  let hi = Math.min(0.995, best.phi + 0.05);
+  const g = (Math.sqrt(5) - 1) / 2;
+  for (let it = 0; it < 12; it++) {
+    const a = hi - g * (hi - lo);
+    const b = lo + g * (hi - lo);
+    const ra = evaluate(a);
+    const rb = evaluate(b);
+    if (!ra || !rb) break;
+    if (ra.logL > rb.logL) {
+      hi = b;
+      if (ra.logL > best.r.logL) best = { phi: a, r: ra };
+    } else {
+      lo = a;
+      if (rb.logL > best.r.logL) best = { phi: b, r: rb };
+    }
+  }
+  return {
+    flickerShare: best.phi,
+    velocitySigma: best.r.velocitySigma,
+    velocity: best.r.velocity
+  };
+}
+function invert(N) {
+  const p = N.length;
+  const M = N.map((row, i) => [
+    ...row,
+    ...Array.from({ length: p }, (_, j) => i === j ? 1 : 0)
+  ]);
+  for (let c = 0; c < p; c++) {
+    let piv = c;
+    for (let r = c + 1; r < p; r++)
+      if (Math.abs(M[r][c]) > Math.abs(M[piv][c])) piv = r;
+    if (Math.abs(M[piv][c]) < 1e-14) return null;
+    [M[c], M[piv]] = [M[piv], M[c]];
+    const d = M[c][c];
+    for (let k = 0; k < 2 * p; k++) M[c][k] /= d;
+    for (let r = 0; r < p; r++) {
+      if (r === c) continue;
+      const f = M[r][c];
+      if (f === 0) continue;
+      for (let k = 0; k < 2 * p; k++) M[r][k] -= f * M[c][k];
+    }
+  }
+  return M.map((row) => row.slice(p));
+}
+
+// src/analysis/coordinate-series.ts
+var MS_PER_YEAR = 365.25 * 864e5;
+var TWO_PI2 = 2 * Math.PI;
+var MIN_SIGMA_M = 5e-4;
+function lsq(A, y, w) {
+  const p = A[0]?.length ?? 0;
+  const N = Array.from({ length: p }, () => new Array(p).fill(0));
+  const b = new Array(p).fill(0);
+  for (let i = 0; i < A.length; i++) {
+    const a = A[i];
+    for (let j = 0; j < p; j++) {
+      b[j] += w[i] * a[j] * y[i];
+      for (let k = 0; k < p; k++) N[j][k] += w[i] * a[j] * a[k];
+    }
+  }
+  const M = N.map((row, i) => [
+    ...row,
+    ...Array.from({ length: p }, (_, j) => i === j ? 1 : 0)
+  ]);
+  for (let c = 0; c < p; c++) {
+    let piv = c;
+    for (let r = c + 1; r < p; r++)
+      if (Math.abs(M[r][c]) > Math.abs(M[piv][c])) piv = r;
+    if (Math.abs(M[piv][c]) < 1e-12) return null;
+    [M[c], M[piv]] = [M[piv], M[c]];
+    const d = M[c][c];
+    for (let k = 0; k < 2 * p; k++) M[c][k] /= d;
+    for (let r = 0; r < p; r++) {
+      if (r === c) continue;
+      const f = M[r][c];
+      if (f === 0) continue;
+      for (let k = 0; k < 2 * p; k++) M[r][k] -= f * M[c][k];
+    }
+  }
+  const Ninv = M.map((row) => row.slice(p));
+  const x = Ninv.map((row) => row.reduce((s, v, k) => s + v * b[k], 0));
+  return { x, Ninv };
+}
+function median3(xs) {
+  const s = [...xs].sort((a, b) => a - b);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+function robustSigma(xs) {
+  if (xs.length < 2) return 0;
+  const m = median3(xs);
+  return 1.4826 * median3(xs.map((x) => Math.abs(x - m)));
+}
+function designRow(tMs, d) {
+  const dt = (tMs - d.refEpochMs) / MS_PER_YEAR;
+  const row = [1, dt];
+  for (const j of d.jumps) row.push(tMs >= j ? 1 : 0);
+  if (d.seasonal) {
+    const ph = TWO_PI2 * (tMs / MS_PER_YEAR);
+    row.push(Math.sin(ph), Math.cos(ph), Math.sin(2 * ph), Math.cos(2 * ph));
+  }
+  return row;
+}
+function fitComponent(t, y, w, used, d) {
+  const A = [];
+  const yy = [];
+  const ww = [];
+  for (let i = 0; i < t.length; i++) {
+    if (!used[i]) continue;
+    A.push(designRow(t[i], d));
+    yy.push(y[i]);
+    ww.push(w[i]);
+  }
+  if (A.length <= (A[0]?.length ?? 0)) return null;
+  const s = lsq(A, yy, ww);
+  if (!s) return null;
+  const residuals = t.map(
+    (ti, i) => y[i] - designRow(ti, d).reduce((acc, a, k) => acc + a * s.x[k], 0)
+  );
+  let wrss = 0;
+  let sumW = 0;
+  for (let i = 0; i < t.length; i++) {
+    if (!used[i]) continue;
+    wrss += w[i] * residuals[i] ** 2;
+    sumW += w[i];
+  }
+  return { ...s, wrss, sumW, residuals };
+}
+function fitCoordinateSeries(samples, opts = {}) {
+  const pts = [...samples].sort((a, b) => a.tMs - b.tMs);
+  if (pts.length < 5) return null;
+  const t = pts.map((p) => p.tMs);
+  const spanYears = (t[t.length - 1] - t[0]) / MS_PER_YEAR;
+  if (spanYears <= 0) return null;
+  const ref = [0, 1, 2].map(
+    (k2) => median3(pts.map((p) => p.ecef[k2]))
+  );
+  const [lat, lon] = ecefToGeodetic(ref[0], ref[1], ref[2]);
+  const sl = Math.sin(lat);
+  const cl = Math.cos(lat);
+  const so = Math.sin(lon);
+  const co = Math.cos(lon);
+  const enu = pts.map((p) => {
+    const dx = p.ecef[0] - ref[0];
+    const dy = p.ecef[1] - ref[1];
+    const dz = p.ecef[2] - ref[2];
+    return [
+      -so * dx + co * dy,
+      -sl * co * dx - sl * so * dy + cl * dz,
+      cl * co * dx + cl * so * dy + sl * dz
+    ];
+  });
+  const weights = [0, 1, 2].map(
+    (k2) => pts.map((p) => {
+      const s = p.sigmaEnu?.[k2];
+      return s && s > 0 ? 1 / Math.max(s, MIN_SIGMA_M) ** 2 : 1;
+    })
+  );
+  const series = [0, 1, 2].map((k2) => enu.map((v) => v[k2]));
+  const seasonal = opts.seasonal === "auto" || opts.seasonal === void 0 ? spanYears >= 2 : opts.seasonal;
+  const design = {
+    refEpochMs: opts.refEpochMs ?? (t[0] + t[t.length - 1]) / 2,
+    jumps: [...opts.jumps ?? []].filter((j) => j > t[0] && j <= t[t.length - 1]).sort((a, b) => a - b),
+    seasonal
+  };
+  const detected = /* @__PURE__ */ new Set();
+  const k = opts.outlierK ?? 4;
+  const used = pts.map(() => true);
+  const fitAll = () => [0, 1, 2].map(
+    (c) => fitComponent(t, series[c], weights[c], used, design)
+  );
+  const robustPass = () => {
+    for (let iter = 0; iter < 10; iter++) {
+      const sol2 = fitAll();
+      if (sol2.some((s) => !s)) return null;
+      const scales = sol2.map(
+        (s) => Math.max(robustSigma(s.residuals.filter((_, i) => used[i])), 1e-4)
+      );
+      let changed = false;
+      for (let i = 0; i < t.length; i++) {
+        const bad = sol2.some(
+          (s, c) => Math.abs(s.residuals[i]) > k * scales[c]
+        );
+        if (bad === used[i]) {
+          used[i] = !bad;
+          changed = true;
+        }
+      }
+      if (!changed) return sol2;
+    }
+    return fitAll();
+  };
+  let sol = robustPass();
+  if (!sol) return null;
+  if (opts.detectJumps ?? true) {
+    const minSide = opts.minSamplesPerSide ?? 5;
+    for (let added = 0; added < (opts.maxJumps ?? 3); added++) {
+      const idx = t.map((_, i) => i).filter((i) => used[i]);
+      const nUsed = idx.length;
+      const bicOf = (s, p) => s.reduce((acc, c) => acc + nUsed * Math.log(c.wrss / c.sumW), 0) + 3 * p * Math.log(nUsed);
+      const p0 = designRow(t[0], design).length;
+      const bic0 = bicOf(sol, p0);
+      let best = null;
+      for (let j = minSide; j <= nUsed - minSide; j++) {
+        const tj = (t[idx[j - 1]] + t[idx[j]]) / 2;
+        if (design.jumps.some((x) => Math.abs(x - tj) < 7 * 864e5))
+          continue;
+        const trial = {
+          ...design,
+          jumps: [...design.jumps, tj].sort((a, b) => a - b)
+        };
+        const s = [0, 1, 2].map(
+          (c) => fitComponent(t, series[c], weights[c], used, trial)
+        );
+        if (s.some((x) => !x)) continue;
+        const bic = bicOf(s, p0 + 1);
+        if (!best || bic < best.bic)
+          best = { tMs: tj, bic, sol: s };
+      }
+      if (!best || bic0 - best.bic <= 10) break;
+      design.jumps = [...design.jumps, best.tMs].sort((a, b) => a - b);
+      detected.add(best.tMs);
+      sol = robustPass();
+      if (!sol) return null;
+    }
+  }
+  const nJ = design.jumps.length;
+  const component = (c) => {
+    const s = sol[c];
+    const nUsed = used.filter(Boolean).length;
+    const p = s.x.length;
+    const vf = nUsed > p ? s.wrss / (nUsed - p) : 1;
+    const amp = (i) => seasonal ? Math.hypot(s.x[i], s.x[i + 1]) : null;
+    const noise = opts.noiseModel ?? true ? fitWhiteFlicker(
+      t.flatMap((ti, i) => used[i] ? [designRow(ti, design)] : []),
+      series[c].filter((_, i) => used[i]),
+      t.flatMap((ti, i) => used[i] ? [ti / MS_PER_YEAR] : [])
+    ) : null;
+    return {
+      offset: s.x[0],
+      velocity: s.x[1],
+      velocitySigma: Math.sqrt(s.Ninv[1][1] * vf),
+      velocitySigmaRealistic: noise?.velocitySigma ?? null,
+      flickerShare: noise?.flickerShare ?? null,
+      steps: s.x.slice(2, 2 + nJ),
+      annualAmplitude: amp(2 + nJ),
+      semiannualAmplitude: amp(4 + nJ),
+      wrms: Math.sqrt(s.wrss / s.sumW)
+    };
+  };
+  const points = pts.map((p, i) => ({
+    tMs: p.tMs,
+    enu: enu[i],
+    model: [0, 1, 2].map((c) => series[c][i] - sol[c].residuals[i]),
+    outlier: !used[i]
+  }));
+  return {
+    refEcef: ref,
+    refEpochMs: design.refEpochMs,
+    e: component(0),
+    n: component(1),
+    u: component(2),
+    jumps: design.jumps.map((tMs) => ({ tMs, detected: detected.has(tMs) })),
+    points,
+    spanYears,
+    used: used.filter(Boolean).length,
+    outliers: used.filter((u) => !u).length,
+    seasonal
+  };
+}
+
+// src/analysis/network-alignment.ts
+function applyHelmertFit(x, f) {
+  const [r1, r2, r3] = f.r;
+  return [
+    x[0] + f.t[0] + f.d * x[0] - r3 * x[1] + r2 * x[2],
+    x[1] + f.t[1] + r3 * x[0] + f.d * x[1] - r1 * x[2],
+    x[2] + f.t[2] - r2 * x[0] + r1 * x[1] + f.d * x[2]
+  ];
+}
+function solve(N, b) {
+  const n = b.length;
+  const M = N.map((row, i) => [...row, b[i]]);
+  for (let c = 0; c < n; c++) {
+    let p = c;
+    for (let r = c + 1; r < n; r++)
+      if (Math.abs(M[r][c]) > Math.abs(M[p][c])) p = r;
+    if (Math.abs(M[p][c]) < 1e-6) return null;
+    [M[c], M[p]] = [M[p], M[c]];
+    for (let r = 0; r < n; r++) {
+      if (r === c) continue;
+      const f = M[r][c] / M[c][c];
+      for (let k = c; k <= n; k++) M[r][k] -= f * M[c][k];
+    }
+  }
+  return M.map((row, i) => row[n] / row[i]);
+}
+function estimateHelmert(from, to, opts = {}) {
+  const model = opts.model ?? "translation";
+  const nPar = model === "translation" ? 3 : 7;
+  const minRefs = opts.minRefs ?? (model === "translation" ? 3 : 4);
+  const maxRes = opts.maxResidualM ?? 0.015;
+  if (from.length !== to.length) return null;
+  const used = from.map(() => true);
+  const c = [0, 1, 2].map(
+    (k) => from.reduce((s, p) => s + p[k], 0) / Math.max(from.length, 1)
+  );
+  for (; ; ) {
+    const idx = used.flatMap((u, i) => u ? [i] : []);
+    if (idx.length < minRefs || idx.length * 3 <= nPar) return null;
+    const N = Array.from(
+      { length: nPar },
+      () => new Array(nPar).fill(0)
+    );
+    const b = new Array(nPar).fill(0);
+    for (const i of idx) {
+      const x = [from[i][0] - c[0], from[i][1] - c[1], from[i][2] - c[2]];
+      for (let k = 0; k < 3; k++) {
+        const row = new Array(nPar).fill(0);
+        row[k] = 1;
+        if (nPar === 7) {
+          if (k === 0) {
+            row[4] = x[2];
+            row[5] = -x[1];
+          } else if (k === 1) {
+            row[3] = -x[2];
+            row[5] = x[0];
+          } else {
+            row[3] = x[1];
+            row[4] = -x[0];
+          }
+          row[6] = x[k];
+        }
+        const y = to[i][k] - from[i][k];
+        for (let a = 0; a < nPar; a++) {
+          b[a] += row[a] * y;
+          for (let bb = 0; bb < nPar; bb++) N[a][bb] += row[a] * row[bb];
+        }
+      }
+    }
+    const p = solve(N, b);
+    if (!p) return null;
+    const r = nPar === 7 ? [p[3], p[4], p[5]] : [0, 0, 0];
+    const d = nPar === 7 ? p[6] : 0;
+    const t = [
+      p[0] - (d * c[0] - r[2] * c[1] + r[1] * c[2]),
+      p[1] - (r[2] * c[0] + d * c[1] - r[0] * c[2]),
+      p[2] - (-r[1] * c[0] + r[0] * c[1] + d * c[2])
+    ];
+    const fit = { model, t, r, d, residuals: [], used, rms: 0 };
+    fit.residuals = from.map((x, i) => {
+      const y = applyHelmertFit(x, fit);
+      return [to[i][0] - y[0], to[i][1] - y[1], to[i][2] - y[2]];
+    });
+    let worst = -1;
+    let worstNorm = maxRes;
+    let ss = 0;
+    for (const i of idx) {
+      const n = Math.hypot(...fit.residuals[i]);
+      ss += n * n;
+      if (n > worstNorm) {
+        worstNorm = n;
+        worst = i;
+      }
+    }
+    fit.rms = Math.sqrt(ss / (3 * idx.length));
+    if (worst < 0 || idx.length <= minRefs) {
+      fit.used = [...used];
+      return fit;
+    }
+    used[worst] = false;
+  }
+}
+
 // src/antex/index.ts
 function label(line) {
   return (line.length >= 80 ? line.substring(60, 80) : line.substring(60)).trimEnd();
@@ -20509,6 +21119,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   BAND_LABELS,
   BAND_PRESETS,
   BDS_SATELLITES,
+  BLQ_CONSTITUENTS,
   BitReader,
   CONSTELLATIONS,
   C_LIGHT,
@@ -20606,6 +21217,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   analyzeQuality,
   antexFreqOfGroup,
   applyHelmert,
+  applyHelmertFit,
   applyIonoDcb,
   applyOrbitClock,
   biasMetres,
@@ -20653,6 +21265,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   ecefToAzEl,
   ecefToGeodetic,
   ephInfoToEphemeris,
+  estimateHelmert,
   estimateNarrowlaneFcb,
   estimateNetworkFcbs,
   estimateWidelaneFcb,
@@ -20664,6 +21277,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   feedNavicBlock,
   fetchSourcetable,
   findSatBias,
+  fitCoordinateSeries,
   fixPppPosition,
   fmtD,
   fmtF,
@@ -20758,12 +21372,14 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   nlWavelength,
   nmeaCoordToDecimal,
   obsEpochToDate,
+  oceanLoadingEnu,
   oem4Frames,
   padL,
   padR,
   parseAntex,
   parseBiasSinex,
   parseBinex,
+  parseBlq,
   parseClk,
   parseCrxDataLine,
   parseIonex,