gnss-js 2.10.1 → 2.12.0

package/dist/positioning.d.cts

@@ -1,12 +1,12 @@
-import { E as Ephemeris } from './nav-DImXUdbp.cjs';
+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';
 import './ephemeris-BAnBLLB9.cjs';
 import './ecef-CF0uAysr.cjs';
-import './nav-BYmYoh9A.cjs';
+import './nav-CvZXmumD.cjs';
 
 /**
  * Klobuchar broadcast ionospheric model (IS-GPS-200, 20.3.3.5.2.5).
@@ -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,12 +1,12 @@
-import { E as Ephemeris } from './nav-DImXUdbp.js';
+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';
 import './ephemeris-BAnBLLB9.js';
 import './ecef-CF0uAysr.js';
-import './nav-CN8rxL4h.js';
+import './nav-D2DFlVpa.js';
 
 /**
  * Klobuchar broadcast ionospheric model (IS-GPS-200, 20.3.3.5.2.5).
@@ -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,8 +41,8 @@ import {
   sunEcef,
   toRtkEpoch,
   wlWavelength
-} from "./chunk-K3GLUWZI.js";
-import "./chunk-WQX354KD.js";
+} from "./chunk-RWFJEVLJ.js";
+import "./chunk-H3AKFD25.js";
 import "./chunk-7T5DLVZL.js";
 import "./chunk-HVXYFUCB.js";
 import "./chunk-CVCTRIWU.js";
@@ -50,7 +50,7 @@ import "./chunk-37QNKGTC.js";
 import "./chunk-LEEU5OIO.js";
 import "./chunk-6FAL6P4G.js";
 import "./chunk-GPEP67TG.js";
-import "./chunk-YUW33VXK.js";
+import "./chunk-HUXQABJI.js";
 import "./chunk-V2D5KUKH.js";
 import "./chunk-FIEWO4J4.js";
 export {