@neilberkman/sidereon 0.13.0 → 0.15.0

package/pkg/sidereon.js

@@ -128,6 +128,75 @@ export class AcquisitionResult {
 }
 if (Symbol.dispose) AcquisitionResult.prototype[Symbol.dispose] = AcquisitionResult.prototype.free;
 
+/**
+ * Airborne receiver and multipath contribution model.
+ */
+export class AirborneModel {
+    static __wrap(ptr) {
+        const obj = Object.create(AirborneModel.prototype);
+        obj.__wbg_ptr = ptr;
+        AirborneModelFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AirborneModelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_airbornemodel_free(ptr, 0);
+    }
+    /**
+     * AAD-A airborne model.
+     * @returns {AirborneModel}
+     */
+    static aadA() {
+        const ret = wasm.airbornemodel_aadA();
+        return AirborneModel.__wrap(ret);
+    }
+    /**
+     * Default airborne model.
+     * @returns {AirborneModel}
+     */
+    static defaultModel() {
+        const ret = wasm.airbornemodel_defaultModel();
+        return AirborneModel.__wrap(ret);
+    }
+    /**
+     * Construct an airborne model from a receiver noise term in metres.
+     * @param {number} sigma_noise_divergence_m
+     */
+    constructor(sigma_noise_divergence_m) {
+        const ret = wasm.airbornemodel_new(sigma_noise_divergence_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        AirborneModelFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Airborne receiver, divergence, and multipath sigma, metres, or `null`.
+     * @param {number} elevation_rad
+     * @returns {any}
+     */
+    sigmaAirM(elevation_rad) {
+        const ret = wasm.airbornemodel_sigmaAirM(this.__wbg_ptr, elevation_rad);
+        return ret;
+    }
+    /**
+     * Receiver noise and code-carrier divergence sigma, metres.
+     * @returns {number}
+     */
+    get sigmaNoiseDivergenceM() {
+        const ret = wasm.airbornemodel_sigmaNoiseDivergenceM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) AirborneModel.prototype[Symbol.dispose] = AirborneModel.prototype.free;
+
 /**
  * A receiver or satellite ANTEX antenna calibration block.
  */
@@ -3165,6 +3234,131 @@ export class CoverageGrid {
 }
 if (Symbol.dispose) CoverageGrid.prototype[Symbol.dispose] = CoverageGrid.prototype.free;
 
+/**
+ * SBAS degradation terms used when deriving an error model from a store.
+ */
+export class DegradationParams {
+    static __wrap(ptr) {
+        const obj = Object.create(DegradationParams.prototype);
+        obj.__wbg_ptr = ptr;
+        DegradationParamsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DegradationParamsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_degradationparams_free(ptr, 0);
+    }
+    /**
+     * Default degradation parameters.
+     * @returns {DegradationParams}
+     */
+    static defaultParams() {
+        const ret = wasm.degradationparams_defaultParams();
+        return DegradationParams.__wrap(ret);
+    }
+    /**
+     * Variance multiplier applied to the UDRE variance table.
+     * @returns {number}
+     */
+    get deltaUdre() {
+        const ret = wasm.degradationparams_deltaUdre(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * En-route degradation term, metres.
+     * @returns {number}
+     */
+    get epsErM() {
+        const ret = wasm.degradationparams_epsErM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Fast-correction degradation term, metres.
+     * @returns {number}
+     */
+    get epsFcM() {
+        const ret = wasm.degradationparams_epsFcM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Ionospheric degradation term added to UIRE, metres.
+     * @returns {number}
+     */
+    get epsIonoM() {
+        const ret = wasm.degradationparams_epsIonoM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Long-term-correction degradation term, metres.
+     * @returns {number}
+     */
+    get epsLtcM() {
+        const ret = wasm.degradationparams_epsLtcM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Range-rate-correction degradation term, metres.
+     * @returns {number}
+     */
+    get epsRrcM() {
+        const ret = wasm.degradationparams_epsRrcM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * True when all degradation parameters are inside the valid domain.
+     * @returns {boolean}
+     */
+    isValid() {
+        const ret = wasm.degradationparams_isValid(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Construct SBAS degradation parameters.
+     *
+     * Omitted numeric fields use the no-degradation defaults. Invalid values
+     * throw a `RangeError`.
+     * @param {number | null} [delta_udre]
+     * @param {number | null} [eps_fc_m]
+     * @param {number | null} [eps_rrc_m]
+     * @param {number | null} [eps_ltc_m]
+     * @param {number | null} [eps_er_m]
+     * @param {number | null} [eps_iono_m]
+     * @param {boolean | null} [rss_udre]
+     */
+    constructor(delta_udre, eps_fc_m, eps_rrc_m, eps_ltc_m, eps_er_m, eps_iono_m, rss_udre) {
+        const ret = wasm.degradationparams_new(!isLikeNone(delta_udre), isLikeNone(delta_udre) ? 0 : delta_udre, !isLikeNone(eps_fc_m), isLikeNone(eps_fc_m) ? 0 : eps_fc_m, !isLikeNone(eps_rrc_m), isLikeNone(eps_rrc_m) ? 0 : eps_rrc_m, !isLikeNone(eps_ltc_m), isLikeNone(eps_ltc_m) ? 0 : eps_ltc_m, !isLikeNone(eps_er_m), isLikeNone(eps_er_m) ? 0 : eps_er_m, !isLikeNone(eps_iono_m), isLikeNone(eps_iono_m) ? 0 : eps_iono_m, isLikeNone(rss_udre) ? 0xFFFFFF : rss_udre ? 1 : 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        DegradationParamsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * No extra degradation and no UDRE inflation.
+     * @returns {DegradationParams}
+     */
+    static none() {
+        const ret = wasm.degradationparams_none();
+        return DegradationParams.__wrap(ret);
+    }
+    /**
+     * Whether UDRE degradation terms are combined by root-sum-square.
+     * @returns {boolean}
+     */
+    get rssUdre() {
+        const ret = wasm.degradationparams_rssUdre(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) DegradationParams.prototype[Symbol.dispose] = DegradationParams.prototype.free;
+
 /**
  * A DGNSS rover solve: the corrected SPP solution plus the base-relative
  * baseline.
@@ -4172,6 +4366,53 @@ export class Ephemeris {
 }
 if (Symbol.dispose) Ephemeris.prototype[Symbol.dispose] = Ephemeris.prototype.free;
 
+/**
+ * A horizontal one-sigma error ellipse.
+ */
+export class ErrorEllipse {
+    static __wrap(ptr) {
+        const obj = Object.create(ErrorEllipse.prototype);
+        obj.__wbg_ptr = ptr;
+        ErrorEllipseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ErrorEllipseFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_errorellipse_free(ptr, 0);
+    }
+    /**
+     * Semi-major-axis orientation in radians, from east toward north.
+     * @returns {number}
+     */
+    get orientationRad() {
+        const ret = wasm.errorellipse_orientationRad(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Semi-major axis length, metres.
+     * @returns {number}
+     */
+    get semiMajorM() {
+        const ret = wasm.errorellipse_semiMajorM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Semi-minor axis length, metres.
+     * @returns {number}
+     */
+    get semiMinorM() {
+        const ret = wasm.errorellipse_semiMinorM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) ErrorEllipse.prototype[Symbol.dispose] = ErrorEllipse.prototype.free;
+
 /**
  * A confidence ellipse from a 2x2 covariance block: semi-axes scaled by the
  * two-degree-of-freedom chi-square quantile `-2 ln(1 - confidence)`.
@@ -4745,6 +4986,85 @@ export class GeoidGrid {
 }
 if (Symbol.dispose) GeoidGrid.prototype[Symbol.dispose] = GeoidGrid.prototype.free;
 
+/**
+ * Geometry observability and covariance-validation diagnostics.
+ */
+export class GeometryQuality {
+    static __wrap(ptr) {
+        const obj = Object.create(GeometryQuality.prototype);
+        obj.__wbg_ptr = ptr;
+        GeometryQualityFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GeometryQualityFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_geometryquality_free(ptr, 0);
+    }
+    /**
+     * Singular-value condition number of the design matrix.
+     * @returns {number}
+     */
+    get conditionNumber() {
+        const ret = wasm.geometryquality_conditionNumber(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether residuals or a propagated prior validated the covariance bound.
+     * @returns {boolean}
+     */
+    get covarianceValidated() {
+        const ret = wasm.geometryquality_covarianceValidated(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Geometric dilution of precision for the solved state.
+     * @returns {number}
+     */
+    get gdop() {
+        const ret = wasm.geometryquality_gdop(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether residual-based RAIM can test the solve.
+     * @returns {boolean}
+     */
+    get raimCheckable() {
+        const ret = wasm.geometryquality_raimCheckable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Rank of the design matrix used by the solve.
+     * @returns {number}
+     */
+    get rank() {
+        const ret = wasm.geometryquality_rank(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Observation redundancy, `nObs - nParams`.
+     * @returns {number}
+     */
+    get redundancy() {
+        const ret = wasm.geometryquality_redundancy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Observability and validation tier.
+     * @returns {ObservabilityTier}
+     */
+    get tier() {
+        const ret = wasm.geometryquality_tier(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) GeometryQuality.prototype[Symbol.dispose] = GeometryQuality.prototype.free;
+
 /**
  * One GLONASS broadcast state-vector record. `toeUtcJ2000S` is UTC seconds past
  * J2000; position is PZ-90.11 ECEF metres, velocity m/s, acceleration m/s^2.
@@ -8162,6 +8482,35 @@ export class ObsPhaseShift {
 }
 if (Symbol.dispose) ObsPhaseShift.prototype[Symbol.dispose] = ObsPhaseShift.prototype.free;
 
+/**
+ * Observability and validation tier for an estimation design.
+ *
+ * `ZeroRedundancy` means the design is full rank but has no residual degrees of
+ * freedom, so snapshot-solve covariance bounds are unvalidated unless a
+ * propagated prior is present. `Weak` means the design exceeded the configured
+ * condition-number or GDOP cutoff; the returned bounds are reported as computed
+ * and are not clamped.
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const ObservabilityTier = Object.freeze({
+    /**
+     * At least one estimated parameter is not observable.
+     */
+    RankDeficient: 0, "0": "RankDeficient",
+    /**
+     * Full rank with no residual degrees of freedom.
+     */
+    ZeroRedundancy: 1, "1": "ZeroRedundancy",
+    /**
+     * Full rank with residual degrees of freedom, but above a cutoff.
+     */
+    Weak: 2, "2": "Weak",
+    /**
+     * Full rank and within the configured cutoffs.
+     */
+    Nominal: 3, "3": "Nominal",
+});
+
 /**
  * Optional observation-code allow-list for raw and carrier-phase rows. Build
  * with `new ObservationFilter()` then chain `.withSystem(system, codes)`.
@@ -10529,6 +10878,61 @@ export class ParsedTleFile {
 }
 if (Symbol.dispose) ParsedTleFile.prototype[Symbol.dispose] = ParsedTleFile.prototype.free;
 
+/**
+ * A percentile circle or sphere radius.
+ */
+export class PercentileRadius {
+    static __wrap(ptr) {
+        const obj = Object.create(PercentileRadius.prototype);
+        obj.__wbg_ptr = ptr;
+        PercentileRadiusFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PercentileRadiusFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_percentileradius_free(ptr, 0);
+    }
+    /**
+     * Approximate named radius, metres, when applicable.
+     * @returns {number}
+     */
+    get approxM() {
+        const ret = wasm.percentileradius_approxM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether `approxM` is valid for the covariance ratio.
+     * @returns {boolean}
+     */
+    get approxValid() {
+        const ret = wasm.percentileradius_approxValid(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Probability mass inside this radius.
+     * @returns {number}
+     */
+    get probability() {
+        const ret = wasm.percentileradius_probability(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Exact circle or sphere radius, metres.
+     * @returns {number}
+     */
+    get radiusM() {
+        const ret = wasm.percentileradius_radiusM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) PercentileRadius.prototype[Symbol.dispose] = PercentileRadius.prototype.free;
+
 /**
  * A long span represented by contiguous independently-fitted reduced-orbit
  * segments. Carries the fitted segments and the time scale they were fitted in;
@@ -10733,34 +11137,180 @@ export class PiecewiseOrbitSourceFit {
 if (Symbol.dispose) PiecewiseOrbitSourceFit.prototype[Symbol.dispose] = PiecewiseOrbitSourceFit.prototype.free;
 
 /**
- * Static integer-fixed PPP solution.
+ * Standard position-error metrics derived from a position covariance.
  */
-export class PppFixedSolution {
+export class PositionErrorMetrics {
     static __wrap(ptr) {
-        const obj = Object.create(PppFixedSolution.prototype);
+        const obj = Object.create(PositionErrorMetrics.prototype);
         obj.__wbg_ptr = ptr;
-        PppFixedSolutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        PositionErrorMetricsFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PppFixedSolutionFinalization.unregister(this);
+        PositionErrorMetricsFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_pppfixedsolution_free(ptr, 0);
+        wasm.__wbg_positionerrormetrics_free(ptr, 0);
+    }
+    /**
+     * Horizontal 50 percent circle radius.
+     * @returns {PercentileRadius}
+     */
+    get cepM() {
+        const ret = wasm.positionerrormetrics_cepM(this.__wbg_ptr);
+        return PercentileRadius.__wrap(ret);
     }
     /**
+     * Distance root mean square, metres.
      * @returns {number}
      */
-    get codeRmsM() {
-        const ret = wasm.pppfixedsolution_codeRmsM(this.__wbg_ptr);
+    get drmsM() {
+        const ret = wasm.positionerrormetrics_drmsM(this.__wbg_ptr);
         return ret;
     }
     /**
-     * @returns {boolean}
+     * Horizontal one-sigma covariance ellipse.
+     * @returns {ErrorEllipse}
+     */
+    get ellipse() {
+        const ret = wasm.positionerrormetrics_ellipse(this.__wbg_ptr);
+        return ErrorEllipse.__wrap(ret);
+    }
+    /**
+     * Mean radial spherical error, metres.
+     * @returns {number}
+     */
+    get mrseM() {
+        const ret = wasm.positionerrormetrics_mrseM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Horizontal 95 percent circle radius.
+     * @returns {PercentileRadius}
+     */
+    get r95M() {
+        const ret = wasm.positionerrormetrics_r95M(this.__wbg_ptr);
+        return PercentileRadius.__wrap(ret);
+    }
+    /**
+     * Horizontal 99 percent circle radius.
+     * @returns {PercentileRadius}
+     */
+    get r99M() {
+        const ret = wasm.positionerrormetrics_r99M(this.__wbg_ptr);
+        return PercentileRadius.__wrap(ret);
+    }
+    /**
+     * Three-dimensional 50 percent sphere radius.
+     * @returns {PercentileRadius}
+     */
+    get sepM() {
+        const ret = wasm.positionerrormetrics_sepM(this.__wbg_ptr);
+        return PercentileRadius.__wrap(ret);
+    }
+    /**
+     * East standard deviation, metres.
+     * @returns {number}
+     */
+    get sigmaEM() {
+        const ret = wasm.positionerrormetrics_sigmaEM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * North standard deviation, metres.
+     * @returns {number}
+     */
+    get sigmaNM() {
+        const ret = wasm.positionerrormetrics_sigmaNM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Up standard deviation, metres.
+     * @returns {number}
+     */
+    get sigmaUM() {
+        const ret = wasm.positionerrormetrics_sigmaUM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Two times distance root mean square, metres.
+     * @returns {number}
+     */
+    get twoDrmsM() {
+        const ret = wasm.positionerrormetrics_twoDrmsM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Vertical 50 percent one-dimensional radius, metres.
+     * @returns {number}
+     */
+    get vepM() {
+        const ret = wasm.positionerrormetrics_vepM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) PositionErrorMetrics.prototype[Symbol.dispose] = PositionErrorMetrics.prototype.free;
+
+/**
+ * IEEE 1139 fractional-frequency PSD power-law noise type.
+ * @enum {0 | 1 | 2 | 3 | 4}
+ */
+export const PowerLawNoiseType = Object.freeze({
+    /**
+     * Random-walk frequency modulation, `S_y(f) = h_-2 f^-2`.
+     */
+    RandomWalkFM: 0, "0": "RandomWalkFM",
+    /**
+     * Flicker frequency modulation, `S_y(f) = h_-1 f^-1`.
+     */
+    FlickerFM: 1, "1": "FlickerFM",
+    /**
+     * White frequency modulation, `S_y(f) = h_0`.
+     */
+    WhiteFM: 2, "2": "WhiteFM",
+    /**
+     * Flicker phase modulation, `S_y(f) = h_1 f`.
+     */
+    FlickerPM: 3, "3": "FlickerPM",
+    /**
+     * White phase modulation, `S_y(f) = h_2 f^2`.
+     */
+    WhitePM: 4, "4": "WhitePM",
+});
+
+/**
+ * Static integer-fixed PPP solution.
+ */
+export class PppFixedSolution {
+    static __wrap(ptr) {
+        const obj = Object.create(PppFixedSolution.prototype);
+        obj.__wbg_ptr = ptr;
+        PppFixedSolutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PppFixedSolutionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pppfixedsolution_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get codeRmsM() {
+        const ret = wasm.pppfixedsolution_codeRmsM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
      */
     get converged() {
         const ret = wasm.pppfixedsolution_converged(this.__wbg_ptr);
@@ -12420,6 +12970,15 @@ export class RtkFixedSolution {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
+    /**
+     * Geometry observability and covariance-validation diagnostics for the
+     * float design used by the integer-fixed solve.
+     * @returns {GeometryQuality}
+     */
+    get geometryQuality() {
+        const ret = wasm.rtkfixedsolution_geometryQuality(this.__wbg_ptr);
+        return GeometryQuality.__wrap(ret);
+    }
     /**
      * @returns {number}
      */
@@ -12451,6 +13010,24 @@ export class RtkFixedSolution {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Whether residual-based RAIM can test the float design used by the
+     * integer-fixed solve.
+     * @returns {boolean}
+     */
+    get raimCheckable() {
+        const ret = wasm.rtkfixedsolution_raimCheckable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Observation redundancy, `nObs - nParams`, for the float design used by
+     * the integer-fixed solve.
+     * @returns {number}
+     */
+    get redundancy() {
+        const ret = wasm.rtkfixedsolution_redundancy(this.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) RtkFixedSolution.prototype[Symbol.dispose] = RtkFixedSolution.prototype.free;
 
@@ -12506,6 +13083,17 @@ export class RtkFloatSolution {
         const ret = wasm.rtkfloatsolution_converged(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Geometry observability and covariance-validation diagnostics for the
+     * final double-difference design. `ZeroRedundancy` bounds are unvalidated
+     * for snapshot solves, `Weak` bounds are unclamped, and rank-deficient
+     * designs are returned as a singular-geometry `Error`.
+     * @returns {GeometryQuality}
+     */
+    get geometryQuality() {
+        const ret = wasm.rtkfloatsolution_geometryQuality(this.__wbg_ptr);
+        return GeometryQuality.__wrap(ret);
+    }
     /**
      * @returns {number}
      */
@@ -12527,6 +13115,22 @@ export class RtkFloatSolution {
         const ret = wasm.rtkfloatsolution_phaseRmsM(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Whether residual-based RAIM can test the float design.
+     * @returns {boolean}
+     */
+    get raimCheckable() {
+        const ret = wasm.rtkfloatsolution_raimCheckable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Observation redundancy, `nObs - nParams`, for the float design.
+     * @returns {number}
+     */
+    get redundancy() {
+        const ret = wasm.rtkfloatsolution_redundancy(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {number}
      */
@@ -12832,6 +13436,391 @@ export class SbasCorrectionStore {
 }
 if (Symbol.dispose) SbasCorrectionStore.prototype[Symbol.dispose] = SbasCorrectionStore.prototype.free;
 
+/**
+ * Index-aligned SBAS error model for protection-level geometry rows.
+ */
+export class SbasErrorModel {
+    static __wrap(ptr) {
+        const obj = Object.create(SbasErrorModel.prototype);
+        obj.__wbg_ptr = ptr;
+        SbasErrorModelFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SbasErrorModelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sbaserrormodel_free(ptr, 0);
+    }
+    /**
+     * Build an SBAS error model from a decoded correction store.
+     *
+     * `geo` is an SBAS satellite token, `geometry` is protection geometry, and
+     * `epochJ2000S` is the receive epoch used for freshness checks. Omit
+     * `airborne` or `degradation` to use their defaults.
+     * @param {SbasCorrectionStore} store
+     * @param {string} geo
+     * @param {any} geometry
+     * @param {AirborneModel | null | undefined} airborne
+     * @param {number} epoch_j2000_s
+     * @param {DegradationParams | null} [degradation]
+     * @returns {SbasErrorModel}
+     */
+    static fromStore(store, geo, geometry, airborne, epoch_j2000_s, degradation) {
+        _assertClass(store, SbasCorrectionStore);
+        const ptr0 = passStringToWasm0(geo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ptr1 = 0;
+        if (!isLikeNone(airborne)) {
+            _assertClass(airborne, AirborneModel);
+            ptr1 = airborne.__destroy_into_raw();
+        }
+        let ptr2 = 0;
+        if (!isLikeNone(degradation)) {
+            _assertClass(degradation, DegradationParams);
+            ptr2 = degradation.__destroy_into_raw();
+        }
+        const ret = wasm.sbaserrormodel_fromStore(store.__wbg_ptr, ptr0, len0, geometry, ptr1, epoch_j2000_s, ptr2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SbasErrorModel.__wrap(ret[0]);
+    }
+    /**
+     * Construct an SBAS error model from rows.
+     *
+     * `rows` is an array of `{ id, sigmaFltM, sigmaUireM?, sigmaAirM?,
+     * sigmaTropoM? }` objects. As a shorthand, a row may provide only
+     * `{ id, sigmaM }`, which is stored as the total one-sigma range term.
+     * @param {any} rows
+     */
+    constructor(rows) {
+        const ret = wasm.sbaserrormodel_new(rows);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        SbasErrorModelFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Number of range-error rows in the model.
+     * @returns {number}
+     */
+    get rowCount() {
+        const ret = wasm.sbaserrormodel_rowCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Return the row for a satellite token, or `undefined` if it is absent.
+     * @param {string} id
+     * @returns {SbasSisError | undefined}
+     */
+    rowFor(id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sbaserrormodel_rowFor(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : SbasSisError.__wrap(ret[0]);
+    }
+    /**
+     * Error-model rows as plain objects.
+     * @returns {any}
+     */
+    get rows() {
+        const ret = wasm.sbaserrormodel_rows(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) SbasErrorModel.prototype[Symbol.dispose] = SbasErrorModel.prototype.free;
+
+/**
+ * Fixed SBAS protection-level multipliers.
+ */
+export class SbasKMultipliers {
+    static __wrap(ptr) {
+        const obj = Object.create(SbasKMultipliers.prototype);
+        obj.__wbg_ptr = ptr;
+        SbasKMultipliersFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SbasKMultipliersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sbaskmultipliers_free(ptr, 0);
+    }
+    /**
+     * En-route through non-precision-approach SBAS K multipliers.
+     * @returns {SbasKMultipliers}
+     */
+    static enRouteNpa() {
+        const ret = wasm.sbaskmultipliers_enRouteNpa();
+        return SbasKMultipliers.__wrap(ret);
+    }
+    /**
+     * Horizontal K multiplier.
+     * @returns {number}
+     */
+    get kH() {
+        const ret = wasm.sbaskmultipliers_kH(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Vertical K multiplier.
+     * @returns {number}
+     */
+    get kV() {
+        const ret = wasm.sbaskmultipliers_kV(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Construct SBAS horizontal and vertical K multipliers.
+     *
+     * Both values must be positive finite numbers.
+     * @param {number} k_h
+     * @param {number} k_v
+     */
+    constructor(k_h, k_v) {
+        const ret = wasm.sbaskmultipliers_new(k_h, k_v);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        SbasKMultipliersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Precision-approach SBAS K multipliers.
+     * @returns {SbasKMultipliers}
+     */
+    static precisionApproach() {
+        const ret = wasm.sbaskmultipliers_precisionApproach();
+        return SbasKMultipliers.__wrap(ret);
+    }
+}
+if (Symbol.dispose) SbasKMultipliers.prototype[Symbol.dispose] = SbasKMultipliers.prototype.free;
+
+/**
+ * SBAS protection-level input or numerical failure.
+ * @enum {0 | 1 | 2}
+ */
+export const SbasPlError = Object.freeze({
+    /**
+     * The geometry lacks enough independent rows for the active clocks.
+     */
+    InsufficientGeometry: 0, "0": "InsufficientGeometry",
+    /**
+     * Matrix projection or covariance processing failed.
+     */
+    NumericalFailure: 1, "1": "NumericalFailure",
+    /**
+     * The supplied error model or K multipliers are outside their domain.
+     */
+    InvalidErrorModel: 2, "2": "InvalidErrorModel",
+});
+
+/**
+ * SBAS protection-level output for one geometry snapshot.
+ */
+export class SbasProtection {
+    static __wrap(ptr) {
+        const obj = Object.create(SbasProtection.prototype);
+        obj.__wbg_ptr = ptr;
+        SbasProtectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SbasProtectionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sbasprotection_free(ptr, 0);
+    }
+    /**
+     * East one-sigma standard deviation, metres.
+     * @returns {number}
+     */
+    get dEastM() {
+        const ret = wasm.sbasprotection_dEastM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * East-north covariance term, square metres.
+     * @returns {number}
+     */
+    get dEnM2() {
+        const ret = wasm.sbasprotection_dEnM2(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Horizontal one-sigma semi-major axis, metres.
+     * @returns {number}
+     */
+    get dMajorM() {
+        const ret = wasm.sbasprotection_dMajorM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * North one-sigma standard deviation, metres.
+     * @returns {number}
+     */
+    get dNorthM() {
+        const ret = wasm.sbasprotection_dNorthM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Horizontal protection level, metres.
+     * @returns {number}
+     */
+    get hplM() {
+        const ret = wasm.sbasprotection_hplM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Vertical one-sigma standard deviation, metres.
+     * @returns {number}
+     */
+    get sigmaUM() {
+        const ret = wasm.sbasprotection_sigmaUM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Vertical protection level, metres.
+     * @returns {number}
+     */
+    get vplM() {
+        const ret = wasm.sbasprotection_vplM(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) SbasProtection.prototype[Symbol.dispose] = SbasProtection.prototype.free;
+
+/**
+ * One satellite's SBAS one-sigma range-error budget.
+ */
+export class SbasSisError {
+    static __wrap(ptr) {
+        const obj = Object.create(SbasSisError.prototype);
+        obj.__wbg_ptr = ptr;
+        SbasSisErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SbasSisErrorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sbassiserror_free(ptr, 0);
+    }
+    /**
+     * Satellite token for this range-error row.
+     * @returns {string}
+     */
+    get id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sbassiserror_id(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Construct one SBAS range-error row.
+     *
+     * Component sigmas are metres. They are combined by root-sum-square when
+     * the model is evaluated.
+     * @param {string} id
+     * @param {number} sigma_flt_m
+     * @param {number} sigma_uire_m
+     * @param {number} sigma_air_m
+     * @param {number} sigma_tropo_m
+     */
+    constructor(id, sigma_flt_m, sigma_uire_m, sigma_air_m, sigma_tropo_m) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sbassiserror_new(ptr0, len0, sigma_flt_m, sigma_uire_m, sigma_air_m, sigma_tropo_m);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        SbasSisErrorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Airborne receiver noise, divergence, and multipath sigma, metres.
+     * @returns {number}
+     */
+    get sigmaAirM() {
+        const ret = wasm.sbassiserror_sigmaAirM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Fast and long-term correction residual sigma, metres.
+     * @returns {number}
+     */
+    get sigmaFltM() {
+        const ret = wasm.sbassiserror_sigmaFltM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Total one-sigma range error, metres, or `null` if invalid.
+     * @returns {any}
+     */
+    sigmaM() {
+        const ret = wasm.sbassiserror_sigmaM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Tropospheric residual sigma, metres.
+     * @returns {number}
+     */
+    get sigmaTropoM() {
+        const ret = wasm.sbassiserror_sigmaTropoM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * User ionospheric range-error sigma, metres.
+     * @returns {number}
+     */
+    get sigmaUireM() {
+        const ret = wasm.sbassiserror_sigmaUireM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sum-of-squares range variance, square metres, or `null` if invalid.
+     * @returns {any}
+     */
+    varianceM2() {
+        const ret = wasm.sbassiserror_varianceM2(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) SbasSisError.prototype[Symbol.dispose] = SbasSisError.prototype.free;
+
 /**
  * Per-constellation single-frequency pseudorange code-selection policy. Build
  * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
@@ -14554,6 +15543,17 @@ export class SppSolution {
         }
         return v1;
     }
+    /**
+     * Geometry observability and covariance-validation diagnostics for this
+     * solved design. `ZeroRedundancy` marks unvalidated snapshot covariance
+     * bounds, `Weak` leaves large bounds unclamped, and rank-deficient designs
+     * are returned as a singular-geometry `Error` rather than a solution.
+     * @returns {GeometryQuality}
+     */
+    get geometryQuality() {
+        const ret = wasm.sppsolution_geometryQuality(this.__wbg_ptr);
+        return GeometryQuality.__wrap(ret);
+    }
     /**
      * ECEF position as a `Float64Array` `[x, y, z]`, metres.
      * @returns {Float64Array}
@@ -14564,6 +15564,22 @@ export class SppSolution {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
+    /**
+     * Whether residual-based RAIM can test the accepted solve.
+     * @returns {boolean}
+     */
+    get raimCheckable() {
+        const ret = wasm.sppsolution_raimCheckable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Degrees of freedom in the accepted solve: `usedCount - (3 + clocks)`.
+     * @returns {number}
+     */
+    get redundancy() {
+        const ret = wasm.sppsolution_redundancy(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Post-fit residuals, metres, index-aligned to `usedSats`.
      * @returns {Float64Array}
@@ -15356,6 +16372,9 @@ export class Tle {
      */
     toLines() {
         const ret = wasm.tle_toLines(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
@@ -15998,6 +17017,26 @@ export function allanDeviation(series, tau0_s, averaging_factors) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Exact ADEV log-log slope for a power-law noise type.
+ * @param {PowerLawNoiseType} noise_type
+ * @returns {number}
+ */
+export function allanDeviationPowerLawSlope(noise_type) {
+    const ret = wasm.allanDeviationPowerLawSlope(noise_type);
+    return ret;
+}
+
+/**
+ * Exact Allan-variance tau exponent for a power-law noise type.
+ * @param {PowerLawNoiseType} noise_type
+ * @returns {number}
+ */
+export function allanVariancePowerLawTauExponent(noise_type) {
+    const ret = wasm.allanVariancePowerLawTauExponent(noise_type);
+    return ret;
+}
+
 /**
  * Alpha-beta measurement update applied to a predicted scalar state.
  *
@@ -16914,6 +17953,23 @@ export function detectCycleSlips(arc, options) {
     return v1;
 }
 
+/**
+ * Detect candidate displacement steps in a station position series.
+ *
+ * `options` may set `windowYears`, `scoreThreshold`, `minOffsetM`,
+ * `minSamplesEachSide`, `minSeparationYears`, and nested `midas` controls.
+ * @param {any} series
+ * @param {any} options
+ * @returns {any}
+ */
+export function detectSteps(series, options) {
+    const ret = wasm.detectSteps(series, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Apply base pseudorange corrections to rover observations by satellite token.
  *
@@ -17714,6 +18770,47 @@ export function fitPiecewiseReducedOrbitTle(tle, options) {
     return PiecewiseOrbitSourceFit.__wrap(ret[0]);
 }
 
+/**
+ * Identify power-law clock-noise regions from ADEV and MDEV curves.
+ *
+ * `adev` and `mdev` are `{ tauS, deviation, n }` objects, matching the output
+ * from the Allan-family functions. `options` may set `basicTauS`,
+ * `measurementBandwidthHz`, `minPointsPerOctave`, `slopeTolerance`, and
+ * `scatterTolerance`.
+ * @param {any} adev
+ * @param {any} mdev
+ * @param {any} options
+ * @returns {any}
+ */
+export function fitPowerLawNoise(adev, mdev, options) {
+    const ret = wasm.fitPowerLawNoise(adev, mdev, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Fit one satellite orbit from caller-supplied precise ephemeris samples.
+ *
+ * `samples` is the same array accepted by `preciseEphemerisSamplesFromSamples`:
+ * `{ sat, epoch, positionEcefM, clockS?, clockEvent? }` with epochs in seconds
+ * since J2000.
+ * @param {any} samples
+ * @param {string} satellite
+ * @param {any} options
+ * @returns {any}
+ */
+export function fitPreciseEphemerisSampleOrbit(samples, satellite, options) {
+    const ptr0 = passStringToWasm0(satellite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fitPreciseEphemerisSampleOrbit(samples, ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Fit a reduced-orbit model to ECEF position samples.
  *
@@ -17775,6 +18872,28 @@ export function fitReducedOrbitTle(tle, options) {
     return ReducedOrbitSourceFit.__wrap(ret[0]);
 }
 
+/**
+ * Fit one satellite orbit from a parsed SP3 precise product.
+ *
+ * `satellite` is an IGS token such as `"G01"`. `options` may set
+ * `forceModel`, `integrator`, `integratorOptions`, `solverOptions`,
+ * `linearSolve`, `minLedgerSamples`, and `drag`.
+ * @param {Sp3} sp3
+ * @param {string} satellite
+ * @param {any} options
+ * @returns {any}
+ */
+export function fitSp3PreciseOrbit(sp3, satellite, options) {
+    _assertClass(sp3, Sp3);
+    const ptr0 = passStringToWasm0(satellite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fitSp3PreciseOrbit(sp3.__wbg_ptr, ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Fit SGP4 mean elements and optional B* to TEME state samples.
  * @param {any} samples
@@ -17789,6 +18908,25 @@ export function fitTle(samples, config) {
     return TleFit.__wrap(ret[0]);
 }
 
+/**
+ * Fit a geodetic trajectory model with velocity, seasonal, and step terms.
+ *
+ * `model` may set `referenceEpochYear`, `includeAnnual`,
+ * `includeSemiannual`, and `offsetEpochsYear`. `options` may set `loss`,
+ * `fScaleM`, and `maxNfev`.
+ * @param {any} series
+ * @param {any} model
+ * @param {any} options
+ * @returns {any}
+ */
+export function fitTrajectory(series, model, options) {
+    const ret = wasm.fitTrajectory(series, model, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Fix Melbourne-Wubbena wide-lane ambiguities over a dual-frequency RTK arc.
  *
@@ -19495,6 +20633,51 @@ export function meridianTransitsSpk(spk, body, station, start_unix_us, end_unix_
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Rotate an ECEF covariance to ENU and compute position-error metrics.
+ *
+ * `receiver` is `{ latRad, lonRad, heightM? }` with radians and metres.
+ * @param {any} covariance_ecef_m2
+ * @param {any} receiver
+ * @returns {PositionErrorMetrics}
+ */
+export function metricsFromEcefCovarianceM2(covariance_ecef_m2, receiver) {
+    const ret = wasm.metricsFromEcefCovarianceM2(covariance_ecef_m2, receiver);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PositionErrorMetrics.__wrap(ret[0]);
+}
+
+/**
+ * Compute position-error metrics from an ENU covariance in square metres.
+ * @param {any} covariance_enu_m2
+ * @returns {PositionErrorMetrics}
+ */
+export function metricsFromEnuCovarianceM2(covariance_enu_m2) {
+    const ret = wasm.metricsFromEnuCovarianceM2(covariance_enu_m2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PositionErrorMetrics.__wrap(ret[0]);
+}
+
+/**
+ * Compute position-error metrics from a kinematic solution object.
+ *
+ * The object must include `positionM` and `positionCovarianceM2`; optional
+ * extra kinematic fields are accepted and ignored by this metric calculation.
+ * @param {any} solution
+ * @returns {PositionErrorMetrics}
+ */
+export function metricsFromKinematicSolution(solution) {
+    const ret = wasm.metricsFromKinematicSolution(solution);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PositionErrorMetrics.__wrap(ret[0]);
+}
+
 /**
  * Modified Allan deviation for explicit averaging factors.
  *
@@ -19514,6 +20697,16 @@ export function modifiedAdev(series, tau0_s, averaging_factors) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Exact MDEV log-log slope for a power-law noise type.
+ * @param {PowerLawNoiseType} noise_type
+ * @returns {number}
+ */
+export function modifiedAllanDeviationPowerLawSlope(noise_type) {
+    const ret = wasm.modifiedAllanDeviationPowerLawSlope(noise_type);
+    return ret;
+}
+
 /**
  * Mean, variance, skewness, and excess kurtosis of a residual set in one pass.
  *
@@ -19725,6 +20918,23 @@ export function nequickGStecTecu(_eval) {
     return ret[0];
 }
 
+/**
+ * Estimate a station network velocity field in one local ENU frame.
+ *
+ * The input is `{ frame: { origin, removeCommonMode? }, stations }`. Each
+ * station has `{ id, reference, series }`, and each series follows
+ * `velocityMidas`.
+ * @param {any} input
+ * @returns {any}
+ */
+export function networkField(input) {
+    const ret = wasm.networkField(input);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Scalar normalized innovation squared statistic.
  * @param {number} innovation
@@ -19896,6 +21106,24 @@ export function ntripRequestBytes(config) {
     return v1;
 }
 
+/**
+ * Stable string label for an [`ObservabilityTier`] enum value.
+ * @param {ObservabilityTier} tier
+ * @returns {string}
+ */
+export function observabilityTierLabel(tier) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.observabilityTierLabel(tier);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Missing-position sentinel used in failed observable-state batch elements.
  *
@@ -20085,6 +21313,27 @@ export function oceanTideLoading(station_ecef_m, year, month, day, fractional_ho
     return v4;
 }
 
+/**
+ * Broadcast-derived per-satellite orbit-repeat lag, in seconds.
+ *
+ * `satellite` is an IGS token such as `"G01"`, and `nearEpochJ2000S` is the
+ * broadcast-selection epoch in seconds since J2000.
+ * @param {BroadcastEphemeris} ephemeris
+ * @param {string} satellite
+ * @param {number} near_epoch_j2000_s
+ * @returns {number}
+ */
+export function orbitRepeatLag(ephemeris, satellite, near_epoch_j2000_s) {
+    _assertClass(ephemeris, BroadcastEphemeris);
+    const ptr0 = passStringToWasm0(satellite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.orbitRepeatLag(ephemeris.__wbg_ptr, ptr0, len0, near_epoch_j2000_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Orthometric height `H = h - N` (metres above mean sea level) from an
  * ellipsoidal height and a geodetic position in radians, using the built-in
@@ -20518,6 +21767,24 @@ export function parseTleFile(text, ops_mode_label) {
     return ParsedTleFile.__wrap(ret[0]);
 }
 
+/**
+ * Score repeating components at candidate periods.
+ *
+ * `series` and `candidatePeriodsS` are JS number arrays. `sampleIntervalS`
+ * defaults to one second. The result is an array of `{ periodS, strength }`.
+ * @param {any} series
+ * @param {any} candidate_periods_s
+ * @param {number | null} [sample_interval_s]
+ * @returns {any}
+ */
+export function periodicityStrength(series, candidate_periods_s, sample_interval_s) {
+    const ret = wasm.periodicityStrength(series, candidate_periods_s, !isLikeNone(sample_interval_s), isLikeNone(sample_interval_s) ? 0 : sample_interval_s);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Sun-satellite-observer phase angle in degrees.
  * @param {Float64Array} satellite_position_km
@@ -20810,7 +22077,7 @@ export function propagateKepler(coe, mu_km3_s2, dt_s) {
  * epochs.
  *
  * `request` is a plain object; see the `PropagateStateRequest` TypeScript type.
- * Throws a `TypeError` for malformed input (wrong shape, unknown selector), a
+ * Throws a `TypeError` for malformed input (wrong layout, unknown selector), a
  * `RangeError` for a non-positive initial step, and an `Error` if the engine's
  * propagation fails.
  * @param {any} request
@@ -20906,6 +22173,44 @@ export function relativeState(chief, deputy) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Compute pre-data ARAIM reliability using an ARAIM ISM range-error model.
+ *
+ * `geometry` and `ism` use the same plain objects accepted by `araim`.
+ * `options` follows `reliabilityDesign`. External effects are returned in local
+ * east, north, up metres. Uncheckable rows return `null` for optional fields.
+ * @param {any} geometry
+ * @param {any} ism
+ * @param {any} options
+ * @returns {any}
+ */
+export function reliabilityAraim(geometry, ism, options) {
+    const ret = wasm.reliabilityAraim(geometry, ism, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute pre-data reliability from supplied range design rows.
+ *
+ * `rows` is an array of `{ id, designRow, sigmaM }` objects. `options` may set
+ * `{ alpha?, power?, beta?, lambda0Override?, lambda0?, minRedundancy? }`.
+ * `power` is converted to the core missed-detection probability. Rows below
+ * `minRedundancy` return `null` for `mdbM`, `externalEnuM`, and `biasToNoise`.
+ * @param {any} rows
+ * @param {any} options
+ * @returns {any}
+ */
+export function reliabilityDesign(rows, options) {
+    const ret = wasm.reliabilityDesign(rows, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Repair RINEX navigation text.
  * @param {Uint8Array} bytes
@@ -20938,6 +22243,16 @@ export function repairRinexObs(bytes, options) {
     return RinexObsRepair.__wrap(ret[0]);
 }
 
+/**
+ * Default ground-track repeat period for a GNSS constellation, in seconds.
+ * @param {GnssSystem} system
+ * @returns {number}
+ */
+export function repeatPeriod(system) {
+    const ret = wasm.repeatPeriod(system);
+    return ret;
+}
+
 /**
  * Build a sampled GPS C/A code replica, an `Int8Array`.
  * @param {bigint} prn
@@ -21340,6 +22655,24 @@ export function sbasCorrectedState(broadcast, store, geo, sat, t_j2000_s, mode)
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Stable string label for an [`SbasPlError`] enum value.
+ * @param {SbasPlError} error
+ * @returns {string}
+ */
+export function sbasPlErrorLabel(error) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.sbasPlErrorLabel(error);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Convert an SBAS broadcast PRN number such as `129` to an SBAS satellite
  * token such as `"S29"`. Returns `null` when the PRN is outside the SBAS range.
@@ -21351,6 +22684,27 @@ export function sbasPrnToSat(broadcast_prn) {
     return ret;
 }
 
+/**
+ * Compute SBAS horizontal and vertical protection levels.
+ *
+ * `geometry` is the ARAIM protection geometry object with rows, receiver, and
+ * clock systems. `model` supplies one range-error row per satellite. `k`
+ * supplies the fixed SBAS multipliers.
+ * @param {any} geometry
+ * @param {SbasErrorModel} model
+ * @param {SbasKMultipliers} k
+ * @returns {SbasProtection}
+ */
+export function sbasProtectionLevels(geometry, model, k) {
+    _assertClass(model, SbasErrorModel);
+    _assertClass(k, SbasKMultipliers);
+    const ret = wasm.sbasProtectionLevels(geometry, model.__wbg_ptr, k.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return SbasProtection.__wrap(ret[0]);
+}
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -21562,6 +22916,25 @@ export function shapiroWilk(x) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Apply a sidereal residual filter to a scalar series.
+ *
+ * `series` is a JS number array, `periodS` is seconds, and `options` may set
+ * `sampleIntervalS`, `priorPeriods`, `minCoverage`, and `templateMethod`.
+ * Returns `{ filtered, template, coverage, underCovered }`.
+ * @param {any} series
+ * @param {number} period_s
+ * @param {any} options
+ * @returns {any}
+ */
+export function siderealFilter(series, period_s, options) {
+    const ret = wasm.siderealFilter(series, period_s, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Build satellite-keyed pseudorange sigmas in metres from `{ satelliteId,
  * elevationDeg, cn0Dbhz? }` entries. Invalid entries are dropped by the core.
@@ -22638,6 +24011,24 @@ export function validateAgainstSp3Ids(records, ids) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Estimate robust station velocity with the MIDAS method.
+ *
+ * `series` is `{ samples, frame? }`, where samples are
+ * `{ epochYear, positionM, covarianceM2? }`. The frame is `"enu"` by default
+ * or `{ kind: "ecef", reference }`.
+ * @param {any} series
+ * @param {any} options
+ * @returns {any}
+ */
+export function velocityMidas(series, options) {
+    const ret = wasm.velocityMidas(series, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Satellites visible above `minElevationDeg` from `station` at a single instant,
  * from already-initialized [`Tle`]s: the opsmode-preserving constellation
@@ -22761,6 +24152,24 @@ export function writeDtedTreeToMmapStore(root, out_path) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
+
+/**
+ * Compute Baarda's w-test noncentrality from false-alarm probability and power.
+ *
+ * `alpha` is the two-sided false-alarm probability. `power` is detection power,
+ * so the core missed-detection probability is `1 - power`. The returned object
+ * contains `delta0` and `lambda0 = delta0 * delta0`.
+ * @param {number} alpha
+ * @param {number} power
+ * @returns {any}
+ */
+export function wtestNoncentrality(alpha, power) {
+    const ret = wasm.wtestNoncentrality(alpha, power);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -23199,6 +24608,9 @@ const AcquisitionGridFinalization = (typeof FinalizationRegistry === 'undefined'
 const AcquisitionResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_acquisitionresult_free(ptr, 1));
+const AirborneModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_airbornemodel_free(ptr, 1));
 const AntennaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_antenna_free(ptr, 1));
@@ -23283,6 +24695,9 @@ const CovarianceTransportResultFinalization = (typeof FinalizationRegistry === '
 const CoverageGridFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_coveragegrid_free(ptr, 1));
+const DegradationParamsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_degradationparams_free(ptr, 1));
 const DgnssSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_dgnsssolution_free(ptr, 1));
@@ -23319,6 +24734,9 @@ const EncounterFrameFinalization = (typeof FinalizationRegistry === 'undefined')
 const EphemerisFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ephemeris_free(ptr, 1));
+const ErrorEllipseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_errorellipse_free(ptr, 1));
 const ErrorEllipse2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_errorellipse2_free(ptr, 1));
@@ -23340,6 +24758,9 @@ const FrameStatesFinalization = (typeof FinalizationRegistry === 'undefined')
 const GeoidGridFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_geoidgrid_free(ptr, 1));
+const GeometryQualityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_geometryquality_free(ptr, 1));
 const GlonassRecordJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_glonassrecordjs_free(ptr, 1));
@@ -23514,12 +24935,18 @@ const OrthometricHeightMFinalization = (typeof FinalizationRegistry === 'undefin
 const ParsedTleFileFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_parsedtlefile_free(ptr, 1));
+const PercentileRadiusFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_percentileradius_free(ptr, 1));
 const PiecewiseOrbitFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_piecewiseorbit_free(ptr, 1));
 const PiecewiseOrbitSourceFitFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_piecewiseorbitsourcefit_free(ptr, 1));
+const PositionErrorMetricsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_positionerrormetrics_free(ptr, 1));
 const PppFixedSolutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pppfixedsolution_free(ptr, 1));
@@ -23586,6 +25013,18 @@ const SatelliteVectorFinalization = (typeof FinalizationRegistry === 'undefined'
 const SbasCorrectionStoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sbascorrectionstore_free(ptr, 1));
+const SbasErrorModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sbaserrormodel_free(ptr, 1));
+const SbasKMultipliersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sbaskmultipliers_free(ptr, 1));
+const SbasProtectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sbasprotection_free(ptr, 1));
+const SbasSisErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sbassiserror_free(ptr, 1));
 const SignalPolicyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signalpolicy_free(ptr, 1));