gnss-js 1.23.0 → 1.25.0

package/dist/positioning.d.cts

@@ -1,5 +1,6 @@
 import { E as Ephemeris } from './nav-DImXUdbp.cjs';
 import { DopValues } from './orbit.cjs';
+import { I as IonexGrid } from './ionex-DaW5x9nq.cjs';
 import './ephemeris-Ohl6NAfw.cjs';
 import './ecef-CF0uAysr.cjs';
 import './nav-BYmYoh9A.cjs';
@@ -34,6 +35,52 @@ interface KlobucharCoeffs {
  */
 declare function klobucharDelay(coeffs: KlobucharCoeffs, latRad: number, lonRad: number, azRad: number, elRad: number, gpsTowSec: number): number;
 
+/**
+ * Slant ionospheric delay from a Global Ionosphere Map (IONEX/GIM).
+ *
+ * A GIM gives vertical TEC on an hourly lat/lon grid (see
+ * {@link parseIonex}). For single-frequency positioning this is a much
+ * stronger correction than the broadcast Klobuchar model — GIMs capture
+ * ~80–90% of the true ionosphere versus Klobuchar's ~50% — so feeding
+ * `solveSpp` a GIM (the `gim` option) collapses most of the residual
+ * height bias a single-frequency solution otherwise carries.
+ *
+ * The evaluation is the standard thin-shell recipe: pierce the shell at
+ * {@link H_ION}, interpolate vertical TEC there (bilinear in space,
+ * linear in time), map to slant with the obliquity factor, and convert
+ * TEC → L1 group delay. The result is the delay on GPS L1; `solveSpp`
+ * scales it to each system's primary frequency by (f_L1/f)².
+ */
+
+/**
+ * L1 group delay per unit slant TEC: 40.3 · 10¹⁶ / f_L1² (m per TECU).
+ * 40.3 m·Hz²/(el/m²), one TECU = 10¹⁶ el/m². ≈ 0.1624 m/TECU.
+ */
+declare const IONO_L1_M_PER_TECU: number;
+/**
+ * Space- and time-interpolated vertical TEC (TECU) at `timeMs`, or null
+ * outside the map's time span or where the grid marks no value.
+ *
+ * IGS GIMs are global, so spatial coverage is total; a pierce point is
+ * bilinearly interpolated and clamped to the nearest edge cell rather
+ * than rejected. Null therefore signals a time gap or a no-value cell,
+ * not an out-of-area position.
+ */
+declare function gimVerticalTec(grid: IonexGrid, timeMs: number, latDeg: number, lonDeg: number): number | null;
+/**
+ * Slant ionospheric group delay on GPS L1 (m) from a GIM, or null when
+ * the pierce point falls outside the map's coverage in space or time.
+ *
+ * @param grid   Parsed IONEX grid ({@link parseIonex}).
+ * @param latRad Receiver geodetic latitude (radians).
+ * @param lonRad Receiver geodetic longitude (radians).
+ * @param azRad  Satellite azimuth (radians).
+ * @param elRad  Satellite elevation (radians).
+ * @param timeMs Epoch (ms). GIM epochs are UTC; a GPS-scale time differs
+ *   by leap seconds (~18 s), negligible against hourly maps.
+ */
+declare function gimSlantIonoDelayL1(grid: IonexGrid, latRad: number, lonRad: number, azRad: number, elRad: number, timeMs: number): number | null;
+
 /**
  * RTK positioning, stage 1: epoch-wise double-differenced (DD)
  * processing of a base/rover receiver pair.
@@ -54,7 +101,29 @@ declare function klobucharDelay(coeffs: KlobucharCoeffs, latRad: number, lonRad:
  *   (LAMBDA) needs the joint float ambiguity covariance — which the
  *   EKF maintains natively. This mirrors RTKLIB's float-filter
  *   structure (rtkpos.c), which the implementation was validated
- *   against; no integer fixing is attempted (`ratio` is reserved).
+ *   against.
+ *
+ * Stage 2 — integer ambiguity resolution (opt-in via
+ * `ambiguityResolution: 'instant'`): after each float update the
+ * engine extracts the DD ambiguity subvector and its joint covariance
+ * from the filter, runs MLAMBDA (`lambdaSearch`, a port of RTKLIB's
+ * lambda.c) and validates the best candidate with the ratio test
+ * (s₂/s₁ ≥ `ratioThreshold`, default 3.0 — RTKLIB's default). On
+ * acceptance the rover position is conditioned on the integer
+ * ambiguities (xa = x − P_xb·Q_b⁻¹·(b − ǎ), RTKLIB rtkpos.c
+ * `resamb_LAMBDA`) and reported as a FIXED solution; the filter state
+ * itself is *not* modified (instant, per-epoch fixing — RTKLIB's
+ * `armode=instantaneous`; continuous AR/fix-and-hold, which feed the
+ * fix back into the filter, are stage-3 continuity options). When the
+ * full set fails the ratio test, partial fixing retries after
+ * dropping the lowest-elevation ambiguity, one at a time, down to
+ * half the candidate set (and never below `minFixAmbiguities`) — an
+ * elevation-ordered subset walk in the spirit of RTKLIB demo5's
+ * satellite exclusion, floored so an unconverged float cannot buy a
+ * lucky ratio on a tiny subset. GLONASS ambiguities are excluded from
+ * fixing by
+ * default (DD IFB is only integer-safe across same-model receivers;
+ * enable with `glonassAr`).
  *
  * Differencing model: for satellites s and reference r observed by
  * rover R and base B, the DD pseudorange/phase cancels satellite
@@ -208,18 +277,65 @@ interface RtkFloatOptions {
     slipGateM?: number;
     /** Measurement-update relinearisations (IEKF). Default 2. */
     updateIterations?: number;
+    /**
+     * Integer ambiguity resolution: 'off' keeps the stage-1 float-only
+     * behaviour; 'instant' attempts a per-epoch LAMBDA fix after each
+     * float update (no state feedback — RTKLIB `armode=instantaneous`).
+     * Default 'off'.
+     */
+    ambiguityResolution?: 'off' | 'instant';
+    /** Ratio-test acceptance threshold (s₂/s₁). Default 3.0 (RTKLIB). */
+    ratioThreshold?: number;
+    /**
+     * Additional elevation mask (deg) for ambiguities entering the fix
+     * (RTKLIB `elmaskar`); 0 = use every measured ambiguity. Default 0.
+     */
+    arElevationMaskDeg?: number;
+    /**
+     * Include GLONASS FDMA ambiguities in the integer fix. Only sound
+     * across same-model receivers (differential IFB). Default false.
+     */
+    glonassAr?: boolean;
+    /**
+     * Partial fixing: when the full ambiguity set fails the ratio test,
+     * drop the lowest-elevation ambiguity and retry (elevation-ordered
+     * subset walk), never below half the candidates. Default true.
+     */
+    partialFixing?: boolean;
+    /** Minimum DD ambiguities to attempt/accept a fix. Default 4. */
+    minFixAmbiguities?: number;
 }
 interface RtkFloatSolution {
     /** Epoch, GPS-scale milliseconds. */
     timeMs: number;
-    /** Rover position, ECEF metres. */
+    /**
+     * Rover position, ECEF metres — the ambiguity-fixed position when
+     * `status === 'fixed'`, the float filter position otherwise.
+     */
     position: [number, number, number];
-    /** Float baseline rover − base, ECEF metres. */
+    /** Float baseline rover − base, ECEF metres (always the float). */
     floatBaseline: [number, number, number];
+    /**
+     * Solution quality: 'fixed' when LAMBDA passed the ratio test,
+     * 'float' when carrier ambiguities contributed but no (accepted)
+     * fix, 'dgnss' when the epoch was updated from code DDs only.
+     */
+    status: 'fixed' | 'float' | 'dgnss';
     /** Satellites contributing DD rows this epoch (incl. references). */
     nSats: number;
-    /** Ambiguity-validation ratio — undefined at stage 1 (no LAMBDA). */
+    /**
+     * Ambiguity-validation ratio (s₂/s₁ of the LAMBDA candidates,
+     * capped at 999.9 as RTKLIB): the accepted subset's ratio when
+     * fixed, the full-set ratio otherwise. Undefined when no fix was
+     * attempted (`ambiguityResolution: 'off'` or no eligible set).
+     */
     ratio?: number;
+    /** Number of integer-fixed DD ambiguities (when `status==='fixed'`). */
+    nFixed?: number;
+    /** Fixed baseline rover − base, ECEF metres (when fixed). */
+    fixedBaseline?: [number, number, number];
+    /** Integer DD ambiguity (cycles) per fixed PRN (when fixed). */
+    fixedAmbiguities?: Record<string, number>;
     /** Formal position sigmas (filter covariance), ECEF metres. */
     sigmas: [number, number, number];
     /** Float DD ambiguity (cycles) per non-reference PRN. */
@@ -262,6 +378,17 @@ declare class RtkFloatEngine {
      * transform of state and covariance (P' = T P Tᵀ).
      */
     private retarget;
+    /**
+     * Try to fix the ambiguity subset `idxs` (indices into `this.amb`):
+     * extract the float subvector b and covariance Q_b from the filter,
+     * run MLAMBDA and, without touching the filter state, condition the
+     * position on the best integer candidate,
+     *   xa = x − P_xb·Q_b⁻¹·(b − ǎ)
+     * (RTKLIB rtkpos.c `resamb_LAMBDA`). Returns null when Q_b is not
+     * positive definite / invertible or the search fails; ratio
+     * validation is the caller's job.
+     */
+    private tryFix;
     /**
      * Process one synchronized epoch (same nominal `timeMs` for both
      * receivers). Returns null until a first position can be
@@ -271,6 +398,88 @@ declare class RtkFloatEngine {
     process(rover: RtkEpochMeasurements, base: RtkEpochMeasurements, timeMs: number): RtkFloatSolution | null;
 }
 
+/**
+ * Integer ambiguity resolution: LAMBDA decorrelation + MLAMBDA
+ * integer least-squares search.
+ *
+ * Port of RTKLIB's `lambda.c` (demo5 / rtklibexplorer fork,
+ * src/lambda.c, Copyright (c) 2007-2008 T. Takasu, BSD-2-Clause),
+ * cross-checked against the reference papers where the C comments are
+ * thin:
+ *
+ * - [1] P.J.G. Teunissen, "The least-squares ambiguity decorrelation
+ *   adjustment: a method for fast GPS ambiguity estimation",
+ *   J. Geodesy 70, 65-82, 1995.
+ * - [2] X.-W. Chang, X. Yang, T. Zhou, "MLAMBDA: A modified LAMBDA
+ *   method for integer least-squares estimation", J. Geodesy 79,
+ *   552-565, 2005.
+ *
+ * Pipeline (identical to RTKLIB's `lambda()`):
+ * 1. LᵀDL factorization of the float covariance, Q = Lᵀ·diag(D)·L
+ *    with L unit lower triangular (RTKLIB's `LD`).
+ * 2. LAMBDA reduction [1]: integer Gauss transformations interleaved
+ *    with symmetric permutations until the transformed D is
+ *    (approximately) descending — producing a unimodular Z with
+ *    Qz = ZᵀQZ = Lᵀ·diag(D)·L far better conditioned than Q.
+ * 3. MLAMBDA search [2] in the decorrelated space: depth-first
+ *    enumeration over a shrinking ellipsoid, keeping the `m` smallest
+ *    residual quadratic forms (z−ž)ᵀQz⁻¹(z−ž).
+ * 4. Back-transform the candidates to the original space, a = Z⁻ᵀ·ž
+ *    (RTKLIB solves ZᵀF = E; Z is unimodular so F is exactly integer).
+ *
+ * Deviations from lambda.c:
+ * - matrices are `Float64Array` in the same column-major layout, with
+ *   allocation-failure paths dropped (JS throws instead),
+ * - failures (non-positive-definite Q, search loop overflow) return
+ *   `null` instead of a status code + stderr message,
+ * - back-transformed candidates are rounded to the nearest integer:
+ *   F = Z⁻ᵀ·ž is exactly integer in ℤ arithmetic and the rounding only
+ *   removes the ~1e-12 fuzz of the floating-point triangular solve,
+ * - the ratio s₂/s₁ used by the RTKLIB caller (`rtkpos.c`) is returned
+ *   alongside the candidates (∞ when s₁ = 0, i.e. noise-free input).
+ */
+/** Result of an integer least-squares search. */
+interface LambdaResult {
+    /**
+     * The `m` best integer candidate vectors (length n each), sorted by
+     * ascending residual quadratic form; `candidates[0]` is the integer
+     * least-squares minimizer.
+     */
+    candidates: Float64Array[];
+    /**
+     * Residual quadratic forms sᵢ = (a−ǎᵢ)ᵀQ⁻¹(a−ǎᵢ) matching
+     * `candidates`, ascending.
+     */
+    residuals: Float64Array;
+    /**
+     * Ratio-test statistic s₂/s₁ (second-best over best); `Infinity`
+     * when the best residual is exactly 0 (noise-free input). Callers
+     * typically cap it (RTKLIB uses 999.9) before thresholding.
+     */
+    ratio: number;
+}
+/**
+ * LAMBDA/MLAMBDA integer least-squares estimation (RTKLIB `lambda`):
+ * decorrelate the float ambiguities, search the `m` best integer
+ * vectors and back-transform them to the original space.
+ *
+ * @param a Float ambiguities (length ≥ n).
+ * @param Q Their covariance, n×n (symmetric — row/column-major agree).
+ * @param n Number of ambiguities.
+ * @param m Number of candidates to return (default 2: best +
+ *   second-best, what the ratio test needs).
+ * @returns Candidates + residuals + ratio, or null when Q is not
+ *   positive definite or the search does not terminate.
+ */
+declare function lambdaSearch(a: Float64Array, Q: Float64Array, n: number, m?: number): LambdaResult | null;
+/**
+ * LAMBDA reduction only (RTKLIB `lambda_reduction`): the unimodular
+ * decorrelation matrix Z (n×n, column-major) such that Qz = ZᵀQZ is
+ * (near-)diagonally dominant. Exposed for diagnostics/tests; returns
+ * null when Q is not positive definite.
+ */
+declare function lambdaReduction(Q: Float64Array, n: number): Float64Array | null;
+
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
  * ephemerides.
@@ -279,7 +488,7 @@ declare class RtkFloatEngine {
  * constellation (absorbing inter-system time offsets), satellite clock
  * polynomial + relativistic correction, broadcast group delay
  * (TGD/BGD), Sagnac (Earth-rotation) correction, elevation
- * masking/weighting, and a simple tropospheric model. Ionospheric
+ * masking/weighting, and a Saastamoinen tropospheric model. Ionospheric
  * delay can be modelled from the broadcast Klobuchar coefficients
  * (`iono` option) for single-frequency measurements; for metre-level
  * results prefer the iono-free combination (ionoFree helper) with
@@ -289,7 +498,7 @@ declare class RtkFloatEngine {
 interface SppOptions {
     /** Elevation mask in degrees (applied after the first pass). Default 10. */
     elevationMaskDeg?: number;
-    /** Apply the simple tropospheric model. Default true. */
+    /** Apply the Saastamoinen tropospheric model. Default true. */
     troposphere?: boolean;
     /** Maximum Gauss-Newton iterations. Default 15. */
     maxIterations?: number;
@@ -303,6 +512,15 @@ interface SppOptions {
      * iono-free combinations.
      */
     iono?: KlobucharCoeffs;
+    /**
+     * Global Ionosphere Map (IONEX/GIM, from `parseIonex`). When given it
+     * takes precedence over `iono`: the slant delay is read from the map
+     * (~80–90% of the true ionosphere vs Klobuchar's ~50%), falling back
+     * to `iono` — if also supplied — only where the map has no value for
+     * an epoch/cell (a time gap; global maps always cover space). Omit for
+     * iono-free input.
+     */
+    gim?: IonexGrid;
     /**
      * Apply the broadcast group-delay correction (GPS TGD, Galileo
      * BGD E5a/E1, BeiDou TGD1) to the satellite clock. Correct for
@@ -351,4 +569,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 DgnssOptions, type DgnssSolution, type EphemerisSource, type KlobucharCoeffs, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SppOptions, type SppSolution, ionoFree, klobucharDelay, satClockCorrection, solveDgnss, solveSpp, toRtkEpoch };
+export { type DgnssOptions, type DgnssSolution, type EphemerisSource, IONO_L1_M_PER_TECU, type KlobucharCoeffs, type LambdaResult, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SppOptions, type SppSolution, gimSlantIonoDelayL1, gimVerticalTec, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, satClockCorrection, solveDgnss, solveSpp, toRtkEpoch };

package/dist/positioning.d.ts

@@ -1,5 +1,6 @@
 import { E as Ephemeris } from './nav-DImXUdbp.js';
 import { DopValues } from './orbit.js';
+import { I as IonexGrid } from './ionex-DaW5x9nq.js';
 import './ephemeris-Ohl6NAfw.js';
 import './ecef-CF0uAysr.js';
 import './nav-CN8rxL4h.js';
@@ -34,6 +35,52 @@ interface KlobucharCoeffs {
  */
 declare function klobucharDelay(coeffs: KlobucharCoeffs, latRad: number, lonRad: number, azRad: number, elRad: number, gpsTowSec: number): number;
 
+/**
+ * Slant ionospheric delay from a Global Ionosphere Map (IONEX/GIM).
+ *
+ * A GIM gives vertical TEC on an hourly lat/lon grid (see
+ * {@link parseIonex}). For single-frequency positioning this is a much
+ * stronger correction than the broadcast Klobuchar model — GIMs capture
+ * ~80–90% of the true ionosphere versus Klobuchar's ~50% — so feeding
+ * `solveSpp` a GIM (the `gim` option) collapses most of the residual
+ * height bias a single-frequency solution otherwise carries.
+ *
+ * The evaluation is the standard thin-shell recipe: pierce the shell at
+ * {@link H_ION}, interpolate vertical TEC there (bilinear in space,
+ * linear in time), map to slant with the obliquity factor, and convert
+ * TEC → L1 group delay. The result is the delay on GPS L1; `solveSpp`
+ * scales it to each system's primary frequency by (f_L1/f)².
+ */
+
+/**
+ * L1 group delay per unit slant TEC: 40.3 · 10¹⁶ / f_L1² (m per TECU).
+ * 40.3 m·Hz²/(el/m²), one TECU = 10¹⁶ el/m². ≈ 0.1624 m/TECU.
+ */
+declare const IONO_L1_M_PER_TECU: number;
+/**
+ * Space- and time-interpolated vertical TEC (TECU) at `timeMs`, or null
+ * outside the map's time span or where the grid marks no value.
+ *
+ * IGS GIMs are global, so spatial coverage is total; a pierce point is
+ * bilinearly interpolated and clamped to the nearest edge cell rather
+ * than rejected. Null therefore signals a time gap or a no-value cell,
+ * not an out-of-area position.
+ */
+declare function gimVerticalTec(grid: IonexGrid, timeMs: number, latDeg: number, lonDeg: number): number | null;
+/**
+ * Slant ionospheric group delay on GPS L1 (m) from a GIM, or null when
+ * the pierce point falls outside the map's coverage in space or time.
+ *
+ * @param grid   Parsed IONEX grid ({@link parseIonex}).
+ * @param latRad Receiver geodetic latitude (radians).
+ * @param lonRad Receiver geodetic longitude (radians).
+ * @param azRad  Satellite azimuth (radians).
+ * @param elRad  Satellite elevation (radians).
+ * @param timeMs Epoch (ms). GIM epochs are UTC; a GPS-scale time differs
+ *   by leap seconds (~18 s), negligible against hourly maps.
+ */
+declare function gimSlantIonoDelayL1(grid: IonexGrid, latRad: number, lonRad: number, azRad: number, elRad: number, timeMs: number): number | null;
+
 /**
  * RTK positioning, stage 1: epoch-wise double-differenced (DD)
  * processing of a base/rover receiver pair.
@@ -54,7 +101,29 @@ declare function klobucharDelay(coeffs: KlobucharCoeffs, latRad: number, lonRad:
  *   (LAMBDA) needs the joint float ambiguity covariance — which the
  *   EKF maintains natively. This mirrors RTKLIB's float-filter
  *   structure (rtkpos.c), which the implementation was validated
- *   against; no integer fixing is attempted (`ratio` is reserved).
+ *   against.
+ *
+ * Stage 2 — integer ambiguity resolution (opt-in via
+ * `ambiguityResolution: 'instant'`): after each float update the
+ * engine extracts the DD ambiguity subvector and its joint covariance
+ * from the filter, runs MLAMBDA (`lambdaSearch`, a port of RTKLIB's
+ * lambda.c) and validates the best candidate with the ratio test
+ * (s₂/s₁ ≥ `ratioThreshold`, default 3.0 — RTKLIB's default). On
+ * acceptance the rover position is conditioned on the integer
+ * ambiguities (xa = x − P_xb·Q_b⁻¹·(b − ǎ), RTKLIB rtkpos.c
+ * `resamb_LAMBDA`) and reported as a FIXED solution; the filter state
+ * itself is *not* modified (instant, per-epoch fixing — RTKLIB's
+ * `armode=instantaneous`; continuous AR/fix-and-hold, which feed the
+ * fix back into the filter, are stage-3 continuity options). When the
+ * full set fails the ratio test, partial fixing retries after
+ * dropping the lowest-elevation ambiguity, one at a time, down to
+ * half the candidate set (and never below `minFixAmbiguities`) — an
+ * elevation-ordered subset walk in the spirit of RTKLIB demo5's
+ * satellite exclusion, floored so an unconverged float cannot buy a
+ * lucky ratio on a tiny subset. GLONASS ambiguities are excluded from
+ * fixing by
+ * default (DD IFB is only integer-safe across same-model receivers;
+ * enable with `glonassAr`).
  *
  * Differencing model: for satellites s and reference r observed by
  * rover R and base B, the DD pseudorange/phase cancels satellite
@@ -208,18 +277,65 @@ interface RtkFloatOptions {
     slipGateM?: number;
     /** Measurement-update relinearisations (IEKF). Default 2. */
     updateIterations?: number;
+    /**
+     * Integer ambiguity resolution: 'off' keeps the stage-1 float-only
+     * behaviour; 'instant' attempts a per-epoch LAMBDA fix after each
+     * float update (no state feedback — RTKLIB `armode=instantaneous`).
+     * Default 'off'.
+     */
+    ambiguityResolution?: 'off' | 'instant';
+    /** Ratio-test acceptance threshold (s₂/s₁). Default 3.0 (RTKLIB). */
+    ratioThreshold?: number;
+    /**
+     * Additional elevation mask (deg) for ambiguities entering the fix
+     * (RTKLIB `elmaskar`); 0 = use every measured ambiguity. Default 0.
+     */
+    arElevationMaskDeg?: number;
+    /**
+     * Include GLONASS FDMA ambiguities in the integer fix. Only sound
+     * across same-model receivers (differential IFB). Default false.
+     */
+    glonassAr?: boolean;
+    /**
+     * Partial fixing: when the full ambiguity set fails the ratio test,
+     * drop the lowest-elevation ambiguity and retry (elevation-ordered
+     * subset walk), never below half the candidates. Default true.
+     */
+    partialFixing?: boolean;
+    /** Minimum DD ambiguities to attempt/accept a fix. Default 4. */
+    minFixAmbiguities?: number;
 }
 interface RtkFloatSolution {
     /** Epoch, GPS-scale milliseconds. */
     timeMs: number;
-    /** Rover position, ECEF metres. */
+    /**
+     * Rover position, ECEF metres — the ambiguity-fixed position when
+     * `status === 'fixed'`, the float filter position otherwise.
+     */
     position: [number, number, number];
-    /** Float baseline rover − base, ECEF metres. */
+    /** Float baseline rover − base, ECEF metres (always the float). */
     floatBaseline: [number, number, number];
+    /**
+     * Solution quality: 'fixed' when LAMBDA passed the ratio test,
+     * 'float' when carrier ambiguities contributed but no (accepted)
+     * fix, 'dgnss' when the epoch was updated from code DDs only.
+     */
+    status: 'fixed' | 'float' | 'dgnss';
     /** Satellites contributing DD rows this epoch (incl. references). */
     nSats: number;
-    /** Ambiguity-validation ratio — undefined at stage 1 (no LAMBDA). */
+    /**
+     * Ambiguity-validation ratio (s₂/s₁ of the LAMBDA candidates,
+     * capped at 999.9 as RTKLIB): the accepted subset's ratio when
+     * fixed, the full-set ratio otherwise. Undefined when no fix was
+     * attempted (`ambiguityResolution: 'off'` or no eligible set).
+     */
     ratio?: number;
+    /** Number of integer-fixed DD ambiguities (when `status==='fixed'`). */
+    nFixed?: number;
+    /** Fixed baseline rover − base, ECEF metres (when fixed). */
+    fixedBaseline?: [number, number, number];
+    /** Integer DD ambiguity (cycles) per fixed PRN (when fixed). */
+    fixedAmbiguities?: Record<string, number>;
     /** Formal position sigmas (filter covariance), ECEF metres. */
     sigmas: [number, number, number];
     /** Float DD ambiguity (cycles) per non-reference PRN. */
@@ -262,6 +378,17 @@ declare class RtkFloatEngine {
      * transform of state and covariance (P' = T P Tᵀ).
      */
     private retarget;
+    /**
+     * Try to fix the ambiguity subset `idxs` (indices into `this.amb`):
+     * extract the float subvector b and covariance Q_b from the filter,
+     * run MLAMBDA and, without touching the filter state, condition the
+     * position on the best integer candidate,
+     *   xa = x − P_xb·Q_b⁻¹·(b − ǎ)
+     * (RTKLIB rtkpos.c `resamb_LAMBDA`). Returns null when Q_b is not
+     * positive definite / invertible or the search fails; ratio
+     * validation is the caller's job.
+     */
+    private tryFix;
     /**
      * Process one synchronized epoch (same nominal `timeMs` for both
      * receivers). Returns null until a first position can be
@@ -271,6 +398,88 @@ declare class RtkFloatEngine {
     process(rover: RtkEpochMeasurements, base: RtkEpochMeasurements, timeMs: number): RtkFloatSolution | null;
 }
 
+/**
+ * Integer ambiguity resolution: LAMBDA decorrelation + MLAMBDA
+ * integer least-squares search.
+ *
+ * Port of RTKLIB's `lambda.c` (demo5 / rtklibexplorer fork,
+ * src/lambda.c, Copyright (c) 2007-2008 T. Takasu, BSD-2-Clause),
+ * cross-checked against the reference papers where the C comments are
+ * thin:
+ *
+ * - [1] P.J.G. Teunissen, "The least-squares ambiguity decorrelation
+ *   adjustment: a method for fast GPS ambiguity estimation",
+ *   J. Geodesy 70, 65-82, 1995.
+ * - [2] X.-W. Chang, X. Yang, T. Zhou, "MLAMBDA: A modified LAMBDA
+ *   method for integer least-squares estimation", J. Geodesy 79,
+ *   552-565, 2005.
+ *
+ * Pipeline (identical to RTKLIB's `lambda()`):
+ * 1. LᵀDL factorization of the float covariance, Q = Lᵀ·diag(D)·L
+ *    with L unit lower triangular (RTKLIB's `LD`).
+ * 2. LAMBDA reduction [1]: integer Gauss transformations interleaved
+ *    with symmetric permutations until the transformed D is
+ *    (approximately) descending — producing a unimodular Z with
+ *    Qz = ZᵀQZ = Lᵀ·diag(D)·L far better conditioned than Q.
+ * 3. MLAMBDA search [2] in the decorrelated space: depth-first
+ *    enumeration over a shrinking ellipsoid, keeping the `m` smallest
+ *    residual quadratic forms (z−ž)ᵀQz⁻¹(z−ž).
+ * 4. Back-transform the candidates to the original space, a = Z⁻ᵀ·ž
+ *    (RTKLIB solves ZᵀF = E; Z is unimodular so F is exactly integer).
+ *
+ * Deviations from lambda.c:
+ * - matrices are `Float64Array` in the same column-major layout, with
+ *   allocation-failure paths dropped (JS throws instead),
+ * - failures (non-positive-definite Q, search loop overflow) return
+ *   `null` instead of a status code + stderr message,
+ * - back-transformed candidates are rounded to the nearest integer:
+ *   F = Z⁻ᵀ·ž is exactly integer in ℤ arithmetic and the rounding only
+ *   removes the ~1e-12 fuzz of the floating-point triangular solve,
+ * - the ratio s₂/s₁ used by the RTKLIB caller (`rtkpos.c`) is returned
+ *   alongside the candidates (∞ when s₁ = 0, i.e. noise-free input).
+ */
+/** Result of an integer least-squares search. */
+interface LambdaResult {
+    /**
+     * The `m` best integer candidate vectors (length n each), sorted by
+     * ascending residual quadratic form; `candidates[0]` is the integer
+     * least-squares minimizer.
+     */
+    candidates: Float64Array[];
+    /**
+     * Residual quadratic forms sᵢ = (a−ǎᵢ)ᵀQ⁻¹(a−ǎᵢ) matching
+     * `candidates`, ascending.
+     */
+    residuals: Float64Array;
+    /**
+     * Ratio-test statistic s₂/s₁ (second-best over best); `Infinity`
+     * when the best residual is exactly 0 (noise-free input). Callers
+     * typically cap it (RTKLIB uses 999.9) before thresholding.
+     */
+    ratio: number;
+}
+/**
+ * LAMBDA/MLAMBDA integer least-squares estimation (RTKLIB `lambda`):
+ * decorrelate the float ambiguities, search the `m` best integer
+ * vectors and back-transform them to the original space.
+ *
+ * @param a Float ambiguities (length ≥ n).
+ * @param Q Their covariance, n×n (symmetric — row/column-major agree).
+ * @param n Number of ambiguities.
+ * @param m Number of candidates to return (default 2: best +
+ *   second-best, what the ratio test needs).
+ * @returns Candidates + residuals + ratio, or null when Q is not
+ *   positive definite or the search does not terminate.
+ */
+declare function lambdaSearch(a: Float64Array, Q: Float64Array, n: number, m?: number): LambdaResult | null;
+/**
+ * LAMBDA reduction only (RTKLIB `lambda_reduction`): the unimodular
+ * decorrelation matrix Z (n×n, column-major) such that Qz = ZᵀQZ is
+ * (near-)diagonally dominant. Exposed for diagnostics/tests; returns
+ * null when Q is not positive definite.
+ */
+declare function lambdaReduction(Q: Float64Array, n: number): Float64Array | null;
+
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
  * ephemerides.
@@ -279,7 +488,7 @@ declare class RtkFloatEngine {
  * constellation (absorbing inter-system time offsets), satellite clock
  * polynomial + relativistic correction, broadcast group delay
  * (TGD/BGD), Sagnac (Earth-rotation) correction, elevation
- * masking/weighting, and a simple tropospheric model. Ionospheric
+ * masking/weighting, and a Saastamoinen tropospheric model. Ionospheric
  * delay can be modelled from the broadcast Klobuchar coefficients
  * (`iono` option) for single-frequency measurements; for metre-level
  * results prefer the iono-free combination (ionoFree helper) with
@@ -289,7 +498,7 @@ declare class RtkFloatEngine {
 interface SppOptions {
     /** Elevation mask in degrees (applied after the first pass). Default 10. */
     elevationMaskDeg?: number;
-    /** Apply the simple tropospheric model. Default true. */
+    /** Apply the Saastamoinen tropospheric model. Default true. */
     troposphere?: boolean;
     /** Maximum Gauss-Newton iterations. Default 15. */
     maxIterations?: number;
@@ -303,6 +512,15 @@ interface SppOptions {
      * iono-free combinations.
      */
     iono?: KlobucharCoeffs;
+    /**
+     * Global Ionosphere Map (IONEX/GIM, from `parseIonex`). When given it
+     * takes precedence over `iono`: the slant delay is read from the map
+     * (~80–90% of the true ionosphere vs Klobuchar's ~50%), falling back
+     * to `iono` — if also supplied — only where the map has no value for
+     * an epoch/cell (a time gap; global maps always cover space). Omit for
+     * iono-free input.
+     */
+    gim?: IonexGrid;
     /**
      * Apply the broadcast group-delay correction (GPS TGD, Galileo
      * BGD E5a/E1, BeiDou TGD1) to the satellite clock. Correct for
@@ -351,4 +569,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 DgnssOptions, type DgnssSolution, type EphemerisSource, type KlobucharCoeffs, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SppOptions, type SppSolution, ionoFree, klobucharDelay, satClockCorrection, solveDgnss, solveSpp, toRtkEpoch };
+export { type DgnssOptions, type DgnssSolution, type EphemerisSource, IONO_L1_M_PER_TECU, type KlobucharCoeffs, type LambdaResult, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SppOptions, type SppSolution, gimSlantIonoDelayL1, gimVerticalTec, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, satClockCorrection, solveDgnss, solveSpp, toRtkEpoch };

package/dist/positioning.js

@@ -1,12 +1,17 @@
 import {
+  IONO_L1_M_PER_TECU,
   RtkFloatEngine,
+  gimSlantIonoDelayL1,
+  gimVerticalTec,
   ionoFree,
   klobucharDelay,
+  lambdaReduction,
+  lambdaSearch,
   satClockCorrection,
   solveDgnss,
   solveSpp,
   toRtkEpoch
-} from "./chunk-CUWF56ST.js";
+} from "./chunk-4XGKCVE3.js";
 import "./chunk-MHGNKSSH.js";
 import "./chunk-37QNKGTC.js";
 import "./chunk-6FAL6P4G.js";
@@ -14,9 +19,14 @@ import "./chunk-HVXYFUCB.js";
 import "./chunk-LEEU5OIO.js";
 import "./chunk-FIEWO4J4.js";
 export {
+  IONO_L1_M_PER_TECU,
   RtkFloatEngine,
+  gimSlantIonoDelayL1,
+  gimVerticalTec,
   ionoFree,
   klobucharDelay,
+  lambdaReduction,
+  lambdaSearch,
   satClockCorrection,
   solveDgnss,
   solveSpp,