gnss-js 1.10.0 → 1.12.0

package/dist/index.cjs

@@ -118,6 +118,7 @@ __export(src_exports, {
   computeStats: () => computeStats2,
   computeVisibility: () => computeVisibility,
   connectToMountpoint: () => connectToMountpoint,
+  createGzipLineSink: () => createGzipLineSink,
   createStationMeta: () => createStationMeta,
   createStreamStats: () => createStreamStats,
   crxDecompress: () => crxDecompress,
@@ -128,6 +129,7 @@ __export(src_exports, {
   deg2dms: () => deg2dms,
   deg2rad: () => deg2rad,
   detrendIonoArcs: () => detrendIonoArcs,
+  dopplerHz: () => dopplerHz,
   ecefToAzEl: () => ecefToAzEl,
   ecefToGeodetic: () => ecefToGeodetic,
   ephInfoToEphemeris: () => ephInfoToEphemeris,
@@ -200,6 +202,7 @@ __export(src_exports, {
   horizonDistance: () => horizonDistance,
   ionoFree: () => ionoFree,
   keplerPosition: () => keplerPosition,
+  klobucharDelay: () => klobucharDelay,
   maskRadForAzimuth: () => maskRadForAzimuth,
   msmEpochToDate: () => msmEpochToDate,
   navTimesFromEph: () => navTimesFromEph,
@@ -214,11 +217,13 @@ __export(src_exports, {
   parseRinexStream: () => parseRinexStream,
   parseSinexBiasDcb: () => parseSinexBiasDcb,
   parseSourcetable: () => parseSourcetable,
+  parseSp3: () => parseSp3,
   phiAltBOC: () => phiAltBOC,
   phiBOCc: () => phiBOCc,
   phiBOCs: () => phiBOCs,
   phiBPSK: () => phiBPSK,
   rad2deg: () => rad2deg,
+  rangeRate: () => rangeRate,
   readString: () => readString,
   reportDecodeError: () => reportDecodeError,
   resetGloFreqCache: () => resetGloFreqCache,
@@ -229,6 +234,8 @@ __export(src_exports, {
   setGloFreqNumber: () => setGloFreqNumber,
   setRtcm3DebugHandler: () => setRtcm3DebugHandler,
   solveSpp: () => solveSpp,
+  sp3Position: () => sp3Position,
+  stationHeaderLines: () => stationHeaderLines,
   systemCmp: () => systemCmp,
   systemName: () => systemName,
   transformFrame: () => transformFrame,
@@ -236,7 +243,11 @@ __export(src_exports, {
   updateStreamStats: () => updateStreamStats,
   verifyChecksum: () => verifyChecksum,
   vincenty: () => vincenty,
-  writeRinexNav: () => writeRinexNav
+  writeModernObsBlob: () => writeModernObsBlob,
+  writeRinex2ObsBlob: () => writeRinex2ObsBlob,
+  writeRinex4ObsBlob: () => writeRinex4ObsBlob,
+  writeRinexNav: () => writeRinexNav,
+  writeRinexObsBlob: () => writeRinexObsBlob
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -2662,6 +2673,496 @@ function parseIonex(text) {
   return { epochs, lats, lons, maps };
 }
 
+// src/rinex/sp3.ts
+var BAD_CLOCK = 999999.999999;
+function parseSp3(text) {
+  const lines = text.split("\n");
+  const epochs = [];
+  const satellites = {};
+  let version = "";
+  let intervalSec = 0;
+  let timeSystem = "GPS";
+  let timeSystemSet = false;
+  let epochIdx = -1;
+  for (const line of lines) {
+    if (!version && line.startsWith("#") && line.charAt(1) !== "#") {
+      version = line.charAt(1);
+    }
+    if (line.startsWith("##")) {
+      const f = line.slice(2).trim().split(/\s+/);
+      intervalSec = Number(f[2]) || 0;
+    } else if (line.startsWith("%c") && !timeSystemSet) {
+      const sys = line.slice(9, 12).trim();
+      if (sys && !/^c+$/.test(sys)) {
+        timeSystem = sys;
+        timeSystemSet = true;
+      }
+    } else if (line.startsWith("*")) {
+      const f = line.slice(1).trim().split(/\s+/).map(Number);
+      if (f.length >= 6 && f.every(Number.isFinite)) {
+        const sec = f[5];
+        epochs.push(
+          Date.UTC(
+            f[0],
+            f[1] - 1,
+            f[2],
+            f[3],
+            f[4],
+            Math.floor(sec),
+            Math.round(sec % 1 * 1e3)
+          )
+        );
+        epochIdx++;
+      }
+    } else if (line.startsWith("P") && epochIdx >= 0) {
+      const prn = line.slice(1, 4).replace(/\s/g, "0");
+      const f = line.slice(4).trim().split(/\s+/).map(Number);
+      if (f.length < 3) continue;
+      const [xKm, yKm, zKm] = f;
+      let arr = satellites[prn];
+      if (!arr) satellites[prn] = arr = [];
+      while (arr.length < epochIdx) arr.push(null);
+      if (xKm === 0 && yKm === 0 && zKm === 0) {
+        arr.push(null);
+        continue;
+      }
+      const clkUs = f[3];
+      arr.push({
+        x: xKm * 1e3,
+        y: yKm * 1e3,
+        z: zKm * 1e3,
+        clk: clkUs !== void 0 && Math.abs(clkUs) < BAD_CLOCK ? clkUs * 1e-6 : null
+      });
+    }
+  }
+  for (const arr of Object.values(satellites)) {
+    while (arr.length < epochs.length) arr.push(null);
+  }
+  return { version, epochs, intervalSec, timeSystem, satellites };
+}
+function sp3Position(sp3, prn, tMs, order = 9) {
+  const samples = sp3.satellites[prn];
+  const { epochs } = sp3;
+  const n = epochs.length;
+  if (!samples || n < order) return null;
+  if (tMs < epochs[0] || tMs > epochs[n - 1]) return null;
+  let lo = 0;
+  let hi = n - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (epochs[mid] <= tMs) lo = mid;
+    else hi = mid - 1;
+  }
+  let start = lo - (order >> 1) + (order % 2 === 0 ? 1 : 0);
+  start = Math.max(0, Math.min(n - order, start));
+  for (let i = start; i < start + order; i++) {
+    if (!samples[i]) return null;
+  }
+  const t0 = epochs[start];
+  const t = (tMs - t0) / 1e3;
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  for (let i = 0; i < order; i++) {
+    const ti = (epochs[start + i] - t0) / 1e3;
+    let w = 1;
+    for (let j = 0; j < order; j++) {
+      if (j === i) continue;
+      const tj = (epochs[start + j] - t0) / 1e3;
+      w *= (t - tj) / (ti - tj);
+    }
+    const s = samples[start + i];
+    x += w * s.x;
+    y += w * s.y;
+    z += w * s.z;
+  }
+  let clk = null;
+  const a = samples[lo];
+  const b = samples[Math.min(lo + 1, n - 1)];
+  if (a?.clk != null && b?.clk != null) {
+    const span = epochs[Math.min(lo + 1, n - 1)] - epochs[lo];
+    const f = span > 0 ? (tMs - epochs[lo]) / span : 0;
+    clk = a.clk * (1 - f) + b.clk * f;
+  } else if (a?.clk != null) {
+    clk = a.clk;
+  }
+  return { x, y, z, clk };
+}
+
+// src/rinex/obs-writer-common.ts
+function createGzipLineSink() {
+  const encoder = new TextEncoder();
+  const compressor = new CompressionStream("gzip");
+  const writer = compressor.writable.getWriter();
+  const compressedChunks = [];
+  const readerDone = (async () => {
+    const reader = compressor.readable.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      compressedChunks.push(value);
+    }
+  })();
+  let batch = [];
+  async function flush() {
+    if (batch.length === 0) return;
+    await writer.write(encoder.encode(batch.join("\n") + "\n"));
+    batch = [];
+  }
+  return {
+    push(line) {
+      batch.push(line);
+    },
+    flush,
+    async finish() {
+      await flush();
+      await writer.close();
+      await readerDone;
+      return new Blob(compressedChunks, {
+        type: "application/gzip"
+      });
+    }
+  };
+}
+function stationHeaderLines(header) {
+  const pos = header.approxPosition ?? [0, 0, 0];
+  const delta = header.antDelta ?? [0, 0, 0];
+  return [
+    hdrLine(header.markerName || "UNKNOWN", "MARKER NAME"),
+    hdrLine("", "MARKER NUMBER"),
+    hdrLine(
+      `${padL(header.observer || "", 20)}${padL(header.agency || "", 40)}`,
+      "OBSERVER / AGENCY"
+    ),
+    hdrLine(
+      `${padL(header.receiverNumber || "", 20)}${padL(header.receiverType || "", 20)}${padL(header.receiverVersion || "", 20)}`,
+      "REC # / TYPE / VERS"
+    ),
+    hdrLine(
+      `${padL(header.antNumber || "", 20)}${padL(header.antType || "", 20)}`,
+      "ANT # / TYPE"
+    ),
+    hdrLine(
+      `${fmtF(pos[0], 14, 4)}${fmtF(pos[1], 14, 4)}${fmtF(pos[2], 14, 4)}`,
+      "APPROX POSITION XYZ"
+    ),
+    hdrLine(
+      `${fmtF(delta[0], 14, 4)}${fmtF(delta[1], 14, 4)}${fmtF(delta[2], 14, 4)}`,
+      "ANTENNA: DELTA H/E/N"
+    )
+  ];
+}
+
+// src/rinex/obs-writer.ts
+function writeRinexObsBlob(header, epochs, obsTypes) {
+  return writeModernObsBlob(header, epochs, obsTypes, {
+    version: "3.04",
+    comment: "Merged from multiple RINEX files"
+  });
+}
+async function writeModernObsBlob(header, epochs, obsTypes, opts) {
+  if (epochs.length === 0) return new Blob([], { type: "application/gzip" });
+  const sink = createGzipLineSink();
+  const BATCH = 200;
+  const systems = [...obsTypes.keys()];
+  const sysChar = systems.length === 1 ? systems[0] : "M";
+  sink.push(
+    hdrLine(
+      `     ${opts.version}           OBSERVATION DATA    ${sysChar}`,
+      "RINEX VERSION / TYPE"
+    )
+  );
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = `${now.getUTCFullYear()}${String(now.getUTCMonth() + 1).padStart(2, "0")}${String(now.getUTCDate()).padStart(2, "0")} ${String(now.getUTCHours()).padStart(2, "0")}${String(now.getUTCMinutes()).padStart(2, "0")}${String(now.getUTCSeconds()).padStart(2, "0")} UTC`;
+  sink.push(
+    hdrLine(
+      `${padL("GNSSCalc", 20)}${padL("", 20)}${dateStr}`,
+      "PGM / RUN BY / DATE"
+    )
+  );
+  sink.push(hdrLine(opts.comment, "COMMENT"));
+  for (const line of stationHeaderLines(header)) sink.push(line);
+  for (const [sys, types] of obsTypes) {
+    for (let i = 0; i < types.length; i += 13) {
+      const chunk = types.slice(i, i + 13);
+      let content;
+      if (i === 0) {
+        content = `${sys}  ${padR(String(types.length), 3)}`;
+      } else {
+        content = "      ";
+      }
+      content += chunk.map((t) => ` ${padL(t, 3)}`).join("");
+      sink.push(hdrLine(content, "SYS / # / OBS TYPES"));
+    }
+  }
+  const timeSys = systems.includes("R") && systems.length === 1 ? "GLO" : "GPS";
+  const obsTimeLine = (d) => `  ${d.getUTCFullYear()}    ${String(d.getUTCMonth() + 1).padStart(2)}    ${String(d.getUTCDate()).padStart(2)}    ${String(d.getUTCHours()).padStart(2)}    ${String(d.getUTCMinutes()).padStart(2)}   ${(d.getUTCSeconds() + d.getUTCMilliseconds() / 1e3).toFixed(7).padStart(10)}     ${timeSys}`;
+  sink.push(
+    hdrLine(obsTimeLine(new Date(epochs[0].time)), "TIME OF FIRST OBS")
+  );
+  sink.push(
+    hdrLine(
+      obsTimeLine(new Date(epochs[epochs.length - 1].time)),
+      "TIME OF LAST OBS"
+    )
+  );
+  if (epochs.length >= 2) {
+    const interval = (epochs[1].time - epochs[0].time) / 1e3;
+    if (interval > 0 && interval < 3600) {
+      sink.push(hdrLine(fmtF(interval, 10, 3), "INTERVAL"));
+    }
+  }
+  if (header.glonassSlots && Object.keys(header.glonassSlots).length > 0) {
+    const entries = Object.entries(header.glonassSlots).sort(
+      ([a], [b]) => Number(a) - Number(b)
+    );
+    for (let i = 0; i < entries.length; i += 8) {
+      const chunk = entries.slice(i, i + 8);
+      let content = i === 0 ? padR(String(entries.length), 3) + " " : "    ";
+      for (const [slot, freq] of chunk) {
+        content += `R${padR(slot, 2)} ${padR(String(freq), 2)} `;
+      }
+      sink.push(hdrLine(content, "GLONASS SLOT / FRQ #"));
+    }
+  }
+  sink.push(hdrLine("", "END OF HEADER"));
+  await sink.flush();
+  let epochCount = 0;
+  for (const epoch of epochs) {
+    const t = new Date(epoch.time);
+    const sec = t.getUTCSeconds() + t.getUTCMilliseconds() / 1e3;
+    const prns = [...epoch.sats.keys()].sort();
+    sink.push(
+      `> ${t.getUTCFullYear()} ${String(t.getUTCMonth() + 1).padStart(2, "0")} ${String(t.getUTCDate()).padStart(2, "0")} ${String(t.getUTCHours()).padStart(2, "0")} ${String(t.getUTCMinutes()).padStart(2, "0")}${fmtF(sec, 11, 7)}  0${padR(String(prns.length), 3)}`
+    );
+    for (const prn of prns) {
+      const sys = prn[0];
+      const sysTypes = obsTypes.get(sys);
+      if (!sysTypes) continue;
+      const valArr = epoch.sats.get(prn);
+      let line = prn;
+      for (let i = 0; i < sysTypes.length; i++) {
+        const val = i < valArr.length ? valArr[i] : NaN;
+        if (!isNaN(val)) {
+          line += fmtF(val, 14, 3) + "  ";
+        } else {
+          line += " ".repeat(16);
+        }
+      }
+      sink.push(line);
+    }
+    epochCount++;
+    if (epochCount % BATCH === 0) await sink.flush();
+  }
+  return sink.finish();
+}
+
+// src/rinex/obs-writer-v2.ts
+var V3_TO_V2 = {
+  // GPS
+  C1C: "C1",
+  C1S: "C1",
+  C1L: "C1",
+  C1X: "C1",
+  C1W: "P1",
+  C1P: "P1",
+  C2C: "C2",
+  C2S: "P2",
+  C2L: "P2",
+  C2X: "P2",
+  C2W: "P2",
+  C2P: "P2",
+  C5I: "C5",
+  C5Q: "C5",
+  C5X: "C5",
+  L1C: "L1",
+  L1S: "L1",
+  L1L: "L1",
+  L1X: "L1",
+  L1W: "L1",
+  L1P: "L1",
+  L2C: "L2",
+  L2S: "L2",
+  L2L: "L2",
+  L2X: "L2",
+  L2W: "L2",
+  L2P: "L2",
+  L5I: "L5",
+  L5Q: "L5",
+  L5X: "L5",
+  D1C: "D1",
+  D1S: "D1",
+  D1L: "D1",
+  D1X: "D1",
+  D1W: "D1",
+  D1P: "D1",
+  D2C: "D2",
+  D2S: "D2",
+  D2L: "D2",
+  D2X: "D2",
+  D2W: "D2",
+  D2P: "D2",
+  D5I: "D5",
+  D5Q: "D5",
+  D5X: "D5",
+  S1C: "S1",
+  S1S: "S1",
+  S1L: "S1",
+  S1X: "S1",
+  S1W: "S1",
+  S1P: "S1",
+  S2C: "S2",
+  S2S: "S2",
+  S2L: "S2",
+  S2X: "S2",
+  S2W: "S2",
+  S2P: "S2",
+  S5I: "S5",
+  S5Q: "S5",
+  S5X: "S5"
+};
+function v3ToV2Code(code3) {
+  return V3_TO_V2[code3] ?? null;
+}
+async function writeRinex2ObsBlob(header, epochs, obsTypes) {
+  if (epochs.length === 0) return new Blob([], { type: "application/gzip" });
+  const gpsCodes = obsTypes.get("G") ?? obsTypes.get("R") ?? [];
+  const v2Codes = [];
+  const v2CodeSet = /* @__PURE__ */ new Set();
+  const v3ToV2Map = /* @__PURE__ */ new Map();
+  for (const code3 of gpsCodes) {
+    const code2 = v3ToV2Code(code3);
+    if (!code2) continue;
+    if (!v2CodeSet.has(code2)) {
+      v2CodeSet.add(code2);
+      v3ToV2Map.set(code3, v2Codes.length);
+      v2Codes.push(code2);
+    } else {
+      v3ToV2Map.set(code3, v2Codes.indexOf(code2));
+    }
+  }
+  const gloCodes = obsTypes.get("R") ?? [];
+  for (const code3 of gloCodes) {
+    const code2 = v3ToV2Code(code3);
+    if (!code2) continue;
+    if (!v2CodeSet.has(code2)) {
+      v2CodeSet.add(code2);
+      v3ToV2Map.set(code3, v2Codes.length);
+      v2Codes.push(code2);
+    } else if (!v3ToV2Map.has(code3)) {
+      v3ToV2Map.set(code3, v2Codes.indexOf(code2));
+    }
+  }
+  const sink = createGzipLineSink();
+  const BATCH = 200;
+  const hasSystems = /* @__PURE__ */ new Set();
+  for (const epoch of epochs) {
+    for (const prn of epoch.sats.keys()) {
+      const sys = prn[0];
+      if (sys === "G" || sys === "R") hasSystems.add(sys);
+    }
+  }
+  const sysChar = hasSystems.has("G") && hasSystems.has("R") ? "M" : hasSystems.has("R") ? "R" : "G";
+  sink.push(
+    hdrLine(
+      `     2.11           OBSERVATION DATA    ${sysChar}`,
+      "RINEX VERSION / TYPE"
+    )
+  );
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}-${String(now.getUTCDate()).padStart(2, "0")} ${String(now.getUTCHours()).padStart(2, "0")}:${String(now.getUTCMinutes()).padStart(2, "0")}:${String(now.getUTCSeconds()).padStart(2, "0")}`;
+  sink.push(
+    hdrLine(
+      `${padL("GNSSCalc", 20)}${padL("", 20)}${dateStr}`,
+      "PGM / RUN BY / DATE"
+    )
+  );
+  sink.push(hdrLine("Converted from RINEX 3 by GNSSCalc", "COMMENT"));
+  for (const line of stationHeaderLines(header)) sink.push(line);
+  sink.push(hdrLine("     1     1", "WAVELENGTH FACT L1/2"));
+  for (let i = 0; i < v2Codes.length; i += 9) {
+    const chunk = v2Codes.slice(i, i + 9);
+    let content;
+    if (i === 0) {
+      content = padR(String(v2Codes.length), 6);
+    } else {
+      content = "      ";
+    }
+    content += chunk.map((c) => padR(c, 6)).join("");
+    sink.push(hdrLine(content, "# / TYPES OF OBSERV"));
+  }
+  const first = new Date(epochs[0].time);
+  const timeSys = sysChar === "R" ? "GLO" : "GPS";
+  sink.push(
+    hdrLine(
+      `  ${first.getUTCFullYear()}    ${String(first.getUTCMonth() + 1).padStart(2)}    ${String(first.getUTCDate()).padStart(2)}    ${String(first.getUTCHours()).padStart(2)}    ${String(first.getUTCMinutes()).padStart(2)}   ${(first.getUTCSeconds() + first.getUTCMilliseconds() / 1e3).toFixed(7).padStart(10)}     ${timeSys}`,
+      "TIME OF FIRST OBS"
+    )
+  );
+  sink.push(hdrLine("", "END OF HEADER"));
+  await sink.flush();
+  let epochCount = 0;
+  for (const epoch of epochs) {
+    const t = new Date(epoch.time);
+    const sec = t.getUTCSeconds() + t.getUTCMilliseconds() / 1e3;
+    const prns = [...epoch.sats.keys()].filter((p) => p[0] === "G" || p[0] === "R").sort();
+    if (prns.length === 0) continue;
+    const yy = t.getUTCFullYear() % 100;
+    const yyS = padR(String(yy), 2);
+    const moS = padR(String(t.getUTCMonth() + 1), 2);
+    const ddS = padR(String(t.getUTCDate()), 2);
+    const hhS = padR(String(t.getUTCHours()), 2);
+    const mmS = padR(String(t.getUTCMinutes()), 2);
+    const secS = fmtF(sec, 11, 7);
+    const nSats = padR(String(prns.length), 3);
+    let epochLine = ` ${yyS} ${moS} ${ddS} ${hhS} ${mmS}${secS}  0${nSats}`;
+    for (let i = 0; i < prns.length; i++) {
+      if (i > 0 && i % 12 === 0) {
+        sink.push(epochLine);
+        epochLine = " ".repeat(32);
+      }
+      epochLine += prns[i];
+    }
+    sink.push(epochLine);
+    for (const prn of prns) {
+      const sys = prn[0];
+      const sysCodes3 = obsTypes.get(sys) ?? [];
+      const valArr = epoch.sats.get(prn);
+      const v2Vals = new Array(v2Codes.length).fill(NaN);
+      for (let j = 0; j < sysCodes3.length; j++) {
+        const v2Idx = v3ToV2Map.get(sysCodes3[j]);
+        if (v2Idx != null && j < valArr.length && !isNaN(valArr[j])) {
+          v2Vals[v2Idx] = valArr[j];
+        }
+      }
+      let line = "";
+      for (let j = 0; j < v2Codes.length; j++) {
+        const val = v2Vals[j];
+        if (!isNaN(val)) {
+          line += fmtF(val, 14, 3) + "  ";
+        } else {
+          line += " ".repeat(16);
+        }
+        if ((j + 1) % 5 === 0 || j === v2Codes.length - 1) {
+          sink.push(line);
+          line = "";
+        }
+      }
+    }
+    epochCount++;
+    if (epochCount % BATCH === 0) await sink.flush();
+  }
+  return sink.finish();
+}
+
+// src/rinex/obs-writer-v4.ts
+function writeRinex4ObsBlob(header, epochs, obsTypes) {
+  return writeModernObsBlob(header, epochs, obsTypes, {
+    version: "4.01",
+    comment: "Converted to RINEX 4 by GNSSCalc"
+  });
+}
+
 // src/rtcm3/decoder.ts
 var debugHandler = null;
 function setRtcm3DebugHandler(fn) {
@@ -4104,6 +4605,7 @@ function gmForSystem(sys) {
   if (sys === "C") return GM_BDS;
   return GM_GPS;
 }
+var geoVelocityPass = false;
 function keplerPosition(eph, t) {
   const GM = gmForSystem(eph.system);
   const a = eph.sqrtA * eph.sqrtA;
@@ -4131,8 +4633,16 @@ function keplerPosition(eph, t) {
   const uk = phik + duk;
   const rk = a * (1 - eph.e * cosE) + drk;
   const ik = eph.i0 + dik + eph.idot * tk;
+  const EkDot = n / (1 - eph.e * cosE);
+  const vkDot = EkDot * Math.sqrt(1 - eph.e * eph.e) / (1 - eph.e * cosE);
+  const dukDot = 2 * vkDot * (eph.cus * cos2phi - eph.cuc * sin2phi);
+  const drkDot = a * eph.e * sinE * EkDot + 2 * vkDot * (eph.crs * cos2phi - eph.crc * sin2phi);
+  const dikDot = eph.idot + 2 * vkDot * (eph.cis * cos2phi - eph.cic * sin2phi);
+  const ukDot = vkDot + dukDot;
   const xp = rk * Math.cos(uk);
   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;
   if (isBdsGeo) {
     const omegak2 = eph.omega0 + eph.omegaDot * tk - OMEGA_E * eph.toe;
@@ -4148,23 +4658,43 @@ function keplerPosition(eph, t) {
     const sinPhi = Math.sin(phi);
     const COS5 = Math.cos(-5 * Math.PI / 180);
     const SIN5 = Math.sin(-5 * Math.PI / 180);
+    const px = xg * cosPhi + yg * sinPhi * COS5 + zg * sinPhi * SIN5;
+    const py = -xg * sinPhi + yg * cosPhi * COS5 + zg * cosPhi * SIN5;
+    const pz = -yg * SIN5 + zg * COS5;
+    if (geoVelocityPass) {
+      return { prn: eph.prn, x: px, y: py, z: pz, vx: 0, vy: 0, vz: 0 };
+    }
+    geoVelocityPass = true;
+    const h = 0.5;
+    const pm = keplerPosition(eph, t - h);
+    const pp = keplerPosition(eph, t + h);
+    geoVelocityPass = false;
     return {
       prn: eph.prn,
-      x: xg * cosPhi + yg * sinPhi * COS5 + zg * sinPhi * SIN5,
-      y: -xg * sinPhi + yg * cosPhi * COS5 + zg * cosPhi * SIN5,
-      z: -yg * SIN5 + zg * COS5
+      x: px,
+      y: py,
+      z: pz,
+      vx: (pp.x - pm.x) / (2 * h),
+      vy: (pp.y - pm.y) / (2 * h),
+      vz: (pp.z - pm.z) / (2 * h)
     };
   }
   const omegak = eph.omega0 + (eph.omegaDot - OMEGA_E) * tk - OMEGA_E * eph.toe;
+  const omegakDot = eph.omegaDot - OMEGA_E;
   const cosO = Math.cos(omegak);
   const sinO = Math.sin(omegak);
   const cosI = Math.cos(ik);
   const sinI = Math.sin(ik);
+  const x = xp * cosO - yp * cosI * sinO;
+  const y = xp * sinO + yp * cosI * cosO;
   return {
     prn: eph.prn,
-    x: xp * cosO - yp * cosI * sinO,
-    y: xp * sinO + yp * cosI * cosO,
-    z: yp * sinI
+    x,
+    y,
+    z: yp * sinI,
+    vx: xpDot * cosO - ypDot * cosI * sinO + yp * sinI * sinO * dikDot - omegakDot * y,
+    vy: xpDot * sinO + ypDot * cosI * cosO - yp * sinI * cosO * dikDot + omegakDot * x,
+    vz: ypDot * sinI + yp * cosI * dikDot
   };
 }
 function gloDerivatives(state, acc) {
@@ -4218,7 +4748,25 @@ function glonassPosition(eph, tUtc) {
   if (Math.abs(remainder) > 1e-3) {
     state = rk4Step(state, acc, remainder);
   }
-  return { prn: eph.prn, x: state[0], y: state[1], z: state[2] };
+  return {
+    prn: eph.prn,
+    x: state[0],
+    y: state[1],
+    z: state[2],
+    vx: state[3],
+    vy: state[4],
+    vz: state[5]
+  };
+}
+function rangeRate(sat, rx, rxVel = [0, 0, 0]) {
+  const dx = sat.x - rx[0];
+  const dy = sat.y - rx[1];
+  const dz = sat.z - rx[2];
+  const rho = Math.hypot(dx, dy, dz);
+  return ((sat.vx - rxVel[0]) * dx + (sat.vy - rxVel[1]) * dy + (sat.vz - rxVel[2]) * dz) / rho;
+}
+function dopplerHz(rangeRateMs, freqHz) {
+  return -rangeRateMs * freqHz / C_LIGHT;
 }
 function ecefToAzEl(rxX, rxY, rxZ, satX, satY, satZ) {
   const [lat, lon] = ecefToGeodetic(rxX, rxY, rxZ);
@@ -4837,6 +5385,37 @@ function dateToEpoch(date) {
   return year + (date.getTime() - start) / (end - start);
 }
 
+// src/positioning/klobuchar.ts
+function klobucharDelay(coeffs, latRad, lonRad, azRad, elRad, gpsTowSec) {
+  const { alpha, beta } = coeffs;
+  if (alpha.length < 4 || beta.length < 4) return 0;
+  const E = elRad / Math.PI;
+  const phiU = latRad / Math.PI;
+  const lambdaU = lonRad / Math.PI;
+  const psi = 0.0137 / (E + 0.11) - 0.022;
+  let phiI = phiU + psi * Math.cos(azRad);
+  if (phiI > 0.416) phiI = 0.416;
+  else if (phiI < -0.416) phiI = -0.416;
+  const lambdaI = lambdaU + psi * Math.sin(azRad) / Math.cos(phiI * Math.PI);
+  const phiM = phiI + 0.064 * Math.cos((lambdaI - 1.617) * Math.PI);
+  let t = 43200 * lambdaI + gpsTowSec;
+  t %= 86400;
+  if (t < 0) t += 86400;
+  let amp = 0;
+  let per = 0;
+  for (let n = 3; n >= 0; n--) {
+    amp = amp * phiM + alpha[n];
+    per = per * phiM + beta[n];
+  }
+  if (amp < 0) amp = 0;
+  if (per < 72e3) per = 72e3;
+  const F = 1 + 16 * Math.pow(0.53 - E, 3);
+  const x = 2 * Math.PI * (t - 50400) / per;
+  if (Math.abs(x) >= 1.57) return F * 5e-9;
+  const x2 = x * x;
+  return F * (5e-9 + amp * (1 - x2 / 2 + x2 * x2 / 24));
+}
+
 // src/positioning/index.ts
 var GM_GPS2 = 3986005e8;
 var F_REL = -4442807633e-19;
@@ -4863,6 +5442,16 @@ function ionoFree(p1, p2, f1, f2) {
   const g = f1 * f1 / (f1 * f1 - f2 * f2);
   return g * p1 - (g - 1) * p2;
 }
+var GPS_EPOCH_MS_SPP = Date.UTC(1980, 0, 6);
+var PRIMARY_FREQ_HZ = {
+  G: 157542e4,
+  E: 157542e4,
+  J: 157542e4,
+  S: 157542e4,
+  C: 1561098e3,
+  R: 1602e6
+};
+var F_L1 = 157542e4;
 function tropoDelay(elevationRad) {
   const sinEl = Math.sin(elevationRad);
   return 2.47 / (sinEl + 0.0121);
@@ -4897,8 +5486,10 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
     troposphere = true,
     maxIterations = 15,
     convergenceM = 1e-4,
-    tgd = true
+    tgd = true,
+    iono
   } = opts;
+  const gpsTow = (timeMs - GPS_EPOCH_MS_SPP) / 1e3 % 604800;
   const all = [...pseudoranges.keys()].filter((p) => ephemerides.has(p));
   const minSats = (list) => 3 + new Set(list.map((p) => p[0])).size;
   if (all.length < minSats(all)) return null;
@@ -4922,6 +5513,8 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
       const Htv = new Array(dim).fill(0);
       let rows = 0;
       for (const k of Object.keys(residuals2)) delete residuals2[k];
+      const positionSaneIter = x2 * x2 + y2 * y2 + z2 * z2 > 1e12;
+      const [rxLat, rxLon] = positionSaneIter ? ecefToGeodetic(x2, y2, z2) : [0, 0];
       for (const prn of prns) {
         const psr = pseudoranges.get(prn);
         const eph = ephemerides.get(prn);
@@ -4940,17 +5533,24 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
         const uy = (y2 - sy) / rho;
         const uz = (z2 - sz) / rho;
         let elev = Math.PI / 2;
+        let azim = 0;
         let weight = 1;
-        const positionSane = x2 * x2 + y2 * y2 + z2 * z2 > 1e12;
+        const positionSane = positionSaneIter;
         if (positionSane) {
           const azel = ecefToAzEl(x2, y2, z2, sx, sy, sz);
           elev = azel.el;
+          azim = azel.az;
           if (iter >= 2 && elev < elevationMaskDeg * Math.PI / 180) continue;
           const sinEl = Math.max(Math.sin(elev), 0.1);
           weight = sinEl * sinEl;
         }
         const tropo = troposphere && positionSane ? tropoDelay(elev) : 0;
-        const predicted = rho + clk - C_LIGHT * dts + tropo;
+        let ionoM = 0;
+        if (iono && positionSane) {
+          const f = PRIMARY_FREQ_HZ[sys] ?? F_L1;
+          ionoM = C_LIGHT * klobucharDelay(iono, rxLat, rxLon, azim, elev, gpsTow) * (F_L1 / f * (F_L1 / f));
+        }
+        const predicted = rho + clk - C_LIGHT * dts + tropo + ionoM;
         const v = psr - predicted;
         const h = new Array(dim).fill(0);
         h[0] = ux;
@@ -7386,6 +7986,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   computeStats,
   computeVisibility,
   connectToMountpoint,
+  createGzipLineSink,
   createStationMeta,
   createStreamStats,
   crxDecompress,
@@ -7396,6 +7997,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   deg2dms,
   deg2rad,
   detrendIonoArcs,
+  dopplerHz,
   ecefToAzEl,
   ecefToGeodetic,
   ephInfoToEphemeris,
@@ -7468,6 +8070,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   horizonDistance,
   ionoFree,
   keplerPosition,
+  klobucharDelay,
   maskRadForAzimuth,
   msmEpochToDate,
   navTimesFromEph,
@@ -7482,11 +8085,13 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   parseRinexStream,
   parseSinexBiasDcb,
   parseSourcetable,
+  parseSp3,
   phiAltBOC,
   phiBOCc,
   phiBOCs,
   phiBPSK,
   rad2deg,
+  rangeRate,
   readString,
   reportDecodeError,
   resetGloFreqCache,
@@ -7497,6 +8102,8 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   setGloFreqNumber,
   setRtcm3DebugHandler,
   solveSpp,
+  sp3Position,
+  stationHeaderLines,
   systemCmp,
   systemName,
   transformFrame,
@@ -7504,5 +8111,9 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   updateStreamStats,
   verifyChecksum,
   vincenty,
-  writeRinexNav
+  writeModernObsBlob,
+  writeRinex2ObsBlob,
+  writeRinex4ObsBlob,
+  writeRinexNav,
+  writeRinexObsBlob
 });