gnss-js 0.1.2 → 1.0.0

package/dist/analysis.cjs

@@ -0,0 +1,1381 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/analysis/index.ts
+var analysis_exports = {};
+__export(analysis_exports, {
+  CompletenessAccumulator: () => CompletenessAccumulator,
+  CycleSlipAccumulator: () => CycleSlipAccumulator,
+  MultipathAccumulator: () => MultipathAccumulator,
+  analyzeQuality: () => analyzeQuality
+});
+module.exports = __toCommonJS(analysis_exports);
+
+// src/constants/gnss.ts
+var SYSTEM_NAMES = {
+  G: "GPS",
+  R: "GLONASS",
+  E: "Galileo",
+  C: "BeiDou",
+  J: "QZSS",
+  I: "NavIC",
+  S: "SBAS"
+};
+var C_LIGHT = 299792458;
+var FREQ = {
+  G: { "1": 157542e4, "2": 12276e5, "5": 117645e4 },
+  R: { "3": 1202025e3 },
+  E: { "1": 157542e4, "5": 117645e4, "6": 127875e4, "7": 120714e4, "8": 1191795e3 },
+  C: { "1": 157542e4, "2": 1561098e3, "5": 117645e4, "6": 126852e4, "7": 120714e4 },
+  J: { "1": 157542e4, "2": 12276e5, "5": 117645e4, "6": 127875e4 },
+  I: { "5": 117645e4, "9": 2492028e3 },
+  S: { "1": 157542e4, "5": 117645e4 }
+};
+var BAND_LABELS = {
+  G: { "1": "L1", "2": "L2", "5": "L5" },
+  R: { "1": "G1", "2": "G2", "3": "G3" },
+  E: { "1": "E1", "5": "E5a", "6": "E6", "7": "E5b", "8": "E5" },
+  C: { "1": "B1C", "2": "B1I", "5": "B2a", "6": "B3I", "7": "B2I" },
+  J: { "1": "L1", "2": "L2", "5": "L5", "6": "L6" },
+  I: { "5": "L5", "9": "S" },
+  S: { "1": "L1", "5": "L5" }
+};
+var DUAL_FREQ_PAIRS = {
+  G: [["1", "2"], ["1", "5"]],
+  R: [["1", "2"], ["1", "3"]],
+  E: [["1", "5"], ["1", "7"], ["1", "6"]],
+  C: [["2", "7"], ["2", "6"], ["1", "5"]],
+  J: [["1", "2"], ["1", "5"]],
+  I: [["5", "9"]],
+  S: [["1", "5"]]
+};
+var GLO_F1_BASE = 1602e6;
+var GLO_F1_STEP = 562500;
+var GLO_F2_BASE = 1246e6;
+var GLO_F2_STEP = 437500;
+var GLO_F3 = 1202025e3;
+var GLO_CHANNEL_FALLBACK = {
+  R01: 1,
+  R02: -4,
+  R03: 5,
+  R04: 6,
+  R05: 1,
+  R06: -4,
+  R07: 5,
+  R08: 6,
+  R09: -2,
+  R10: -7,
+  R11: 0,
+  R12: -1,
+  R13: -2,
+  R14: -7,
+  R15: 0,
+  R16: -1,
+  R17: 4,
+  R18: -3,
+  R19: 3,
+  R20: 2,
+  R21: 4,
+  R22: -3,
+  R23: 3,
+  R24: 2
+};
+function buildGloChannelMap(slots) {
+  if (Object.keys(slots).length === 0) return { ...GLO_CHANNEL_FALLBACK };
+  const map = {};
+  for (const [slot, k] of Object.entries(slots)) {
+    map[`R${String(slot).padStart(2, "0")}`] = k;
+  }
+  return map;
+}
+function gloFreq(gloChannels, prn, band) {
+  const k = gloChannels[prn];
+  if (k === void 0) return void 0;
+  if (band === "1") return GLO_F1_BASE + k * GLO_F1_STEP;
+  if (band === "2") return GLO_F2_BASE + k * GLO_F2_STEP;
+  if (band === "3") return GLO_F3;
+  return void 0;
+}
+function getFreq(gloChannels, prn, band) {
+  const sys = prn[0];
+  if (sys === "R") return gloFreq(gloChannels, prn, band);
+  return FREQ[sys]?.[band];
+}
+var ATTR_PRIORITY = {
+  X: 8,
+  C: 7,
+  S: 6,
+  L: 6,
+  Q: 6,
+  I: 5,
+  B: 5,
+  D: 4,
+  Z: 3,
+  P: 2,
+  W: 1
+};
+function attrRank(code) {
+  return ATTR_PRIORITY[code[2] ?? ""] ?? 3;
+}
+function buildObsIndices(header) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [sys, codes] of Object.entries(header.obsTypes)) {
+    if (sys === "_v2") continue;
+    const lIdx = /* @__PURE__ */ new Map();
+    const lRank = /* @__PURE__ */ new Map();
+    const cIdx = /* @__PURE__ */ new Map();
+    const cRank = /* @__PURE__ */ new Map();
+    for (let i = 0; i < codes.length; i++) {
+      const code = codes[i];
+      const type = code[0];
+      const band = code[1];
+      if (!band) continue;
+      const rank = attrRank(code);
+      if (type === "L" && rank > (lRank.get(band) ?? -1)) {
+        lIdx.set(band, i);
+        lRank.set(band, rank);
+      }
+      if ((type === "C" || type === "P") && rank > (cRank.get(band) ?? -1)) {
+        cIdx.set(band, i);
+        cRank.set(band, rank);
+      }
+    }
+    const bandMap = /* @__PURE__ */ new Map();
+    for (const [band, li] of lIdx) {
+      bandMap.set(band, { L: li, C: cIdx.get(band) ?? null });
+    }
+    if (bandMap.size > 0) result.set(sys, bandMap);
+  }
+  const v2codes = header.obsTypes["_v2"];
+  if (v2codes) {
+    const lIdx = /* @__PURE__ */ new Map();
+    const cIdx = /* @__PURE__ */ new Map();
+    for (let i = 0; i < v2codes.length; i++) {
+      const code = v2codes[i];
+      const type = code[0];
+      const band = code[1];
+      if (!band) continue;
+      if (type === "L" && !lIdx.has(band)) lIdx.set(band, i);
+      if ((type === "C" || type === "P") && !cIdx.has(band)) cIdx.set(band, i);
+    }
+    const bandMap = /* @__PURE__ */ new Map();
+    for (const [band, li] of lIdx) {
+      bandMap.set(band, { L: li, C: cIdx.get(band) ?? null });
+    }
+    if (bandMap.size > 0) result.set("_v2", bandMap);
+  }
+  return result;
+}
+var ARC_GAP_FACTOR = 5;
+
+// src/analysis/multipath.ts
+var MIN_ARC_LENGTH = 10;
+var MultipathAccumulator = class {
+  state = /* @__PURE__ */ new Map();
+  results = [];
+  interval;
+  obsIndices;
+  gloChannels;
+  constructor(header) {
+    this.interval = header.interval ?? 30;
+    this.obsIndices = buildObsIndices(header);
+    this.gloChannels = buildGloChannelMap(header.glonassSlots);
+  }
+  /** Observation callback — wire this into parseRinexStream. */
+  onObservation = (time, prn, _codes, values) => {
+    const sys = prn[0];
+    const bandMap = this.obsIndices.get(sys) ?? this.obsIndices.get("_v2");
+    if (!bandMap) return;
+    const bandData = /* @__PURE__ */ new Map();
+    for (const [band, { C, L }] of bandMap) {
+      if (C === null) continue;
+      const cVal = values[C];
+      const lVal = values[L];
+      const freq = getFreq(this.gloChannels, prn, band);
+      if (cVal != null && cVal !== 0 && lVal != null && lVal !== 0 && freq) {
+        bandData.set(band, { C: cVal, L: lVal, f: freq });
+      }
+    }
+    if (bandData.size < 2) return;
+    const pairs = DUAL_FREQ_PAIRS[sys] ?? [];
+    for (const [bi, bj] of pairs) {
+      const di = bandData.get(bi);
+      const dj = bandData.get(bj);
+      if (!di || !dj) continue;
+      const \u03BBi = C_LIGHT / di.f;
+      const \u03BBj = C_LIGHT / dj.f;
+      const \u03B1 = di.f * di.f / (dj.f * dj.f);
+      const coeff = 2 / (\u03B1 - 1);
+      const mp = di.C - (1 + coeff) * di.L * \u03BBi + coeff * dj.L * \u03BBj;
+      this.pushMp(prn, bi, bj, time, mp);
+    }
+  };
+  pushMp(prn, band, refBand, time, mp) {
+    if (!isFinite(mp)) return;
+    const pairKey = `${band}-${refBand}`;
+    let satStates = this.state.get(prn);
+    if (!satStates) {
+      satStates = /* @__PURE__ */ new Map();
+      this.state.set(prn, satStates);
+    }
+    let bandState = satStates.get(pairKey);
+    if (!bandState) {
+      bandState = { arc: { times: [], rawMp: [] }, lastTime: 0 };
+      satStates.set(pairKey, bandState);
+    }
+    const gap = bandState.lastTime > 0 ? (time - bandState.lastTime) / 1e3 : 0;
+    if (bandState.lastTime > 0 && gap > this.interval * ARC_GAP_FACTOR) {
+      this.closeArc(prn, band, refBand, bandState);
+    }
+    bandState.arc.times.push(time);
+    bandState.arc.rawMp.push(mp);
+    bandState.lastTime = time;
+  }
+  /** External cycle-slip notification — close affected arcs for this PRN. */
+  notifySlip(_time, prn, bands) {
+    const satStates = this.state.get(prn);
+    if (!satStates) return;
+    for (const [pairKey, bandState] of satStates) {
+      const [band, refBand] = pairKey.split("-");
+      if (bands.has(band) || bands.has(refBand)) {
+        this.closeArc(prn, band, refBand, bandState);
+      }
+    }
+  }
+  closeArc(prn, band, refBand, state) {
+    const arc = state.arc;
+    if (arc.times.length >= MIN_ARC_LENGTH) {
+      const mean = arc.rawMp.reduce((a, b) => a + b, 0) / arc.rawMp.length;
+      const sys = prn[0];
+      const bLabel = BAND_LABELS[sys]?.[band] ?? band;
+      const rLabel = BAND_LABELS[sys]?.[refBand] ?? refBand;
+      const label = `${prn} MP ${bLabel}-${rLabel}`;
+      const points = arc.times.map((t, i) => ({
+        time: t,
+        mp: arc.rawMp[i] - mean
+      }));
+      const rms = Math.sqrt(points.reduce((s, p) => s + p.mp * p.mp, 0) / points.length);
+      this.results.push({ prn, system: sys, band, refBand, label, points, rms });
+    }
+    state.arc = { times: [], rawMp: [] };
+  }
+  /** Finalize: close remaining arcs and compute statistics. */
+  finalize() {
+    for (const [prn, satStates] of this.state) {
+      for (const [pairKey, bandState] of satStates) {
+        const [band, refBand] = pairKey.split("-");
+        this.closeArc(prn, band, refBand, bandState);
+      }
+    }
+    const signalGroups = /* @__PURE__ */ new Map();
+    for (const series of this.results) {
+      const key = `${series.system}-${series.band}-${series.refBand}`;
+      if (!signalGroups.has(key)) signalGroups.set(key, []);
+      signalGroups.get(key).push(series);
+    }
+    const signalStats = [];
+    for (const [, seriesList] of signalGroups) {
+      const { system, band, refBand } = seriesList[0];
+      let sumSq = 0;
+      let count = 0;
+      for (const s of seriesList) {
+        for (const p of s.points) {
+          sumSq += p.mp * p.mp;
+          count++;
+        }
+      }
+      const rms = count > 0 ? Math.sqrt(sumSq / count) : 0;
+      const bLabel = BAND_LABELS[system]?.[band] ?? band;
+      const rLabel = BAND_LABELS[system]?.[refBand] ?? refBand;
+      const sysName = SYSTEM_NAMES[system] ?? system;
+      signalStats.push({
+        label: `MP ${bLabel}-${rLabel} (${sysName})`,
+        system,
+        band,
+        refBand,
+        rms,
+        count,
+        satellites: seriesList.length
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.band.localeCompare(b.band);
+    });
+    return { series: this.results, signalStats };
+  }
+};
+
+// src/analysis/cycle-slip.ts
+var MW_MIN_THRESHOLD = 0.5;
+var MW_SIGMA_FACTOR = 4;
+var MW_MIN_EPOCHS = 3;
+var GF_THRESHOLD_M = 0.15;
+var SF_THRESHOLD_M = 3;
+function mwSmoothInit(value) {
+  return { mean: value, m2: 0, n: 1 };
+}
+function mwSmoothUpdate(s, value) {
+  const n = s.n + 1;
+  const delta = value - s.mean;
+  const mean = s.mean + delta / n;
+  const delta2 = value - mean;
+  return { mean, m2: s.m2 + delta * delta2, n };
+}
+function mwSmoothStddev(s) {
+  return s.n > 1 ? Math.sqrt(s.m2 / (s.n - 1)) : Infinity;
+}
+var CycleSlipAccumulator = class {
+  obsIndices;
+  prev = /* @__PURE__ */ new Map();
+  events = [];
+  interval;
+  /** GLONASS PRN → channel k for FDMA frequency computation. */
+  gloChannels;
+  onSlip;
+  // Per-signal epoch/slip counting
+  signalEpochs = /* @__PURE__ */ new Map();
+  signalSlips = /* @__PURE__ */ new Map();
+  signalSats = /* @__PURE__ */ new Map();
+  constructor(header, onSlip) {
+    this.interval = header.interval ?? 30;
+    this.obsIndices = buildObsIndices(header);
+    this.gloChannels = buildGloChannelMap(header.glonassSlots);
+    this.onSlip = onSlip;
+  }
+  recordSlip(sigKey, time, prn, signal, magnitude, bands) {
+    this.events.push({ time, prn, signal, magnitude });
+    this.signalSlips.set(sigKey, (this.signalSlips.get(sigKey) ?? 0) + 1);
+    if (!this.signalSats.has(sigKey)) this.signalSats.set(sigKey, /* @__PURE__ */ new Set());
+    this.signalSats.get(sigKey).add(prn);
+    this.onSlip?.(time, prn, bands);
+  }
+  countEpoch(sigKey) {
+    this.signalEpochs.set(sigKey, (this.signalEpochs.get(sigKey) ?? 0) + 1);
+  }
+  /** Resolve frequency for a given PRN + band. Handles GLONASS FDMA. */
+  getFreqForPrn(prn, band) {
+    return getFreq(this.gloChannels, prn, band);
+  }
+  onObservation = (time, prn, _codes, values) => {
+    const sys = prn[0];
+    const idxMap = this.obsIndices.get(sys) ?? this.obsIndices.get("_v2");
+    if (!idxMap) return;
+    if (sys !== "R" && !FREQ[sys]) return;
+    const phaseM = /* @__PURE__ */ new Map();
+    const codeM = /* @__PURE__ */ new Map();
+    for (const [band, { L, C }] of idxMap) {
+      const freq = this.getFreqForPrn(prn, band);
+      if (!freq) continue;
+      const lVal = values[L];
+      if (lVal != null && lVal !== 0) phaseM.set(band, lVal * (C_LIGHT / freq));
+      if (C !== null) {
+        const cVal = values[C];
+        if (cVal != null && cVal !== 0) codeM.set(band, cVal);
+      }
+    }
+    if (phaseM.size === 0) return;
+    const prev = this.prev.get(prn);
+    const gap = prev ? (time - prev.time) / 1e3 : 0;
+    const isArcBreak = !prev || gap > this.interval * ARC_GAP_FACTOR;
+    const mwSmooth = /* @__PURE__ */ new Map();
+    const gfMap = /* @__PURE__ */ new Map();
+    const pairs = DUAL_FREQ_PAIRS[sys] ?? [];
+    for (const [b1, b2] of pairs) {
+      const l1 = phaseM.get(b1);
+      const l2 = phaseM.get(b2);
+      const f1 = this.getFreqForPrn(prn, b1);
+      const f2 = this.getFreqForPrn(prn, b2);
+      if (!f1 || !f2) continue;
+      const pairKey = `${b1}-${b2}`;
+      if (l1 !== void 0 && l2 !== void 0) {
+        gfMap.set(pairKey, l1 - l2);
+      }
+      const c1 = codeM.get(b1);
+      const c2 = codeM.get(b2);
+      if (l1 !== void 0 && l2 !== void 0 && c1 !== void 0 && c2 !== void 0) {
+        const lambda_wl = C_LIGHT / (f1 - f2);
+        const phi_wl = (f1 * l1 - f2 * l2) / C_LIGHT;
+        const P_nl = (f1 * c1 + f2 * c2) / ((f1 + f2) * lambda_wl);
+        const mw = phi_wl - P_nl;
+        const prevSmooth = isArcBreak ? void 0 : prev?.mwSmooth.get(pairKey);
+        if (prevSmooth && prevSmooth.n >= MW_MIN_EPOCHS) {
+          const lbl1 = BAND_LABELS[sys]?.[b1] ?? b1;
+          const lbl2 = BAND_LABELS[sys]?.[b2] ?? b2;
+          const signal = `MW ${lbl1}-${lbl2}`;
+          const sigKey = `${sys}:${signal}`;
+          this.countEpoch(sigKey);
+          const stddev = mwSmoothStddev(prevSmooth);
+          const threshold = Math.max(MW_MIN_THRESHOLD, MW_SIGMA_FACTOR * stddev);
+          const deviation = Math.abs(mw - prevSmooth.mean);
+          if (deviation > threshold) {
+            this.recordSlip(sigKey, time, prn, signal, deviation, /* @__PURE__ */ new Set([b1, b2]));
+            mwSmooth.set(pairKey, mwSmoothInit(mw));
+          } else {
+            mwSmooth.set(pairKey, mwSmoothUpdate(prevSmooth, mw));
+          }
+        } else if (prevSmooth) {
+          mwSmooth.set(pairKey, mwSmoothUpdate(prevSmooth, mw));
+        } else {
+          mwSmooth.set(pairKey, mwSmoothInit(mw));
+        }
+      }
+    }
+    if (!isArcBreak && prev) {
+      const dualChecked = /* @__PURE__ */ new Set();
+      for (const [b1, b2] of pairs) {
+        const pairKey = `${b1}-${b2}`;
+        const lbl1 = BAND_LABELS[sys]?.[b1] ?? b1;
+        const lbl2 = BAND_LABELS[sys]?.[b2] ?? b2;
+        if (mwSmooth.has(pairKey)) {
+          dualChecked.add(b1);
+          dualChecked.add(b2);
+          continue;
+        }
+        const curGf = gfMap.get(pairKey);
+        const prevGf = prev.gf.get(pairKey);
+        if (curGf !== void 0 && prevGf !== void 0) {
+          const signal = `GF ${lbl1}-${lbl2}`;
+          const sigKey = `${sys}:${signal}`;
+          this.countEpoch(sigKey);
+          const jump = Math.abs(curGf - prevGf);
+          if (jump > GF_THRESHOLD_M) {
+            this.recordSlip(sigKey, time, prn, signal, jump, /* @__PURE__ */ new Set([b1, b2]));
+          }
+          dualChecked.add(b1);
+          dualChecked.add(b2);
+        }
+      }
+      for (const [band, lm] of phaseM) {
+        if (dualChecked.has(band)) continue;
+        const prevLm = prev.phase.get(band);
+        if (prevLm === void 0) continue;
+        const cm = codeM.get(band);
+        const prevCm = prev.code.get(band);
+        if (cm === void 0 || prevCm === void 0) continue;
+        const dPhase = lm - prevLm;
+        const dCode = cm - prevCm;
+        const jumpM = Math.abs(dPhase - dCode);
+        const lbl = BAND_LABELS[sys]?.[band] ?? band;
+        const sigKey = `${sys}:${lbl}`;
+        this.countEpoch(sigKey);
+        if (jumpM > SF_THRESHOLD_M) {
+          this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+        }
+      }
+    }
+    this.prev.set(prn, { time, mwSmooth, gf: gfMap, phase: phaseM, code: codeM });
+  };
+  finalize() {
+    const satSlipCounts = {};
+    for (const ev of this.events) {
+      satSlipCounts[ev.prn] = (satSlipCounts[ev.prn] ?? 0) + 1;
+    }
+    const signalStats = [];
+    const allKeys = /* @__PURE__ */ new Set([...this.signalEpochs.keys(), ...this.signalSlips.keys()]);
+    for (const sigKey of allKeys) {
+      const [sys, ...rest] = sigKey.split(":");
+      const signal = rest.join(":");
+      const totalEpochs = this.signalEpochs.get(sigKey) ?? 0;
+      const totalSlips = this.signalSlips.get(sigKey) ?? 0;
+      const sysName = SYSTEM_NAMES[sys] ?? sys;
+      signalStats.push({
+        label: `${signal} (${sysName})`,
+        system: sys,
+        totalSlips,
+        satellites: this.signalSats.get(sigKey)?.size ?? 0,
+        totalEpochs,
+        slipRate: totalEpochs > 0 ? totalSlips / totalEpochs * 1e3 : 0
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.label.localeCompare(b.label);
+    });
+    return { events: this.events, signalStats, satSlipCounts };
+  }
+};
+
+// src/analysis/completeness.ts
+var CompletenessAccumulator = class {
+  // PRN → code → { seen, expected, present }
+  // "seen" gates counting: expected only increments after a satellite has transmitted
+  // the signal at least once (avoids inflating expected for signals a sat doesn't have,
+  // e.g. L5 on GPS Block IIR).
+  data = /* @__PURE__ */ new Map();
+  header;
+  constructor(header) {
+    this.header = header;
+  }
+  onObservation = (_time, prn, codes, values) => {
+    let satMap = this.data.get(prn);
+    if (!satMap) {
+      satMap = /* @__PURE__ */ new Map();
+      this.data.set(prn, satMap);
+    }
+    for (let i = 0; i < codes.length; i++) {
+      const code = codes[i];
+      const hasValue = values[i] != null && values[i] !== 0;
+      let cell = satMap.get(code);
+      if (!cell) {
+        cell = { seen: false, expected: 0, present: 0 };
+        satMap.set(code, cell);
+      }
+      if (hasValue) cell.seen = true;
+      if (cell.seen) cell.expected++;
+      if (hasValue) cell.present++;
+    }
+  };
+  finalize() {
+    const cells = [];
+    const systemSet = /* @__PURE__ */ new Set();
+    for (const [prn, satMap] of this.data) {
+      const sys = prn[0];
+      systemSet.add(sys);
+      for (const [code, { seen, expected, present }] of satMap) {
+        if (!seen) continue;
+        const band = code[1] ?? "?";
+        cells.push({
+          prn,
+          system: sys,
+          code,
+          band,
+          expected,
+          present,
+          percent: expected > 0 ? present / expected * 100 : 0
+        });
+      }
+    }
+    const sigAgg = /* @__PURE__ */ new Map();
+    for (const c of cells) {
+      const key = `${c.system}:${c.code}`;
+      let agg = sigAgg.get(key);
+      if (!agg) {
+        agg = { expected: 0, present: 0, sats: /* @__PURE__ */ new Set() };
+        sigAgg.set(key, agg);
+      }
+      agg.expected += c.expected;
+      agg.present += c.present;
+      agg.sats.add(c.prn);
+    }
+    const signalStats = [];
+    for (const [key, agg] of sigAgg) {
+      const [sys, code] = key.split(":");
+      const band = code[1] ?? "?";
+      const bandLabel = BAND_LABELS[sys]?.[band] ?? `Band ${band}`;
+      const sysName = SYSTEM_NAMES[sys] ?? sys;
+      signalStats.push({
+        code,
+        system: sys,
+        label: `${code} (${sysName} ${bandLabel})`,
+        expected: agg.expected,
+        present: agg.present,
+        percent: agg.expected > 0 ? agg.present / agg.expected * 100 : 0,
+        satellites: agg.sats.size
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.code.localeCompare(b.code);
+    });
+    const systems = [...systemSet].sort((a, b) => {
+      return (sysOrder.indexOf(a) === -1 ? 99 : sysOrder.indexOf(a)) - (sysOrder.indexOf(b) === -1 ? 99 : sysOrder.indexOf(b));
+    });
+    return { cells, signalStats, systems };
+  }
+};
+
+// src/rinex/crx.ts
+function crxRepair(old, diff) {
+  const chars = old.split("");
+  for (let i = 0; i < diff.length; i++) {
+    const dc = diff[i];
+    if (dc === " ") {
+    } else if (dc === "&") {
+      chars[i] = " ";
+    } else {
+      chars[i] = dc;
+    }
+  }
+  if (diff.length > chars.length) {
+    for (let i = chars.length; i < diff.length; i++) {
+      chars[i] = diff[i] === "&" ? " " : diff[i];
+    }
+  }
+  return chars.join("");
+}
+function parseCrxDataLine(line, ntype) {
+  const fields = [];
+  let pos = 0;
+  for (let j = 0; j < ntype; j++) {
+    if (pos >= line.length || line[pos] === "\0") {
+      fields.push({ empty: true, init: false, arcOrder: -1, value: 0 });
+      pos++;
+      continue;
+    }
+    if (line[pos] === " ") {
+      fields.push({ empty: true, init: false, arcOrder: -1, value: 0 });
+      pos++;
+      continue;
+    }
+    const start = pos;
+    while (pos < line.length && line[pos] !== " ") pos++;
+    const token = line.substring(start, pos);
+    if (pos < line.length && line[pos] === " ") pos++;
+    if (token.length >= 3 && token[1] === "&") {
+      const arcOrder = parseInt(token[0]);
+      const value = parseInt(token.substring(2));
+      fields.push({ empty: false, init: true, arcOrder, value: isNaN(value) ? 0 : value });
+    } else {
+      const value = parseInt(token);
+      fields.push({ empty: false, init: false, arcOrder: -1, value: isNaN(value) ? 0 : value });
+    }
+  }
+  const flagStr = pos < line.length ? line.substring(pos) : "";
+  return { fields, flagStr };
+}
+function crxDecompress(prev, field) {
+  if (field.init) {
+    const a = new Array(Math.max(field.arcOrder + 1, 1)).fill(0);
+    a[0] = field.value;
+    return { state: { accum: a, order: 0, arcOrder: field.arcOrder }, result: field.value };
+  }
+  if (!prev) {
+    return { state: { accum: [0], order: 0, arcOrder: 0 }, result: 0 };
+  }
+  let order = prev.order;
+  if (order < prev.arcOrder) order++;
+  const accum = [...prev.accum];
+  while (accum.length <= order) accum.push(0);
+  accum[order] = field.value;
+  for (let k = order; k >= 1; k--) {
+    accum[k - 1] += accum[k];
+  }
+  return { state: { accum, order, arcOrder: prev.arcOrder }, result: accum[0] };
+}
+
+// src/rinex/parser.ts
+var CHUNK_SIZE = 2 * 1024 * 1024;
+var yieldToMain = () => new Promise((r) => setTimeout(r, 0));
+var noYield = () => Promise.resolve();
+var SYSTEM_ORDER = ["G", "R", "E", "C", "J", "I", "S"];
+var SYSTEM_RANK = Object.fromEntries(SYSTEM_ORDER.map((s, i) => [s, i]));
+function systemCmp(a, b) {
+  const ra = SYSTEM_RANK[a.charAt(0)] ?? 99;
+  const rb = SYSTEM_RANK[b.charAt(0)] ?? 99;
+  if (ra !== rb) return ra - rb;
+  return a.localeCompare(b);
+}
+function parseHeader(lines) {
+  const h = {
+    version: 0,
+    type: "",
+    satSystem: "",
+    markerName: "",
+    markerType: "",
+    observer: "",
+    agency: "",
+    receiverNumber: "",
+    receiverType: "",
+    receiverVersion: "",
+    antNumber: "",
+    antType: "",
+    approxPosition: null,
+    antDelta: null,
+    interval: null,
+    timeOfFirstObs: null,
+    timeOfLastObs: null,
+    obsTypes: {},
+    glonassSlots: {},
+    isCrx: false,
+    crxVersion: 0
+  };
+  let currentObsSys = "";
+  for (const raw of lines) {
+    const label = raw.substring(60).trim();
+    const data = raw.substring(0, 60);
+    switch (label) {
+      case "CRINEX VERS   / TYPE": {
+        h.isCrx = true;
+        h.crxVersion = parseFloat(data.substring(0, 9)) || 0;
+        break;
+      }
+      case "RINEX VERSION / TYPE": {
+        h.version = parseFloat(data.substring(0, 9));
+        h.type = data.substring(20, 21).trim();
+        h.satSystem = data.substring(40, 41).trim();
+        break;
+      }
+      case "MARKER NAME":
+        h.markerName = data.trim();
+        break;
+      case "MARKER TYPE":
+        h.markerType = data.trim();
+        break;
+      case "OBSERVER / AGENCY":
+        h.observer = data.substring(0, 20).trim();
+        h.agency = data.substring(20).trim();
+        break;
+      case "REC # / TYPE / VERS":
+        h.receiverNumber = data.substring(0, 20).trim();
+        h.receiverType = data.substring(20, 40).trim();
+        h.receiverVersion = data.substring(40, 60).trim();
+        break;
+      case "ANT # / TYPE":
+        h.antNumber = data.substring(0, 20).trim();
+        h.antType = data.substring(20).trim();
+        break;
+      case "ANTENNA: DELTA H/E/N": {
+        const d = data.trim().split(/\s+/).map(Number);
+        if (d.length >= 3 && !d.slice(0, 3).some(isNaN)) {
+          h.antDelta = [d[0], d[1], d[2]];
+        }
+        break;
+      }
+      case "APPROX POSITION XYZ": {
+        const p = data.trim().split(/\s+/).map(Number);
+        if (p.length >= 3 && p[0] !== void 0 && p[1] !== void 0 && p[2] !== void 0 && !isNaN(p[0]) && !isNaN(p[1]) && !isNaN(p[2])) {
+          h.approxPosition = [p[0], p[1], p[2]];
+        }
+        break;
+      }
+      case "INTERVAL":
+        h.interval = parseFloat(data);
+        break;
+      case "TIME OF FIRST OBS":
+        h.timeOfFirstObs = parseHeaderTime(data);
+        break;
+      case "TIME OF LAST OBS":
+        h.timeOfLastObs = parseHeaderTime(data);
+        break;
+      case "SYS / # / OBS TYPES": {
+        const sys = data[0]?.trim();
+        if (sys) {
+          currentObsSys = sys;
+          const count = parseInt(data.substring(3, 6));
+          const codes = data.substring(7, 60).trim().split(/\s+/).filter(Boolean);
+          h.obsTypes[currentObsSys] = codes;
+          void count;
+        } else if (currentObsSys && h.obsTypes[currentObsSys]) {
+          const codes = data.substring(7, 60).trim().split(/\s+/).filter(Boolean);
+          h.obsTypes[currentObsSys].push(...codes);
+        }
+        break;
+      }
+      case "GLONASS SLOT / FRQ #": {
+        const nSats = parseInt(data.substring(0, 3));
+        void nSats;
+        for (let i = 0; i < 8; i++) {
+          const off = 4 + i * 7;
+          const sat = data.substring(off, off + 3).trim();
+          const ch = data.substring(off + 3, off + 7).trim();
+          if (sat && sat[0] === "R" && ch) {
+            const slot = parseInt(sat.substring(1));
+            const k = parseInt(ch);
+            if (!isNaN(slot) && !isNaN(k)) h.glonassSlots[slot] = k;
+          }
+        }
+        break;
+      }
+      case "# / TYPES OF OBSERV": {
+        const existing = h.obsTypes["_v2"];
+        const codes = data.substring(6, 60).trim().split(/\s+/).filter(Boolean);
+        if (!existing || existing.length === 0) {
+          h.obsTypes["_v2"] = codes;
+        } else {
+          existing.push(...codes);
+        }
+        break;
+      }
+    }
+  }
+  return h;
+}
+function parseHeaderTime(data) {
+  const p = data.trim().split(/\s+/).map(Number);
+  if (p.length < 6) return null;
+  const yr = p[0], mo = p[1], dy = p[2], hr = p[3], mn = p[4], sc = p[5];
+  if ([yr, mo, dy, hr, mn, sc].some(isNaN)) return null;
+  const wholeSec = Math.floor(sc);
+  const ms = Math.round((sc - wholeSec) * 1e3);
+  return new Date(Date.UTC(yr, mo - 1, dy, hr, mn, wholeSec, ms));
+}
+function snrIndicesWithBand(obsTypes, system) {
+  const codes = obsTypes[system];
+  if (!codes) return [];
+  const result = [];
+  for (let i = 0; i < codes.length; i++) {
+    const c = codes[i];
+    if (c.startsWith("S")) result.push({ idx: i, band: c[1] });
+  }
+  return result;
+}
+function snrIndicesWithBandV2(obsTypes) {
+  const codes = obsTypes["_v2"];
+  if (!codes) return [];
+  const result = [];
+  for (let i = 0; i < codes.length; i++) {
+    const c = codes[i];
+    if (c.startsWith("S")) result.push({ idx: i, band: c[1] });
+  }
+  return result;
+}
+function readObsValue(line, index) {
+  const start = index * 16;
+  if (start + 14 > line.length) return null;
+  const raw = line.substring(start, start + 14).trim();
+  if (!raw) return null;
+  const v = parseFloat(raw);
+  return isNaN(v) ? null : v;
+}
+function parseEpochLine3(line) {
+  if (line[0] !== ">") return null;
+  const yr = parseInt(line.substring(2, 6));
+  const mo = parseInt(line.substring(7, 9));
+  const dy = parseInt(line.substring(10, 12));
+  const hr = parseInt(line.substring(13, 15));
+  const mn = parseInt(line.substring(16, 18));
+  const sc = parseFloat(line.substring(19, 29));
+  const flag = parseInt(line.substring(31, 32));
+  const numSats = parseInt(line.substring(32, 35));
+  if ([yr, mo, dy, hr, mn].some(isNaN) || isNaN(sc)) return null;
+  const wholeSec = Math.floor(sc);
+  const ms = Math.round((sc - wholeSec) * 1e3);
+  const time = Date.UTC(yr, mo - 1, dy, hr, mn, wholeSec, ms);
+  return { time, flag: isNaN(flag) ? 0 : flag, numSats: isNaN(numSats) ? 0 : numSats };
+}
+function parseEpochLine2(line) {
+  const yr2 = parseInt(line.substring(1, 3));
+  const mo = parseInt(line.substring(4, 6));
+  const dy = parseInt(line.substring(7, 9));
+  const hr = parseInt(line.substring(10, 12));
+  const mn = parseInt(line.substring(13, 15));
+  const sc = parseFloat(line.substring(15, 26));
+  const flag = parseInt(line.substring(28, 29));
+  const numSats = parseInt(line.substring(29, 32));
+  if ([yr2, mo, dy, hr, mn].some(isNaN) || isNaN(sc)) return null;
+  const yr = yr2 >= 80 ? 1900 + yr2 : 2e3 + yr2;
+  const wholeSec = Math.floor(sc);
+  const ms = Math.round((sc - wholeSec) * 1e3);
+  const time = Date.UTC(yr, mo - 1, dy, hr, mn, wholeSec, ms);
+  const satIds = [];
+  const satPart = line.substring(32);
+  for (let i = 0; i + 3 <= satPart.length; i += 3) {
+    const id = satPart.substring(i, i + 3).trim();
+    if (id) satIds.push(id);
+  }
+  return { time, flag: isNaN(flag) ? 0 : flag, numSats: isNaN(numSats) ? 0 : numSats, satIds };
+}
+async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode) {
+  const skipEpochs = !!workerMode;
+  const yield_ = workerMode ? noYield : yieldToMain;
+  const decoder = new TextDecoder("ascii");
+  let buffer = "";
+  let header = null;
+  const headerLines = [];
+  const epochs = [];
+  const satellitesSeen = {};
+  let epochInfo = null;
+  let satsPerSystem = {};
+  let snrValues = [];
+  let snrPerSystemAccum = {};
+  let snrPerSatAccum = {};
+  let snrPerSatBandAccum = {};
+  let satLinesRemaining = 0;
+  let eventSkipLines = 0;
+  let v2SatIds = [];
+  let v2SatIndex = 0;
+  let v2LinesPerSat = 0;
+  let v2CurrentSatLine = 0;
+  let v2SnrBandInfo = [];
+  let v2ContinuationSatsRemaining = 0;
+  let crxPhase = "epoch";
+  let crxSatList = [];
+  let crxSatIndex = 0;
+  let crxPrevEpochLine = "";
+  const crxDiffStates = /* @__PURE__ */ new Map();
+  function trackSat(sys, prn) {
+    if (!satellitesSeen[sys]) satellitesSeen[sys] = /* @__PURE__ */ new Set();
+    satellitesSeen[sys].add(prn);
+    satsPerSystem[sys] = (satsPerSystem[sys] ?? 0) + 1;
+  }
+  function pushSnr(sys, prn, val, band) {
+    if (skipEpochs) return;
+    snrValues.push(val);
+    if (!snrPerSystemAccum[sys]) snrPerSystemAccum[sys] = [];
+    snrPerSystemAccum[sys].push(val);
+    if (!snrPerSatAccum[prn]) snrPerSatAccum[prn] = [];
+    snrPerSatAccum[prn].push(val);
+    if (band) {
+      const key = `${prn}:${band}`;
+      if (!snrPerSatBandAccum[key]) snrPerSatBandAccum[key] = [];
+      snrPerSatBandAccum[key].push(val);
+    }
+  }
+  function finishEpoch() {
+    if (!epochInfo) return;
+    if (!skipEpochs) {
+      const snrBySys = {};
+      for (const [sys, vals] of Object.entries(snrPerSystemAccum)) {
+        if (vals.length > 0) snrBySys[sys] = vals.reduce((a, b) => a + b, 0) / vals.length;
+      }
+      const meanSnr = snrValues.length > 0 ? snrValues.reduce((a, b) => a + b, 0) / snrValues.length : null;
+      const snrPerSat = {};
+      for (const [prn, vals] of Object.entries(snrPerSatAccum)) {
+        if (vals.length > 0) snrPerSat[prn] = vals.reduce((a, b) => a + b, 0) / vals.length;
+      }
+      const snrPerSatBand = {};
+      for (const [key, vals] of Object.entries(snrPerSatBandAccum)) {
+        if (vals.length > 0) snrPerSatBand[key] = vals.reduce((a, b) => a + b, 0) / vals.length;
+      }
+      epochs.push({
+        time: epochInfo.time,
+        totalSats: Object.values(satsPerSystem).reduce((a, b) => a + b, 0),
+        satsPerSystem: { ...satsPerSystem },
+        meanSnr,
+        snrPerSystem: snrBySys,
+        snrPerSat,
+        snrPerSatBand
+      });
+    }
+    epochInfo = null;
+    satsPerSystem = {};
+    snrValues = [];
+    snrPerSystemAccum = {};
+    snrPerSatAccum = {};
+    snrPerSatBandAccum = {};
+  }
+  function resetEpochAccum(info) {
+    epochInfo = info;
+    satsPerSystem = {};
+    snrValues = [];
+    snrPerSystemAccum = {};
+    snrPerSatAccum = {};
+    snrPerSatBandAccum = {};
+  }
+  const snrCache = /* @__PURE__ */ new Map();
+  function getSnrIndices(sys) {
+    let cached = snrCache.get(sys);
+    if (!cached) {
+      cached = snrIndicesWithBand(header.obsTypes, sys);
+      snrCache.set(sys, cached);
+    }
+    return cached;
+  }
+  function processSatLineV3(line) {
+    if (!header || line.length < 3) return;
+    const sys = line[0];
+    const prn = line.substring(0, 3);
+    trackSat(sys, prn);
+    const obsLine = line.substring(3);
+    const codes = header.obsTypes[sys] ?? [];
+    if (onSatObs && epochInfo) {
+      const values = new Array(codes.length);
+      for (let i = 0; i < codes.length; i++) values[i] = readObsValue(obsLine, i);
+      if (!skipEpochs) {
+        for (const { idx, band } of getSnrIndices(sys)) {
+          const val = values[idx] ?? null;
+          if (val !== null && val > 0) pushSnr(sys, prn, val, band);
+        }
+      }
+      onSatObs(epochInfo.time, prn, codes, values);
+    } else if (!skipEpochs) {
+      for (const { idx, band } of getSnrIndices(sys)) {
+        const val = readObsValue(obsLine, idx);
+        if (val !== null && val > 0) pushSnr(sys, prn, val, band);
+      }
+    }
+  }
+  let v2ObsAccum = [];
+  function processSatLineV2(line) {
+    if (!header || v2SatIndex >= v2SatIds.length) return;
+    const satId = v2SatIds[v2SatIndex];
+    let sys = satId[0];
+    if (sys === " " || /\d/.test(sys)) sys = "G";
+    const prn = sys + satId.substring(1).padStart(2, "0");
+    if (v2CurrentSatLine === 0) {
+      trackSat(sys, prn);
+      if (onSatObs) v2ObsAccum = [];
+    }
+    const lineOffset = v2CurrentSatLine * 5;
+    for (const { idx, band } of v2SnrBandInfo) {
+      if (idx >= lineOffset && idx < lineOffset + 5) {
+        const val = readObsValue(line, idx - lineOffset);
+        if (val !== null && val > 0) pushSnr(sys, prn, val, band);
+      }
+    }
+    if (onSatObs) {
+      for (let i = 0; i < 5; i++) {
+        if (lineOffset + i < (header.obsTypes["_v2"] ?? []).length) {
+          v2ObsAccum.push(readObsValue(line, i));
+        }
+      }
+    }
+    v2CurrentSatLine++;
+    if (v2CurrentSatLine >= v2LinesPerSat) {
+      if (onSatObs && epochInfo) {
+        const codes = header.obsTypes["_v2"] ?? [];
+        onSatObs(epochInfo.time, prn, codes, v2ObsAccum);
+      }
+      v2CurrentSatLine = 0;
+      v2SatIndex++;
+    }
+  }
+  function processCrxSatDataLine(prn, line) {
+    if (!header) return;
+    const sys = prn[0];
+    trackSat(sys, prn);
+    const ntype = header.version >= 3 ? (header.obsTypes[sys] ?? []).length : (header.obsTypes["_v2"] ?? []).length;
+    if (ntype === 0) return;
+    const { fields } = parseCrxDataLine(line, ntype);
+    let states = crxDiffStates.get(prn);
+    if (!states) {
+      states = new Array(ntype).fill(null);
+      crxDiffStates.set(prn, states);
+    }
+    while (states.length < ntype) states.push(null);
+    const sBandMap = skipEpochs ? null : new Map(
+      (header.version >= 3 ? getSnrIndices(sys) : snrIndicesWithBandV2(header.obsTypes)).map((s) => [s.idx, s.band])
+    );
+    const obsValues = onSatObs ? new Array(ntype).fill(null) : [];
+    for (let j = 0; j < ntype; j++) {
+      const field = fields[j];
+      if (field.empty) continue;
+      const { state, result } = crxDecompress(states[j] ?? null, field);
+      states[j] = state;
+      if (onSatObs) obsValues[j] = result / 1e3;
+      if (sBandMap) {
+        const band = sBandMap.get(j);
+        if (band !== void 0) {
+          const snrFloat = result / 1e3;
+          if (snrFloat > 0) pushSnr(sys, prn, snrFloat, band);
+        }
+      }
+    }
+    if (onSatObs && epochInfo) {
+      const codes = header.version >= 3 ? header.obsTypes[sys] ?? [] : header.obsTypes["_v2"] ?? [];
+      onSatObs(epochInfo.time, prn, codes, obsValues);
+    }
+  }
+  let crxEpochTopFrom = ">";
+  let crxEpochTopTo = ">";
+  let crxEventSkipLines = 0;
+  function processCrxLine(line) {
+    if (!header) return;
+    const isV3 = header.version >= 3;
+    if (header.crxVersion < 3) {
+      crxEpochTopFrom = "&";
+      crxEpochTopTo = " ";
+    }
+    if (crxEventSkipLines > 0) {
+      crxEventSkipLines--;
+      return;
+    }
+    if (crxPhase === "epoch") {
+      if (header.crxVersion >= 3 && line[0] === "&") return;
+      const isInitEpoch = line[0] === crxEpochTopFrom;
+      const isTextDiff = !isInitEpoch && crxPrevEpochLine.length > 0;
+      if (isInitEpoch || isTextDiff) {
+        let epochLine;
+        if (isInitEpoch) {
+          epochLine = crxEpochTopTo + line.substring(1);
+          crxPrevEpochLine = "";
+        } else {
+          epochLine = crxRepair(crxPrevEpochLine, line);
+        }
+        if (isV3) {
+          if (epochLine[0] !== ">") return;
+          const info = parseEpochLine3(epochLine);
+          if (!info) {
+            crxPrevEpochLine = epochLine;
+            return;
+          }
+          if (info.flag >= 2) {
+            crxPrevEpochLine = epochLine;
+            crxEventSkipLines = info.numSats;
+            return;
+          }
+          if (info.flag !== 0) {
+            crxPrevEpochLine = epochLine;
+            return;
+          }
+          resetEpochAccum(info);
+          const satPart = epochLine.substring(41).replace(/\s+$/, "");
+          crxSatList = [];
+          for (let i = 0; i + 3 <= satPart.length; i += 3) {
+            crxSatList.push(satPart.substring(i, i + 3));
+          }
+          crxSatIndex = 0;
+          crxPrevEpochLine = epochLine;
+          crxPhase = "clock";
+        } else {
+          const info = parseEpochLine2(epochLine);
+          if (!info) {
+            crxPrevEpochLine = epochLine;
+            return;
+          }
+          if (info.flag >= 2) {
+            crxPrevEpochLine = epochLine;
+            crxEventSkipLines = info.numSats;
+            return;
+          }
+          if (info.flag !== 0) {
+            crxPrevEpochLine = epochLine;
+            return;
+          }
+          resetEpochAccum(info);
+          crxSatList = (info.satIds ?? []).map((id) => {
+            let sys = id[0];
+            if (sys === " " || /\d/.test(sys)) sys = "G";
+            return sys + id.substring(1).padStart(2, "0");
+          });
+          crxSatIndex = 0;
+          crxPrevEpochLine = epochLine;
+          crxPhase = "clock";
+        }
+      }
+    } else if (crxPhase === "clock") {
+      if (crxSatList.length > 0) {
+        crxPhase = "satdata";
+      } else {
+        crxPhase = "epoch";
+        finishEpoch();
+      }
+    } else if (crxPhase === "satdata") {
+      const prn = crxSatList[crxSatIndex];
+      processCrxSatDataLine(prn, line);
+      crxSatIndex++;
+      if (crxSatIndex >= crxSatList.length) {
+        crxPhase = "epoch";
+        finishEpoch();
+      }
+    }
+  }
+  function processRinexLine(line) {
+    if (!header) return;
+    if (eventSkipLines > 0) {
+      eventSkipLines--;
+      return;
+    }
+    if (header.version >= 3) {
+      if (satLinesRemaining > 0) {
+        processSatLineV3(line);
+        satLinesRemaining--;
+        if (satLinesRemaining === 0) finishEpoch();
+      } else if (line[0] === ">") {
+        const info = parseEpochLine3(line);
+        if (!info) return;
+        if (info.flag >= 2 && info.flag <= 5) {
+          eventSkipLines = info.numSats;
+          return;
+        }
+        if (info.flag === 0) {
+          resetEpochAccum(info);
+          satLinesRemaining = info.numSats;
+          if (info.numSats === 0) finishEpoch();
+        }
+      }
+    } else {
+      if (v2ContinuationSatsRemaining > 0) {
+        const satPart = line.substring(32);
+        for (let i = 0; i + 3 <= satPart.length; i += 3) {
+          const id = satPart.substring(i, i + 3).trim();
+          if (id) v2SatIds.push(id);
+        }
+        v2ContinuationSatsRemaining--;
+        if (v2ContinuationSatsRemaining === 0) {
+          v2SatIndex = 0;
+          v2CurrentSatLine = 0;
+          satLinesRemaining = v2SatIds.length * v2LinesPerSat;
+          if (satLinesRemaining === 0) finishEpoch();
+        }
+      } else if (satLinesRemaining > 0) {
+        processSatLineV2(line);
+        satLinesRemaining--;
+        if (satLinesRemaining === 0) finishEpoch();
+      } else {
+        const info = parseEpochLine2(line);
+        if (!info) return;
+        if (info.flag >= 2 && info.flag <= 5) {
+          eventSkipLines = info.numSats;
+          return;
+        }
+        if (info.flag === 0) {
+          resetEpochAccum(info);
+          v2SatIds = info.satIds ?? [];
+          const v2ObsPerSat = (header.obsTypes["_v2"] ?? []).length;
+          v2LinesPerSat = Math.ceil(v2ObsPerSat / 5) || 1;
+          v2SnrBandInfo = snrIndicesWithBandV2(header.obsTypes);
+          v2SatIndex = 0;
+          v2CurrentSatLine = 0;
+          const continuationLines = Math.max(0, Math.ceil((info.numSats - 12) / 12));
+          if (continuationLines > 0) {
+            v2ContinuationSatsRemaining = continuationLines;
+          } else {
+            satLinesRemaining = v2SatIds.length * v2LinesPerSat;
+            if (satLinesRemaining === 0) finishEpoch();
+          }
+        }
+      }
+    }
+  }
+  function processLine(line) {
+    if (!header) return;
+    if (header.isCrx) {
+      processCrxLine(line);
+    } else {
+      processRinexLine(line);
+    }
+  }
+  function processChunkText(text, isLast) {
+    buffer += text;
+    const lastNl = buffer.lastIndexOf("\n");
+    if (lastNl === -1 && !isLast) return;
+    const chunk = isLast ? buffer : buffer.substring(0, lastNl);
+    buffer = isLast ? "" : buffer.substring(lastNl + 1);
+    const lines = chunk.split("\n");
+    for (const rawLine of lines) {
+      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+      if (!line && !header) continue;
+      if (!header) {
+        headerLines.push(line);
+        if (line.includes("END OF HEADER")) header = parseHeader(headerLines);
+        continue;
+      }
+      processLine(line);
+    }
+  }
+  const magic = new Uint8Array(await file.slice(0, 2).arrayBuffer());
+  const isGz = magic[0] === 31 && magic[1] === 139;
+  if (magic[0] === 31 && magic[1] === 157) {
+    throw new Error("Unix compress (.Z) files are not supported. Please decompress first (e.g. uncompress or gzip -d).");
+  }
+  if (isGz) {
+    let bytesRead = 0;
+    const raw = file.stream();
+    const decompressed = raw.pipeThrough(new DecompressionStream("gzip"));
+    const reader = decompressed.getReader();
+    for (; ; ) {
+      if (signal?.aborted) {
+        reader.cancel();
+        throw new DOMException("Aborted", "AbortError");
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytesRead += value.byteLength;
+      processChunkText(decoder.decode(value, { stream: true }), false);
+      onProgress?.(Math.min(99, Math.round(bytesRead / (file.size * 4) * 100)));
+      await yield_();
+    }
+    processChunkText(decoder.decode(), true);
+  } else {
+    for (let offset = 0; offset < file.size; offset += CHUNK_SIZE) {
+      if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+      const end = Math.min(offset + CHUNK_SIZE, file.size);
+      const slice = file.slice(offset, end);
+      const arrayBuf = await slice.arrayBuffer();
+      processChunkText(decoder.decode(arrayBuf, { stream: end < file.size }), false);
+      onProgress?.(Math.min(99, Math.round(end / file.size * 100)));
+      await yield_();
+    }
+    if (buffer.length > 0) {
+      processChunkText("", true);
+    }
+  }
+  if (epochInfo && satLinesRemaining === 0 && crxPhase === "epoch") finishEpoch();
+  if (!header) throw new Error("No valid RINEX header found (missing END OF HEADER).");
+  onProgress?.(100);
+  return { header, epochs, stats: computeStats(header, epochs, satellitesSeen) };
+}
+function computeStats(header, epochs, satellitesSeen) {
+  const n = epochs.length;
+  const startTime = n > 0 ? new Date(epochs[0].time) : header.timeOfFirstObs;
+  const endTime = n > 0 ? new Date(epochs[n - 1].time) : header.timeOfLastObs;
+  let duration = null;
+  if (startTime && endTime) duration = (endTime.getTime() - startTime.getTime()) / 1e3;
+  let interval = header.interval;
+  if (interval === null && n >= 2) interval = (epochs[1].time - epochs[0].time) / 1e3;
+  const uniqueSatsPerSystem = {};
+  let totalUnique = 0;
+  const systems = [];
+  for (const [sys, prns] of Object.entries(satellitesSeen)) {
+    uniqueSatsPerSystem[sys] = prns.size;
+    totalUnique += prns.size;
+    systems.push(sys);
+  }
+  systems.sort(systemCmp);
+  const meanSatellites = n > 0 ? epochs.reduce((s, e) => s + e.totalSats, 0) / n : 0;
+  const snrEpochs = epochs.filter((e) => e.meanSnr !== null);
+  const meanSnr = snrEpochs.length > 0 ? snrEpochs.reduce((s, e) => s + e.meanSnr, 0) / snrEpochs.length : null;
+  return {
+    totalEpochs: n,
+    validEpochs: n,
+    duration,
+    startTime,
+    endTime,
+    interval,
+    uniqueSatellites: totalUnique,
+    uniqueSatsPerSystem,
+    systems,
+    meanSatellites,
+    meanSnr
+  };
+}
+
+// src/analysis/quality-analysis.ts
+async function analyzeQuality(file, header, onProgress, signal) {
+  const mpAccum = new MultipathAccumulator(header);
+  const csAccum = new CycleSlipAccumulator(header, (time, prn, bands) => {
+    mpAccum.notifySlip(time, prn, bands);
+  });
+  const compAccum = new CompletenessAccumulator(header);
+  await parseRinexStream(
+    file,
+    onProgress,
+    signal,
+    (time, prn, codes, values) => {
+      csAccum.onObservation(time, prn, codes, values);
+      mpAccum.onObservation(time, prn, codes, values);
+      compAccum.onObservation(time, prn, codes, values);
+    },
+    true
+    /* workerMode: skip EpochSummary construction */
+  );
+  return {
+    cycleSlips: csAccum.finalize(),
+    completeness: compAccum.finalize(),
+    multipath: mpAccum.finalize()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompletenessAccumulator,
+  CycleSlipAccumulator,
+  MultipathAccumulator,
+  analyzeQuality
+});