gnss-js 1.26.0 → 1.28.0

package/dist/index.cjs

@@ -117,6 +117,7 @@ __export(src_exports, {
   binexRecords: () => binexRecords,
   buildGloChannelMap: () => buildGloChannelMap,
   buildObsIndices: () => buildObsIndices,
+  buildPppAntenna: () => buildPppAntenna,
   clampUnit: () => clampUnit,
   computeAllPositions: () => computeAllPositions,
   computeDop: () => computeDop,
@@ -130,6 +131,7 @@ __export(src_exports, {
   connectToMountpoint: () => connectToMountpoint,
   crc32: () => crc32,
   createGzipLineSink: () => createGzipLineSink,
+  createPppCorrections: () => createPppCorrections,
   createStationMeta: () => createStationMeta,
   createStreamStats: () => createStreamStats,
   crxDecompress: () => crxDecompress,
@@ -215,6 +217,7 @@ __export(src_exports, {
   glonassAlmanacEpochMs: () => glonassAlmanacEpochMs,
   glonassAlmanacPosition: () => glonassAlmanacPosition,
   glonassPosition: () => glonassPosition,
+  gmst: () => gmst,
   greatCircleMidpoint: () => greatCircleMidpoint,
   hdrLine: () => hdrLine,
   horizonDistance: () => horizonDistance,
@@ -224,8 +227,10 @@ __export(src_exports, {
   lambdaReduction: () => lambdaReduction,
   lambdaSearch: () => lambdaSearch,
   maskRadForAzimuth: () => maskRadForAzimuth,
+  moonEcef: () => moonEcef,
   msmEpochToDate: () => msmEpochToDate,
   navTimesFromEph: () => navTimesFromEph,
+  niellMapping: () => niellMapping,
   nmeaCoordToDecimal: () => nmeaCoordToDecimal,
   oem4Frames: () => oem4Frames,
   padL: () => padL,
@@ -275,10 +280,13 @@ __export(src_exports, {
   selectEphemeris: () => selectEphemeris,
   setGloFreqNumber: () => setGloFreqNumber,
   setRtcm3DebugHandler: () => setRtcm3DebugHandler,
+  solidEarthTide: () => solidEarthTide,
   solveDgnss: () => solveDgnss,
+  solvePpp: () => solvePpp,
   solveSpp: () => solveSpp,
   sp3Position: () => sp3Position,
   stationHeaderLines: () => stationHeaderLines,
+  sunEcef: () => sunEcef,
   systemCmp: () => systemCmp,
   systemName: () => systemName,
   toRtkEpoch: () => toRtkEpoch,
@@ -289,6 +297,7 @@ __export(src_exports, {
   updateStreamStats: () => updateStreamStats,
   verifyChecksum: () => verifyChecksum,
   vincenty: () => vincenty,
+  writeCrx: () => writeCrx,
   writeModernObsBlob: () => writeModernObsBlob,
   writeRinex2ObsBlob: () => writeRinex2ObsBlob,
   writeRinex4ObsBlob: () => writeRinex4ObsBlob,
@@ -639,7 +648,7 @@ function getDayOfYear(date) {
     (date.getTime() - Date.UTC(date.getUTCFullYear())) / MILLISECONDS_IN_DAY
   ) + 1;
 }
-function getDateFromDayOfYear(dayOfYear, date) {
+function getDateFromDayOfYear(dayOfYear2, date) {
   return new Date(
     Date.UTC(
       date.getUTCFullYear(),
@@ -649,7 +658,7 @@ function getDateFromDayOfYear(dayOfYear, date) {
       date.getUTCMinutes(),
       date.getUTCSeconds(),
       date.getUTCMilliseconds()
-    ) + (dayOfYear - 1) * MILLISECONDS_IN_DAY
+    ) + (dayOfYear2 - 1) * MILLISECONDS_IN_DAY
   );
 }
 function getDayOfWeek(date) {
@@ -1319,6 +1328,442 @@ function crxDecompress(prev, field) {
   };
 }
 
+// src/rinex/crx-writer.ts
+var ARC_ORDER = 3;
+function emptyData() {
+  return { u: [0, 0, 0, 0], l: [0, 0, 0, 0], order: -1 };
+}
+function cAtol(s) {
+  let i = 0;
+  while (i < s.length && (s[i] === " " || s[i] === "	")) i++;
+  let sign = 1;
+  if (s[i] === "+" || s[i] === "-") {
+    if (s[i] === "-") sign = -1;
+    i++;
+  }
+  let n = 0;
+  let any = false;
+  while (i < s.length && s[i] >= "0" && s[i] <= "9") {
+    n = n * 10 + (s.charCodeAt(i) - 48);
+    i++;
+    any = true;
+  }
+  return any ? sign * n : 0;
+}
+function strdiff(s1, s2) {
+  let ds = "";
+  const n = Math.min(s1.length, s2.length);
+  let i = 0;
+  for (; i < n; i++) {
+    if (s2[i] === s1[i]) ds += " ";
+    else if (s2[i] === " ") ds += "&";
+    else ds += s2[i];
+  }
+  if (s1.length > s2.length) {
+    for (let k = i; k < s1.length; k++) ds += s1[k] === " " ? " " : "&";
+  } else if (s2.length > s1.length) {
+    ds += s2.slice(i);
+  }
+  let end = ds.length;
+  while (end > 0 && ds[end - 1] === " ") end--;
+  return ds.slice(0, end);
+}
+function readValue(field14) {
+  const c = field14.padEnd(14, " ").split("");
+  const p7 = c[7];
+  c[10] = c[9];
+  c[9] = c[8];
+  let l = cAtol(c.slice(9, 14).join(""));
+  let u;
+  if (p7 === " ") {
+    u = 0;
+  } else if (p7 === "-") {
+    u = 0;
+    l = -l;
+  } else {
+    c[8] = ".";
+    u = cAtol(c.slice(0, 14).join(""));
+    if (u < 0) l = -l;
+  }
+  return { u, l };
+}
+function putdiff(dddu, dddl) {
+  dddu += Math.trunc(dddl / 1e5);
+  dddl %= 1e5;
+  if (dddu < 0 && dddl > 0) {
+    dddu++;
+    dddl -= 1e5;
+  } else if (dddu > 0 && dddl < 0) {
+    dddu--;
+    dddl += 1e5;
+  }
+  if (dddu === 0) return String(dddl);
+  return `${dddu}${String(Math.abs(dddl)).padStart(5, "0")}`;
+}
+function putClock(du, dl, cOrder) {
+  du += Math.trunc(dl / 1e8);
+  dl %= 1e8;
+  if (du < 0 && dl > 0) {
+    du++;
+    dl -= 1e8;
+  } else if (du > 0 && dl < 0) {
+    du--;
+    dl += 1e8;
+  }
+  let out = "";
+  if (cOrder === 0) out += `${ARC_ORDER}&`;
+  if (du === 0) out += String(dl);
+  else out += `${du}${String(Math.abs(dl)).padStart(8, "0")}`;
+  return out;
+}
+function chop(line) {
+  let end = line.length;
+  if (end > 0 && line[end - 1] === "\r") end--;
+  while (end > 0 && line[end - 1] === " ") end--;
+  return line.slice(0, end);
+}
+function readSat(lines, cursor, rinexVersion, ntype, ntypeGnss) {
+  let line = chop(lines[cursor.li++] ?? "");
+  let maxField;
+  let ntypeRec;
+  let firstRec;
+  let satId = "";
+  if (rinexVersion === 2) {
+    maxField = 5;
+    ntypeRec = ntype;
+    firstRec = 0;
+  } else {
+    satId = line.slice(0, 3);
+    const sys = line[0];
+    maxField = ntypeRec = ntypeGnss[sys] ?? -1;
+    if (maxField < 0) return null;
+    firstRec = 3;
+  }
+  const data = [];
+  let flag = "";
+  for (let i = 0; i < ntypeRec; i += maxField) {
+    const nfield = Math.min(ntypeRec - i, maxField);
+    const need = firstRec + 16 * nfield;
+    let body = line;
+    if (body.length < need) body = body.padEnd(need, " ");
+    for (let j = 0; j < nfield; j++) {
+      const p = firstRec + j * 16;
+      const rec = body.slice(p, p + 16);
+      const d = emptyData();
+      if (rec[10] === ".") {
+        flag += rec[14] ?? " ";
+        flag += rec[15] ?? " ";
+        const v = readValue(rec.slice(0, 14));
+        d.u[0] = v.u;
+        d.l[0] = v.l;
+        d.order = 0;
+      } else if (rec.slice(0, 14).trim() === "") {
+        flag += rec[14] ?? " ";
+        flag += rec[15] ?? " ";
+        d.order = -1;
+      } else {
+        return null;
+      }
+      data.push(d);
+    }
+    if (i + maxField < ntypeRec) {
+      line = chop(lines[cursor.li++] ?? "");
+    }
+  }
+  return { sat: { data, flag, ntypeRec }, satId };
+}
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function crinexDate() {
+  const d = /* @__PURE__ */ new Date();
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  const mon = MONTHS[d.getUTCMonth()];
+  const yy = String(d.getUTCFullYear() % 100).padStart(2, "0");
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  return `${dd}-${mon}-${yy} ${hh}:${mm}`;
+}
+function writeCrx(rinexText, opts = {}) {
+  const rawLines = rinexText.split("\n");
+  const cursor = { li: 0 };
+  const out = [];
+  const firstLine = chop(rawLines[cursor.li++] ?? "");
+  if (firstLine.slice(60, 80) !== "RINEX VERSION / TYPE" || firstLine[20] !== "O") {
+    throw new Error("writeCrx: not a RINEX observation file");
+  }
+  const rinexVersion = parseInt(firstLine, 10);
+  const rinexVersionFull = readVersionFull(firstLine);
+  if (rinexVersionFull < 0) throw new Error("writeCrx: invalid RINEX version");
+  const crxVersion = rinexVersionFull >= 402 ? "3.1" : rinexVersion === 2 ? "1.0" : "3.0";
+  out.push(
+    `${crxVersion.padEnd(20)}${"COMPACT RINEX FORMAT".padEnd(40)}${"CRINEX VERS   / TYPE".padEnd(20)}`
+  );
+  const prog = (opts.prog ?? "gnss-js writeCrx").slice(0, 40);
+  const date = opts.date ?? crinexDate();
+  out.push(`${prog.padEnd(40)}${date.padEnd(20)}CRINEX PROG / DATE`);
+  out.push(firstLine);
+  let ntype = 0;
+  const ntypeGnss = {};
+  let line;
+  do {
+    line = chop(rawLines[cursor.li++] ?? "");
+    out.push(line);
+    const label2 = line.slice(60).trimStart();
+    if (label2.startsWith("# / TYPES OF OBSERV") && line[5] !== " ") {
+      ntype = parseInt(line, 10);
+    } else if (label2.startsWith("SYS / # / OBS TYPES") && line[0] !== " ") {
+      ntypeGnss[line[0]] = parseInt(line.slice(3), 10);
+    }
+    if (cursor.li >= rawLines.length) break;
+  } while (!line.slice(60).trimStart().startsWith("END OF HEADER"));
+  const v2 = rinexVersion === 2;
+  const off = v2 ? { event: 28, nsat: 29, satlst: 32, clock: 68, satOld: 32, shiftClk: 1 } : {
+    event: 31,
+    nsat: 32,
+    satlst: 41,
+    clock: 41,
+    satOld: 41,
+    shiftClk: 4,
+    psec: 57
+  };
+  let oldline = "&";
+  let nsatOld = 0;
+  let clk0 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+  let dy0 = [];
+  let flag0 = [];
+  let oldpsec = "";
+  let clkOrderPrev = -1;
+  const resetArcs = () => {
+    oldline = "&";
+    nsatOld = 0;
+    clkOrderPrev = -1;
+  };
+  for (; ; ) {
+    if (cursor.li >= rawLines.length) break;
+    let epoch = rawLines[cursor.li];
+    if (epoch === void 0) break;
+    if (epoch === "" && cursor.li === rawLines.length - 1) break;
+    cursor.li++;
+    epoch = chop(epoch);
+    if (epoch === "") continue;
+    let newline;
+    if (v2) {
+      newline = epoch;
+    } else {
+      newline = epoch.length < 41 ? epoch.padEnd(41, " ") : epoch;
+    }
+    const eventFlag = parseInt(newline[off.event] ?? "0", 10) || 0;
+    if (eventFlag > 1) {
+      putEventData(rawLines, cursor, v2, newline, out, ntypeGnss, (n) => {
+        ntype = n;
+      });
+      resetArcs();
+      clk0 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+      dy0 = [];
+      flag0 = [];
+      continue;
+    }
+    let newpsec = "";
+    if (rinexVersionFull >= 402 && newline.length === 62) {
+      const psec = newline.slice(off.psec, off.psec + 5);
+      if (/^\d{5}$/.test(psec)) newpsec = psec;
+      newline = newline.slice(0, off.psec).replace(/\s+$/, "");
+    }
+    let clkOrder = -1;
+    const clk1 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+    if (newline.length > off.clock) {
+      clkOrder = readClock(
+        newline.slice(off.clock),
+        off.shiftClk,
+        clk1,
+        clkOrderPrev
+      );
+      if (clkOrder > -1) {
+        newline = newline.slice(0, off.clock).replace(/\s+$/, "");
+        if (!v2 && newline.length < 41) newline = newline.padEnd(41, " ");
+      }
+    }
+    clkOrderPrev = clkOrder;
+    const nsat = parseInt((newline.slice(off.nsat) || "0").trim(), 10) || 0;
+    if (v2 && nsat > 12) {
+      newline = readMoreSat(rawLines, cursor, nsat, newline);
+    }
+    const sats = [];
+    const satIds = [];
+    let bad = false;
+    let satlist = v2 ? newline.slice(off.satlst, off.satlst + nsat * 3) : "";
+    for (let i = 0; i < nsat; i++) {
+      const r = readSat(rawLines, cursor, rinexVersion, ntype, ntypeGnss);
+      if (!r) {
+        bad = true;
+        break;
+      }
+      sats.push(r.sat);
+      satIds.push(v2 ? satlist.slice(i * 3, i * 3 + 3) : r.satId);
+    }
+    if (bad) continue;
+    if (!v2) satlist = satIds.join("");
+    const fullNew = v2 ? newline : newline.slice(0, 41) + satlist;
+    const oldSatList = v2 ? oldline.slice(off.satOld, off.satOld + nsatOld * 3) : oldline.slice(off.satOld);
+    const sattbl = [];
+    const dup = /* @__PURE__ */ new Set();
+    for (let i = 0; i < nsat; i++) {
+      const id = satIds[i];
+      if (dup.has(id)) {
+        bad = true;
+        break;
+      }
+      dup.add(id);
+      let found = -1;
+      for (let j = 0; j < nsatOld; j++) {
+        if (oldSatList.slice(j * 3, j * 3 + 3) === id) {
+          found = j;
+          break;
+        }
+      }
+      sattbl.push(found);
+    }
+    if (bad) continue;
+    out.push(strdiff(oldline, fullNew));
+    let clockLine = "";
+    if (clkOrder > -1) {
+      if (clkOrder > 0) processClock(clk1, clk0, clkOrder);
+      clockLine += putClock(clk1.u[clkOrder], clk1.l[clkOrder], clkOrder);
+    }
+    if (newpsec.length === 5) {
+      clockLine += " " + strdiff(oldpsec, newpsec);
+    }
+    out.push(clockLine);
+    const dataLines = buildData(sats, sattbl, dy0, flag0, rinexVersion);
+    for (const dl of dataLines) out.push(dl);
+    oldline = fullNew;
+    nsatOld = nsat;
+    clk0 = clk1;
+    oldpsec = newpsec;
+    dy0 = sats.map((s) => s.data);
+    flag0 = sats.map((s) => s.flag);
+  }
+  return out.join("\n") + "\n";
+}
+function readClock(field, shiftClk, clk1, prevOrder) {
+  const c = field.split("");
+  if (c[2] !== ".") return -1;
+  for (let k = 0; k < shiftClk; k++) c[2 + k] = c[3 + k];
+  c[2 + shiftClk] = ".";
+  const s = c.join("");
+  const m = /(-?\d+)\.(\d+)/.exec(s);
+  if (!m) return -1;
+  clk1.u[0] = parseInt(m[1], 10);
+  clk1.l[0] = parseInt(m[2], 10);
+  if (c[0] === "-" || c[1] === "-") clk1.l[0] = -clk1.l[0];
+  return Math.min(prevOrder + 1, ARC_ORDER);
+}
+function processClock(clk1, clk0, clkOrder) {
+  for (let i = 0; i < clkOrder; i++) {
+    clk1.u[i + 1] = clk1.u[i] - clk0.u[i];
+    clk1.l[i + 1] = clk1.l[i] - clk0.l[i];
+  }
+}
+function takeDiff(py1, py0) {
+  py1.order = py0.order;
+  if (py1.order < ARC_ORDER) py1.order++;
+  for (let k = 0; k < py1.order; k++) {
+    py1.u[k + 1] = py1.u[k] - py0.u[k];
+    py1.l[k + 1] = py1.l[k] - py0.l[k];
+  }
+}
+function buildData(sats, sattbl, dy0, flag0, rinexVersion) {
+  const lines = [];
+  for (let i = 0; i < sats.length; i++) {
+    const sat = sats[i];
+    const i0 = sattbl[i];
+    const prevFlag = (i0 >= 0 ? flag0[i0] ?? "" : "").split("");
+    let line = "";
+    for (let j = 0; j < sat.ntypeRec; j++) {
+      const py1 = sat.data[j];
+      if (py1.order >= 0) {
+        if (i0 < 0 || dy0[i0]?.[j]?.order === -1) {
+          py1.order = 0;
+          line += `${ARC_ORDER}&`;
+        } else {
+          takeDiff(py1, dy0[i0][j]);
+          if (Math.abs(py1.u[py1.order]) > 1e5) {
+            py1.order = 0;
+            line += `${ARC_ORDER}&`;
+          }
+        }
+        line += putdiff(py1.u[py1.order], py1.l[py1.order]);
+      } else if (i0 >= 0 && rinexVersion === 2) {
+        prevFlag[j * 2] = " ";
+        prevFlag[j * 2 + 1] = " ";
+      }
+      line += " ";
+    }
+    if (i0 < 0 && rinexVersion !== 2) {
+      for (const ch of sat.flag) line += ch === " " ? "&" : ch;
+    } else {
+      line += i0 < 0 ? strdiff("", sat.flag) : strdiff(prevFlag.join(""), sat.flag);
+      line = line.replace(/ +$/, "");
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function putEventData(lines, cursor, v2, epochLine, out, ntypeGnss, setNtype) {
+  if (v2) {
+    out.push("&" + epochLine.slice(1));
+    if (epochLine.length > 29) {
+      const n = parseInt(epochLine.slice(29), 10) || 0;
+      for (let i = 0; i < n; i++) {
+        const l = chop(lines[cursor.li++] ?? "");
+        out.push(l);
+        if (l.slice(60).trimStart().startsWith("# / TYPES OF OBSERV") && l[5] !== " ") {
+          setNtype(parseInt(l, 10));
+        }
+      }
+    }
+  } else {
+    out.push(epochLine.replace(/\s+$/, ""));
+    const n = parseInt(epochLine.slice(32), 10) || 0;
+    for (let i = 0; i < n; i++) {
+      const l = chop(lines[cursor.li++] ?? "");
+      out.push(l);
+      if (l.slice(60).trimStart().startsWith("SYS / # / OBS TYPES") && l[0] !== " ") {
+        ntypeGnss[l[0]] = parseInt(l.slice(3), 10);
+      }
+    }
+  }
+}
+function readMoreSat(lines, cursor, n, epochLine) {
+  let result = epochLine;
+  let remaining = n;
+  while (remaining > 12) {
+    const l = lines[cursor.li++] ?? "";
+    const chopped = chop(l);
+    result += chopped[2] === " " ? chopped.slice(32) : chopped;
+    remaining -= 12;
+  }
+  return result;
+}
+function readVersionFull(line) {
+  if (line[5] === "2" && line[6] === " ") return 200;
+  const d = (c) => c !== void 0 && c >= "0" && c <= "9";
+  if (!d(line[5]) || line[6] !== "." || !d(line[7]) || !d(line[8])) return -1;
+  return (line.charCodeAt(5) - 48) * 100 + (line.charCodeAt(7) - 48) * 10 + (line.charCodeAt(8) - 48);
+}
+
 // src/rinex/format.ts
 function padL(s, w) {
   return s.length >= w ? s.slice(0, w) : s + " ".repeat(w - s.length);
@@ -7186,14 +7631,14 @@ function parseOrbitBlock(c, masks) {
       const gnssIod = c.u(IOD_BITS[sys.system]);
       const rad = c.s(13);
       const inT = c.s(12);
-      const cross = c.s(12);
+      const cross2 = c.s(12);
       corrections.push({
         system: sys.system,
         prn,
         gnssIod,
         deltaRadial: rad === -4096 ? null : rad * 25e-4,
         deltaInTrack: inT === -2048 ? null : inT * 8e-3,
-        deltaCrossTrack: cross === -2048 ? null : cross * 8e-3
+        deltaCrossTrack: cross2 === -2048 ? null : cross2 * 8e-3
       });
     }
   }
@@ -10220,17 +10665,17 @@ function ecefToAzEl(rxX, rxY, rxZ, satX, satY, satZ) {
 function computeDop(satAzEls) {
   const n = satAzEls.length;
   if (n < 4) return null;
-  const H2 = [];
+  const H3 = [];
   for (const { az, el } of satAzEls) {
     const cosEl = Math.cos(el);
-    H2.push([cosEl * Math.sin(az), cosEl * Math.cos(az), Math.sin(el), 1]);
+    H3.push([cosEl * Math.sin(az), cosEl * Math.cos(az), Math.sin(el), 1]);
   }
   const HtH = Array.from({ length: 4 }, () => new Array(4).fill(0));
   for (let i = 0; i < 4; i++) {
     for (let j = 0; j < 4; j++) {
       let sum = 0;
       for (let k = 0; k < n; k++) {
-        sum += H2[k][i] * H2[k][j];
+        sum += H3[k][i] * H3[k][j];
       }
       HtH[i][j] = sum;
     }
@@ -11357,7 +11802,7 @@ function solveDgnss(rover, base, basePos, ephemerides, timeMs, opts = {}) {
     let cov = null;
     for (let iter = 0; iter < maxIterations; iter++) {
       iterations = iter + 1;
-      const H2 = [];
+      const H3 = [];
       const v = [];
       const terms = /* @__PURE__ */ new Map();
       const termOf = (g) => {
@@ -11373,11 +11818,11 @@ function solveDgnss(rover, base, basePos, ephemerides, timeMs, opts = {}) {
         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);
-        H2.push([ts.u[0] - tr.u[0], ts.u[1] - tr.u[1], ts.u[2] - tr.u[2]]);
+        H3.push([ts.u[0] - tr.u[0], ts.u[1] - tr.u[1], ts.u[2] - tr.u[2]]);
       }
-      const Ht = transpose(H2);
+      const Ht = transpose(H3);
       const HtW = matMul(Ht, W);
-      const N = matMul(HtW, H2);
+      const N = matMul(HtW, H3);
       const b = matMul(
         HtW,
         v.map((s) => [s])
@@ -11393,7 +11838,7 @@ function solveDgnss(rover, base, basePos, ephemerides, timeMs, opts = {}) {
       z += dx[2][0];
       cov = Ninv;
       rows.forEach((row, i) => {
-        residuals[row.g.prn] = v[i] - (H2[i][0] * dx[0][0] + H2[i][1] * dx[1][0] + H2[i][2] * dx[2][0]);
+        residuals[row.g.prn] = v[i] - (H3[i][0] * dx[0][0] + H3[i][1] * dx[1][0] + H3[i][2] * dx[2][0]);
       });
       if (Math.hypot(dx[0][0], dx[1][0], dx[2][0]) < convergenceM) {
         converged = true;
@@ -11785,19 +12230,19 @@ var RtkFloatEngine = class {
     const PPrior = this.P;
     let xi = [...this.x];
     let K = [];
-    let H2 = [];
+    let H3 = [];
     for (let it = 0; it < Math.max(o.updateIterations, 1); it++) {
-      H2 = [];
+      H3 = [];
       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);
-        H2.push(h);
+        H3.push(h);
       }
-      const Ht = transpose(H2);
-      const S = matMul(matMul(H2, PPrior), Ht);
+      const Ht = transpose(H3);
+      const S = matMul(matMul(H3, 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);
@@ -11813,7 +12258,7 @@ var RtkFloatEngine = class {
       xi = xPrior.map((s, i) => s + dx[i][0]);
     }
     this.x = xi;
-    const KH = matMul(K, H2);
+    const KH = matMul(K, H3);
     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];
@@ -11906,6 +12351,800 @@ var RtkFloatEngine = class {
   }
 };
 
+// src/positioning/ppp-tropo.ts
+var HYD_AVG_A = [
+  0.0012769934,
+  1268323e-9,
+  0.0012465397,
+  0.0012196049,
+  0.0012045996
+];
+var HYD_AVG_B = [
+  0.0029153695,
+  0.0029152299,
+  0.0029288445,
+  0.0029022565,
+  0.0029024912
+];
+var HYD_AVG_C = [
+  0.062610505,
+  0.062837393,
+  0.063721774,
+  0.063824265,
+  0.064258455
+];
+var HYD_AMP_A = [0, 12709626e-12, 26523662e-12, 34000452e-12, 41202191e-12];
+var HYD_AMP_B = [0, 21414979e-12, 30160779e-12, 72562722e-12, 11723375e-11];
+var HYD_AMP_C = [0, 901284e-10, 43497037e-12, 84795348e-11, 0.0017037206];
+var HT_A = 253e-7;
+var HT_B = 549e-5;
+var HT_C = 114e-5;
+var WET_A = [
+  58021897e-11,
+  56794847e-11,
+  58118019e-11,
+  59727542e-11,
+  61641693e-11
+];
+var WET_B = [
+  0.0014275268,
+  0.0015138625,
+  0.0014572752,
+  0.0015007428,
+  0.0017599082
+];
+var WET_C = [
+  0.043472961,
+  0.04672951,
+  0.043908931,
+  0.044626982,
+  0.054736038
+];
+var LATS = [15, 30, 45, 60, 75];
+function interpLat(table, absLatDeg) {
+  if (absLatDeg <= 15) return table[0];
+  if (absLatDeg >= 75) return table[4];
+  let i = 0;
+  while (i < 4 && absLatDeg > LATS[i + 1]) i++;
+  const t = (absLatDeg - LATS[i]) / (LATS[i + 1] - LATS[i]);
+  return table[i] + t * (table[i + 1] - table[i]);
+}
+function marini(sinEl, a, b, c) {
+  const num = 1 + a / (1 + b / (1 + c));
+  const den = sinEl + a / (sinEl + b / (sinEl + c));
+  return num / den;
+}
+function dayOfYear(timeMs) {
+  const d = new Date(timeMs);
+  const start = Date.UTC(d.getUTCFullYear(), 0, 1);
+  return Math.floor((timeMs - start) / 864e5) + 1;
+}
+function niellMapping(elRad, latRad, heightM, timeMs) {
+  const sinEl = Math.sin(Math.max(elRad, 1e-3));
+  const absLat = Math.abs(latRad * 180 / Math.PI);
+  const hKm = heightM / 1e3;
+  let doy = dayOfYear(timeMs);
+  if (latRad < 0) doy += 365.25 / 2;
+  const yfrac = Math.cos(2 * Math.PI * (doy - 28) / 365.25);
+  const ah = interpLat(HYD_AVG_A, absLat) - interpLat(HYD_AMP_A, absLat) * yfrac;
+  const bh = interpLat(HYD_AVG_B, absLat) - interpLat(HYD_AMP_B, absLat) * yfrac;
+  const ch = interpLat(HYD_AVG_C, absLat) - interpLat(HYD_AMP_C, absLat) * yfrac;
+  const mHt = marini(sinEl, HT_A, HT_B, HT_C);
+  const dmdh = 1 / sinEl - mHt;
+  const mh = marini(sinEl, ah, bh, ch) + dmdh * hKm;
+  const aw = interpLat(WET_A, absLat);
+  const bw = interpLat(WET_B, absLat);
+  const cw = interpLat(WET_C, absLat);
+  const mw = marini(sinEl, aw, bw, cw);
+  const h = heightM < 0 ? 0 : heightM > 1e4 ? 1e4 : heightM;
+  const pres = 1013.25 * Math.pow(1 - 22557e-9 * h, 5.2568);
+  const zhd = 22768e-7 * pres / (1 - 266e-5 * Math.cos(2 * latRad) - 28e-5 * (h / 1e3));
+  return { zhd, mh, mw };
+}
+
+// src/positioning/ppp-astro.ts
+var AU = 149597870700;
+var GPS_UTC_LEAP = 18;
+var J2000_MS = Date.UTC(2e3, 0, 1, 12, 0, 0);
+var DEG = Math.PI / 180;
+function daysSinceJ2000(timeMs) {
+  return (timeMs - GPS_UTC_LEAP * 1e3 - J2000_MS) / 864e5;
+}
+function gmst(timeMs) {
+  const d = daysSinceJ2000(timeMs);
+  let deg = 280.46061837 + 360.98564736629 * d;
+  deg %= 360;
+  if (deg < 0) deg += 360;
+  return deg * DEG;
+}
+function eciToEcef(v, theta) {
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return [v[0] * c + v[1] * s, -v[0] * s + v[1] * c, v[2]];
+}
+function sunEcef(timeMs) {
+  const n = daysSinceJ2000(timeMs);
+  const L = (280.46 + 0.9856474 * n) * DEG;
+  const g = (357.528 + 0.9856003 * n) * DEG;
+  const lambda = L + (1.915 * Math.sin(g) + 0.02 * Math.sin(2 * g)) * DEG;
+  const eps = (23.439 - 4e-7 * n) * DEG;
+  const R = (1.00014 - 0.01671 * Math.cos(g) - 14e-5 * Math.cos(2 * g)) * AU;
+  const eci = [
+    R * Math.cos(lambda),
+    R * Math.cos(eps) * Math.sin(lambda),
+    R * Math.sin(eps) * Math.sin(lambda)
+  ];
+  return eciToEcef(eci, gmst(timeMs));
+}
+function moonEcef(timeMs) {
+  const T = daysSinceJ2000(timeMs) / 36525;
+  const L0 = 218.31617 + 481267.88088 * T - 1.3972 * T;
+  const l = 134.96292 + 477198.86753 * T;
+  const lp = 357.52543 + 35999.04944 * T;
+  const F = 93.27283 + 483202.01873 * T;
+  const D = 297.85027 + 445267.11135 * T;
+  const s = (x) => Math.sin(x * DEG);
+  const c = (x) => Math.cos(x * DEG);
+  const lon = L0 + 6.28875 * s(l) + 1.274018 * s(2 * D - l) + 0.658309 * s(2 * D) + 0.213616 * s(2 * l) - 0.185596 * s(lp) - 0.114336 * s(2 * F) + 0.058793 * s(2 * D - 2 * l) + 0.057212 * s(2 * D - lp - l) + 0.05332 * s(2 * D + l);
+  const lat = 5.128189 * s(F) + 0.280606 * s(l + F) + 0.277693 * s(l - F) + 0.173238 * s(2 * D - F) + 0.055413 * s(2 * D + F - l) + 0.046272 * s(2 * D - F - l);
+  const r = (385e3 - 20905 * c(l) - 3699 * c(2 * D - l) - 2956 * c(2 * D) - 570 * c(2 * l)) * 1e3;
+  const eps = (23.4393 - 4e-7 * daysSinceJ2000(timeMs)) * DEG;
+  const lonR = lon * DEG;
+  const latR = lat * DEG;
+  const xe = r * Math.cos(latR) * Math.cos(lonR);
+  const ye = r * Math.cos(latR) * Math.sin(lonR);
+  const ze = r * Math.sin(latR);
+  const eci = [
+    xe,
+    ye * Math.cos(eps) - ze * Math.sin(eps),
+    ye * Math.sin(eps) + ze * Math.cos(eps)
+  ];
+  return eciToEcef(eci, gmst(timeMs));
+}
+var H2 = 0.6078;
+var L2 = 0.0847;
+var RE = 6378137;
+var GM_SUN_RATIO = 332946.0482;
+var GM_MOON_RATIO = 0.0123000371;
+function solidEarthTide(rcv, sun, moon) {
+  const rNorm = Math.hypot(rcv[0], rcv[1], rcv[2]);
+  const rHat = [
+    rcv[0] / rNorm,
+    rcv[1] / rNorm,
+    rcv[2] / rNorm
+  ];
+  const disp = [0, 0, 0];
+  for (const [body, ratio] of [
+    [sun, GM_SUN_RATIO],
+    [moon, GM_MOON_RATIO]
+  ]) {
+    const rj = Math.hypot(body[0], body[1], body[2]);
+    const jHat = [
+      body[0] / rj,
+      body[1] / rj,
+      body[2] / rj
+    ];
+    const dot2 = rHat[0] * jHat[0] + rHat[1] * jHat[1] + rHat[2] * jHat[2];
+    const factor = ratio * RE * RE * RE * RE / (rj * rj * rj);
+    const radialScale = H2 * (1.5 * dot2 * dot2 - 0.5);
+    const tanScale = 3 * L2 * dot2;
+    for (let k = 0; k < 3; k++) {
+      disp[k] += factor * (radialScale * rHat[k] + tanScale * (jHat[k] - dot2 * rHat[k]));
+    }
+  }
+  return disp;
+}
+
+// src/positioning/ppp-antenna.ts
+function parseAntexTime(s) {
+  const p = s.trim().split(/\s+/).map(Number);
+  if (p.length < 3 || p.some((v) => Number.isNaN(v))) return null;
+  return Date.UTC(
+    p[0],
+    (p[1] || 1) - 1,
+    p[2] || 1,
+    p[3] ?? 0,
+    p[4] ?? 0,
+    Math.floor(p[5] ?? 0)
+  );
+}
+function freqOf(entry, code) {
+  return entry.frequencies.find((f) => f.frequency === code);
+}
+function combineIf(fA, fB, f1, f2) {
+  const g = f1 * f1 / (f1 * f1 - f2 * f2);
+  const mm = 1e-3;
+  const pco = [
+    (g * fA.pcoN - (g - 1) * fB.pcoN) * mm,
+    (g * fA.pcoE - (g - 1) * fB.pcoE) * mm,
+    (g * fA.pcoU - (g - 1) * fB.pcoU) * mm
+  ];
+  const nz = Math.min(fA.pcvNoazi.length, fB.pcvNoazi.length);
+  const pcvNoazi = new Array(nz);
+  for (let i = 0; i < nz; i++) {
+    pcvNoazi[i] = (g * fA.pcvNoazi[i] - (g - 1) * fB.pcvNoazi[i]) * mm;
+  }
+  return { pco, pcvZen1Deg: 0, pcvDzenDeg: 0, pcvNoazi };
+}
+function buildPppAntenna(antex) {
+  const sats = /* @__PURE__ */ new Map();
+  const rcvs = /* @__PURE__ */ new Map();
+  for (const a of antex.antennas) {
+    if (a.isSatellite) {
+      const list = sats.get(a.serialNo) ?? [];
+      list.push(a);
+      sats.set(a.serialNo, list);
+    } else if (!rcvs.has(a.type)) {
+      rcvs.set(a.type, a);
+    }
+  }
+  const withZen = (entry, off) => ({
+    ...off,
+    pcvZen1Deg: entry.zen1,
+    pcvDzenDeg: entry.dzen
+  });
+  return {
+    satOffset(prn, dateMs, band1, band2, f1, f2) {
+      const list = sats.get(prn);
+      if (!list) return null;
+      const entry = list.find((e) => {
+        const from = parseAntexTime(e.validFrom);
+        const until = parseAntexTime(e.validUntil);
+        return (from == null || dateMs >= from) && (until == null || dateMs <= until);
+      });
+      if (!entry) return null;
+      const a = freqOf(entry, band1);
+      const b = freqOf(entry, band2);
+      if (!a || !b) return null;
+      return withZen(entry, combineIf(a, b, f1, f2));
+    },
+    rcvOffset(antType, band1, band2, f1, f2) {
+      const entry = rcvs.get(antType);
+      if (!entry) return null;
+      const a = freqOf(entry, band1);
+      const b = freqOf(entry, band2);
+      if (!a || !b) return null;
+      return withZen(entry, combineIf(a, b, f1, f2));
+    }
+  };
+}
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function norm(a) {
+  const n = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / n, a[1] / n, a[2] / n];
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function satBodyFrame(satEcef, sunEcef2) {
+  const z = norm([-satEcef[0], -satEcef[1], -satEcef[2]]);
+  const eSun = norm([
+    sunEcef2[0] - satEcef[0],
+    sunEcef2[1] - satEcef[1],
+    sunEcef2[2] - satEcef[2]
+  ]);
+  const y = norm(cross(z, eSun));
+  const x = norm(cross(y, z));
+  return { x, y, z };
+}
+function satPcoToEcef(pcoBody, frame) {
+  return [
+    pcoBody[0] * frame.x[0] + pcoBody[1] * frame.y[0] + pcoBody[2] * frame.z[0],
+    pcoBody[0] * frame.x[1] + pcoBody[1] * frame.y[1] + pcoBody[2] * frame.z[1],
+    pcoBody[0] * frame.x[2] + pcoBody[1] * frame.y[2] + pcoBody[2] * frame.z[2]
+  ];
+}
+function enuToEcef(enu, latRad, lonRad) {
+  const sl = Math.sin(latRad);
+  const cl = Math.cos(latRad);
+  const so = Math.sin(lonRad);
+  const co = Math.cos(lonRad);
+  const [e, n, u] = enu;
+  return [
+    -so * e - sl * co * n + cl * co * u,
+    co * e - sl * so * n + cl * so * u,
+    cl * n + sl * u
+  ];
+}
+function interpPcv(off, angleDeg) {
+  const { pcvZen1Deg, pcvDzenDeg, pcvNoazi } = off;
+  if (pcvDzenDeg <= 0 || pcvNoazi.length < 2) return 0;
+  const x = (angleDeg - pcvZen1Deg) / pcvDzenDeg;
+  if (x <= 0) return pcvNoazi[0];
+  if (x >= pcvNoazi.length - 1) return pcvNoazi[pcvNoazi.length - 1];
+  const i = Math.floor(x);
+  const t = x - i;
+  return pcvNoazi[i] * (1 - t) + pcvNoazi[i + 1] * t;
+}
+function phaseWindup(prn, losRcvToSat, satFrame, latRad, lonRad, state) {
+  const k = [
+    -losRcvToSat[0],
+    -losRcvToSat[1],
+    -losRcvToSat[2]
+  ];
+  const kx = satFrame.x;
+  const ky = satFrame.y;
+  const kdotx = dot(k, kx);
+  const kcrossY = cross(k, ky);
+  const dS = [
+    kx[0] - k[0] * kdotx - kcrossY[0],
+    kx[1] - k[1] * kdotx - kcrossY[1],
+    kx[2] - k[2] * kdotx - kcrossY[2]
+  ];
+  const north = enuToEcef([0, 1, 0], latRad, lonRad);
+  const east = enuToEcef([1, 0, 0], latRad, lonRad);
+  const kdotn = dot(k, north);
+  const kcrossE = cross(k, east);
+  const dR = [
+    north[0] - k[0] * kdotn + kcrossE[0],
+    north[1] - k[1] * kdotn + kcrossE[1],
+    north[2] - k[2] * kdotn + kcrossE[2]
+  ];
+  const nS = Math.hypot(dS[0], dS[1], dS[2]) || 1;
+  const nR = Math.hypot(dR[0], dR[1], dR[2]) || 1;
+  let cosPhi = dot(dS, dR) / (nS * nR);
+  cosPhi = Math.max(-1, Math.min(1, cosPhi));
+  const zeta = cross(dS, dR);
+  const sign = dot(k, zeta) >= 0 ? 1 : -1;
+  const dphi = sign * Math.acos(cosPhi) / (2 * Math.PI);
+  const prev = state.get(prn);
+  const wu = prev == null ? dphi : dphi + Math.round(prev - dphi);
+  state.set(prn, wu);
+  return wu;
+}
+
+// src/positioning/ppp-corrections.ts
+function applyCorrections(corrections, geom, ctx) {
+  if (corrections.evaluate) return corrections.evaluate(geom, ctx);
+  return { rangeM: 0, phaseWindupM: 0 };
+}
+function createPppCorrections(cfg) {
+  const useSat = cfg.satPco ?? false;
+  const useRcv = cfg.rcvPco ?? true;
+  const useTides = cfg.tides ?? true;
+  const useWindup = cfg.windup ?? true;
+  const antDelta = cfg.antDeltaEnu ?? [0, 0, 0];
+  const windupState = /* @__PURE__ */ new Map();
+  return {
+    epochContext(timeMs, rcvEcef) {
+      const sun = sunEcef(timeMs);
+      const moon = moonEcef(timeMs);
+      const tideDisp = useTides ? solidEarthTide(rcvEcef, sun, moon) : [0, 0, 0];
+      return { timeMs, sun, moon, tideDisp };
+    },
+    evaluate(geom, ctx) {
+      let rangeM = 0;
+      let phaseWindupM = 0;
+      const e = geom.los;
+      const [latDeg, lonDeg] = ecefToGeodetic(
+        geom.rcvEcef[0],
+        geom.rcvEcef[1],
+        geom.rcvEcef[2]
+      );
+      const latRad = latDeg * Math.PI / 180;
+      const lonRad = lonDeg * Math.PI / 180;
+      const frame = ctx ? satBodyFrame(geom.satEcef, ctx.sun) : null;
+      if (useSat && frame && geom.band1 && geom.band2) {
+        const off = cfg.antenna.satOffset(
+          geom.prn,
+          ctx.timeMs,
+          geom.band1,
+          geom.band2,
+          geom.f1,
+          geom.f2
+        );
+        if (off) {
+          const pcoEcef = satPcoToEcef(off.pco, frame);
+          rangeM += dot(e, pcoEcef);
+          const satR = Math.hypot(
+            geom.satEcef[0],
+            geom.satEcef[1],
+            geom.satEcef[2]
+          );
+          const cosNadir = (e[0] * geom.satEcef[0] + e[1] * geom.satEcef[1] + e[2] * geom.satEcef[2]) / satR;
+          const nadirDeg = Math.acos(Math.max(-1, Math.min(1, cosNadir))) * 180 / Math.PI;
+          rangeM += interpPcv(off, nadirDeg);
+        }
+      }
+      if (useRcv && geom.band1 && geom.band2) {
+        const off = cfg.antenna.rcvOffset(
+          cfg.rcvAntType,
+          geom.band1,
+          geom.band2,
+          geom.f1,
+          geom.f2
+        );
+        if (off) {
+          const total = [
+            off.pco[0] + antDelta[0],
+            off.pco[1] + antDelta[1],
+            off.pco[2] + antDelta[2]
+          ];
+          const ecef = enuToEcef(total, latRad, lonRad);
+          rangeM -= dot(e, ecef);
+          const zenithDeg = 90 - geom.elRad * 180 / Math.PI;
+          rangeM += interpPcv(off, zenithDeg);
+        }
+      }
+      if (useTides && ctx) {
+        rangeM -= dot(e, ctx.tideDisp);
+      }
+      if (useWindup && frame) {
+        const wu = phaseWindup(geom.prn, e, frame, latRad, lonRad, windupState);
+        const lambdaIf = 299792458 / (geom.f1 + geom.f2);
+        phaseWindupM = wu * lambdaIf;
+      }
+      return { rangeM, phaseWindupM };
+    }
+  };
+}
+
+// src/positioning/ppp.ts
+function matVec(P, h) {
+  const n = P.length;
+  const out = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    let s = 0;
+    const Pi = P[i];
+    for (let j = 0; j < n; j++) s += Pi[j] * h[j];
+    out[i] = s;
+  }
+  return out;
+}
+function ekfUpdateScalar(x, P, h, innovation, r, rejectK = 0) {
+  const n = x.length;
+  const Ph = matVec(P, h);
+  let hPh = 0;
+  for (let i = 0; i < n; i++) hPh += h[i] * Ph[i];
+  const s = hPh + r;
+  if (s <= 0) return false;
+  if (rejectK > 0 && innovation * innovation > rejectK * rejectK * s) {
+    return false;
+  }
+  const K = Ph.map((v) => v / s);
+  for (let i = 0; i < n; i++) x[i] += K[i] * innovation;
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      P[i][j] -= K[i] * Ph[j];
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const m = 0.5 * (P[i][j] + P[j][i]);
+      P[i][j] = m;
+      P[j][i] = m;
+    }
+  }
+  return true;
+}
+function ifCoeffs(f1, f2) {
+  const g = f1 * f1 / (f1 * f1 - f2 * f2);
+  const lambdaIf = C_LIGHT / (f1 + f2);
+  return { g, lambdaIf };
+}
+function sagnacRotate(x, y, z, travelS) {
+  const theta = OMEGA_E * travelS;
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return [x * c + y * s, -x * s + y * c, z];
+}
+function satStateAtEmission(sp3, prn, recvTimeMs, rcv) {
+  let travelS = 0.075;
+  let sx = 0;
+  let sy = 0;
+  let sz = 0;
+  let clkS = null;
+  let velDotPos = 0;
+  for (let iter = 0; iter < 3; iter++) {
+    const tEmit = recvTimeMs - travelS * 1e3;
+    const p = sp3Position(sp3, prn, tEmit);
+    if (!p || p.clk == null) return null;
+    const pPlus = sp3Position(sp3, prn, tEmit + 500);
+    const pMinus = sp3Position(sp3, prn, tEmit - 500);
+    if (pPlus && pMinus) {
+      const vx = (pPlus.x - pMinus.x) / 1;
+      const vy = (pPlus.y - pMinus.y) / 1;
+      const vz = (pPlus.z - pMinus.z) / 1;
+      velDotPos = p.x * vx + p.y * vy + p.z * vz;
+    }
+    clkS = p.clk;
+    const [rx, ry, rz] = sagnacRotate(p.x, p.y, p.z, travelS);
+    sx = rx;
+    sy = ry;
+    sz = rz;
+    const dx = sx - rcv[0];
+    const dy = sy - rcv[1];
+    const dz = sz - rcv[2];
+    const range = Math.hypot(dx, dy, dz);
+    travelS = range / C_LIGHT;
+  }
+  if (clkS == null) return null;
+  const relS = -2 * velDotPos / (C_LIGHT * C_LIGHT);
+  const clkM = C_LIGHT * (clkS + relS);
+  return { state: { x: sx, y: sy, z: sz, clkM }, travelS };
+}
+var IDX_X = 0;
+var IDX_Y = 1;
+var IDX_Z = 2;
+var IDX_CLK = 3;
+var IDX_ZWD = 4;
+var NBASE = 5;
+function solvePpp(epochs, sp3, opts) {
+  const elevMask = (opts.elevationMaskDeg ?? 10) * Math.PI / 180;
+  const codeSigma = opts.codeSigma ?? 3;
+  const phaseSigma = opts.phaseSigma ?? 0.01;
+  const ztdQ = opts.ztdProcessNoise ?? 1e-8;
+  const corrections = opts.corrections;
+  const x = [
+    opts.aprioriPos[0],
+    opts.aprioriPos[1],
+    opts.aprioriPos[2],
+    0,
+    // receiver clock (m)
+    0.1
+    // zenith wet delay (m) a priori
+  ];
+  const P = [];
+  for (let i = 0; i < NBASE; i++) {
+    P.push(new Array(NBASE).fill(0));
+  }
+  P[IDX_X][IDX_X] = 100 * 100;
+  P[IDX_Y][IDX_Y] = 100 * 100;
+  P[IDX_Z][IDX_Z] = 100 * 100;
+  P[IDX_CLK][IDX_CLK] = 1e10;
+  P[IDX_ZWD][IDX_ZWD] = 0.5 * 0.5;
+  const ambIdx = /* @__PURE__ */ new Map();
+  const lastSeen = /* @__PURE__ */ new Map();
+  const mwState = /* @__PURE__ */ new Map();
+  const detectSlip = (o, ei) => {
+    const lamW = C_LIGHT / (o.f1 - o.f2);
+    const lw = o.l1 - o.l2;
+    const pn = (o.f1 * o.c1 + o.f2 * o.c2) / (o.f1 + o.f2);
+    const mw = lw - pn / lamW;
+    const st = mwState.get(o.prn);
+    let slip = o.slip;
+    if (!st || ei - st.lastEi > 2)
+      slip = true;
+    else if (Math.abs(mw - st.mean) > 4) slip = true;
+    if (slip) mwState.set(o.prn, { mean: mw, n: 1, lastEi: ei });
+    else {
+      const n = st.n + 1;
+      mwState.set(o.prn, {
+        mean: st.mean + (mw - st.mean) / Math.min(n, 100),
+        n,
+        lastEi: ei
+      });
+    }
+    return slip;
+  };
+  const growState = (initVal, initVar) => {
+    const idx = x.length;
+    x.push(initVal);
+    for (const row of P) row.push(0);
+    P.push(new Array(x.length).fill(0));
+    P[idx][idx] = initVar;
+    return idx;
+  };
+  const dropState = (idx) => {
+    x.splice(idx, 1);
+    P.splice(idx, 1);
+    for (const row of P) row.splice(idx, 1);
+    for (const [prn, i] of ambIdx) {
+      if (i === idx) ambIdx.delete(prn);
+      else if (i > idx) ambIdx.set(prn, i - 1);
+    }
+  };
+  let clockSeeded = false;
+  const series = [];
+  const truth = opts.groundTruth;
+  const t0 = epochs[0]?.timeMs ?? 0;
+  let convergenceSec = null;
+  let convergedStreak = 0;
+  for (let ei = 0; ei < epochs.length; ei++) {
+    const epoch = epochs[ei];
+    P[IDX_CLK][IDX_CLK] = 1e10;
+    P[IDX_ZWD][IDX_ZWD] += ztdQ * (ei > 0 ? 1 : 0);
+    const rcv = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
+    const [latDeg, , heightM] = ecefToGeodetic(rcv[0], rcv[1], rcv[2]);
+    const latRad = latDeg * Math.PI / 180;
+    const epochCtx = corrections?.epochContext?.(epoch.timeMs, rcv) ?? null;
+    const vis = [];
+    for (const o of epoch.obs) {
+      if (o.c1 === 0 || o.c2 === 0 || o.l1 === 0 || o.l2 === 0) continue;
+      const slip = detectSlip(o, ei);
+      const sat = satStateAtEmission(sp3, o.prn, epoch.timeMs, rcv);
+      if (!sat) continue;
+      const [elRad, azRad] = getAer(
+        sat.state.x,
+        sat.state.y,
+        sat.state.z,
+        rcv[0],
+        rcv[1],
+        rcv[2]
+      );
+      if (elRad < elevMask) continue;
+      const dx = sat.state.x - rcv[0];
+      const dy = sat.state.y - rcv[1];
+      const dz = sat.state.z - rcv[2];
+      const range = Math.hypot(dx, dy, dz);
+      const e = [dx / range, dy / range, dz / range];
+      const { g } = ifCoeffs(o.f1, o.f2);
+      const lam1 = C_LIGHT / o.f1;
+      const lam2 = C_LIGHT / o.f2;
+      if (o.c1 === 0 || o.c2 === 0 || o.l1 === 0 || o.l2 === 0) continue;
+      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 { zhd, mh, mw } = trop;
+      const geom = {
+        prn: o.prn,
+        satEcef: [sat.state.x, sat.state.y, sat.state.z],
+        rcvEcef: rcv,
+        los: e,
+        elRad,
+        azRad,
+        f1: o.f1,
+        f2: o.f2,
+        band1: o.band1,
+        band2: o.band2,
+        g
+      };
+      const corr = corrections ? applyCorrections(corrections, geom, epochCtx) : { rangeM: 0, phaseWindupM: 0 };
+      vis.push({
+        prn: o.prn,
+        e,
+        elRad,
+        pIf,
+        lIf,
+        satClkM: sat.state.clkM,
+        range,
+        tropoFixed: zhd * mh + corr.rangeM,
+        mw,
+        windupM: corr.phaseWindupM,
+        slip
+      });
+    }
+    const zwd0 = x[IDX_ZWD];
+    if (vis.length > 0) {
+      if (!clockSeeded) {
+        const s = vis.map(
+          (v) => v.pIf - (v.range - v.satClkM + v.tropoFixed + zwd0 * v.mw)
+        ).sort((a, b) => a - b);
+        x[IDX_CLK] = s[Math.floor(s.length / 2)];
+        clockSeeded = true;
+      }
+      P[IDX_CLK][IDX_CLK] = 1e10;
+    }
+    let nSats = 0;
+    let sumPhaseResSq = 0;
+    let nPhaseRes = 0;
+    for (const v of vis) {
+      const common = v.range + x[IDX_CLK] - v.satClkM + v.tropoFixed + zwd0 * v.mw;
+      let ai = ambIdx.get(v.prn);
+      if (ai === void 0 || v.slip) {
+        const bInit = v.lIf - (common + v.windupM);
+        if (ai === void 0) {
+          ai = growState(bInit, 100 * 100);
+        } else {
+          x[ai] = bInit;
+          for (let j = 0; j < P.length; j++) {
+            P[ai][j] = 0;
+            P[j][ai] = 0;
+          }
+          P[ai][ai] = 100 * 100;
+        }
+        ambIdx.set(v.prn, ai);
+      }
+      const n = x.length;
+      const sinEl = Math.max(Math.sin(v.elRad), 0.1);
+      const rCode = (codeSigma / sinEl) ** 2;
+      const rPhase = (phaseSigma / sinEl) ** 2;
+      {
+        const h = new Array(n).fill(0);
+        h[IDX_X] = -v.e[0];
+        h[IDX_Y] = -v.e[1];
+        h[IDX_Z] = -v.e[2];
+        h[IDX_CLK] = 1;
+        h[IDX_ZWD] = v.mw;
+        const innov = v.pIf - common;
+        if (Math.abs(innov) < 1e6) ekfUpdateScalar(x, P, h, innov, rCode, 4);
+      }
+      {
+        const commonPh = v.range + x[IDX_CLK] - v.satClkM + v.tropoFixed + x[IDX_ZWD] * v.mw;
+        const innov = v.lIf - (commonPh + v.windupM + x[ai]);
+        if (Math.abs(innov) > 0.15) {
+          x[ai] = v.lIf - (commonPh + v.windupM);
+          for (let j = 0; j < P.length; j++) {
+            P[ai][j] = 0;
+            P[j][ai] = 0;
+          }
+          P[ai][ai] = 100 * 100;
+        } else {
+          const h = new Array(n).fill(0);
+          h[IDX_X] = -v.e[0];
+          h[IDX_Y] = -v.e[1];
+          h[IDX_Z] = -v.e[2];
+          h[IDX_CLK] = 1;
+          h[IDX_ZWD] = v.mw;
+          h[ai] = 1;
+          if (ekfUpdateScalar(x, P, h, innov, rPhase, 4)) {
+            sumPhaseResSq += innov * innov;
+            nPhaseRes++;
+          }
+        }
+      }
+      lastSeen.set(v.prn, ei);
+      nSats++;
+    }
+    for (const [prn, seen] of [...lastSeen]) {
+      if (ei - seen > 20) {
+        const idx = ambIdx.get(prn);
+        if (idx !== void 0) dropState(idx);
+        lastSeen.delete(prn);
+      }
+    }
+    const pos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
+    let enu = null;
+    let error3d = null;
+    if (truth) {
+      enu = getEnuDifference(
+        pos[0],
+        pos[1],
+        pos[2],
+        truth[0],
+        truth[1],
+        truth[2]
+      );
+      error3d = Math.hypot(
+        pos[0] - truth[0],
+        pos[1] - truth[1],
+        pos[2] - truth[2]
+      );
+      if (error3d < 0.1) {
+        convergedStreak++;
+        if (convergedStreak >= 10 && convergenceSec == null) {
+          convergenceSec = (epoch.timeMs - t0) / 1e3;
+        }
+      } else {
+        convergedStreak = 0;
+        convergenceSec = null;
+      }
+    }
+    series.push({
+      timeMs: epoch.timeMs,
+      enu,
+      error3d,
+      position: pos,
+      nSats,
+      ztdWet: x[IDX_ZWD],
+      phaseResRms: nPhaseRes > 0 ? Math.sqrt(sumPhaseResSq / nPhaseRes) : 0
+    });
+  }
+  const finalPos = [x[IDX_X], x[IDX_Y], x[IDX_Z]];
+  const llh = ecefToGeodetic(finalPos[0], finalPos[1], finalPos[2]);
+  const finalError3d = truth ? Math.hypot(
+    finalPos[0] - truth[0],
+    finalPos[1] - truth[1],
+    finalPos[2] - truth[2]
+  ) : null;
+  return {
+    position: finalPos,
+    llh,
+    series,
+    ztdWet: x[IDX_ZWD],
+    epochsUsed: epochs.length,
+    convergenceSec,
+    finalError3d
+  };
+}
+
 // src/positioning/index.ts
 var GM_GPS3 = 3986005e8;
 var F_REL = -4442807633e-19;
@@ -12046,7 +13285,8 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
         let ionoM = 0;
         if ((gim || iono) && positionSane) {
           let l1M = null;
-          if (gim) l1M = gimSlantIonoDelayL1(gim, rxLat, rxLon, azim, elev, timeMs);
+          if (gim)
+            l1M = gimSlantIonoDelayL1(gim, rxLat, rxLon, azim, elev, timeMs);
           if (l1M === null && iono) {
             l1M = C_LIGHT * klobucharDelay(iono, rxLat, rxLon, azim, elev, gpsTow);
           }
@@ -14490,6 +15730,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   binexRecords,
   buildGloChannelMap,
   buildObsIndices,
+  buildPppAntenna,
   clampUnit,
   computeAllPositions,
   computeDop,
@@ -14503,6 +15744,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   connectToMountpoint,
   crc32,
   createGzipLineSink,
+  createPppCorrections,
   createStationMeta,
   createStreamStats,
   crxDecompress,
@@ -14588,6 +15830,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   glonassAlmanacEpochMs,
   glonassAlmanacPosition,
   glonassPosition,
+  gmst,
   greatCircleMidpoint,
   hdrLine,
   horizonDistance,
@@ -14597,8 +15840,10 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   lambdaReduction,
   lambdaSearch,
   maskRadForAzimuth,
+  moonEcef,
   msmEpochToDate,
   navTimesFromEph,
+  niellMapping,
   nmeaCoordToDecimal,
   oem4Frames,
   padL,
@@ -14648,10 +15893,13 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   selectEphemeris,
   setGloFreqNumber,
   setRtcm3DebugHandler,
+  solidEarthTide,
   solveDgnss,
+  solvePpp,
   solveSpp,
   sp3Position,
   stationHeaderLines,
+  sunEcef,
   systemCmp,
   systemName,
   toRtkEpoch,
@@ -14662,6 +15910,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   updateStreamStats,
   verifyChecksum,
   vincenty,
+  writeCrx,
   writeModernObsBlob,
   writeRinex2ObsBlob,
   writeRinex4ObsBlob,