gnss-js 1.11.0 → 1.12.0

package/dist/rinex.cjs

@@ -23,6 +23,7 @@ __export(rinex_exports, {
   EMPTY_WARNINGS: () => EMPTY_WARNINGS,
   SYSTEM_ORDER: () => SYSTEM_ORDER,
   WarningAccumulator: () => WarningAccumulator,
+  createGzipLineSink: () => createGzipLineSink,
   crxDecompress: () => crxDecompress,
   crxRepair: () => crxRepair,
   fmtF: () => fmtF,
@@ -33,9 +34,16 @@ __export(rinex_exports, {
   parseIonex: () => parseIonex,
   parseNavFile: () => parseNavFile,
   parseRinexStream: () => parseRinexStream,
+  parseSp3: () => parseSp3,
+  sp3Position: () => sp3Position,
+  stationHeaderLines: () => stationHeaderLines,
   systemCmp: () => systemCmp,
   systemName: () => systemName,
-  writeRinexNav: () => writeRinexNav
+  writeModernObsBlob: () => writeModernObsBlob,
+  writeRinex2ObsBlob: () => writeRinex2ObsBlob,
+  writeRinex4ObsBlob: () => writeRinex4ObsBlob,
+  writeRinexNav: () => writeRinexNav,
+  writeRinexObsBlob: () => writeRinexObsBlob
 });
 module.exports = __toCommonJS(rinex_exports);
 
@@ -1535,11 +1543,502 @@ 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"
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EMPTY_WARNINGS,
   SYSTEM_ORDER,
   WarningAccumulator,
+  createGzipLineSink,
   crxDecompress,
   crxRepair,
   fmtF,
@@ -1550,7 +2049,14 @@ function parseIonex(text) {
   parseIonex,
   parseNavFile,
   parseRinexStream,
+  parseSp3,
+  sp3Position,
+  stationHeaderLines,
   systemCmp,
   systemName,
-  writeRinexNav
+  writeModernObsBlob,
+  writeRinex2ObsBlob,
+  writeRinex4ObsBlob,
+  writeRinexNav,
+  writeRinexObsBlob
 });

package/dist/rinex.d.cts

@@ -135,4 +135,132 @@ interface IonexGrid {
 }
 declare function parseIonex(text: string): IonexGrid;
 
-export { type CrxField, type DiffState, EMPTY_WARNINGS, type IonexGrid, NavResult, RinexHeader, type RinexWarning, type RinexWarnings, WarningAccumulator, type WarningSeverity, crxDecompress, crxRepair, fmtF, hdrLine, padL, padR, parseCrxDataLine, parseIonex, writeRinexNav };
+/**
+ * SP3-c/-d precise orbit and clock parser, with Lagrange interpolation
+ * for evaluating positions between the tabulated epochs.
+ *
+ * Positions are converted to meters (SP3 tabulates km), clocks to
+ * seconds (SP3 tabulates microseconds). Missing positions (all-zero
+ * coordinates) and the 999999.999999 bad-clock sentinel become null.
+ * Epoch tags are read in the file's own time scale (GPS for IGS/MGEX
+ * products) as epoch milliseconds, matching the convention of the
+ * RINEX parsers in this library.
+ */
+interface Sp3Sample {
+    /** ECEF meters. */
+    x: number;
+    y: number;
+    z: number;
+    /** Satellite clock offset in seconds, or null when flagged bad. */
+    clk: number | null;
+}
+interface Sp3File {
+    version: string;
+    /** Epoch timestamps (ms). */
+    epochs: number[];
+    /** Tabulated interval in seconds (from the ## header line). */
+    intervalSec: number;
+    /** Time system from the %c line, e.g. 'GPS'. */
+    timeSystem: string;
+    /** prn → per-epoch samples (null where the satellite is missing). */
+    satellites: Record<string, (Sp3Sample | null)[]>;
+}
+declare function parseSp3(text: string): Sp3File;
+/**
+ * Satellite position at an arbitrary time by Lagrange interpolation
+ * over the `order` nearest tabulated samples (default 9, the standard
+ * choice for 5–15 min SP3 tables; centimetre-level between nodes).
+ * Clock is interpolated linearly between the bracketing samples.
+ *
+ * Returns null outside the covered span, near data gaps, or when the
+ * satellite is absent.
+ */
+declare function sp3Position(sp3: Sp3File, prn: string, tMs: number, order?: number): {
+    x: number;
+    y: number;
+    z: number;
+    clk: number | null;
+} | null;
+
+/**
+ * RINEX 3.04 / 4.01 observation file writer.
+ *
+ * The two formats share the same header layout and epoch record
+ * encoding — only the version line and the provenance comment differ
+ * (see obs-writer.test.ts, which pins this). RINEX 2.11 lives in
+ * obs-writer-v2.ts (different header records and epoch layout).
+ *
+ * Streams text through gzip compression so we never hold the full
+ * uncompressed output in memory. Returns a gzip-compressed Blob.
+ */
+
+/**
+ * Compact epoch — stores observation values in Float64Arrays
+ * indexed by a per-system obs code registry (NaN = missing).
+ * ~10-15x less memory than Map-of-Maps.
+ */
+interface CompactEpoch {
+    time: number;
+    sats: Map<string, Float64Array>;
+}
+/**
+ * Write RINEX 3.04 obs file from compact observations.
+ *
+ * The `obsTypes` map defines both the RINEX header declaration order and
+ * the Float64Array index order for each system.
+ */
+declare function writeRinexObsBlob(header: RinexHeader, epochs: CompactEpoch[], obsTypes: Map<string, string[]>): Promise<Blob>;
+/** Shared RINEX 3/4 implementation (also used by obs-writer-v4.ts). */
+declare function writeModernObsBlob(header: RinexHeader, epochs: CompactEpoch[], obsTypes: Map<string, string[]>, opts: {
+    version: string;
+    comment: string;
+}): Promise<Blob>;
+
+/**
+ * RINEX 2.11 observation file writer.
+ *
+ * Converts RINEX 3 obs codes to RINEX 2 format and writes
+ * a valid RINEX 2.11 observation file.
+ */
+
+/**
+ * Write RINEX 2.11 obs file from compact observations.
+ * Only GPS+GLONASS satellites are included (RINEX 2 limitation).
+ */
+declare function writeRinex2ObsBlob(header: RinexHeader, epochs: CompactEpoch[], obsTypes: Map<string, string[]>): Promise<Blob>;
+
+/**
+ * RINEX 4.01 observation file writer.
+ *
+ * RINEX 4 is structurally identical to RINEX 3 for our output — same
+ * header layout, same epoch record format. Only the version line and
+ * the provenance comment differ, so this delegates to the shared
+ * implementation in obs-writer.ts.
+ */
+
+/** Write RINEX 4.01 obs file from compact observations. */
+declare function writeRinex4ObsBlob(header: RinexHeader, epochs: CompactEpoch[], obsTypes: Map<string, string[]>): Promise<Blob>;
+
+/**
+ * Shared plumbing for the RINEX 2/3/4 observation writers.
+ */
+
+/**
+ * Batched line sink that streams text through gzip compression so the
+ * full uncompressed output is never held in memory.
+ *
+ * Callers decide when to `flush()` (the writers flush every N epochs);
+ * `finish()` flushes, closes the stream, and returns the Blob.
+ */
+declare function createGzipLineSink(): {
+    push(line: string): void;
+    flush: () => Promise<void>;
+    finish(): Promise<Blob>;
+};
+/**
+ * Station / receiver / antenna header block — byte-identical across
+ * RINEX 2.11, 3.04, and 4.01.
+ */
+declare function stationHeaderLines(header: RinexHeader): string[];
+
+export { type CompactEpoch, type CrxField, type DiffState, EMPTY_WARNINGS, type IonexGrid, NavResult, RinexHeader, type RinexWarning, type RinexWarnings, type Sp3File, type Sp3Sample, WarningAccumulator, type WarningSeverity, createGzipLineSink, crxDecompress, crxRepair, fmtF, hdrLine, padL, padR, parseCrxDataLine, parseIonex, parseSp3, sp3Position, stationHeaderLines, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexObsBlob };