gnss-js 2.11.0 → 2.12.0

package/dist/positioning.d.cts

@@ -1,6 +1,6 @@
 import { E as Ephemeris } from './nav-COp0Vmlw.cjs';
 import { DopValues } from './orbit.cjs';
-import { I as IonexGrid, C as ClkFile, S as Sp3File } from './clk-DGVBGRzA.cjs';
+import { I as IonexGrid, C as ClkFile, S as SatOsbTable, b as Sp3File } from './bias-sinex-OGMw9xEZ.cjs';
 import { AntexFile } from './antex.cjs';
 import { a as ObsEpoch } from './msm-DWtoTvx2.cjs';
 import { a as HasOrbitCorrection, b as HasClockCorrection } from './has-BaXnQarR.cjs';
@@ -690,6 +690,14 @@ interface LambdaResult {
      * typically cap it (RTKLIB uses 999.9) before thresholding.
      */
     ratio: number;
+    /**
+     * Bootstrapped success rate of the decorrelated ambiguities,
+     * Π (2Φ(1/(2σᵢ)) − 1) over the conditional standard deviations σᵢ —
+     * a lower bound on the probability that the integer solution is right
+     * (Teunissen 1998). Unlike the ratio, it depends only on the model's
+     * precision, so it refuses fixes the float solution can't yet support.
+     */
+    successRate: number;
 }
 /**
  * LAMBDA/MLAMBDA integer least-squares estimation (RTKLIB `lambda`):
@@ -1068,6 +1076,11 @@ interface PppSatObs {
      * up satellite code (OSB) biases from an SSR/HAS source; optional. */
     code1?: string;
     code2?: string;
+    /** RINEX-3 tracking codes of the two *carriers* (e.g. '1C','2W'), for
+     *  satellite phase-bias (OSB) lookup when they differ from the code's
+     *  (GPS: C1W code with L1C phase). Default: `code1` / `code2`. */
+    phase1?: string;
+    phase2?: string;
     /** True if a cycle slip is flagged on either band (LLI or detected). */
     slip: boolean;
 }
@@ -1110,6 +1123,37 @@ interface PppOptions {
      * instead of the SP3 5-minute clocks — the dominant PPP accuracy term.
      * Satellites/epochs absent from the CLK fall back to the SP3 clock. */
     clk?: ClkFile;
+    /** Satellite observable-specific biases (code + phase OSB) consistent with
+     *  the orbit/clock product — e.g. the CNES "ABS" biases that accompany GFZ
+     *  rapid products. With phase OSBs the float ambiguities keep their integer
+     *  nature (between satellites), which is what PPP-AR (`fixPppPosition`)
+     *  needs. Used with an Sp3File; a custom source supplies its own biases. */
+    osb?: SatOsbTable;
+    /**
+     * Integer ambiguity resolution (PPP-AR). Needs satellite phase biases
+     * (`osb`, or a source with `phaseBias`) — without them the ambiguities
+     * aren't integers and this is ignored. Every `everyS` seconds the
+     * converged ambiguities are resolved (wide-lane by rounding, narrow-lane
+     * by LAMBDA, between satellites of a constellation) and, if the fix is
+     * accepted, the epoch gets an ambiguity-fixed position next to the float
+     * one. `true` uses the defaults.
+     */
+    ar?: boolean | {
+        /** LAMBDA ratio test threshold. Default 3. */
+        ratio?: number;
+        /** Max wide-lane fractional part (cycles). Default 0.15. */
+        wlThreshold?: number;
+        /** Min arc age before an ambiguity is a candidate (s). Default 600. */
+        minArcS?: number;
+        /** Attempt interval (s). Default 120. */
+        everyS?: number;
+        /** Min bootstrapped success rate. Default 0.999. */
+        successRate?: number;
+        /** Min between-satellite ambiguities in a fix. Default 5. */
+        minFixed?: number;
+        /** Max χ²/dof of the float ambiguities vs the integers. Default 20. */
+        maxChi2?: number;
+    };
 }
 interface PppEpochResult {
     timeMs: number;
@@ -1125,6 +1169,10 @@ interface PppEpochResult {
     ztdHydrostatic: number;
     /** RMS of post-fit phase residuals this epoch (m). */
     phaseResRms: number;
+    /** PPP-AR: between-satellite ambiguities fixed (0 = float only). */
+    nFixed: number;
+    /** PPP-AR: the ambiguity-fixed position, when the latest attempt fixed. */
+    fixedPosition: [number, number, number] | null;
 }
 interface PppSolution {
     /** Final estimated ECEF position (m). */
@@ -1144,6 +1192,17 @@ interface PppSolution {
     convergenceSec: number | null;
     /** Final 3D error vs ground truth (m), if given. */
     finalError3d: number | null;
+    /** PPP-AR summary, when `ar` was requested with a phase-bias product. */
+    ar?: {
+        /** Seconds from the first epoch to the first accepted fix (null: none). */
+        firstFixSec: number | null;
+        /** Ambiguities fixed at the end (0: the session ends float). */
+        nFixedEnd: number;
+        /** The ambiguity-fixed position at the end, or null. */
+        position: [number, number, number] | null;
+        /** Share of epochs with at least one ambiguity fixed. */
+        fixedEpochShare: number;
+    };
     /** Per-arc converged float ambiguities — one per continuous satellite
      * tracking arc — the raw material for ambiguity resolution (PPP-AR). */
     arcs: PppArc[];
@@ -1212,6 +1271,10 @@ interface PppEphemerisSource {
      *  corrected code is `observed − codeBias`. SP3/CLK sources omit this (the
      *  float ambiguity + broadcast clock reference absorb it). */
     codeBias?(prn: string, signalCode: string, tEmitMs: number): number | null;
+    /** Optional satellite *phase* bias (m) for a carrier tracking code
+     *  ('1C','2W'…): the corrected carrier is `observed − phaseBias`. Only
+     *  integer-clock products (for PPP-AR) provide these. */
+    phaseBias?(prn: string, signalCode: string, tEmitMs: number): number | null;
 }
 /** Default source: SP3 orbits + clocks, with optional high-rate CLK. Velocity
  *  is a central finite difference (±0.5 s); the clock prefers the high-rate CLK
@@ -1219,7 +1282,10 @@ interface PppEphemerisSource {
 declare class Sp3EphemerisSource implements PppEphemerisSource {
     private readonly sp3;
     private readonly clk?;
-    constructor(sp3: Sp3File, clk?: ClkFile | undefined);
+    private readonly osb?;
+    constructor(sp3: Sp3File, clk?: ClkFile | undefined, osb?: SatOsbTable | undefined);
+    codeBias?: PppEphemerisSource['codeBias'];
+    phaseBias?: PppEphemerisSource['phaseBias'];
     satState(prn: string, tEmitMs: number): SatSample | null;
 }
 /**
@@ -1248,6 +1314,16 @@ declare class PppEngine {
     private arcs;
     private arcSnap;
     private mwState;
+    /** Previous epoch's phase terms per satellite, for the time-differenced
+     *  (clock-free) cycle-slip test. */
+    private tdPrev;
+    /** Consecutive gated-out phase updates per satellite. */
+    private phaseRejects;
+    /** PPP-AR: the latest accepted fix (null: float). */
+    private lastFix;
+    private lastArMs;
+    private firstFixMs;
+    private fixedEpochs;
     private series;
     private ei;
     private t0;
@@ -1265,6 +1341,16 @@ declare class PppEngine {
     private clockOf;
     /** Process one epoch, carrying the filter forward; returns its result. */
     process(epoch: PppEpoch): PppEpochResult;
+    /**
+     * PPP-AR. Every `everyS`, resolve the converged ambiguities of the
+     * satellites in view (between satellites of one constellation) and, when
+     * the fix passes the ratio, success-rate and χ² tests, condition the
+     * float position on it ({@link fixPppPosition}). The float filter itself
+     * is never constrained — a wrong fix can't contaminate later epochs, and
+     * the next attempt starts clean. Between attempts the last fix carries
+     * over (static) or is dropped (kinematic).
+     */
+    private tryFix;
     /** Finalise the session: capture the AR state, flush open arcs, assemble. */
     solution(): PppSolution;
 }
@@ -1371,6 +1457,18 @@ interface ArOptions {
     wlThreshold?: number;
     /** Min LAMBDA ratio to accept the narrow-lane fix. Default 3. */
     ratioThreshold?: number;
+    /** Partial fixing: when the full set fails the ratio test, drop the
+     *  lowest-elevation satellite and retry while more than this many
+     *  between-satellite ambiguities remain. Default 4. */
+    minPartial?: number;
+    /** Min bootstrapped success rate (0–1) to accept a fix, besides the
+     *  ratio test. Default 0 (ratio test only). */
+    minSuccessRate?: number;
+    /** `fixPppPosition`: min between-satellite ambiguities to accept. Default 1. */
+    minFixed?: number;
+    /** `fixPppPosition`: max χ²/dof of the float ambiguities against the fixed
+     *  integers (a wrong fix sits many σ away). Default Infinity. */
+    maxChi2?: number;
 }
 interface ArFixedSat {
     prn: string;
@@ -1378,15 +1476,22 @@ interface ArFixedSat {
     n1: number;
     /** Fixed IF ambiguity (m). */
     aIF: number;
+    /** PRN of this satellite's single-difference reference (itself for a
+     *  reference satellite). */
+    ref: string;
 }
 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). */
+    /** Reference PRN of the first constellation (whose absolute N1 stays
+     *  float); see `refPrns` for all. */
     refPrn: string | null;
-    /** Fixed satellites (includes the reference with its float-rounded N1). */
+    /** One reference per constellation — differences are taken within a
+     *  constellation, where the receiver phase bias is common. */
+    refPrns: string[];
+    /** Satellites in the fix (references included, with a float-rounded N1). */
     sats: ArFixedSat[];
     /** PRNs whose wide-lane did not round confidently (excluded). */
     rejectedWl: string[];
@@ -1397,6 +1502,11 @@ interface ArResult {
  * `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).
+ *
+ * Everything is differenced between satellites of the same constellation
+ * (one reference each, the highest), which removes the receiver's
+ * wide-lane and narrow-lane phase biases — those differ per constellation
+ * and per receiver, so an undifferenced ambiguity is never an integer.
  */
 declare function resolvePppAmbiguities(sats: ArSat[], Qaif: Float64Array, opts?: ArOptions): ArResult;
 interface FixedPositionResult {

package/dist/positioning.d.ts

@@ -1,6 +1,6 @@
 import { E as Ephemeris } from './nav-COp0Vmlw.js';
 import { DopValues } from './orbit.js';
-import { I as IonexGrid, C as ClkFile, S as Sp3File } from './clk-DGVBGRzA.js';
+import { I as IonexGrid, C as ClkFile, S as SatOsbTable, b as Sp3File } from './bias-sinex-OGMw9xEZ.js';
 import { AntexFile } from './antex.js';
 import { a as ObsEpoch } from './msm-CcQJV3PC.js';
 import { a as HasOrbitCorrection, b as HasClockCorrection } from './has-BaXnQarR.js';
@@ -690,6 +690,14 @@ interface LambdaResult {
      * typically cap it (RTKLIB uses 999.9) before thresholding.
      */
     ratio: number;
+    /**
+     * Bootstrapped success rate of the decorrelated ambiguities,
+     * Π (2Φ(1/(2σᵢ)) − 1) over the conditional standard deviations σᵢ —
+     * a lower bound on the probability that the integer solution is right
+     * (Teunissen 1998). Unlike the ratio, it depends only on the model's
+     * precision, so it refuses fixes the float solution can't yet support.
+     */
+    successRate: number;
 }
 /**
  * LAMBDA/MLAMBDA integer least-squares estimation (RTKLIB `lambda`):
@@ -1068,6 +1076,11 @@ interface PppSatObs {
      * up satellite code (OSB) biases from an SSR/HAS source; optional. */
     code1?: string;
     code2?: string;
+    /** RINEX-3 tracking codes of the two *carriers* (e.g. '1C','2W'), for
+     *  satellite phase-bias (OSB) lookup when they differ from the code's
+     *  (GPS: C1W code with L1C phase). Default: `code1` / `code2`. */
+    phase1?: string;
+    phase2?: string;
     /** True if a cycle slip is flagged on either band (LLI or detected). */
     slip: boolean;
 }
@@ -1110,6 +1123,37 @@ interface PppOptions {
      * instead of the SP3 5-minute clocks — the dominant PPP accuracy term.
      * Satellites/epochs absent from the CLK fall back to the SP3 clock. */
     clk?: ClkFile;
+    /** Satellite observable-specific biases (code + phase OSB) consistent with
+     *  the orbit/clock product — e.g. the CNES "ABS" biases that accompany GFZ
+     *  rapid products. With phase OSBs the float ambiguities keep their integer
+     *  nature (between satellites), which is what PPP-AR (`fixPppPosition`)
+     *  needs. Used with an Sp3File; a custom source supplies its own biases. */
+    osb?: SatOsbTable;
+    /**
+     * Integer ambiguity resolution (PPP-AR). Needs satellite phase biases
+     * (`osb`, or a source with `phaseBias`) — without them the ambiguities
+     * aren't integers and this is ignored. Every `everyS` seconds the
+     * converged ambiguities are resolved (wide-lane by rounding, narrow-lane
+     * by LAMBDA, between satellites of a constellation) and, if the fix is
+     * accepted, the epoch gets an ambiguity-fixed position next to the float
+     * one. `true` uses the defaults.
+     */
+    ar?: boolean | {
+        /** LAMBDA ratio test threshold. Default 3. */
+        ratio?: number;
+        /** Max wide-lane fractional part (cycles). Default 0.15. */
+        wlThreshold?: number;
+        /** Min arc age before an ambiguity is a candidate (s). Default 600. */
+        minArcS?: number;
+        /** Attempt interval (s). Default 120. */
+        everyS?: number;
+        /** Min bootstrapped success rate. Default 0.999. */
+        successRate?: number;
+        /** Min between-satellite ambiguities in a fix. Default 5. */
+        minFixed?: number;
+        /** Max χ²/dof of the float ambiguities vs the integers. Default 20. */
+        maxChi2?: number;
+    };
 }
 interface PppEpochResult {
     timeMs: number;
@@ -1125,6 +1169,10 @@ interface PppEpochResult {
     ztdHydrostatic: number;
     /** RMS of post-fit phase residuals this epoch (m). */
     phaseResRms: number;
+    /** PPP-AR: between-satellite ambiguities fixed (0 = float only). */
+    nFixed: number;
+    /** PPP-AR: the ambiguity-fixed position, when the latest attempt fixed. */
+    fixedPosition: [number, number, number] | null;
 }
 interface PppSolution {
     /** Final estimated ECEF position (m). */
@@ -1144,6 +1192,17 @@ interface PppSolution {
     convergenceSec: number | null;
     /** Final 3D error vs ground truth (m), if given. */
     finalError3d: number | null;
+    /** PPP-AR summary, when `ar` was requested with a phase-bias product. */
+    ar?: {
+        /** Seconds from the first epoch to the first accepted fix (null: none). */
+        firstFixSec: number | null;
+        /** Ambiguities fixed at the end (0: the session ends float). */
+        nFixedEnd: number;
+        /** The ambiguity-fixed position at the end, or null. */
+        position: [number, number, number] | null;
+        /** Share of epochs with at least one ambiguity fixed. */
+        fixedEpochShare: number;
+    };
     /** Per-arc converged float ambiguities — one per continuous satellite
      * tracking arc — the raw material for ambiguity resolution (PPP-AR). */
     arcs: PppArc[];
@@ -1212,6 +1271,10 @@ interface PppEphemerisSource {
      *  corrected code is `observed − codeBias`. SP3/CLK sources omit this (the
      *  float ambiguity + broadcast clock reference absorb it). */
     codeBias?(prn: string, signalCode: string, tEmitMs: number): number | null;
+    /** Optional satellite *phase* bias (m) for a carrier tracking code
+     *  ('1C','2W'…): the corrected carrier is `observed − phaseBias`. Only
+     *  integer-clock products (for PPP-AR) provide these. */
+    phaseBias?(prn: string, signalCode: string, tEmitMs: number): number | null;
 }
 /** Default source: SP3 orbits + clocks, with optional high-rate CLK. Velocity
  *  is a central finite difference (±0.5 s); the clock prefers the high-rate CLK
@@ -1219,7 +1282,10 @@ interface PppEphemerisSource {
 declare class Sp3EphemerisSource implements PppEphemerisSource {
     private readonly sp3;
     private readonly clk?;
-    constructor(sp3: Sp3File, clk?: ClkFile | undefined);
+    private readonly osb?;
+    constructor(sp3: Sp3File, clk?: ClkFile | undefined, osb?: SatOsbTable | undefined);
+    codeBias?: PppEphemerisSource['codeBias'];
+    phaseBias?: PppEphemerisSource['phaseBias'];
     satState(prn: string, tEmitMs: number): SatSample | null;
 }
 /**
@@ -1248,6 +1314,16 @@ declare class PppEngine {
     private arcs;
     private arcSnap;
     private mwState;
+    /** Previous epoch's phase terms per satellite, for the time-differenced
+     *  (clock-free) cycle-slip test. */
+    private tdPrev;
+    /** Consecutive gated-out phase updates per satellite. */
+    private phaseRejects;
+    /** PPP-AR: the latest accepted fix (null: float). */
+    private lastFix;
+    private lastArMs;
+    private firstFixMs;
+    private fixedEpochs;
     private series;
     private ei;
     private t0;
@@ -1265,6 +1341,16 @@ declare class PppEngine {
     private clockOf;
     /** Process one epoch, carrying the filter forward; returns its result. */
     process(epoch: PppEpoch): PppEpochResult;
+    /**
+     * PPP-AR. Every `everyS`, resolve the converged ambiguities of the
+     * satellites in view (between satellites of one constellation) and, when
+     * the fix passes the ratio, success-rate and χ² tests, condition the
+     * float position on it ({@link fixPppPosition}). The float filter itself
+     * is never constrained — a wrong fix can't contaminate later epochs, and
+     * the next attempt starts clean. Between attempts the last fix carries
+     * over (static) or is dropped (kinematic).
+     */
+    private tryFix;
     /** Finalise the session: capture the AR state, flush open arcs, assemble. */
     solution(): PppSolution;
 }
@@ -1371,6 +1457,18 @@ interface ArOptions {
     wlThreshold?: number;
     /** Min LAMBDA ratio to accept the narrow-lane fix. Default 3. */
     ratioThreshold?: number;
+    /** Partial fixing: when the full set fails the ratio test, drop the
+     *  lowest-elevation satellite and retry while more than this many
+     *  between-satellite ambiguities remain. Default 4. */
+    minPartial?: number;
+    /** Min bootstrapped success rate (0–1) to accept a fix, besides the
+     *  ratio test. Default 0 (ratio test only). */
+    minSuccessRate?: number;
+    /** `fixPppPosition`: min between-satellite ambiguities to accept. Default 1. */
+    minFixed?: number;
+    /** `fixPppPosition`: max χ²/dof of the float ambiguities against the fixed
+     *  integers (a wrong fix sits many σ away). Default Infinity. */
+    maxChi2?: number;
 }
 interface ArFixedSat {
     prn: string;
@@ -1378,15 +1476,22 @@ interface ArFixedSat {
     n1: number;
     /** Fixed IF ambiguity (m). */
     aIF: number;
+    /** PRN of this satellite's single-difference reference (itself for a
+     *  reference satellite). */
+    ref: string;
 }
 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). */
+    /** Reference PRN of the first constellation (whose absolute N1 stays
+     *  float); see `refPrns` for all. */
     refPrn: string | null;
-    /** Fixed satellites (includes the reference with its float-rounded N1). */
+    /** One reference per constellation — differences are taken within a
+     *  constellation, where the receiver phase bias is common. */
+    refPrns: string[];
+    /** Satellites in the fix (references included, with a float-rounded N1). */
     sats: ArFixedSat[];
     /** PRNs whose wide-lane did not round confidently (excluded). */
     rejectedWl: string[];
@@ -1397,6 +1502,11 @@ interface ArResult {
  * `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).
+ *
+ * Everything is differenced between satellites of the same constellation
+ * (one reference each, the highest), which removes the receiver's
+ * wide-lane and narrow-lane phase biases — those differ per constellation
+ * and per receiver, so an undifferenced ambiguity is never an integer.
  */
 declare function resolvePppAmbiguities(sats: ArSat[], Qaif: Float64Array, opts?: ArOptions): ArResult;
 interface FixedPositionResult {

package/dist/positioning.js

@@ -41,7 +41,7 @@ import {
   sunEcef,
   toRtkEpoch,
   wlWavelength
-} from "./chunk-UMINQTMK.js";
+} from "./chunk-RWFJEVLJ.js";
 import "./chunk-H3AKFD25.js";
 import "./chunk-7T5DLVZL.js";
 import "./chunk-HVXYFUCB.js";

package/dist/rinex.cjs

@@ -22,6 +22,7 @@ var rinex_exports = {};
 __export(rinex_exports, {
   EMPTY_WARNINGS: () => EMPTY_WARNINGS,
   SYSTEM_ORDER: () => SYSTEM_ORDER,
+  SatOsbTable: () => SatOsbTable,
   WarningAccumulator: () => WarningAccumulator,
   biasMetres: () => biasMetres,
   clkBias: () => clkBias,
@@ -59,20 +60,14 @@ module.exports = __toCommonJS(rinex_exports);
 // 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) {
@@ -782,6 +777,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));
@@ -931,7 +935,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] ?? [];
@@ -956,10 +960,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 = [];
@@ -1050,6 +1052,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);
@@ -1067,10 +1070,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;
@@ -1091,11 +1095,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";
@@ -2658,6 +2658,50 @@ function findSatBias(bias, prn, obs1, obs2, tMs) {
   }
   return null;
 }
+var SatOsbTable = class {
+  byKey = /* @__PURE__ */ new Map();
+  constructor(bias) {
+    const recs = Array.isArray(bias) ? bias : bias.records;
+    const groups = /* @__PURE__ */ new Map();
+    for (const r of recs) {
+      if (r.type !== "OSB" || !r.prn || r.station) continue;
+      if (r.unit !== "ns") continue;
+      const k = `${r.prn} ${r.obs1}`;
+      let g = groups.get(k);
+      if (!g) groups.set(k, g = []);
+      g.push(r);
+    }
+    for (const [k, g] of groups) {
+      g.sort((a, b) => a.startMs - b.startMs);
+      this.byKey.set(k, {
+        start: Float64Array.from(g, (r) => r.startMs),
+        end: Float64Array.from(g, (r) => r.endMs),
+        m: Float64Array.from(g, biasMetres)
+      });
+    }
+  }
+  /** Whether any phase (L…) OSB is present — i.e. the product supports AR. */
+  get hasPhase() {
+    for (const k of this.byKey.keys())
+      if (k.split(" ")[1][0] === "L") return true;
+    return false;
+  }
+  /** OSB (m) of `prn`'s observable `obs` (e.g. 'C1W', 'L2W') at `tMs`;
+   *  null when the product has none valid then. */
+  get(prn, obs, tMs) {
+    const e = this.byKey.get(`${prn} ${obs}`) ?? this.byKey.get(`${prn} ${obs.slice(0, 2)}X`);
+    if (!e) return null;
+    let lo = 0;
+    let hi = e.start.length - 1;
+    if (tMs < e.start[0]) return null;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (e.start[mid] <= tMs) lo = mid;
+      else hi = mid - 1;
+    }
+    return tMs <= e.end[lo] ? e.m[lo] : null;
+  }
+};
 
 // src/rinex/obs-writer-common.ts
 function createGzipLineSink() {
@@ -3049,6 +3093,7 @@ function writeRinex4ObsBlob(header, epochs, obsTypes) {
 0 && (module.exports = {
   EMPTY_WARNINGS,
   SYSTEM_ORDER,
+  SatOsbTable,
   WarningAccumulator,
   biasMetres,
   clkBias,

package/dist/rinex.d.cts

@@ -2,7 +2,7 @@ import { R as RinexHeader } from './parser-JPjjFgeP.cjs';
 export { E as EpochSummary, P as ParseOptions, a as RinexResult, b as RinexStats, S as SYSTEM_ORDER, c as SatObsCallback, p as parseRinexStream, s as systemCmp, d as systemName } from './parser-JPjjFgeP.cjs';
 import { b as NavResult, N as NavHeader, E as Ephemeris, R as RinexCnavEphemeris, B as BdsCnavEphemeris } from './nav-COp0Vmlw.cjs';
 export { a as BdsCnavMessage, G as GlonassEphemeris, K as KeplerEphemeris, p as parseNavFile } from './nav-COp0Vmlw.cjs';
-export { C as ClkFile, I as IonexGrid, S as Sp3File, a as Sp3Sample, c as clkBias, p as parseClk, b as parseIonex, d as parseSp3, s as sp3Position } from './clk-DGVBGRzA.cjs';
+export { B as BiasRecord, a as BiasSinex, C as ClkFile, I as IonexGrid, S as SatOsbTable, b as Sp3File, c as Sp3Sample, d as biasMetres, e as clkBias, f as findSatBias, p as parseBiasSinex, g as parseClk, h as parseIonex, i as parseSp3, s as sp3Position } from './bias-sinex-OGMw9xEZ.cjs';
 
 /**
  * Compact RINEX (Hatanaka / CRX) decompression utilities.
@@ -185,54 +185,6 @@ 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.
  *
@@ -323,4 +275,4 @@ declare function createGzipLineSink(): {
  */
 declare function stationHeaderLines(header: RinexHeader): string[];
 
-export { BdsCnavEphemeris, 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, modalIntervalS, padL, padR, parseBiasSinex, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob };
+export { BdsCnavEphemeris, 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, modalIntervalS, padL, padR, parseCrxDataLine, stationHeaderLines, writeCrx, writeModernObsBlob, writeRinex2ObsBlob, writeRinex4ObsBlob, writeRinexNav, writeRinexNav4, writeRinexObsBlob };