@neilberkman/sidereon 0.19.1 → 0.21.0

package/pkg/sidereon.js

@@ -5950,6 +5950,54 @@ export class GnssInsFilter {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Apply a gated wheeled-vehicle non-holonomic constraint update.
+     * @returns {any}
+     */
+    updateNonHolonomic() {
+        const ret = wasm.gnssinsfilter_updateNonHolonomic(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a non-holonomic constraint and record checkpoints when an update applies.
+     * @param {FusionRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updateNonHolonomicRecorded(history) {
+        _assertClass(history, FusionRtsHistoryBuilder);
+        const ret = wasm.gnssinsfilter_updateNonHolonomicRecorded(this.__wbg_ptr, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a gated zero-velocity and zero-angular-rate update.
+     * @returns {any}
+     */
+    updateStationary() {
+        const ret = wasm.gnssinsfilter_updateStationary(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply a stationary update and record checkpoints when an update applies.
+     * @param {FusionRtsHistoryBuilder} history
+     * @returns {any}
+     */
+    updateStationaryRecorded(history) {
+        _assertClass(history, FusionRtsHistoryBuilder);
+        const ret = wasm.gnssinsfilter_updateStationaryRecorded(this.__wbg_ptr, history.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Apply a tight raw-observation epoch against a broadcast ephemeris source.
      * @param {BroadcastEphemeris} broadcast
@@ -20386,6 +20434,52 @@ export function boundedIlsSearch(float_cycles, covariance, radius, candidate_lim
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Build dual-frequency RTK arc records from parsed RINEX OBS products.
+ *
+ * Defaults build the GPS `C1C`/`L1C` plus `C2W`/`L2W` arc used by the real
+ * WTZR/WTZZ fixtures.
+ * @param {Sp3} ephemeris
+ * @param {RinexObs} base_obs
+ * @param {RinexObs} rover_obs
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+export function buildDualFrequencyRinexRtkArc(ephemeris, base_obs, rover_obs, options) {
+    _assertClass(ephemeris, Sp3);
+    _assertClass(base_obs, RinexObs);
+    _assertClass(rover_obs, RinexObs);
+    const ret = wasm.buildDualFrequencyRinexRtkArc(ephemeris.__wbg_ptr, base_obs.__wbg_ptr, rover_obs.__wbg_ptr, isLikeNone(options) ? 0 : addToExternrefTable0(options));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Build single-frequency RTK arc records from parsed RINEX OBS products.
+ *
+ * `ephemeris` is an SP3 precise ephemeris handle, `baseObs` and `roverObs`
+ * are parsed RINEX observation files, and `options` may provide
+ * `{ signalPairs, maxEpochs, minCommonSatellites, includePredictionTime }`.
+ * Defaults build the GPS `C1C`/`L1C` arc used by the real WTZR/WTZZ fixtures.
+ * @param {Sp3} ephemeris
+ * @param {RinexObs} base_obs
+ * @param {RinexObs} rover_obs
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+export function buildRinexRtkArc(ephemeris, base_obs, rover_obs, options) {
+    _assertClass(ephemeris, Sp3);
+    _assertClass(base_obs, RinexObs);
+    _assertClass(rover_obs, RinexObs);
+    const ret = wasm.buildRinexRtkArc(ephemeris.__wbg_ptr, base_obs.__wbg_ptr, rover_obs.__wbg_ptr, isLikeNone(options) ? 0 : addToExternrefTable0(options));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * One wrapping GPS C/A chip at a zero-based index.
  * @param {bigint} prn
@@ -21649,6 +21743,19 @@ export function errorEllipse2(covariance, confidence) {
     return ErrorEllipse2.__wrap(ret[0]);
 }
 
+/**
+ * Horizontal one-sigma ellipse from an ENU covariance in square metres.
+ * @param {any} covariance_enu_m2
+ * @returns {ErrorEllipse}
+ */
+export function errorEllipseFromEnuM2(covariance_enu_m2) {
+    const ret = wasm.errorEllipseFromEnuM2(covariance_enu_m2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ErrorEllipse.__wrap(ret[0]);
+}
+
 /**
  * @param {DragForce} drag
  * @param {any} request
@@ -23042,6 +23149,20 @@ export function hessianTrace(jacobian, m, n) {
     return ret[0];
 }
 
+/**
+ * Horizontal percentile circle radius from an ENU covariance.
+ * @param {any} covariance_enu_m2
+ * @param {number} probability
+ * @returns {PercentileRadius}
+ */
+export function horizontalRadiusAt(covariance_enu_m2, probability) {
+    const ret = wasm.horizontalRadiusAt(covariance_enu_m2, probability);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PercentileRadius.__wrap(ret[0]);
+}
+
 /**
  * Gauss angles-only orbit determination.
  *
@@ -24186,6 +24307,22 @@ export function metricsFromKinematicSolution(solution) {
     return PositionErrorMetrics.__wrap(ret[0]);
 }
 
+/**
+ * Compute position-error metrics from a position covariance object.
+ *
+ * The object must include `ecefM2` and `enuM2`, each a 3 by 3 covariance in
+ * square metres.
+ * @param {any} covariance
+ * @returns {PositionErrorMetrics}
+ */
+export function metricsFromPositionCovariance(covariance) {
+    const ret = wasm.metricsFromPositionCovariance(covariance);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PositionErrorMetrics.__wrap(ret[0]);
+}
+
 /**
  * Modified Allan deviation for explicit averaging factors.
  *
@@ -27033,6 +27170,49 @@ export function solveStatic(sp3, epochs, options) {
     return StaticSolution.__wrap(ret[0]);
 }
 
+/**
+ * Solve one static reference-station coordinate from paired RINEX OBS plus SP3.
+ * @param {Sp3} ephemeris
+ * @param {RinexObs} reference_obs
+ * @param {RinexObs} rover_obs
+ * @param {any} config
+ * @returns {any}
+ */
+export function solveStaticReferenceStationRinex(ephemeris, reference_obs, rover_obs, config) {
+    _assertClass(ephemeris, Sp3);
+    _assertClass(reference_obs, RinexObs);
+    _assertClass(rover_obs, RinexObs);
+    const ret = wasm.solveStaticReferenceStationRinex(ephemeris.__wbg_ptr, reference_obs.__wbg_ptr, rover_obs.__wbg_ptr, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Solve one static RTK baseline directly from paired RINEX OBS plus SP3.
+ *
+ * `config.baseM` is the base antenna phase-center ECEF position in metres.
+ * Optional `config.arcOptions` controls RINEX signal extraction; other fields
+ * mirror `RtkStaticArcConfig` but the wavelength and offset maps are filled by
+ * the RINEX builder.
+ * @param {Sp3} ephemeris
+ * @param {RinexObs} base_obs
+ * @param {RinexObs} rover_obs
+ * @param {any} config
+ * @returns {any}
+ */
+export function solveStaticRinexRtkBaseline(ephemeris, base_obs, rover_obs, config) {
+    _assertClass(ephemeris, Sp3);
+    _assertClass(base_obs, RinexObs);
+    _assertClass(rover_obs, RinexObs);
+    const ret = wasm.solveStaticRinexRtkBaseline(ephemeris.__wbg_ptr, base_obs.__wbg_ptr, rover_obs.__wbg_ptr, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Solve a static RTK arc with one batch float solution and one validated fixed
  * solution over the whole arc.
@@ -27096,6 +27276,29 @@ export function solveVelocityBroadcast(broadcast, observations, receiver_ecef_m,
     return VelocitySolution.__wrap(ret[0]);
 }
 
+/**
+ * Solve a static dual-frequency wide-lane fixed RTK baseline from RINEX OBS.
+ *
+ * The function builds the dual-frequency RINEX arc, fixes wide-lane
+ * ambiguities, prepares ionosphere-free narrow-lane records, then runs the
+ * static fixed baseline solver.
+ * @param {Sp3} ephemeris
+ * @param {RinexObs} base_obs
+ * @param {RinexObs} rover_obs
+ * @param {any} config
+ * @returns {any}
+ */
+export function solveWideLaneFixedRinexRtkBaseline(ephemeris, base_obs, rover_obs, config) {
+    _assertClass(ephemeris, Sp3);
+    _assertClass(base_obs, RinexObs);
+    _assertClass(rover_obs, RinexObs);
+    const ret = wasm.solveWideLaneFixedRinexRtkBaseline(ephemeris.__wbg_ptr, base_obs.__wbg_ptr, rover_obs.__wbg_ptr, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Solve a receiver position, preferring precise SP3 products and falling back to
  * broadcast ephemeris, reporting which source was used and how stale it is.
@@ -27248,6 +27451,20 @@ export function spectralSeparationCoefficientHz(desired, interference, receiver_
     return ret[0];
 }
 
+/**
+ * Three-dimensional percentile sphere radius from an ENU covariance.
+ * @param {any} covariance_enu_m2
+ * @param {number} probability
+ * @returns {PercentileRadius}
+ */
+export function sphericalRadiusAt(covariance_enu_m2, probability) {
+    const ret = wasm.sphericalRadiusAt(covariance_enu_m2, probability);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PercentileRadius.__wrap(ret[0]);
+}
+
 /**
  * Continuous seconds since J2000 for a split Julian date.
  * @param {number} jd_whole
@@ -27807,6 +28024,21 @@ export function validateAgainstSp3Ids(records, ids) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Blend a first good post-outage fix back over an outage span.
+ * @param {any} states
+ * @param {any} first_good_fix
+ * @param {any} config
+ * @returns {any}
+ */
+export function velocityMatchOutage(states, first_good_fix, config) {
+    const ret = wasm.velocityMatchOutage(states, first_good_fix, config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Estimate robust station velocity with the MIDAS method.
  *
@@ -27825,6 +28057,20 @@ export function velocityMidas(series, options) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Vertical one-dimensional percentile radius from an up variance.
+ * @param {number} sigma_u_m2
+ * @param {number} probability
+ * @returns {number}
+ */
+export function verticalRadiusAt(sigma_u_m2, probability) {
+    const ret = wasm.verticalRadiusAt(sigma_u_m2, probability);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Satellites visible above `minElevationDeg` from `station` at a single instant,
  * from already-initialized [`Tle`]s: the opsmode-preserving constellation