@neilberkman/sidereon 0.13.0 → 0.14.0

package/pkg/sidereon.js

@@ -4745,6 +4745,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 +8241,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)`.
@@ -12420,6 +12528,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 +12568,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 +12641,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 +12673,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}
      */
@@ -14554,6 +14716,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 +14737,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}
@@ -19896,6 +20085,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.
  *
@@ -23340,6 +23547,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));