gnss-js 1.22.0 → 1.23.0

package/dist/positioning.d.cts

@@ -34,6 +34,243 @@ interface KlobucharCoeffs {
  */
 declare function klobucharDelay(coeffs: KlobucharCoeffs, latRad: number, lonRad: number, azRad: number, elRad: number, gpsTowSec: number): number;
 
+/**
+ * RTK positioning, stage 1: epoch-wise double-differenced (DD)
+ * processing of a base/rover receiver pair.
+ *
+ * Two solvers share the same DD construction:
+ *
+ * - `solveDgnss` — code-based DGNSS: between-receiver single
+ *   differences on pseudoranges, double-differenced against a
+ *   reference satellite (highest elevation per signal group), iterated
+ *   weighted least squares for the rover position with the full DD
+ *   covariance (DDs sharing a reference satellite are correlated).
+ *
+ * - `RtkFloatEngine` — a stateful extended Kalman filter over DD
+ *   carrier phase + code with one float DD ambiguity state per
+ *   satellite/signal. An EKF (rather than epoch-wise iterated least
+ *   squares with appended ambiguity columns) was chosen because the
+ *   float ambiguities must persist across epochs anyway, and stage 2
+ *   (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).
+ *
+ * Differencing model: for satellites s and reference r observed by
+ * rover R and base B, the DD pseudorange/phase cancels satellite
+ * clocks (single difference) and receiver clocks (double difference).
+ * On short baselines the ionospheric and most of the tropospheric
+ * delay cancel too; the residual troposphere is modelled by the same
+ * simple elevation-mapped zenith model `solveSpp` uses, applied
+ * differentially. DDs are formed per *signal group* (constellation
+ * letter + RINEX code, e.g. `G1C`, `C2I`) so that only like signals
+ * are differenced.
+ *
+ * GLONASS (FDMA): DD phase is formed in metres with per-satellite
+ * wavelengths (λ_s·SDφ_s − λ_r·SDφ_r). The common receiver clock
+ * term cancels exactly (λ·f = c on every channel); the per-channel
+ * receiver phase bias (inter-frequency bias, IFB) does not, but it is
+ * constant while lock holds and is absorbed into the float DD
+ * ambiguity — the standard reason GLONASS float works while GLONASS
+ * integer fixing is hard. DD *code* retains the differential
+ * inter-channel code bias between the two receivers, which is small
+ * (well below the code noise) for same-model receivers — IFB-safe
+ * enough for stage 1, and documented as such.
+ *
+ * Time convention: `timeMs` is GPS-scale epoch milliseconds, exactly
+ * as produced by `parseNovatelRange` / the RINEX and RTCM parsers —
+ * the same convention `solveSpp` uses. No system clock is read.
+ *
+ * Adapting decoder output (see `toRtkEpoch`):
+ * - NovAtel: `parseNovatelRange(bytes).epochs[i]` gives
+ *   `{ timeMs, meas }`; `toRtkEpoch(meas)` picks each satellite's
+ *   L1-band measurement. When a log carries both RANGE and RANGECMP
+ *   the same epoch appears twice — keep one epoch per `timeMs`.
+ * - RTCM MSM: for each satellite/signal cell build
+ *   `{ code, pr: pseudorangeM, cp: phaserangeM / lambda, lockTimeMs }`
+ *   (MSM phaseranges are metres; divide by the carrier wavelength to
+ *   get cycles) and pass a `prn → measurement` map for the epoch.
+ */
+
+/** One satellite's measurement on one signal, for one epoch. */
+interface RtkMeasurement {
+    /** RINEX band+attribute, e.g. "1C", "2I". */
+    code: string;
+    /** Pseudorange (m). */
+    pr: number | null;
+    /** Carrier phase (cycles, RINEX sign), optional — DGNSS needs none. */
+    cp?: number | null;
+    /** Continuous lock time (ms) for cycle-slip detection, optional. */
+    lockTimeMs?: number;
+    /** GLONASS frequency channel k (−7…+6), for FDMA wavelengths. */
+    gloChannel?: number | null;
+}
+/** One epoch of measurements: PRN → measurement (one signal per PRN). */
+type RtkEpochMeasurements = ReadonlyMap<string, RtkMeasurement>;
+/** Decoder-shaped observation (structurally `NovatelMeasurement`). */
+interface RawObservation {
+    prn: string;
+    code: string;
+    pr: number | null;
+    cp?: number | null;
+    lockTimeS?: number;
+    gloChannel?: number | null;
+}
+/**
+ * Adapt one epoch of decoder observations (e.g.
+ * `parseNovatelRange(...).epochs[i].meas`) to the RTK input map:
+ * keeps each satellite's preferred L1-band code measurement with a
+ * valid pseudorange, drops unsupported systems (SBAS, NavIC).
+ */
+declare function toRtkEpoch(meas: readonly RawObservation[]): Map<string, RtkMeasurement>;
+/** Ephemeris source: a per-PRN map, or a list searched per epoch. */
+type EphemerisSource = ReadonlyMap<string, Ephemeris> | readonly Ephemeris[];
+interface DgnssOptions {
+    /** Elevation mask at the base, degrees. Default 10. */
+    elevationMaskDeg?: number;
+    /** Model the differential troposphere. Default true. */
+    troposphere?: boolean;
+    /** Maximum Gauss-Newton iterations. Default 15. */
+    maxIterations?: number;
+    /** Convergence threshold on the position update (m). Default 1e-4. */
+    convergenceM?: number;
+    /** Zenith code sigma per receiver (m). Default 0.3. */
+    codeSigmaM?: number;
+    /** Worst-first DD residual rejection threshold (m). Default 20. */
+    rejectThresholdM?: number;
+    /** Initial rover position; defaults to the base position. */
+    initialPosition?: [number, number, number];
+}
+interface DgnssSolution {
+    /** Rover position, ECEF metres. */
+    position: [number, number, number];
+    /** Baseline rover − base, ECEF metres. */
+    baseline: [number, number, number];
+    /** Formal position sigmas from the LSQ covariance, ECEF metres. */
+    sigmas: [number, number, number];
+    /** Satellites used (including references). */
+    usedSatellites: string[];
+    /** Reference satellite per signal group. */
+    refSatellites: Record<string, string>;
+    /** Post-fit DD residual (m) per non-reference PRN. */
+    residuals: Record<string, number>;
+    /** Satellites rejected by the residual screen. */
+    rejectedSatellites: string[];
+    nSats: number;
+    iterations: number;
+    converged: boolean;
+}
+/**
+ * Solve the rover position from one epoch of DD pseudoranges.
+ *
+ * @param rover Rover measurements (PRN → measurement).
+ * @param base Base measurements (PRN → measurement, same codes).
+ * @param basePos Known base position, ECEF metres.
+ * @param ephemerides Broadcast ephemerides (per-PRN map, or a list
+ *   searched by closest epoch — pass `parseNovatelNav(...).ephemerides`
+ *   or `parseNavFile(...).ephemerides` directly).
+ * @param timeMs Receiver epoch, GPS-scale milliseconds.
+ */
+declare function solveDgnss(rover: RtkEpochMeasurements, base: RtkEpochMeasurements, basePos: readonly [number, number, number], ephemerides: EphemerisSource, timeMs: number, opts?: DgnssOptions): DgnssSolution | null;
+interface RtkFloatOptions {
+    /**
+     * 'static': the rover position is a constant state (random walk
+     * `processNoisePosM`·√s, default 0). 'kinematic': the position is
+     * re-initialised each epoch with `kinematicSigmaM` uncertainty
+     * (no velocity states at stage 1 — RTKLIB's default kinematic
+     * handling without doppler). Default 'kinematic'.
+     */
+    mode?: 'static' | 'kinematic';
+    /** Elevation mask at the base, degrees. Default 10. */
+    elevationMaskDeg?: number;
+    /** Model the differential troposphere. Default true. */
+    troposphere?: boolean;
+    /** Zenith code sigma per receiver (m). Default 0.3. */
+    codeSigmaM?: number;
+    /** Zenith phase sigma per receiver (m). Default 0.003. */
+    phaseSigmaM?: number;
+    /** Static-mode position random walk (m/√s). Default 0. */
+    processNoisePosM?: number;
+    /** Kinematic per-epoch position reset sigma (m). Default 30. */
+    kinematicSigmaM?: number;
+    /** Ambiguity random walk (cycles/√s). Default 1e-4. */
+    ambProcessNoiseCycles?: number;
+    /** New float ambiguity sigma (cycles). Default 30. */
+    ambInitSigmaCycles?: number;
+    /** Drop ambiguity states unseen for this long (ms). Default 10000. */
+    maxGapMs?: number;
+    /** DD code innovation gate (m): drop the satellite. Default 30. */
+    codeGateM?: number;
+    /**
+     * Phase-minus-code innovation divergence gate (m): treat as an
+     * undetected cycle slip and re-initialise the ambiguity. Default 5.
+     */
+    slipGateM?: number;
+    /** Measurement-update relinearisations (IEKF). Default 2. */
+    updateIterations?: number;
+}
+interface RtkFloatSolution {
+    /** Epoch, GPS-scale milliseconds. */
+    timeMs: number;
+    /** Rover position, ECEF metres. */
+    position: [number, number, number];
+    /** Float baseline rover − base, ECEF metres. */
+    floatBaseline: [number, number, number];
+    /** Satellites contributing DD rows this epoch (incl. references). */
+    nSats: number;
+    /** Ambiguity-validation ratio — undefined at stage 1 (no LAMBDA). */
+    ratio?: number;
+    /** Formal position sigmas (filter covariance), ECEF metres. */
+    sigmas: [number, number, number];
+    /** Float DD ambiguity (cycles) per non-reference PRN. */
+    ambiguities: Record<string, number>;
+    /** Reference satellite per signal group. */
+    refSatellites: Record<string, string>;
+}
+/**
+ * Epoch-by-epoch float RTK filter: EKF states = rover position
+ * (static or kinematic) + one float DD ambiguity (cycles) per
+ * satellite/signal. Cycle slips are handled via lock-time regressions
+ * (LLI-style resets) and a phase/code divergence gate; reference-
+ * satellite switches re-map the DD ambiguity states algebraically
+ * (N_i' = N_i − N_r', old reference gains −N_r') so no information is
+ * lost. Feed epochs in time order via `process`.
+ */
+declare class RtkFloatEngine {
+    private readonly basePos;
+    private readonly ephemerides;
+    private readonly o;
+    /** State vector [x, y, z, N₁…] and covariance; null before init. */
+    private x;
+    private P;
+    private amb;
+    private refs;
+    private track;
+    private lastMs;
+    constructor(basePos: readonly [number, number, number], ephemerides: EphemerisSource, opts?: RtkFloatOptions);
+    /** Clear all filter state (position, ambiguities, lock history). */
+    reset(): void;
+    private ambIndex;
+    /** Remove one ambiguity state (row/col) from x and P. */
+    private dropAmb;
+    /** Append an ambiguity state with the given value and variance. */
+    private addAmb;
+    /**
+     * Re-map a group's DD ambiguities from the old reference r to the
+     * new reference r' (which must hold a state): N_i' = N_i − N_r' and
+     * the old reference's slot becomes N_r = −N_r'. Exact linear
+     * transform of state and covariance (P' = T P Tᵀ).
+     */
+    private retarget;
+    /**
+     * Process one synchronized epoch (same nominal `timeMs` for both
+     * receivers). Returns null until a first position can be
+     * initialised (via an internal DGNSS solve) or when the epoch has
+     * fewer than 3 usable DD rows.
+     */
+    process(rover: RtkEpochMeasurements, base: RtkEpochMeasurements, timeMs: number): RtkFloatSolution | null;
+}
+
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
  * ephemerides.
@@ -114,4 +351,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 KlobucharCoeffs, type SppOptions, type SppSolution, ionoFree, klobucharDelay, satClockCorrection, solveSpp };
+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 };

package/dist/positioning.d.ts

@@ -34,6 +34,243 @@ interface KlobucharCoeffs {
  */
 declare function klobucharDelay(coeffs: KlobucharCoeffs, latRad: number, lonRad: number, azRad: number, elRad: number, gpsTowSec: number): number;
 
+/**
+ * RTK positioning, stage 1: epoch-wise double-differenced (DD)
+ * processing of a base/rover receiver pair.
+ *
+ * Two solvers share the same DD construction:
+ *
+ * - `solveDgnss` — code-based DGNSS: between-receiver single
+ *   differences on pseudoranges, double-differenced against a
+ *   reference satellite (highest elevation per signal group), iterated
+ *   weighted least squares for the rover position with the full DD
+ *   covariance (DDs sharing a reference satellite are correlated).
+ *
+ * - `RtkFloatEngine` — a stateful extended Kalman filter over DD
+ *   carrier phase + code with one float DD ambiguity state per
+ *   satellite/signal. An EKF (rather than epoch-wise iterated least
+ *   squares with appended ambiguity columns) was chosen because the
+ *   float ambiguities must persist across epochs anyway, and stage 2
+ *   (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).
+ *
+ * Differencing model: for satellites s and reference r observed by
+ * rover R and base B, the DD pseudorange/phase cancels satellite
+ * clocks (single difference) and receiver clocks (double difference).
+ * On short baselines the ionospheric and most of the tropospheric
+ * delay cancel too; the residual troposphere is modelled by the same
+ * simple elevation-mapped zenith model `solveSpp` uses, applied
+ * differentially. DDs are formed per *signal group* (constellation
+ * letter + RINEX code, e.g. `G1C`, `C2I`) so that only like signals
+ * are differenced.
+ *
+ * GLONASS (FDMA): DD phase is formed in metres with per-satellite
+ * wavelengths (λ_s·SDφ_s − λ_r·SDφ_r). The common receiver clock
+ * term cancels exactly (λ·f = c on every channel); the per-channel
+ * receiver phase bias (inter-frequency bias, IFB) does not, but it is
+ * constant while lock holds and is absorbed into the float DD
+ * ambiguity — the standard reason GLONASS float works while GLONASS
+ * integer fixing is hard. DD *code* retains the differential
+ * inter-channel code bias between the two receivers, which is small
+ * (well below the code noise) for same-model receivers — IFB-safe
+ * enough for stage 1, and documented as such.
+ *
+ * Time convention: `timeMs` is GPS-scale epoch milliseconds, exactly
+ * as produced by `parseNovatelRange` / the RINEX and RTCM parsers —
+ * the same convention `solveSpp` uses. No system clock is read.
+ *
+ * Adapting decoder output (see `toRtkEpoch`):
+ * - NovAtel: `parseNovatelRange(bytes).epochs[i]` gives
+ *   `{ timeMs, meas }`; `toRtkEpoch(meas)` picks each satellite's
+ *   L1-band measurement. When a log carries both RANGE and RANGECMP
+ *   the same epoch appears twice — keep one epoch per `timeMs`.
+ * - RTCM MSM: for each satellite/signal cell build
+ *   `{ code, pr: pseudorangeM, cp: phaserangeM / lambda, lockTimeMs }`
+ *   (MSM phaseranges are metres; divide by the carrier wavelength to
+ *   get cycles) and pass a `prn → measurement` map for the epoch.
+ */
+
+/** One satellite's measurement on one signal, for one epoch. */
+interface RtkMeasurement {
+    /** RINEX band+attribute, e.g. "1C", "2I". */
+    code: string;
+    /** Pseudorange (m). */
+    pr: number | null;
+    /** Carrier phase (cycles, RINEX sign), optional — DGNSS needs none. */
+    cp?: number | null;
+    /** Continuous lock time (ms) for cycle-slip detection, optional. */
+    lockTimeMs?: number;
+    /** GLONASS frequency channel k (−7…+6), for FDMA wavelengths. */
+    gloChannel?: number | null;
+}
+/** One epoch of measurements: PRN → measurement (one signal per PRN). */
+type RtkEpochMeasurements = ReadonlyMap<string, RtkMeasurement>;
+/** Decoder-shaped observation (structurally `NovatelMeasurement`). */
+interface RawObservation {
+    prn: string;
+    code: string;
+    pr: number | null;
+    cp?: number | null;
+    lockTimeS?: number;
+    gloChannel?: number | null;
+}
+/**
+ * Adapt one epoch of decoder observations (e.g.
+ * `parseNovatelRange(...).epochs[i].meas`) to the RTK input map:
+ * keeps each satellite's preferred L1-band code measurement with a
+ * valid pseudorange, drops unsupported systems (SBAS, NavIC).
+ */
+declare function toRtkEpoch(meas: readonly RawObservation[]): Map<string, RtkMeasurement>;
+/** Ephemeris source: a per-PRN map, or a list searched per epoch. */
+type EphemerisSource = ReadonlyMap<string, Ephemeris> | readonly Ephemeris[];
+interface DgnssOptions {
+    /** Elevation mask at the base, degrees. Default 10. */
+    elevationMaskDeg?: number;
+    /** Model the differential troposphere. Default true. */
+    troposphere?: boolean;
+    /** Maximum Gauss-Newton iterations. Default 15. */
+    maxIterations?: number;
+    /** Convergence threshold on the position update (m). Default 1e-4. */
+    convergenceM?: number;
+    /** Zenith code sigma per receiver (m). Default 0.3. */
+    codeSigmaM?: number;
+    /** Worst-first DD residual rejection threshold (m). Default 20. */
+    rejectThresholdM?: number;
+    /** Initial rover position; defaults to the base position. */
+    initialPosition?: [number, number, number];
+}
+interface DgnssSolution {
+    /** Rover position, ECEF metres. */
+    position: [number, number, number];
+    /** Baseline rover − base, ECEF metres. */
+    baseline: [number, number, number];
+    /** Formal position sigmas from the LSQ covariance, ECEF metres. */
+    sigmas: [number, number, number];
+    /** Satellites used (including references). */
+    usedSatellites: string[];
+    /** Reference satellite per signal group. */
+    refSatellites: Record<string, string>;
+    /** Post-fit DD residual (m) per non-reference PRN. */
+    residuals: Record<string, number>;
+    /** Satellites rejected by the residual screen. */
+    rejectedSatellites: string[];
+    nSats: number;
+    iterations: number;
+    converged: boolean;
+}
+/**
+ * Solve the rover position from one epoch of DD pseudoranges.
+ *
+ * @param rover Rover measurements (PRN → measurement).
+ * @param base Base measurements (PRN → measurement, same codes).
+ * @param basePos Known base position, ECEF metres.
+ * @param ephemerides Broadcast ephemerides (per-PRN map, or a list
+ *   searched by closest epoch — pass `parseNovatelNav(...).ephemerides`
+ *   or `parseNavFile(...).ephemerides` directly).
+ * @param timeMs Receiver epoch, GPS-scale milliseconds.
+ */
+declare function solveDgnss(rover: RtkEpochMeasurements, base: RtkEpochMeasurements, basePos: readonly [number, number, number], ephemerides: EphemerisSource, timeMs: number, opts?: DgnssOptions): DgnssSolution | null;
+interface RtkFloatOptions {
+    /**
+     * 'static': the rover position is a constant state (random walk
+     * `processNoisePosM`·√s, default 0). 'kinematic': the position is
+     * re-initialised each epoch with `kinematicSigmaM` uncertainty
+     * (no velocity states at stage 1 — RTKLIB's default kinematic
+     * handling without doppler). Default 'kinematic'.
+     */
+    mode?: 'static' | 'kinematic';
+    /** Elevation mask at the base, degrees. Default 10. */
+    elevationMaskDeg?: number;
+    /** Model the differential troposphere. Default true. */
+    troposphere?: boolean;
+    /** Zenith code sigma per receiver (m). Default 0.3. */
+    codeSigmaM?: number;
+    /** Zenith phase sigma per receiver (m). Default 0.003. */
+    phaseSigmaM?: number;
+    /** Static-mode position random walk (m/√s). Default 0. */
+    processNoisePosM?: number;
+    /** Kinematic per-epoch position reset sigma (m). Default 30. */
+    kinematicSigmaM?: number;
+    /** Ambiguity random walk (cycles/√s). Default 1e-4. */
+    ambProcessNoiseCycles?: number;
+    /** New float ambiguity sigma (cycles). Default 30. */
+    ambInitSigmaCycles?: number;
+    /** Drop ambiguity states unseen for this long (ms). Default 10000. */
+    maxGapMs?: number;
+    /** DD code innovation gate (m): drop the satellite. Default 30. */
+    codeGateM?: number;
+    /**
+     * Phase-minus-code innovation divergence gate (m): treat as an
+     * undetected cycle slip and re-initialise the ambiguity. Default 5.
+     */
+    slipGateM?: number;
+    /** Measurement-update relinearisations (IEKF). Default 2. */
+    updateIterations?: number;
+}
+interface RtkFloatSolution {
+    /** Epoch, GPS-scale milliseconds. */
+    timeMs: number;
+    /** Rover position, ECEF metres. */
+    position: [number, number, number];
+    /** Float baseline rover − base, ECEF metres. */
+    floatBaseline: [number, number, number];
+    /** Satellites contributing DD rows this epoch (incl. references). */
+    nSats: number;
+    /** Ambiguity-validation ratio — undefined at stage 1 (no LAMBDA). */
+    ratio?: number;
+    /** Formal position sigmas (filter covariance), ECEF metres. */
+    sigmas: [number, number, number];
+    /** Float DD ambiguity (cycles) per non-reference PRN. */
+    ambiguities: Record<string, number>;
+    /** Reference satellite per signal group. */
+    refSatellites: Record<string, string>;
+}
+/**
+ * Epoch-by-epoch float RTK filter: EKF states = rover position
+ * (static or kinematic) + one float DD ambiguity (cycles) per
+ * satellite/signal. Cycle slips are handled via lock-time regressions
+ * (LLI-style resets) and a phase/code divergence gate; reference-
+ * satellite switches re-map the DD ambiguity states algebraically
+ * (N_i' = N_i − N_r', old reference gains −N_r') so no information is
+ * lost. Feed epochs in time order via `process`.
+ */
+declare class RtkFloatEngine {
+    private readonly basePos;
+    private readonly ephemerides;
+    private readonly o;
+    /** State vector [x, y, z, N₁…] and covariance; null before init. */
+    private x;
+    private P;
+    private amb;
+    private refs;
+    private track;
+    private lastMs;
+    constructor(basePos: readonly [number, number, number], ephemerides: EphemerisSource, opts?: RtkFloatOptions);
+    /** Clear all filter state (position, ambiguities, lock history). */
+    reset(): void;
+    private ambIndex;
+    /** Remove one ambiguity state (row/col) from x and P. */
+    private dropAmb;
+    /** Append an ambiguity state with the given value and variance. */
+    private addAmb;
+    /**
+     * Re-map a group's DD ambiguities from the old reference r to the
+     * new reference r' (which must hold a state): N_i' = N_i − N_r' and
+     * the old reference's slot becomes N_r = −N_r'. Exact linear
+     * transform of state and covariance (P' = T P Tᵀ).
+     */
+    private retarget;
+    /**
+     * Process one synchronized epoch (same nominal `timeMs` for both
+     * receivers). Returns null until a first position can be
+     * initialised (via an internal DGNSS solve) or when the epoch has
+     * fewer than 3 usable DD rows.
+     */
+    process(rover: RtkEpochMeasurements, base: RtkEpochMeasurements, timeMs: number): RtkFloatSolution | null;
+}
+
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
  * ephemerides.
@@ -114,4 +351,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 KlobucharCoeffs, type SppOptions, type SppSolution, ionoFree, klobucharDelay, satClockCorrection, solveSpp };
+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 };

package/dist/positioning.js

@@ -1,18 +1,24 @@
 import {
+  RtkFloatEngine,
   ionoFree,
   klobucharDelay,
   satClockCorrection,
-  solveSpp
-} from "./chunk-B5LU4746.js";
-import "./chunk-JNFV5BYB.js";
+  solveDgnss,
+  solveSpp,
+  toRtkEpoch
+} from "./chunk-CUWF56ST.js";
+import "./chunk-MHGNKSSH.js";
 import "./chunk-37QNKGTC.js";
 import "./chunk-6FAL6P4G.js";
 import "./chunk-HVXYFUCB.js";
 import "./chunk-LEEU5OIO.js";
 import "./chunk-FIEWO4J4.js";
 export {
+  RtkFloatEngine,
   ionoFree,
   klobucharDelay,
   satClockCorrection,
-  solveSpp
+  solveDgnss,
+  solveSpp,
+  toRtkEpoch
 };

package/package.json

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