gnss-js 2.11.0 → 2.13.0

package/README.md

@@ -14,9 +14,10 @@ Everything is exposed through subpath exports (`gnss-js/rinex`, `gnss-js/positio
 
 ## What's inside
 
-- **Formats in** — RINEX 2/3/4 obs + nav (plain, Hatanaka `.crx`, `.gz`), SP3, RINEX CLK, IONEX, SINEX bias; RTCM3 (MSM + legacy obs, ephemeris, SSR/IGS-SSR, station); RTCM 2.x; and the receiver binaries SBF, UBX, NovAtel OEM4, Trimble, BINEX.
+- **Formats in** — RINEX 2/3/4 obs + nav (plain, Hatanaka `.crx`, `.gz`), SP3, RINEX CLK, IONEX, SINEX bias; RTCM3 (MSM + legacy obs, ephemeris, SSR/IGS-SSR, station); RTCM 2.x; and the receiver binaries SBF, UBX, NovAtel OEM4, Trimble, BINEX; Android raw GNSS logs (GnssLogger).
 - **Formats out** — RINEX 2/3/4 observation + navigation writers and Hatanaka (CRINEX) compression.
 - **Navigation** — Keplerian/GLONASS ephemeris handling plus raw-frame decoding of GPS LNAV/CNAV, Galileo I/NAV + F/NAV, BeiDou D1/D2 and B-CNAV1/2/3 (B1C/B2a/B2b), GLONASS strings, and Galileo HAS (E6 C/NAV) corrections.
+- **Authentication** — Galileo OSNMA: the full chain of trust from the Merkle root through ECDSA-signed TESLA keys to per-satellite MAC tags, flagging navigation data Galileo did not sign.
 - **Orbits** — satellite position/velocity, Doppler, DOP, azimuth/elevation, pass prediction and almanac propagation.
 - **Positioning** — SPP, static and kinematic float PPP, PPP-AR (LAMBDA + wide-/narrow-lane FCB estimation), post-processed RTK, DGNSS, and SBAS/DFMC augmentation.
 - **Quality** — multipath, cycle slips, completeness and slant-TEC ionosphere analysis, with SINEX-DCB calibration.
@@ -93,12 +94,29 @@ import { parseUbxRawx, parseUbxRawNav } from 'gnss-js/ubx'; // u-blox
 import { parseNovatelRange, parseNovatelNav } from 'gnss-js/novatel'; // NovAtel OEM4
 import { parseTrimble, parseTrimbleNav } from 'gnss-js/trimble'; // Trimble
 import { parseBinex } from 'gnss-js/binex'; // BINEX
+import { parseAndroidGnssLog } from 'gnss-js/android'; // Android GnssLogger text logs
 
 const sbf = parseSbfMeas(bytes); // measurement epochs + counts
 const nav = parseSbfNav(bytes); // GPS/GAL/BDS/GLO ephemeris from raw blocks
 const has = parseSbfHas(bytes); // Galileo HAS (E6 C/NAV) SSR corrections
 ```
 
+Android phones log raw measurements (`android.location.GnssMeasurement`) through Google's GnssLogger app. `parseAndroidGnssLog(text)` rebuilds pseudoranges, carrier phase, Doppler and C/N0 per signal (GPS, GLONASS, Galileo, BeiDou, QZSS, NavIC, SBAS; L1/E1/B1 and L5/E5a/B2a), in the same epoch shape as the receiver decoders, plus the phone's own position fixes. It matches Google's gps-measurement-tools pseudoranges exactly.
+
+### Galileo OSNMA (navigation message authentication)
+
+`OsnmaReceiver` takes Galileo E1-B I/NAV pages and verifies them the way the OSNMA SIS ICD v1.1 prescribes: public key against the Merkle root (built in, or broadcast in DSM-PKR), the DSM-KROOT's ECDSA signature, every TESLA chain key back to the root key, and the MAC tags over each satellite's ephemeris/clock (ADKD 0/12) and timing parameters (ADKD 4). A tag that fails means the data differ from what Galileo signed. Validated against the official ICD test vectors and live receivers.
+
+```ts
+import { OsnmaReceiver, verifySbfOsnma } from 'gnss-js/osnma';
+
+const s = verifySbfOsnma(sbfBytes); // whole capture
+s.chains; // verified TESLA chains; s.tags → { ok, failed, ... }
+s.satellites; // per PRN: ced.authenticatedIodNav, timing.lastAuthenticated, failures
+
+const rx = new OsnmaReceiver(); // live: rx.pushPage(svid, wn, tow, page); rx.status()
+```
+
 ### RTCM (RTCM3, RTCM2, SSR)
 
 ```ts

package/dist/analysis.cjs

@@ -1113,20 +1113,14 @@ function applyIonoDcb(iono, satDcb) {
 // src/rinex/crx.ts
 function crxRepair(old, diff) {
   const chars = old.split("");
-  for (let i = 0; i < diff.length; i++) {
+  const n = Math.min(old.length, diff.length);
+  for (let i = 0; i < n; 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];
-    }
+    if (dc === " ") continue;
+    chars[i] = dc === "&" ? " " : dc;
   }
+  for (let i = old.length; i < diff.length; i++)
+    chars[i] = diff[i] === "&" ? " " : diff[i];
   return chars.join("");
 }
 function parseCrxDataLine(line, ntype) {
@@ -1371,6 +1365,15 @@ function readObsValue(line, index) {
   const v = parseFloat(raw);
   return isNaN(v) ? null : v;
 }
+function normalizePrn(id) {
+  let sys = id[0];
+  let num = id.substring(1);
+  if (sys === " " || /\d/.test(sys)) {
+    num = id;
+    sys = "G";
+  }
+  return sys + num.replace(/\s/g, "").padStart(2, "0");
+}
 function parseEpochLine3(line) {
   if (line[0] !== ">") return null;
   const yr = parseInt(line.substring(2, 6));
@@ -1520,7 +1523,7 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
   function processSatLineV3(line) {
     if (!header || line.length < 3) return;
     const sys = line[0];
-    const prn = line.substring(0, 3);
+    const prn = normalizePrn(line.substring(0, 3));
     trackSat(sys, prn);
     const obsLine = line.substring(3);
     const codes = header.obsTypes[sys] ?? [];
@@ -1545,10 +1548,8 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
   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");
+    const prn = normalizePrn(v2SatIds[v2SatIndex]);
+    const sys = prn[0];
     if (v2CurrentSatLine === 0) {
       trackSat(sys, prn);
       if (onSatObs) v2ObsAccum = [];
@@ -1639,6 +1640,7 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
         } else {
           epochLine = crxRepair(crxPrevEpochLine, line);
         }
+        epochLine = epochLine.replace(/ +$/, "");
         if (isV3) {
           if (epochLine[0] !== ">") return;
           const info = parseEpochLine3(epochLine);
@@ -1656,10 +1658,11 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
             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));
+          for (let k = 0; k < info.numSats; k++) {
+            crxSatList.push(
+              normalizePrn(epochLine.substring(41 + 3 * k, 44 + 3 * k))
+            );
           }
           crxSatIndex = 0;
           crxPrevEpochLine = epochLine;
@@ -1680,11 +1683,7 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
             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");
-          });
+          crxSatList = (info.satIds ?? []).slice(0, info.numSats).map(normalizePrn);
           crxSatIndex = 0;
           crxPrevEpochLine = epochLine;
           crxPhase = "clock";

package/dist/analysis.js

@@ -8,8 +8,8 @@ import {
   computeIonoRate,
   detrendIonoArcs,
   parseSinexBiasDcb
-} from "./chunk-KUSUN7DP.js";
-import "./chunk-3U5AX7PY.js";
+} from "./chunk-MFCPYUEI.js";
+import "./chunk-FEABDV5P.js";
 import "./chunk-FIEWO4J4.js";
 export {
   CompletenessAccumulator,

package/dist/android.cjs

@@ -0,0 +1,338 @@
+"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/android/index.ts
+var android_exports = {};
+__export(android_exports, {
+  isAndroidGnssLog: () => isAndroidGnssLog,
+  parseAndroidGnssLog: () => parseAndroidGnssLog
+});
+module.exports = __toCommonJS(android_exports);
+
+// src/constants/gnss.ts
+var C_LIGHT = 299792458;
+
+// src/android/index.ts
+var NS_PER_WEEK = 604800000000000n;
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var BDT_MINUS_GPST_S = -14;
+var GLO_RANGE = [159e7, 161e7];
+var GLO_G1 = 1602e6;
+var GLO_G1_STEP = 562500;
+var STATE_CODE_LOCK = 1;
+var STATE_TOW_DECODED = 8;
+var STATE_MSEC_AMBIGUOUS = 16;
+var STATE_GLO_TOD_DECODED = 128;
+var STATE_GAL_E1BC_CODE_LOCK = 1024;
+var STATE_GAL_E1C_2ND_CODE_LOCK = 2048;
+var STATE_GAL_E1B_PAGE_SYNC = 4096;
+var STATE_TOW_KNOWN = 16384;
+var STATE_GLO_TOD_KNOWN = 32768;
+var ADR_VALID = 1;
+var ADR_RESET = 2;
+var ADR_CYCLE_SLIP = 4;
+var ADR_HALF_CYCLE_RESOLVED = 8;
+var MAX_PR_UNC_NS = 500;
+var MAX_ADR_UNC_M = 0.1;
+var SYSTEM = {
+  1: "G",
+  2: "S",
+  3: "R",
+  4: "J",
+  5: "C",
+  6: "E",
+  7: "I"
+};
+var BANDS = {
+  G: [
+    [1, 157542e4],
+    [2, 12276e5],
+    [5, 117645e4]
+  ],
+  S: [
+    [1, 157542e4],
+    [5, 117645e4]
+  ],
+  J: [
+    [1, 157542e4],
+    [2, 12276e5],
+    [5, 117645e4],
+    [6, 127875e4]
+  ],
+  E: [
+    [1, 157542e4],
+    [5, 117645e4],
+    [7, 120714e4],
+    [6, 127875e4]
+  ],
+  C: [
+    [2, 1561098e3],
+    [1, 157542e4],
+    [5, 117645e4],
+    [7, 120714e4],
+    [6, 126852e4]
+  ],
+  I: [[5, 117645e4]]
+};
+var DEFAULT_ATTR = {
+  G1: "C",
+  G2: "L",
+  G5: "Q",
+  S1: "C",
+  S5: "I",
+  J1: "C",
+  J2: "L",
+  J5: "Q",
+  E1: "C",
+  E5: "Q",
+  E7: "Q",
+  E6: "C",
+  C2: "I",
+  C1: "P",
+  C5: "P",
+  C7: "I",
+  C6: "I",
+  I5: "A",
+  R1: "C",
+  R2: "C"
+};
+function prnOf(sys, svid) {
+  let n = svid;
+  if (sys === "S")
+    n = svid - 100;
+  else if (sys === "J")
+    n = svid - 192;
+  else if (sys === "R" && svid > 24) return null;
+  if (n < 1 || n > 99) return null;
+  return sys + String(n).padStart(2, "0");
+}
+function bandOf(sys, freqHz) {
+  if (sys === "R") {
+    if (freqHz >= GLO_RANGE[0] && freqHz <= GLO_RANGE[1]) {
+      const k = Math.round((freqHz - GLO_G1) / GLO_G1_STEP);
+      return { band: 1, freq: GLO_G1 + k * GLO_G1_STEP, gloChannel: k };
+    }
+    return null;
+  }
+  for (const [band, f] of BANDS[sys] ?? [])
+    if (Math.abs(freqHz - f) < 1e6) return { band, freq: f, gloChannel: null };
+  return null;
+}
+var cells = (line) => line.split(",");
+function parseAndroidGnssLog(text) {
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
+  const messageCounts = {};
+  const fixes = [];
+  let device = null;
+  let rawCols = null;
+  let fixCols = null;
+  let leapSeconds = null;
+  let rejected = 0;
+  const groups = [];
+  let curKey = "";
+  for (const line of lines) {
+    if (!line) continue;
+    if (line.startsWith("#")) {
+      const body = line.replace(/^#\s*/, "");
+      if (body.startsWith("Raw,"))
+        rawCols = new Map(cells(body).map((c, i) => [c.trim(), i]));
+      else if (body.startsWith("Fix,"))
+        fixCols = new Map(cells(body).map((c, i) => [c.trim(), i]));
+      else if (/Manufacturer/.test(body)) {
+        const m = (k) => new RegExp(`${k}:\\s*([^:]*?)(?:\\s+\\w+:|$)`).exec(body)?.[1]?.trim() ?? "";
+        device = {
+          manufacturer: m("Manufacturer"),
+          model: m("Model"),
+          version: m("Version").replace(/,$/, "")
+        };
+      }
+      continue;
+    }
+    const type = line.slice(0, line.indexOf(","));
+    if (!type) continue;
+    messageCounts[type] = (messageCounts[type] ?? 0) + 1;
+    if (type === "Raw" && rawCols) {
+      const r = cells(line);
+      const key = r[rawCols.get("TimeNanos")] ?? "";
+      if (key !== curKey) {
+        groups.push([]);
+        curKey = key;
+      }
+      groups[groups.length - 1].push(r);
+    } else if (type === "Fix" && fixCols) {
+      const r = cells(line);
+      const g = (k) => {
+        const i = fixCols.get(k);
+        const v = i === void 0 ? "" : (r[i] ?? "").trim();
+        return v === "" ? null : Number(v);
+      };
+      const lat = g("LatitudeDegrees");
+      const lon = g("LongitudeDegrees");
+      const t = g("UnixTimeMillis");
+      if (lat != null && lon != null && t != null)
+        fixes.push({
+          utcMs: t,
+          provider: (r[fixCols.get("Provider") ?? 1] ?? "").trim(),
+          latDeg: lat,
+          lonDeg: lon,
+          altM: g("AltitudeMeters"),
+          accuracyM: g("AccuracyMeters")
+        });
+    }
+  }
+  const epochs = [];
+  const obsCodes = {};
+  if (!rawCols) {
+    return {
+      epochs,
+      fixes,
+      device,
+      messageCounts,
+      obsCodes,
+      rejected,
+      leapSeconds
+    };
+  }
+  const col = rawCols;
+  const str = (r, k) => {
+    const i = col.get(k);
+    return i === void 0 ? "" : (r[i] ?? "").trim();
+  };
+  const num = (r, k) => {
+    const v = str(r, k);
+    return v === "" ? null : Number(v);
+  };
+  let segment = null;
+  let fullBias = 0n;
+  let bias = 0;
+  const lockStart = /* @__PURE__ */ new Map();
+  for (const rows of groups) {
+    const r0 = rows[0];
+    const timeNanosStr = str(r0, "TimeNanos");
+    const fullBiasStr = str(r0, "FullBiasNanos");
+    if (!timeNanosStr || !fullBiasStr) {
+      rejected += rows.length;
+      continue;
+    }
+    const disc = str(r0, "HardwareClockDiscontinuityCount");
+    if (disc !== segment) {
+      segment = disc;
+      fullBias = BigInt(fullBiasStr.split(".")[0]);
+      bias = num(r0, "BiasNanos") ?? 0;
+    }
+    const leap = num(r0, "LeapSecond");
+    if (leap != null && !Number.isNaN(leap)) leapSeconds = leap;
+    const rxNs = BigInt(timeNanosStr.split(".")[0]) - fullBias;
+    const week = Number(rxNs / NS_PER_WEEK);
+    const rxWeekNs = Number(rxNs % NS_PER_WEEK);
+    const epochWeekNs = Math.round((rxWeekNs - bias) / 100) * 100;
+    const toffNs = rxWeekNs - epochWeekNs - bias;
+    const timeMs = GPS_EPOCH_MS + week * 6048e5 + epochWeekNs / 1e6;
+    const leapNow = leapSeconds ?? 18;
+    const meas = [];
+    for (const r of rows) {
+      const sys = SYSTEM[num(r, "ConstellationType") ?? 1];
+      const svid = num(r, "Svid");
+      if (!sys || svid == null) {
+        rejected++;
+        continue;
+      }
+      const prn = prnOf(sys, svid);
+      const freqHz = num(r, "CarrierFrequencyHz") ?? 157542e4;
+      const b = prn ? bandOf(sys, freqHz) : null;
+      const state = num(r, "State") ?? 0;
+      const towOk = sys === "R" ? (state & (STATE_GLO_TOD_DECODED | STATE_GLO_TOD_KNOWN)) !== 0 : (state & (STATE_TOW_DECODED | STATE_TOW_KNOWN)) !== 0;
+      const codeLock = (state & (STATE_CODE_LOCK | STATE_GAL_E1BC_CODE_LOCK)) !== 0;
+      const prUnc = num(r, "ReceivedSvTimeUncertaintyNanos");
+      const svTimeNs = num(r, "ReceivedSvTimeNanos");
+      if (!prn || !b || !towOk || !codeLock || (state & STATE_MSEC_AMBIGUOUS) !== 0 || svTimeNs == null || prUnc != null && prUnc > MAX_PR_UNC_NS) {
+        rejected++;
+        continue;
+      }
+      const subNs = bias + (num(r, "TimeOffsetNanos") ?? 0);
+      let tauNs;
+      if (sys === "R") {
+        const DAY = 864e11;
+        const tTxNs = svTimeNs - 108e11 + leapNow * 1e9;
+        tauNs = ((rxWeekNs % DAY - tTxNs) % DAY + DAY) % DAY;
+        if (tauNs > DAY / 2) tauNs -= DAY;
+      } else {
+        const tTxNs = svTimeNs - (sys === "C" ? BDT_MINUS_GPST_S * 1e9 : 0);
+        tauNs = rxWeekNs - tTxNs;
+        if (tauNs > 3024e11) tauNs -= 6048e11;
+        else if (tauNs < -3024e11) tauNs += 6048e11;
+      }
+      tauNs -= subNs;
+      if (!(tauNs > 6e7 && tauNs < 16e7)) {
+        rejected++;
+        continue;
+      }
+      const pr = (tauNs - toffNs) * 1e-9 * C_LIGHT;
+      const attrCell = str(r, "CodeType");
+      let attr = attrCell || DEFAULT_ATTR[sys + b.band] || "C";
+      if (!attrCell && sys === "E" && b.band === 1 && (state & STATE_GAL_E1C_2ND_CODE_LOCK) === 0 && (state & STATE_GAL_E1B_PAGE_SYNC) !== 0)
+        attr = "B";
+      const code = `${b.band}${attr}`;
+      const lambda = C_LIGHT / b.freq;
+      const adrState = num(r, "AccumulatedDeltaRangeState") ?? 0;
+      const adr = num(r, "AccumulatedDeltaRangeMeters");
+      const adrUnc = num(r, "AccumulatedDeltaRangeUncertaintyMeters");
+      const lockKey = prn + code;
+      let cp = null;
+      if ((adrState & ADR_VALID) !== 0 && adr != null && adr !== 0 && (adrUnc == null || adrUnc < MAX_ADR_UNC_M)) {
+        cp = adr / lambda - toffNs * 1e-9 * b.freq;
+        if ((adrState & (ADR_RESET | ADR_CYCLE_SLIP)) !== 0 || !lockStart.has(lockKey))
+          lockStart.set(lockKey, timeMs);
+      } else lockStart.delete(lockKey);
+      const prr = num(r, "PseudorangeRateMetersPerSecond");
+      meas.push({
+        prn,
+        code,
+        pr,
+        cp,
+        doppler: prr == null ? null : -prr / lambda,
+        cn0: num(r, "Cn0DbHz"),
+        halfCycleAmbiguous: cp != null && (adrState & ADR_HALF_CYCLE_RESOLVED) === 0,
+        lockTimeMs: cp != null ? timeMs - lockStart.get(lockKey) : 0,
+        gloChannel: b.gloChannel
+      });
+      const list = obsCodes[sys] ??= [];
+      if (!list.includes(code)) list.push(code);
+    }
+    if (meas.length > 0) epochs.push({ timeMs, meas });
+  }
+  return {
+    epochs,
+    fixes,
+    device,
+    messageCounts,
+    obsCodes,
+    rejected,
+    leapSeconds
+  };
+}
+function isAndroidGnssLog(text) {
+  const head = text.slice(0, 16384);
+  return /^#\s*Raw,/m.test(head) || /^Raw,\d+,\d+,/m.test(head);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAndroidGnssLog,
+  parseAndroidGnssLog
+});

package/dist/android.d.cts

@@ -0,0 +1,68 @@
+/** One satellite signal at an epoch, in the shape of the other receiver
+ *  decoders (`ubx`, `sbf`…). */
+interface AndroidMeasurement {
+    /** RINEX PRN, e.g. "G04", "R11", "J02". */
+    prn: string;
+    /** RINEX band + attribute, e.g. "1C", "5Q", "2I". */
+    code: string;
+    /** Pseudorange (m). */
+    pr: number;
+    /** Carrier phase (cycles), null when not tracked/valid. */
+    cp: number | null;
+    /** Doppler (Hz). */
+    doppler: number | null;
+    /** C/N0 (dB-Hz). */
+    cn0: number | null;
+    /** Carrier phase may be off by half a cycle (not half-cycle resolved). */
+    halfCycleAmbiguous: boolean;
+    /** Continuous carrier-lock time (ms): 0 at a slip/reset, then growing —
+     *  the same loss-of-lock signal the other decoders give. */
+    lockTimeMs: number;
+    /** GLONASS frequency channel (−7…+6), from the carrier frequency. */
+    gloChannel: number | null;
+}
+interface AndroidEpoch {
+    /** Receiver epoch (GPS-scale ms — the RINEX-parser convention). */
+    timeMs: number;
+    meas: AndroidMeasurement[];
+}
+/** The phone's own position fix (`Fix,` rows). */
+interface AndroidFix {
+    /** UTC ms. */
+    utcMs: number;
+    /** 'GPS' (GNSS chip), 'FLP' (fused), 'NLP' (network)… */
+    provider: string;
+    latDeg: number;
+    lonDeg: number;
+    /** Altitude (m) as reported (WGS84 ellipsoidal on most devices). */
+    altM: number | null;
+    /** Horizontal accuracy (m, 68%). */
+    accuracyM: number | null;
+}
+interface AndroidLogResult {
+    epochs: AndroidEpoch[];
+    fixes: AndroidFix[];
+    /** Device line (`# Version: … Manufacturer: … Model: …`), if present. */
+    device: {
+        manufacturer: string;
+        model: string;
+        version: string;
+    } | null;
+    /** Rows per record type ('Raw', 'Fix', 'Status', 'Nav'…). */
+    messageCounts: Record<string, number>;
+    /** Observation codes per system letter, first-seen order. */
+    obsCodes: Record<string, string[]>;
+    /** Raw rows dropped (no code lock / ambiguous time / bad values). */
+    rejected: number;
+    /** GPS − UTC leap seconds from the log, if reported. */
+    leapSeconds: number | null;
+}
+/**
+ * Parse a GnssLogger text log. Missing `CarrierFrequencyHz` (very old logs)
+ * means GPS/Galileo/QZSS L1.
+ */
+declare function parseAndroidGnssLog(text: string): AndroidLogResult;
+/** Whether `text` looks like a GnssLogger log (first few KB). */
+declare function isAndroidGnssLog(text: string): boolean;
+
+export { type AndroidEpoch, type AndroidFix, type AndroidLogResult, type AndroidMeasurement, isAndroidGnssLog, parseAndroidGnssLog };

package/dist/android.d.ts

@@ -0,0 +1,68 @@
+/** One satellite signal at an epoch, in the shape of the other receiver
+ *  decoders (`ubx`, `sbf`…). */
+interface AndroidMeasurement {
+    /** RINEX PRN, e.g. "G04", "R11", "J02". */
+    prn: string;
+    /** RINEX band + attribute, e.g. "1C", "5Q", "2I". */
+    code: string;
+    /** Pseudorange (m). */
+    pr: number;
+    /** Carrier phase (cycles), null when not tracked/valid. */
+    cp: number | null;
+    /** Doppler (Hz). */
+    doppler: number | null;
+    /** C/N0 (dB-Hz). */
+    cn0: number | null;
+    /** Carrier phase may be off by half a cycle (not half-cycle resolved). */
+    halfCycleAmbiguous: boolean;
+    /** Continuous carrier-lock time (ms): 0 at a slip/reset, then growing —
+     *  the same loss-of-lock signal the other decoders give. */
+    lockTimeMs: number;
+    /** GLONASS frequency channel (−7…+6), from the carrier frequency. */
+    gloChannel: number | null;
+}
+interface AndroidEpoch {
+    /** Receiver epoch (GPS-scale ms — the RINEX-parser convention). */
+    timeMs: number;
+    meas: AndroidMeasurement[];
+}
+/** The phone's own position fix (`Fix,` rows). */
+interface AndroidFix {
+    /** UTC ms. */
+    utcMs: number;
+    /** 'GPS' (GNSS chip), 'FLP' (fused), 'NLP' (network)… */
+    provider: string;
+    latDeg: number;
+    lonDeg: number;
+    /** Altitude (m) as reported (WGS84 ellipsoidal on most devices). */
+    altM: number | null;
+    /** Horizontal accuracy (m, 68%). */
+    accuracyM: number | null;
+}
+interface AndroidLogResult {
+    epochs: AndroidEpoch[];
+    fixes: AndroidFix[];
+    /** Device line (`# Version: … Manufacturer: … Model: …`), if present. */
+    device: {
+        manufacturer: string;
+        model: string;
+        version: string;
+    } | null;
+    /** Rows per record type ('Raw', 'Fix', 'Status', 'Nav'…). */
+    messageCounts: Record<string, number>;
+    /** Observation codes per system letter, first-seen order. */
+    obsCodes: Record<string, string[]>;
+    /** Raw rows dropped (no code lock / ambiguous time / bad values). */
+    rejected: number;
+    /** GPS − UTC leap seconds from the log, if reported. */
+    leapSeconds: number | null;
+}
+/**
+ * Parse a GnssLogger text log. Missing `CarrierFrequencyHz` (very old logs)
+ * means GPS/Galileo/QZSS L1.
+ */
+declare function parseAndroidGnssLog(text: string): AndroidLogResult;
+/** Whether `text` looks like a GnssLogger log (first few KB). */
+declare function isAndroidGnssLog(text: string): boolean;
+
+export { type AndroidEpoch, type AndroidFix, type AndroidLogResult, type AndroidMeasurement, isAndroidGnssLog, parseAndroidGnssLog };