gnss-js 1.30.0 → 1.32.0

package/dist/positioning.d.ts

@@ -714,6 +714,172 @@ declare function moonEcef(timeMs: number): [number, number, number];
  */
 declare function solidEarthTide(rcv: [number, number, number], sun: [number, number, number], moon: [number, number, number]): [number, number, number];
 
+/**
+ * PPP-AR — integer ambiguity resolution for Precise Point Positioning.
+ *
+ * Float PPP estimates one *ionosphere-free* ambiguity per satellite arc, a
+ * real number in metres. Fixing those to integers is what takes PPP from the
+ * decimetre to the centimetre level. The classic two-step decomposition is
+ * used here:
+ *
+ *   1. **Wide-lane** N_WL = N1 − N2 from the Melbourne–Wübbena combination.
+ *      The WL wavelength is ~86 cm (GPS), so the arc-averaged MW rounds to an
+ *      integer reliably once the satellite WL fractional-cycle bias is removed.
+ *   2. **Narrow-lane** N1, recovered from the float IF ambiguity with N_WL
+ *      fixed, then resolved with LAMBDA on *between-satellite single
+ *      differences* (which cancel the receiver phase bias) after removing the
+ *      satellite NL fractional-cycle bias.
+ *
+ * The satellite WL/NL fractional-cycle biases come from a phase-bias product
+ * (Bias-SINEX OSB from an AR-capable analysis centre such as CNES or CODE).
+ * Without them, a single receiver cannot separate the satellite bias from the
+ * integer, so those biases are required inputs — pass 0 only for a network
+ * datum where they have already been removed.
+ *
+ * The relation between the IF ambiguity (metres) and the integers is
+ *   A_IF = λ_NL·N1 + λ_NL·(f2/(f1−f2))·N_WL,   λ_NL = c/(f1+f2).
+ */
+/** Wide-lane wavelength c/(f1−f2) (m). */
+declare function wlWavelength(f1: number, f2: number): number;
+/** Narrow-lane wavelength c/(f1+f2) (m). */
+declare function nlWavelength(f1: number, f2: number): number;
+/** One satellite's float ambiguity inputs for AR. */
+interface ArSat {
+    prn: string;
+    /** Float ionosphere-free ambiguity (m) from the PPP EKF. */
+    aIF: number;
+    /** Arc-averaged Melbourne–Wübbena wide-lane estimate (cycles). */
+    mwCyc: number;
+    f1: number;
+    f2: number;
+    /** Satellite wide-lane fractional-cycle bias (cycles). Default 0. */
+    wlBiasCyc?: number;
+    /** Satellite narrow-lane fractional-cycle bias (cycles). Default 0. */
+    nlBiasCyc?: number;
+    /** Elevation (deg), used only to pick the reference satellite. */
+    elevDeg?: number;
+}
+interface ArOptions {
+    /** Max |MW − round| to accept a wide-lane (cycles). Default 0.25. */
+    wlThreshold?: number;
+    /** Min LAMBDA ratio to accept the narrow-lane fix. Default 3. */
+    ratioThreshold?: number;
+}
+interface ArFixedSat {
+    prn: string;
+    nWl: number;
+    n1: number;
+    /** Fixed IF ambiguity (m). */
+    aIF: number;
+}
+interface ArResult {
+    /** Whether the narrow-lane fix passed the ratio test. */
+    fixed: boolean;
+    /** LAMBDA ratio statistic (second-best / best). */
+    ratio: number;
+    /** Reference PRN whose absolute N1 stays float (SD datum). */
+    refPrn: string | null;
+    /** Fixed satellites (includes the reference with its float-rounded N1). */
+    sats: ArFixedSat[];
+    /** PRNs whose wide-lane did not round confidently (excluded). */
+    rejectedWl: string[];
+}
+/**
+ * Resolve PPP integer ambiguities from the float IF ambiguities and their
+ * covariance. `Qaif` is the n×n float covariance (m²) in the same order as
+ * `sats`. Returns the fixed narrow-lane / wide-lane integers and the ratio
+ * test result. A `fixed: false` result means the data did not support a
+ * confident fix (keep the float solution).
+ */
+declare function resolvePppAmbiguities(sats: ArSat[], Qaif: Float64Array, opts?: ArOptions): ArResult;
+
+/**
+ * Wide-lane fractional-cycle bias (FCB) estimation for PPP-AR — the
+ * self-contained route to integer ambiguities that needs no external
+ * phase-bias product, only a small network of stations.
+ *
+ * A single receiver cannot resolve ambiguities because its Melbourne–Wübbena
+ * wide-lane float is `Ñ_wl = N (integer) + b_rcv + b_sat`, and the integer
+ * and the satellite fractional bias `b_sat` are entangled. Across a *network*
+ * they separate: every station sees the same `b_sat` for a given satellite
+ * but its own integers and receiver bias, so the fractional part common to
+ * all stations *is* the satellite FCB. This is the classic Ge/Gendt method.
+ *
+ * The estimator alternates:
+ *   1. round each arc to its integer  N = round(Ñ_wl − b_rcv − b_sat);
+ *   2. update each satellite FCB      = circular-mean over stations of
+ *      (Ñ_wl − N − b_rcv);
+ *   3. update each receiver bias       = circular-mean over satellites of
+ *      (Ñ_wl − N − b_sat);
+ *   4. pin the datum (b_rcv of a reference station ≡ 0) — receiver and
+ *      satellite biases otherwise trade off by an arbitrary constant.
+ *
+ * The output `satFcb` feeds `resolvePppAmbiguities`' `wlBiasCyc`.
+ */
+/** Minimal per-satellite observation for wide-lane extraction. */
+interface WlObs {
+    prn: string;
+    f1: number;
+    f2: number;
+    /** Code on f1/f2 (m) and carrier phase on f1/f2 (cycles). */
+    c1: number;
+    c2: number;
+    l1: number;
+    l2: number;
+}
+/**
+ * Extract arc-averaged Melbourne–Wübbena wide-lanes for one station from its
+ * epoch stream. The MW combination
+ *   MW = (L1 − L2) − [(f1·C1 + f2·C2)/(f1+f2)] / (c/(f1−f2))   [cycles]
+ * is geometry-, clock- and (first-order) ionosphere-free, so it holds the
+ * wide-lane ambiguity plus biases and is near-constant within an arc. Arcs
+ * are split on a running-mean jump (cycle slip) or a time gap.
+ */
+declare function extractWidelaneArcs(station: string, epochs: {
+    timeMs: number;
+    obs: WlObs[];
+}[], opts?: {
+    slipCyc?: number;
+    gapMs?: number;
+    minObs?: number;
+}): WlArc[];
+/** One continuous wide-lane arc at a station. */
+interface WlArc {
+    station: string;
+    prn: string;
+    /** Arc-averaged Melbourne–Wübbena wide-lane float (cycles). */
+    wlFloat: number;
+    /** Number of epochs averaged (used as the weight). */
+    nObs: number;
+}
+interface WlFcbOptions {
+    /** Max iterations. Default 50. */
+    maxIter?: number;
+    /** Convergence threshold on the largest bias change (cycles). Default 1e-4. */
+    tol?: number;
+    /** Fix-rate acceptance window |resid| (cycles). Default 0.25. */
+    fixWindow?: number;
+}
+interface WlFcbResult {
+    /** Per-satellite wide-lane FCB (cycles, wrapped to [−0.5, 0.5)). */
+    satFcb: Map<string, number>;
+    /** Per-station wide-lane bias (cycles); the reference station is 0. */
+    rcvBias: Map<string, number>;
+    /** RMS of the post-fit arc residuals Ñ_wl − N − b_rcv − b_sat (cycles). */
+    residRms: number;
+    /** Fraction of arcs whose residual lies within `fixWindow` of an integer. */
+    fixRate: number;
+    /** Reference station pinning the datum. */
+    refStation: string;
+    iterations: number;
+}
+/**
+ * Estimate per-satellite wide-lane FCBs from a network of stations' arc
+ * wide-lane floats. Needs ≥2 stations sharing satellites to break the
+ * integer/bias entanglement.
+ */
+declare function estimateWidelaneFcb(arcs: WlArc[], opts?: WlFcbOptions): WlFcbResult;
+
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
  * ephemerides.
@@ -803,4 +969,4 @@ declare function ionoFree(p1: number, p2: number, f1: number, f2: number): numbe
  */
 declare function solveSpp(pseudoranges: Map<string, number>, ephemerides: Map<string, Ephemeris>, timeMs: number, opts?: SppOptions): SppSolution | null;
 
-export { type AntennaOffset, type CorrectionResult, type DgnssOptions, type DgnssSolution, type EphemerisSource, IONO_L1_M_PER_TECU, type KlobucharCoeffs, type LambdaResult, type PppAntennaModel, type PppCorrectionConfig, type PppCorrections, type PppEpoch, type PppEpochContext, type PppEpochResult, type PppOptions, type PppSatObs, type PppSolution, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SatGeom, type SppOptions, type SppSolution, type TropoMapping, buildPppAntenna, createPppCorrections, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch };
+export { type AntennaOffset, type ArFixedSat, type ArOptions, type ArResult, type ArSat, type CorrectionResult, type DgnssOptions, type DgnssSolution, type EphemerisSource, IONO_L1_M_PER_TECU, type KlobucharCoeffs, type LambdaResult, type PppAntennaModel, type PppCorrectionConfig, type PppCorrections, type PppEpoch, type PppEpochContext, type PppEpochResult, type PppOptions, type PppSatObs, type PppSolution, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SatGeom, type SppOptions, type SppSolution, type TropoMapping, type WlArc, type WlFcbOptions, type WlFcbResult, type WlObs, buildPppAntenna, createPppCorrections, estimateWidelaneFcb, extractWidelaneArcs, gimSlantIonoDelayL1, gimVerticalTec, gmst, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, moonEcef, niellMapping, nlWavelength, resolvePppAmbiguities, satClockCorrection, solidEarthTide, solveDgnss, solvePpp, solveSpp, sunEcef, toRtkEpoch, wlWavelength };

package/dist/positioning.js

@@ -3,6 +3,8 @@ import {
   RtkFloatEngine,
   buildPppAntenna,
   createPppCorrections,
+  estimateWidelaneFcb,
+  extractWidelaneArcs,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,
@@ -12,14 +14,17 @@ import {
   lambdaSearch,
   moonEcef,
   niellMapping,
+  nlWavelength,
+  resolvePppAmbiguities,
   satClockCorrection,
   solidEarthTide,
   solveDgnss,
   solvePpp,
   solveSpp,
   sunEcef,
-  toRtkEpoch
-} from "./chunk-CRFFUU5Y.js";
+  toRtkEpoch,
+  wlWavelength
+} from "./chunk-HOH27N42.js";
 import "./chunk-MHGNKSSH.js";
 import "./chunk-37QNKGTC.js";
 import "./chunk-6FAL6P4G.js";
@@ -32,6 +37,8 @@ export {
   RtkFloatEngine,
   buildPppAntenna,
   createPppCorrections,
+  estimateWidelaneFcb,
+  extractWidelaneArcs,
   gimSlantIonoDelayL1,
   gimVerticalTec,
   gmst,
@@ -41,11 +48,14 @@ export {
   lambdaSearch,
   moonEcef,
   niellMapping,
+  nlWavelength,
+  resolvePppAmbiguities,
   satClockCorrection,
   solidEarthTide,
   solveDgnss,
   solvePpp,
   solveSpp,
   sunEcef,
-  toRtkEpoch
+  toRtkEpoch,
+  wlWavelength
 };

package/dist/rinex.cjs

@@ -23,15 +23,18 @@ __export(rinex_exports, {
   EMPTY_WARNINGS: () => EMPTY_WARNINGS,
   SYSTEM_ORDER: () => SYSTEM_ORDER,
   WarningAccumulator: () => WarningAccumulator,
+  biasMetres: () => biasMetres,
   clkBias: () => clkBias,
   createGzipLineSink: () => createGzipLineSink,
   crxDecompress: () => crxDecompress,
   crxRepair: () => crxRepair,
+  findSatBias: () => findSatBias,
   fmtD: () => fmtD,
   fmtF: () => fmtF,
   hdrLine: () => hdrLine,
   padL: () => padL,
   padR: () => padR,
+  parseBiasSinex: () => parseBiasSinex,
   parseClk: () => parseClk,
   parseCrxDataLine: () => parseCrxDataLine,
   parseIonex: () => parseIonex,
@@ -597,6 +600,7 @@ var SYSTEM_NAMES = {
   I: "NavIC",
   S: "SBAS"
 };
+var C_LIGHT = 299792458;
 
 // src/rinex/parser.ts
 var CHUNK_SIZE = 2 * 1024 * 1024;
@@ -2450,6 +2454,81 @@ function clkBias(clk, prn, tMs) {
   return c[lo] + f * (c[lo + 1] - c[lo]);
 }
 
+// src/rinex/bias-sinex.ts
+function parseEpoch(s, openTo) {
+  const m = /^(\d{4}):(\d{3}):(\d{5})$/.exec(s.trim());
+  if (!m) return openTo;
+  const y = +m[1];
+  if (y === 0) return openTo;
+  const doy = +m[2];
+  const sod = +m[3];
+  return Date.UTC(y, 0, 1) + (doy - 1) * 864e5 + sod * 1e3;
+}
+function parseBiasSinex(text) {
+  const records = [];
+  let inBlock = false;
+  for (const line of text.split("\n")) {
+    if (line.startsWith("+BIAS/SOLUTION")) {
+      inBlock = true;
+      continue;
+    }
+    if (line.startsWith("-BIAS/SOLUTION")) {
+      inBlock = false;
+      continue;
+    }
+    if (!inBlock || line.length < 65 || line.startsWith("*")) continue;
+    const type = line.slice(1, 4).trim();
+    if (type !== "DSB" && type !== "OSB" && type !== "ISB") continue;
+    const prn = line.slice(11, 14).trim();
+    const station = line.slice(15, 24).trim();
+    const obs1 = line.slice(25, 29).trim();
+    const obs2 = line.slice(30, 34).trim();
+    const startMs = parseEpoch(line.slice(35, 49), -Infinity);
+    const endMs = parseEpoch(line.slice(50, 64), Infinity);
+    const tail = line.slice(65).trim().split(/\s+/);
+    if (tail.length < 2) continue;
+    const unit = tail[0];
+    const value = Number(tail[1]);
+    if (!Number.isFinite(value)) continue;
+    records.push({
+      type,
+      prn,
+      station,
+      obs1,
+      obs2,
+      startMs,
+      endMs,
+      value,
+      unit
+    });
+  }
+  const bySat = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (!r.prn || r.station) continue;
+    let a = bySat.get(r.prn);
+    if (!a) {
+      a = [];
+      bySat.set(r.prn, a);
+    }
+    a.push(r);
+  }
+  return { records, bySat };
+}
+function biasMetres(r) {
+  return r.unit === "ns" ? r.value * 1e-9 * C_LIGHT : r.value;
+}
+function findSatBias(bias, prn, obs1, obs2, tMs) {
+  const recs = bias.bySat.get(prn);
+  if (!recs) return null;
+  for (const r of recs) {
+    if (r.obs1 !== obs1) continue;
+    if (obs2 === void 0 ? r.obs2 !== "" : r.obs2 !== obs2) continue;
+    if (tMs != null && (tMs < r.startMs || tMs > r.endMs)) continue;
+    return r;
+  }
+  return null;
+}
+
 // src/rinex/obs-writer-common.ts
 function createGzipLineSink() {
   const encoder = new TextEncoder();
@@ -2828,15 +2907,18 @@ function writeRinex4ObsBlob(header, epochs, obsTypes) {
   EMPTY_WARNINGS,
   SYSTEM_ORDER,
   WarningAccumulator,
+  biasMetres,
   clkBias,
   createGzipLineSink,
   crxDecompress,
   crxRepair,
+  findSatBias,
   fmtD,
   fmtF,
   hdrLine,
   padL,
   padR,
+  parseBiasSinex,
   parseClk,
   parseCrxDataLine,
   parseIonex,

package/dist/rinex.d.cts

@@ -182,6 +182,54 @@ interface Nav4Input {
  */
 declare function writeRinexNav4(nav: Nav4Input): string;
 
+/**
+ * Bias-SINEX (`.BIA`) parser — GNSS code/phase biases published by the IGS
+ * analysis centres. Two record kinds matter here:
+ *
+ *   - **DSB** differential signal bias (OBS1−OBS2), the classic inter-code
+ *     bias used for ionosphere/DCB corrections in SPP.
+ *   - **OSB** observable-specific (absolute) bias for a single OBS, the
+ *     ingredient PPP-AR needs: the *phase* OSBs are the satellite
+ *     fractional-cycle biases that make the ambiguities integer-recoverable.
+ *
+ * Values keep their file unit (`ns` for code/most phase biases, `cyc` for
+ * cycle-based phase biases); `biasMetres` converts ns → m via c.
+ */
+interface BiasRecord {
+    /** 'DSB' | 'OSB' | 'ISB' | … */
+    type: string;
+    /** Satellite PRN (e.g. 'G01', 'E11'); '' for a pure station bias. */
+    prn: string;
+    /** Station (9-char), '' for satellite biases. */
+    station: string;
+    /** First observable code (e.g. 'C1W', 'L1C'). */
+    obs1: string;
+    /** Second observable (DSB only; '' for OSB). */
+    obs2: string;
+    /** Validity start / end (GPS-scale ms); ±Infinity when open. */
+    startMs: number;
+    endMs: number;
+    /** Estimated value in the file unit. */
+    value: number;
+    /** File unit ('ns' | 'cyc' | …). */
+    unit: string;
+}
+interface BiasSinex {
+    records: BiasRecord[];
+    /** All satellite records grouped by PRN (station === ''). */
+    bySat: Map<string, BiasRecord[]>;
+}
+/** Parse a Bias-SINEX file. */
+declare function parseBiasSinex(text: string): BiasSinex;
+/** A satellite bias record's value in metres (ns → m via c; cyc left as-is). */
+declare function biasMetres(r: BiasRecord): number;
+/**
+ * Look up a satellite bias: a DSB by its (obs1,obs2) pair, or an OSB by obs1
+ * alone (pass obs2 = undefined), valid at `tMs` (default: any). Returns the
+ * record or null.
+ */
+declare function findSatBias(bias: BiasSinex, prn: string, obs1: string, obs2?: string, tMs?: number): BiasRecord | null;
+
 /**
  * RINEX 3.04 / 4.01 observation file writer.
  *
@@ -263,4 +311,4 @@ declare function createGzipLineSink(): {
  */
 declare function stationHeaderLines(header: RinexHeader): string[];
 
-export { type CompactEpoch, type CrxField, type DiffState, EMPTY_WARNINGS, Ephemeris, type Nav4Input, NavHeader, NavResult, RinexCnavEphemeris, RinexHeader, type RinexWarning, type RinexWarnings, WarningAccumulator, type WarningSeverity, type WriteCrxOptions, createGzipLineSink, crxDecompress, crxRepair, fmtD, fmtF, hdrLine, padL, padR, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob };
+export { type BiasRecord, type BiasSinex, type CompactEpoch, type CrxField, type DiffState, EMPTY_WARNINGS, Ephemeris, type Nav4Input, NavHeader, NavResult, RinexCnavEphemeris, RinexHeader, type RinexWarning, type RinexWarnings, WarningAccumulator, type WarningSeverity, type WriteCrxOptions, biasMetres, createGzipLineSink, crxDecompress, crxRepair, findSatBias, fmtD, fmtF, hdrLine, padL, padR, parseBiasSinex, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob };

package/dist/rinex.d.ts

@@ -182,6 +182,54 @@ interface Nav4Input {
  */
 declare function writeRinexNav4(nav: Nav4Input): string;
 
+/**
+ * Bias-SINEX (`.BIA`) parser — GNSS code/phase biases published by the IGS
+ * analysis centres. Two record kinds matter here:
+ *
+ *   - **DSB** differential signal bias (OBS1−OBS2), the classic inter-code
+ *     bias used for ionosphere/DCB corrections in SPP.
+ *   - **OSB** observable-specific (absolute) bias for a single OBS, the
+ *     ingredient PPP-AR needs: the *phase* OSBs are the satellite
+ *     fractional-cycle biases that make the ambiguities integer-recoverable.
+ *
+ * Values keep their file unit (`ns` for code/most phase biases, `cyc` for
+ * cycle-based phase biases); `biasMetres` converts ns → m via c.
+ */
+interface BiasRecord {
+    /** 'DSB' | 'OSB' | 'ISB' | … */
+    type: string;
+    /** Satellite PRN (e.g. 'G01', 'E11'); '' for a pure station bias. */
+    prn: string;
+    /** Station (9-char), '' for satellite biases. */
+    station: string;
+    /** First observable code (e.g. 'C1W', 'L1C'). */
+    obs1: string;
+    /** Second observable (DSB only; '' for OSB). */
+    obs2: string;
+    /** Validity start / end (GPS-scale ms); ±Infinity when open. */
+    startMs: number;
+    endMs: number;
+    /** Estimated value in the file unit. */
+    value: number;
+    /** File unit ('ns' | 'cyc' | …). */
+    unit: string;
+}
+interface BiasSinex {
+    records: BiasRecord[];
+    /** All satellite records grouped by PRN (station === ''). */
+    bySat: Map<string, BiasRecord[]>;
+}
+/** Parse a Bias-SINEX file. */
+declare function parseBiasSinex(text: string): BiasSinex;
+/** A satellite bias record's value in metres (ns → m via c; cyc left as-is). */
+declare function biasMetres(r: BiasRecord): number;
+/**
+ * Look up a satellite bias: a DSB by its (obs1,obs2) pair, or an OSB by obs1
+ * alone (pass obs2 = undefined), valid at `tMs` (default: any). Returns the
+ * record or null.
+ */
+declare function findSatBias(bias: BiasSinex, prn: string, obs1: string, obs2?: string, tMs?: number): BiasRecord | null;
+
 /**
  * RINEX 3.04 / 4.01 observation file writer.
  *
@@ -263,4 +311,4 @@ declare function createGzipLineSink(): {
  */
 declare function stationHeaderLines(header: RinexHeader): string[];
 
-export { type CompactEpoch, type CrxField, type DiffState, EMPTY_WARNINGS, Ephemeris, type Nav4Input, NavHeader, NavResult, RinexCnavEphemeris, RinexHeader, type RinexWarning, type RinexWarnings, WarningAccumulator, type WarningSeverity, type WriteCrxOptions, createGzipLineSink, crxDecompress, crxRepair, fmtD, fmtF, hdrLine, padL, padR, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob };
+export { type BiasRecord, type BiasSinex, type CompactEpoch, type CrxField, type DiffState, EMPTY_WARNINGS, Ephemeris, type Nav4Input, NavHeader, NavResult, RinexCnavEphemeris, RinexHeader, type RinexWarning, type RinexWarnings, WarningAccumulator, type WarningSeverity, type WriteCrxOptions, biasMetres, createGzipLineSink, crxDecompress, crxRepair, findSatBias, fmtD, fmtF, hdrLine, padL, padR, parseBiasSinex, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob };

package/dist/rinex.js

@@ -1,12 +1,15 @@
 import {
   EMPTY_WARNINGS,
   WarningAccumulator,
+  biasMetres,
   createGzipLineSink,
+  findSatBias,
   fmtD,
   fmtF,
   hdrLine,
   padL,
   padR,
+  parseBiasSinex,
   parseIonex,
   parseNavFile,
   stationHeaderLines,
@@ -17,7 +20,7 @@ import {
   writeRinexNav,
   writeRinexNav4,
   writeRinexObsBlob
-} from "./chunk-KDM2NVBO.js";
+} from "./chunk-5RNDQQ6J.js";
 import "./chunk-726LQBGM.js";
 import "./chunk-IQ5OIMQD.js";
 import {
@@ -40,15 +43,18 @@ export {
   EMPTY_WARNINGS,
   SYSTEM_ORDER,
   WarningAccumulator,
+  biasMetres,
   clkBias,
   createGzipLineSink,
   crxDecompress,
   crxRepair,
+  findSatBias,
   fmtD,
   fmtF,
   hdrLine,
   padL,
   padR,
+  parseBiasSinex,
   parseClk,
   parseCrxDataLine,
   parseIonex,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnss-js",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "Comprehensive GNSS library for JavaScript — time scales, coordinates, RINEX parsing, RTCM3 decoding, orbit computation, and signal analysis",
   "type": "module",
   "sideEffects": false,