@neilberkman/sidereon 0.13.0 → 0.14.0

package/pkg-node/sidereon.d.ts

@@ -1864,6 +1864,43 @@ export class GeoidGrid {
     undulationsRad(points_rad: Float64Array): Float64Array;
 }
 
+/**
+ * Geometry observability and covariance-validation diagnostics.
+ */
+export class GeometryQuality {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Singular-value condition number of the design matrix.
+     */
+    readonly conditionNumber: number;
+    /**
+     * Whether residuals or a propagated prior validated the covariance bound.
+     */
+    readonly covarianceValidated: boolean;
+    /**
+     * Geometric dilution of precision for the solved state.
+     */
+    readonly gdop: number;
+    /**
+     * Whether residual-based RAIM can test the solve.
+     */
+    readonly raimCheckable: boolean;
+    /**
+     * Rank of the design matrix used by the solve.
+     */
+    readonly rank: number;
+    /**
+     * Observation redundancy, `nObs - nParams`.
+     */
+    readonly redundancy: number;
+    /**
+     * Observability and validation tier.
+     */
+    readonly tier: ObservabilityTier;
+}
+
 /**
  * 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.
@@ -3276,6 +3313,34 @@ export class ObsPhaseShift {
     readonly system: GnssSystem;
 }
 
+/**
+ * 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.
+ */
+export enum ObservabilityTier {
+    /**
+     * At least one estimated parameter is not observable.
+     */
+    RankDeficient = 0,
+    /**
+     * Full rank with no residual degrees of freedom.
+     */
+    ZeroRedundancy = 1,
+    /**
+     * Full rank with residual degrees of freedom, but above a cutoff.
+     */
+    Weak = 2,
+    /**
+     * Full rank and within the configured cutoffs.
+     */
+    Nominal = 3,
+}
+
 /**
  * Optional observation-code allow-list for raw and carrier-phase rows. Build
  * with `new ObservationFilter()` then chain `.withSystem(system, codes)`.
@@ -4770,6 +4835,11 @@ export class RtkFixedSolution {
      * The underlying float baseline as a `Float64Array` `[dx, dy, dz]`, metres.
      */
     readonly floatBaselineM: Float64Array;
+    /**
+     * Geometry observability and covariance-validation diagnostics for the
+     * float design used by the integer-fixed solve.
+     */
+    readonly geometryQuality: GeometryQuality;
     readonly integerCandidates: number;
     /**
      * Integer ambiguity ratio, or `undefined` when no ratio was computed.
@@ -4779,6 +4849,16 @@ export class RtkFixedSolution {
      * Integer ambiguity-fix status: `"Fixed"` or `"NotFixed"`.
      */
     readonly integerStatus: string;
+    /**
+     * Whether residual-based RAIM can test the float design used by the
+     * integer-fixed solve.
+     */
+    readonly raimCheckable: boolean;
+    /**
+     * Observation redundancy, `nObs - nParams`, for the float design used by
+     * the integer-fixed solve.
+     */
+    readonly redundancy: number;
 }
 
 /**
@@ -4798,9 +4878,24 @@ export class RtkFloatSolution {
     readonly baselineM: Float64Array;
     readonly codeRmsM: number;
     readonly converged: boolean;
+    /**
+     * 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`.
+     */
+    readonly geometryQuality: GeometryQuality;
     readonly iterations: number;
     readonly nObservations: number;
     readonly phaseRmsM: number;
+    /**
+     * Whether residual-based RAIM can test the float design.
+     */
+    readonly raimCheckable: boolean;
+    /**
+     * Observation redundancy, `nObs - nParams`, for the float design.
+     */
+    readonly redundancy: number;
     readonly weightedRmsM: number;
 }
 
@@ -5627,10 +5722,25 @@ export class SppSolution {
      * for geodetic output, otherwise `undefined`.
      */
     readonly geodetic: Float64Array | undefined;
+    /**
+     * 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.
+     */
+    readonly geometryQuality: GeometryQuality;
     /**
      * ECEF position as a `Float64Array` `[x, y, z]`, metres.
      */
     readonly positionM: Float64Array;
+    /**
+     * Whether residual-based RAIM can test the accepted solve.
+     */
+    readonly raimCheckable: boolean;
+    /**
+     * Degrees of freedom in the accepted solve: `usedCount - (3 + clocks)`.
+     */
+    readonly redundancy: number;
     /**
      * Post-fit residuals, metres, index-aligned to `usedSats`.
      */
@@ -7733,6 +7843,11 @@ export function normalizedInnovation(innovation: number, innovation_variance: nu
  */
 export function ntripRequestBytes(config: any): Uint8Array;
 
+/**
+ * Stable string label for an [`ObservabilityTier`] enum value.
+ */
+export function observabilityTierLabel(tier: ObservabilityTier): string;
+
 /**
  * Missing-position sentinel used in failed observable-state batch elements.
  *

package/pkg-node/sidereon.js

@@ -4798,6 +4798,86 @@ class GeoidGrid {
 if (Symbol.dispose) GeoidGrid.prototype[Symbol.dispose] = GeoidGrid.prototype.free;
 exports.GeoidGrid = GeoidGrid;
 
+/**
+ * Geometry observability and covariance-validation diagnostics.
+ */
+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;
+exports.GeometryQuality = GeometryQuality;
+
 /**
  * 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.
@@ -8258,6 +8338,36 @@ class ObsPhaseShift {
 if (Symbol.dispose) ObsPhaseShift.prototype[Symbol.dispose] = ObsPhaseShift.prototype.free;
 exports.ObsPhaseShift = ObsPhaseShift;
 
+/**
+ * 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}
+ */
+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",
+});
+exports.ObservabilityTier = ObservabilityTier;
+
 /**
  * Optional observation-code allow-list for raw and carrier-phase rows. Build
  * with `new ObservationFilter()` then chain `.withSystem(system, codes)`.
@@ -12557,6 +12667,15 @@ 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}
      */
@@ -12588,6 +12707,24 @@ 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;
 exports.RtkFixedSolution = RtkFixedSolution;
@@ -12644,6 +12781,17 @@ 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}
      */
@@ -12665,6 +12813,22 @@ 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}
      */
@@ -14717,6 +14881,17 @@ 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}
@@ -14727,6 +14902,22 @@ 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}
@@ -20286,6 +20477,25 @@ function ntripRequestBytes(config) {
 }
 exports.ntripRequestBytes = ntripRequestBytes;
 
+/**
+ * Stable string label for an [`ObservabilityTier`] enum value.
+ * @param {ObservabilityTier} tier
+ * @returns {string}
+ */
+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);
+    }
+}
+exports.observabilityTierLabel = observabilityTierLabel;
+
 /**
  * Missing-position sentinel used in failed observable-state batch elements.
  *
@@ -23881,6 +24091,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));